Cómo determinar el área de un triángulo 3D en Python

Las estimaciones de áreas 3D pasan por generar puntos triangulados 3D utilizando como base un modelo digital de elevación. Una vez generados los puntos 3D, se puede usar álgebra lineal para determinar de manera rápida el área del triángulo 3D muestrando la componente z de los puntos a partir del ráster. El área 2D sería entonces la proyección del tríangulo 3D en el plano xy.

Cómo desplegar un QProgressDialog object con PyQGIS 3

Los objetos del tipo QProgressDialog permiten mostrar en tiempo real el desarrollo de un proceso y observar si éste se está desarrollando con normalidad o se presenta algún tipo de "retraso" que amerita ser corregido. El código a continuación despliega una serie de tres QProgressDialog cuya visualización se hace siempre "On Top" y donde el método 'setWindowModality' está activado con Qt.WindowModal. Si ésto último no se realiza el despliegue de la QProgressDialog parece ejecutarse como si estuviese "congelada".

Adaptar un plugin plantilla tipo botón checkeable para desplegar atributos y áreas de features (capas vectoriales) como tooltip en QGIS 3

En un post anterior se adaptó un plugin, de QGIS 2 a QGIS 3, para desplegar ráster values como tooltip. En este post se va a adaptar ese comportamiento para desplegar los valores de todos los atributos y el área (en hectáreas) de capas vectoriales. El código completo se expone a continuación y se copió en el template.py; renombrado posteriormente como measure_area.py en la carpeta measurearea. Sin embargo, para que funcione adecuadamente se requieren otras modificaciones que se detallan más adelante.

Adaptar un plugin plantilla tipo botón checkeable para producir círculos por dragado del Map Canvas en QGIS 3

En el post anterior se adaptó un plugin plantilla, tipo botón checkeable, para producir rectángulos por dragado del Map Canvas en QGIS 3. Ahora, se va a adaptar la misma plantilla pero para producir círculos por dragado del Map Canvas. El código completo colocado en el archivo template.py se muestra a continuación. Sin embargo, para que funcione adecuadamente se requieren otras modificaciones que se detallan más adelante.

Adaptar un plugin plantilla tipo botón checkeable para producir rectángulos por dragado del Map Canvas en QGIS 3

En el post anterior se produjo un plugin plantilla tipo botón checkeable para PyQGIS 3. Ahora lo vamos a adaptar para producir rectángulos por dragado del Map Canvas; tal como se realizó en este otro post. A continuación, para tener una plantilla verdadera, se elimina en template.py todo el código que permitía generar las tooltips consideradas en el post anterior y se reserva para tal fin. El código final se presenta a continuación.

Cómo producir un plugin plantilla tipo botón checkeable para PyQGIS 3

En esta respuesta de gis.stackexchange.com se propone un plugin tipo botón checkeable con la antigua versión de QGIS 2 y que permite desplegar valores de ráster como tooltips. El comportamiento de este tipo de plugins no está en la oferta de Plugin Builder 3 por lo cual sería útil tenerlo disponible como plantilla. La importancia de este tipo de plugins radica en que sólo nos interesa que al hacer click en él se prepare para iniciar una acción y no se despliegue ningún tipo adicional de QDialog.

Producir polígonos por dragado del Map Canvas con PyQGIS 3

En posts anteriores (1, 2) se introdujo la producción de rectángulos y círculos por dragado del Map Canvas con PyQgis 3. En el actual generalizamos el código para que este abarque polígonos regulares de más de tres lados (en el __init__ de la clase se define el número de lados).

Producir círculos por dragado del Map Canvas con PyQGIS 3

En el post anterior se consideró la produción de rectángulos por dragado del Map Canvas con PyQGIS 3. La geometría de los rectángulos se colocaba de manera interactiva en las rubber bands durante el dragado de los mismos y, una vez liberado el cursor, la geometría del rectángulo final se pasaba como feature a la memory layer correspondiente.

Producir rectángulos por dragado del Map Canvas con PyQGIS 3

Modificando el código de la respuesta que se encuentra en este link es posible construir capas vectoriales tipo polígono, con forma rectángular, como memory layers. El código se presenta a continuación:

Cómo obtener la proyección a partir de la Status Bar de QGIS 3 mediante PyQGIS?

La proyección es un elemento importante a la hora de producir capas vectoriales o ráster porque hará que estas se desplieguen de la manera adecuada desde un punto de vista geográfico. Cuando se abre QGIS, con capas o sin ellas, en la Status Bar se observa la proyección con código EPSG en la parte inferior derecha. La Status Bar en QGIS 3 (PyQt5.QtWidgets.QStatusBar) es un objeto de la ventana principal (PyQt5.QtWidgets.QMainWindow) que se obtiene a partir de los métodos 'mainWindow()' y 'statusBar()' de las clases QgisInterface y PyQt5.QtWidgets.QMainWindow respectivamente

La serie de comandos siguiente, ejecutados en la Python Console de QGIS, permitirá definir y acceder a los metodos de la clase correspondiente a la Status Bar.

Cómo producir rejillas (grid) triangulares mediante PyQGIS 3

En posts pasados (1,2) se consideró la manera de producir rejillas hexagonales mediante PyQGIS 3 y en este le toca el turno a las triangulares. Aunque pueda parecer extraño, a menor número de lados mayor complejidad.

Cortando una rejilla (grid) hexagonal creada con PyQGIS 3

En el post anterior se consideró la creación de una rejilla hexagonal. Esta contenía unos “salientes” laterales y en las partes superior e inferior de la rejilla. Además, el punto de referencia usado para su confección luce desplazado por la necesidad de encajar las filas de la manera adecuada.

Cómo producir rejillas (grid) hexagonales mediante PyQGIS 3

En un post anterior se introdujo un código para producir rejillas hexagonales mediante la versión previa de PyQGIS, es decir, con Python 2. Aunque las diferencias no son muchas, puede ser abrumador tratar de hacerlo funcionar si no nos familiarizamos previamente con las nuevas clases de PyQGIS 3.

Conectando multipolígonos con líneas utilizando la distancia más corta como parámetro con PyQGIS 3

El ejemplo que se refiere a continuación permite conectar multipolígonos con líneas utilizando la distancia más corta como parámetro con PyQGIS 3. Es la adaptación de un código que se realizó con anterioridad con PyQGIS 2. El código con PyQGIS 3 se presenta a continuación:

Dividiendo polígonos irregulares en dos partes con diferentes proporciones y con diferente orientación de la línea de corte con PyQGIS

Un requerimiento común en las opciones de geoproceso es la división de polígonos irregulares en diferentes proporciones y con diferente orientación de la línea de corte. Aunque parece difícil, la opción más sencilla para realizar ésto es mediante la bounding box del polígono rotado por el ángulo correspondiente a la línea de corte para la proporción deseada.

Conectando multipolígonos con líneas utilizando la distancia más corta como parámetro con PyQGIS 2

A pesar de que QGIS 2 ya no tiene mantenimiento en versiones de esta rama, todavía existen usuarios que se niegan a actualizar a QGIS 3 para no tener que adaptar el código ya desarrollado para que funcione en QGIS 3. El ejemplo que se refiere a continuación permite conectar multipolígonos con líneas utilizando la distancia más corta como parámetro con PyQGIS 2. Difiere en varias líneas de código del que se desarrolló también para PyQGIS 3 con el mismo fin (que se incluirá, Dios mediante, en un post futuro). Se presenta a continuación:

Clase plantilla con QDialog que contiene función para producir polilíneas a partir de rasgos adyacentes seleccionados

En posts anteriores (1, 2) se consideró la intersección de rasgos (features) adyacentes de polígonos seleccionados en PyQGIS para crear un plugin de QGIS 2 que permitiera generar las fronteras comunes como multipolilíneas. En éste se adaptó el código allí propuesto para que pudiese funcionar en QGIS 3 y generar un QDialog, con sus elementos Qt equivalentes, en una clase personalizada que se ejecuta desde la Python Console.

Cómo producir buffers, alrededor de puntos, con diferente número de lados en PyQGIS 3

En un post anterior se consideró la producción de buffers, alrededor de puntos, con diferente número de lados en la antigua versión de QGIS. En éste toca modificar el script allí propuesto para que pueda funcionar con PyQGIS 3. Las modificaciones incluyen un sólo punto con proyección EPSG 32612 y una distancia buffer de 1000 metros. Los métodos de clase ahora empleados y que han cambiado con respecto a la versión anterior corresponden a QgsGeometry, QgsPointXY y QgsQgsProject. El script propuesto se encuentra a continuación:

Clase plantilla con QDialog para usar segundo tab de un QTabWidget como contenedor de un QTableWidget para desplegar nombres de campos de capas vectoriales en QGIS 3

En el post anterior se propuso una clase plantilla con QDialog para usar objetos del tipo QTabWidget como contenedores de QTableWidget en QGIS 3. Se usó el primer tab para desplegar una tabla con n filas y 2 columnas; donde n corresponde al número de capas (vectoriales o ráster) que se encuentran visualizadas en el Map Canvas.

Clase plantilla con QDialog para usar objetos del tipo QTabWidget como contenedores de QTableWidget en QGIS 3

En el post anterior se propuso una clase plantilla con QDialog para crear objetos del tipo QTabWidget en QGIS 3. En éste se va a usar el primer tab como contenedor de un objeto QTableWidget. La tabla se va a desplegar con n filas y 2 columnas; donde n corresponde al número de capas (vectoriales o ráster) que se encuentran visualizadas en el Map Canvas. La primera columna ('Layer') desplegará el nombre de la capa y la segunda ('Layer type') el tipo de capa (vectorial o ráster). Si el número de capas varía una función conectará automáticamente para dar cuenta de estos cambios.

Clase plantilla con QDialog para crear objetos del tipo QTabWidget en QGIS 3

En este post se va a continuar con la clase plantilla con QDialog pero, en este caso, para crear objetos del tipo QTabWidget los cuales, a su vez, contienen tabs (objetos del tipo QWidgets). Estos últimos también pueden ser contenedores de objetos QLabel, QTableWidget, imágenes, etcetera. En el código a continuación se presenta un ejemplo sencillo de como implementar los QTabWidget con tres tabs pero sin que actuen como contenedores.

Clase plantilla con QDialog para crear círculos

En el post anterior se introdujo una Clase plantilla con QDialog para crear puntos (como memory layers) a partir de las coordenadas del Map Canvas de QGIS obtenidas con un click del ratón. En este post se van a aprovechar estas coordenadas para crear un buffer circular, dado el radio, que se pide a través de un QInputDialog que se genera en la misma función de creación del buffer circular.

Clase plantilla con QDialog para crear puntos

En el post anterior se introdujo una Clase plantilla con QDialog para visualizar las coordenadas del Map Canvas de QGIS con un click del ratón. En este post se va a aprovechar la generación de estas coordenadas para producir memory layers de puntos con una función especial conectada a un QPushButton.

Clase plantilla con QDialog para visualizar las coordenadas del Map Canvas de QGIS con un click del ratón

En posts anteriores (1, 2, 3) se hizo referencia a la obtención de las coordenadas del Map Canvas de QGIS con un click del ratón mediante la clase QgsMapToolEmitPoint de PyQGIS. En esta nueva entrega vamos a emplear la simplificación producto de la utilización de una clase plantilla con QDialog para el mismo fin.

Plantilla para visualizar elementos de un QDialog con PyQGIS

Aunque con la Python Console es posible visualizar de manera independiente muchos de los diferentes elementos Qt presentes en QGIS, con muy pocas líneas de código también se puede crear una clase "plantilla" para incluir varios de ellos y visualizarlos a todos de manera simultánea antes de crear un plugin. La clase Dlg que se va a proponer a continuación emplea un objeto QDialog al cual se le incorpora una QgsComboBox y una QListWidget.

Matriz de distancia con puntos en el orden correcto

Algunos algoritmos de QGIS, aunque funcionan, no producen los resultados esperados en cuanto a los índices espaciales. Es lo que se desprende de la utilización del algoritmo qgis:distancematrix de la Processing ToolBox en una pregunta de gis.stackexchange.com. Los azimuths determinados para el vecino más próximo no se encuentran asociados a los respectivos índices espaciales. Para resolver ese problema se propuso el script siguiente:

Creando un "buffer" en diferentes direcciones sin solapamiento con el shapefile inicial utilizando PyQGIS 3

En esta pregunta de gis.stackexchange.com se solicita una manera de generar una especie de "buffer" en diferentes direcciones sin solapar la capa inicial y combinando todos los rasgos producidos. Como la capa base es rectangular, dadas las distancias verticales y horizontales que representan "las diferentes direcciones", es sencillo determinar esos rasgos porque sólo hay que calcular dos puntos para genererar cada uno de los cuatro objetos QgsRectangle que se requieren.

Obtener las coordenadas de pantalla a partir de las coordenadas del Map Canvas en un plugin con PyQGIS 3

En el código que se presenta a continuación se pretende, cada vez que se lance un plugin para QGIS 3, que éste aparezca alineado con el vértice superior izquierdo de la View del Map Canvas. Esto corresponde a la posición de un QPoint(0,0). Por tanto, sólo se necesita el método 'mapToGlobal' de la clase QgsMapCanvas para convertirlo en un QPoint con las coordenadas de la pantalla.

Extraer el punto máximo de un ráster para una rejilla de 4x4 con los métodos de GDAL Python en QGIS 3

Esto puede realizarse con el método 'ReadAsArray' del módulo Python de GDAL empleando una ventana de 4x4 y almacenando cada punto donde ocurren los máximos en una memory layer. Para probar esta aproximación se creó un ráster de resolución de 0.5x0.5, con una amplitud (filas, columnas) de 20x20 y valores entre 1 y 1000 para evitar valores repetidos. El código desarrollado se expone a continuación y contiene varios print con propósito de corroboración.

Cómo rotar un ráster con el módulo python de GDAL/OGR

En este hilo de gis.stackexchange.com se refiere la necesidad de rotar un ráster 90 grados en sentido antihorario debido a que los productos de 3B43 TRMM Multisatellite Precipitation monthly están supuestamente rotados 90 grados en sentido horario. Asumiendo que esto es cierto, con la ayuda de un algoritmo encontrado aquí, se desarrolló el codigo siguiente para rotar el array 90 grados en sentido antihorario y luego producir el raśter con los métodos de GDAL.

Sumando rásteres que se solapan sólo en cierta extensión con rasterio

Cuando los rásteres no se solapan adecuadamente en toda su extensión no es posible hacer álgebra de mapas porque al estar almacenados los values en arrays de tipo matricial estas operaciones no pueden realizarse si las matrices no son conformes. Sin embargo, rasterio tiene disponible el método 'Window' que permite la lectura y escritura por ventanas de datos. Si se determina cuáles son las áreas coincidentes es posible hacer la lectura de los arrays en esas zonas específicas y aplicar sólo allí el álgebra de mapas.

Creando un ráster de distancia a la línea costera con PyQGIS 3 y GDAL/OGR

Con PyQGIS, cada centro de celda de un ráster puede ser calculado en un doble loop como un punto y, su distancia a la línea costera, evaluada mediante el método 'closestSegmentWithContext' de la clase QgsGeometry. Posteriormente, la librería GDAL puede ser usada para crear dicho ráster con estos valores de distancia en un array de filas x columnas.

Cómo acceder a los PyQt5.QtWidgets.QLineEdit de los Objetos QgsRasterHistogramWidget para colocar valores máximos y mínimos de capas ráster con PyQGIS 3

En un post anterior se utilizaron objetos de la clase QgsRasterHistogramWidget para obtener histogramas de capas ráster con PyQGIS 3. En las imágenes del widget obtenido por programación en PyQGIS se observa que los valores mínimos y máximos de cada banda (cuatro en total) no son tomados automáticamente por éste. Los espacios destinados a albergar dichos valores, probablemente unos objetos del tipo QLineEDit, permanecen siempre vacios.

Cómo hacer clipping de un ráster por rasgos individuales de un shapefile tipo polígono con GDAL/OGR en Python

En este post se incluye un procedimiento para hacer clipping de un ráster por rasgos individuales de un shapefile tipo polígono mediante los módulos Python de GDAL/OGR. La rutina introduce una proyección en las capas vectoriales de corte (que se eliminan al final de la rutina) e incluye la asignación de los nodata a -999 en las capas ráster (cuya proyección es tomada automáticamente del ráster base) dentro de la función gdal.Warp. El código completo es el siguiente:

Objetos QgsRasterHistogramWidget para obtener histogramas de capas ráster con PyQGIS 3

En la imagen siguiente se observa la generación de los histogramas de un ráster con 4 bandas (las tres RGB más el canal alfa) donde prácticamente no tienen utilidad porque las opciones por defecto, expresadas en el menú de preferencias, cargan simultáneamente todas las bandas y la alfa, con un sólo valor y una frecuencia muy alta, impide la visualización adecuada de las RGB.

Additional No Data Values en capas Raster con PyQGIS 3

Los No Data Values en las capas ráster se adicionan a través de los métodos de la clase QgsRasterDataProvider. Cuando se emplea sólo el método 'setNoDataValue', aunque la visualización en el Map Canvas es la correcta, no se agrega a la Map Legend y por tanto no se inicializa adecuadamente el histograma del ráster.

Cómo añadir un diagrama tipo pie (torta) a una capa vectorial con PyQGIS 3

En el post anterior se consideró la adición de un diagrama tipo histograma a una capa vectorial con PyQGIS 3. Como las clases QgsHistogramDiagram y QgsPieDiagram son equivalentes porque presentan los mismos 37 métodos, se vislumbró que la extrapolación del código del referido post anterior era directa mas no fue así. La razón fue un método de la clase QgsLinearlyInterpolatedDiagramRenderer que ha cambiado en PyQGIS 3.

Cómo añadir un diagrama (histograma) a una capa vectorial con PyQGIS 3

Investigando algunos aspectos relacionados con la generación de histogramas de capas ráster me encontré este post de gis.stackexchange.com donde refiere la manera de generar un histograma en capas vectoriales. Después de adaptarlo a PyQGIS 3 y eliminar todas las líneas que permiten trabajar sólo con los valores por defecto obtuve el código siguiente:

Proyectar la longitud de polígonos sobre segmentos de rectas con PyQGIS 3

Para proyectar la longitud de un polígono sobre una recta es necesario encontrar el ángulo que ésta mantiene con el eje X (será negativo si la pendiente es negativa), rotar cada rasgo ese ángulo con centro de rotación en el centroide, calcular la bounding box del rasgo rotado y, finalmente para comprobar los resultados, rotar la bounding box en sentido contrario por el mismo valor del ángulo (ángulo negativo) y con centro de rotación en el centroide del feature (no de la bounding box).

La situación que se va a probar se encuentra a continuación:

Convex Hull con QgsGeometry en PyQGIS 3 (sin Processing)

En el post anterior se determinó la oriented minimum bounding box utilizando el método disponible en la clase QgsGeometry. Una ligera manipulación de ese código permite, para el mismo vectorial, determinar la Convex Hull que puede simplificar las geometrías tipo polígono. El código se presenta a continuación:

Oriented minimum bounding box con QgsGeometry en PyQGIS 3 (sin Processing)

En el post anterior se determinó la oriented minimum bounding box utilizando el algoritmo correspondiente. No obstante, además de en Processing, el método está también disponible en la clase QgsGeometry. Empleando esta última se desarrolló el código siguiente:

Oriented minimum bounding box con PyQGIS 3

Las oriented minimum bounding box ya se encuentran disponibles como oferta en QGIS 3 a través de la ToolBox de Processing. Sin embargo, los inconvenientes a la hora de acceder a los archivos temporales o en memoria pueden hacernos pensar porqué no tener nuestra propia rutina de cálculo. El fundamento del algoritmo puede ser visualizado aquí.

Cómo pasar de Multi Part a Single Part utilizando PyQGIS 3

En un post anterior se consideró este aspecto con PyQGIS 2. Hoy lo planteamos de nuevo con PyQGIS 3 porque QGIS 3 considera y graba por defecto las geometrías como multiparte (ahora denominadas collect geometries) y esto ha hecho que algunos métodos de PyQGIS 2 no sean útiles en PyQGIS 3 haciendo más complejo el tratamiento de las geometrías; especialmente las de los polígonos (listas de listas). Si han sido trabajadas con QGIS 3 son multipartes así presenten un sólo rasgo. Por esta razón se recomienda, en lo posible, trabajar con los formatos WKT (Well Known Text).

Determinando ángulos de rotación de polígonos con base en segmentos rectos de referencia

En los dos posts anteriores se consideraron la rotación de rasgos de una capa vectorial (a partir de un punto de rotación), en sentido horario, un angulo determinado y la obtención de la bounding box del vectorial rotado. El ángulo no era arbitrario porque se determinó con base en una recta de referencia con sólo dos puntos. El objetivo de ello era encontrar la longitud proyectada del polígono sobre las líneas de referencia.

Utilizando "boundingboxes" en PyQGIS 3 Processing

En el post anterior se consideró la rotación de rasgos de una capa vectorial, en sentido horario, un angulo determinado a partir de un punto de rotación; que si no se especifica se toma como el centroide por defecto. El ángulo no era arbitrario. Su valor corresponde a aquel que la recta de la figura siguiente mantiene con el eje X.

Utilizando "native:rotatefeatures" en PyQGIS 3 Processing

A medida que ha ido avanzando el desarrollo de QGIS 3 a través de sus diferentes versiones (ya vamos por la 8), es cada vez más sencillo programar con PyQGIS porque existen más algoritmos disponibles en las herramientas de la Processing Toolbox. Hoy vamos a considerar el algoritmo "native:rotatefeatures" que permite rotar rasgos de una capa vectorial, en sentido horario, un angulo determinado a partir de un punto de rotación; que si no se especifica se toma como el centroide por defecto.

Cómo rasterizar rasgos individuales de un shapefile tipo polígono con GDAL/OGR en Python

En este post se incluye un procedimiento para rasterizar rasgos individuales de un shapefile tipo polígono mediante los módulos Python de GDAL/OGR. La rutina introduce una proyección, tanto en las capas vectoriales como en las ráster, e incluye la asignación de los nodata a cero en las capas ráster.

Crear un shapefile tipo polilínea mediante la librería pyshp

En esta entrada se va a considerar la creación de un shapefile tipo polilínea mediante la librería pyshp. Los valores a ser introducidos en la tabla de atributos se van a leer desde una hoja de cálculo xls que refleja la creación de un campo de nombre code en el shapefile con sólo dos rasgos.

Crear polígono regular de área específica, a partir de puntos, con PyQGIS 3

La creación de polígonos ya ha sido tratada en Cómo producir buffers, alrededor de puntos, con diferentes números de lados en PyQGIS para la versión anterior de QGIS. Sin embargo, el criterio empleado allí fue el de la distancia buffer, es decir, desde el centro a cualquiera de sus vértices.

Creando buffers rectangulares alrededor de puntos con PyQGIS 3

En un post anterior se consideró el mismo tema con la versión previa de QGIS. No obstante, la portabilidad del código allí propuesto a PyQGIS 3 no resulta muy laboriosa y se incluye a continuación:

Ejecutar la Processing tool UI en PyGIS 2 y 3

En esta pregunta de gis.stackexchange.com se responde la manera de ejecutar la Processing tool UI en PyGIS 2 y en esta otra en PyQGIS 3. Para ejemplificar cómo funciona, ya que el segundo caso adolece del código completo, se va a probar con el procedimiento del post anterior.

Determinando polygon self-intersection con PyQGIS 3

Las self-intersection en polígonos pueden ser determinadas en PyQGIS con el método "saga:polygonselfintersection" que se encuentra en la Processing Tool Box. Es equivalente a la 'unary_union' del módulo python shapely.ops que se encuentra descrito aquí. Para probar el procedimiento se usó el shapefile de la imagen siguiente:

Cómo obtener la señal cuando cambia el renderizado con PyQGIS 3

Aunque el renderizado se asocia generalmente a una capa vectorial o ráster, como el método 'renderComplete' pertenece a la clase QgsMapCanvas sólo basta con cambiar las dimensiones de la Map View de QGIS, sin tener cargada ninguna capa, para que se produzca una conexión al slot mediante el método previamente señalado. Ésto puede ser ejemplificado con el código que se presenta a continuación:

Otras funciones de edición de capas vectoriales de QgsVectorLayerTools en PyQGIS 3

Los métodos para el inicio y finalización de la edición de capas vectoriales, 'startEditing' y 'commitChanges', se encuentran en la clase QgsVectorLayer. Sin embargo, métodos que realizan lo mismo pueden ser invocados a través de la clase QgsVectorLayerTools. No obstante, esta última es una clase compleja de C++ que tiene que ser instanciada de manera diferente a lo usual.

Añadiendo nuevo campo con rumbos (bearings), en grados, minutos y segundos, mediante PyQGIS 3

En el post anterior se trató un tema similar pero con la versión anterior de QGIS. No obstante, el código allí presentado no funciona en QGIS 3 a menos que realicemos algunas pocas modificaciones que incluimos en el script a continuación:

Añadiendo nuevo campo con rumbos (bearings), en grados, minutos y segundos, mediante PyQGIS

En este post se va desarrollar un script que permite crear y actualizar en tiempo de ejecución el campo de un vectorial tipo línea que contendrá el rumbo (grados, minutos y segundos) de los segmentos de recta que constituyen sus rasgos (features). El script es el siguiente:

QgisFeatureRequest para ordenamiento múltiple de rasgos en PyQGIS 3

La clase QgisFeatureRequest puede usarse para seleccionar rasgos ordenados por varios campos. En este post se va a considerar el shapefile de la imagen siguiente para realizar un ordenamiento por dos de sus campos: 'Circuit' y 'area'. Para corroborar que el ordenamiento se realiza según lo previsto se imprimen en la Python Console los ids de los rasgos seguidos de los valores correspondientes a los campos 'Circuit' y 'area'. Aunque posible, no se produce la memory layer con los features ordenados por ambos campos.

Adaptación de un plugin, de QGIS 2 a QGIS 3, para desplegar ráster values como tooltip

Una reserva que impide cambiar rápidamente desde QGIS 2 a QGIS 3 es la imposibilidad de adaptar en un tiempo perentorio todas aquellas aplicaciones, especialmente los plugin, que se han elaborado con Python 2. Hasta ahora, según mi experiencia, los desarrolladores de QGI3 han preservado prácticamente intactas la mayoría de las clases y, aunque numerosos, los cambios son proporcionalmente menores a lo que cabría esperar.

Cómo colocar un plugin "Always On Top" en QGIS 3

En versiones anteriores de QGIS el comportamiento por defecto era mantener el plugin "Always On Top" pero esta situación cambió en la versión 3 de QGIS. Para algunos plugins que se desarrollan puede ser indiferente este comportamiento. Sin embargo, para aquellos que dependen de obtener información mediante un click del ratón en el Map Canvas era tedioso mantenerlo "On Top" haciendo click en el QDialog del plugin minimizado en la barra inferior del escritorio cada vez que se producía el referido click.

Uso de la clase QgsMapToolIdentifyFeature para obtener los atributos de un archivo vectorial y resaltarlos mediante objetos de la clase QgsRubberBand

La clase QgsMapToolIdentifyFeature permite, mediante un click del ratón, obtener información acerca de los rasgos de un archivo vectorial y mediante objetos de la clase QgsRubberBand se puede resaltar la selección para hacerla reconocible y más atractiva visualmente. No obstante, las rubber band tienen que ser removidas adecuadamente mediante código porque sino persisten en el Map Canvas y es imposible eliminarlas si se pierde la referencia a ellas teniendo que reiniciar QGIS.

Reproyección punto a punto de un archivo vectorial con PyQGIS 3

En un post previo se consideró una forma de reproyectar un shapefile tipo polígono utilizando la versión 2 de PyQGIS. En éste, se va a modificar el código allí descrito para que pueda correr en PyQGIS 3 y, además, incluir todos los features del referido archivo vectorial.

Selección avanzada de rasgos con objetos de QgsExpression en PyQGIS 3

En el post anterior se trató el tópico relativo a la selección avanzada de rasgos con objetos de QgsFeatureRequest en PyQGIS 3. Allí, para la selección de rasgos, al método 'getFeatures' se le pasaba como argumento un objeto de la clase QgsFeatureRequest con base en un string (unicode) con sintaxis tipo SQL y relacionada a los campos de atributos. Otra forma de realizar la selección de rasgos es transformar el string en un objeto de la clase QgsExpression y verificar para cada rasgo, mediante su método 'evaluate', si se cumple la condición tipo SQL. Esto produce un código más conciso; tal como se presenta a continuación:

Selección avanzada de rasgos con objetos de QgsFeatureRequest en PyQGIS 3

El método 'getFeatures' de QgsVectorLayer también admite como argumento un objeto de la clase QgsFeatureRequest sobre el cual se le puede pasar un string (unicode) con una consulta o requerimiento tipo SQL con base en los campos de atributos. Esto permitirá seleccionar solo aquellos rasgos que satisfagan el requerimiento.

Dividir vectoriales tipo línea con puntos mediante algoritmo basado en azimuths con inserción directa del punto de corte en la posición correspondiente

En un post anterior desarrollé un procedimiento para dividir vectoriales tipo línea con puntos mediante un algoritmo basado en azimuths e índices de todos los puntos sin inserción directa de los puntos de corte en la lista final. Aunque funciona de la manera esperada tratando de adaptarlo al lenguaje R me di cuenta que el algoritmo tiene un bucle innecesario y es demasiado complejo para una adaptación expedita.

Cómo usar GDAL para leer archivos GRIB en Python y determinar la estadística de las bandas

GRIB (GRIdded Binary o General Regularly-distributed Information in Binary form) es un formato ráster soportado por GDAL el cual es comunmente usado en metereología para almacenar datos históricos o de pronóstico del clima. Este tipo de formato es visualizado por QGIS; tal como se observa en la imagen siguiente:

Obtener coordenadas del movimiento del ratón mediante una clase personalizada en PyQGIS en un plugin de QGIS 3

En un post anterior se consideró la forma de obtener las coordenadas del Map Canvas mediante un click del ratón utilizando una clase personalizada en PyQGIS. Este procedimiento fue conducido a través de la Python Console. Sin embargo, en un plugin hay que saber ubicar la clase dentro del plugin y modificar los parámetros de entrada para que en lugar de imprimir a la Python Console lo haga, por ejemplo, en un elemento Qt como una QTextBrowser.

Manejando píxeles con solapamiento parcial para realizar estadística zonal con PyQGIS en QGIS 3

El manejo de píxeles con solapamiento parcial para realizar estadística zonal robusta con PyQGIS ya había sido tratado en esta pregunta de https://gis.stackexchange.com. No obstante, el planteamiento en ésta otra es algo diferente pero el código puede adaptarse para satisfacer el requerimiento. Se presenta a continuación:

Utilizando gdal:translate (PyQGIS Processing) para convertir values a nodata en QGIS 3

En un post anterior se usó el comando de PyQGIS Processing gdalogr:translate para convertir values a nodata en la versión previa de QGIS. No obstante, el nombre del comando cambió en QGIS 3 (ahora se denomina gdal:translate) y el número de parámetros también se redujo considerablemente. Estos pueden averiguarse con processing.algorithmHelp('gdal:translate') y la salida del comando se presenta a continuación:

Utilizando grass7:v.voronoi en PyQGIS 3 Processing

En un post anterior se consideró un tema similar para la versión previa de QGIS 3 y GRASS 6. La forma elegida de pasarle los parámetros es mediante un diccionario que premite, como ya se ha señalado con anterioridad, prescindir del orden y de los que no son mandatorios.

Usando Processing qgis:creategrid en QGIS 3 (Linux)

En un post anterior ya se probó este método con la versión previa de QGIS y en QGIS 2.99 uno similar (qgis:creategridpolygon) que no sobrevivió a la versión actual 3.0.0. Los parámetros a ser introducidos en este caso, averiguados con processing.algorithmHelp('qgis:creategrid'), son los siguientes:

Dividir vectoriales tipo línea en partes de igual longitud mediante algoritmo basado en azimuths con PyQGIS 3

En un post anterior se consideró la división de vectoriales tipo línea en partes iguales mediante un algoritmo basado en azimuths. Sin embargo, se usaron módulos third party como fiona que son difíciles de instalar en Windows y ahora, para que funcione sin problemas en QGIS 3 para este sistema operativo, he de adaptarlo completamente a PyQGIS.

Dividir vectoriales tipo línea con puntos mediante algoritmo basado en azimuths con PyQGIS 3

En un post anterior se implementó un código para dividir vectoriales tipo línea con puntos mediante un algoritmo basado en azimuths. El referido código fue creado en Linux con fiona. Este módulo es difícil de instalar en Windows 7, al igual que GeoPandas, debido a la necesidad de compiladores C++ específicos para la configuración de nuestro sistema (ahora difíciles de encontrar porque ya prácticamente no tienen soporte sino se usa Windows 10). Como estoy probando QGIS 3 en este Windows voy a utilizar mucho más código PyQGIS prescindiendo, en lo posible, de los módulos third party.

Cómo conectar una QComboBox para actualizar adecuadamente las capas en un plugin con QGIS 3

En un post anterior se trataba el mismo tema para la versión anterior de QGIS. Empleaba la clase QgsLegendInterface que actualmente fue removida en QGIS 3. Este documento señala que la remoción fue realizada en favor de la clase QgsLayerTreeNode y otras no especifícadas.

Método 'writeAsVectorFormat' de QgsVectorFileWriter en QGIS 3

En este post me toca referir el método 'writeAsVectorFormat' de QgsVectorFileWriter debido a que en la adaptación de un plugin se produjo un error en este método debido a que se estaban pasando los parámetros en el orden equivocado. La sintaxis considerada era prácticamente idéntica a la que se encontraba ejemplificada en el PyQGIS Cookbook de la versión 2.x porque, como verifiqué que la clase existía en QGIS 3, asumí erróneamente que los parámetros podrían ser los mismos.

Memory layers de polígonos en PyQGIS3

La inclusión de la clase QgsPointXY ha impuesto nuevos métodos en QgsGeometry y a la que más ha afectado a la hora de hacer funcionar el código es a las geometrías tipo polígono. Esto es así, en mi caso, porque he implementado mis propios procedimientos para rotar y mover geometrías (para comprender mejor las operaciones) en lugar de usar las propias clases de PyQGIS para estos procedimientos; donde los formatos WKT son los que traerían los menores problemas en lugar de las listas de puntos.

Rasgos (features) en el orden en el cual son seleccionados mediante PyQGIS3

En esta pregunta de gis.stackexchange.com se plantea cómo almacenar en una variable externa a la función los valores de id correspondientes a los rasgos (features) que han sido seleccionados y en el orden estricto de su selección. Este requerimiento se basa en el hecho de que si se seleccionan todos los rasgos en un orden determinado y se imprimen sus ids la lista de valores corresponde, contrariamente a lo esperado, al orden en que fueron digitalizados.

Memory layers de líneas en PyQGIS3

A diferencia de las memory layers de puntos que se consideraron en el post anterior, el código que había sido probado en la version 2 de QGIS para las memory layers de líneas corrió, sorprendentemente sin cambios, en la versión 3. Se presenta a continuación:

Memory layers de puntos en PyQGIS 3

Después de estar luchando con la adaptación de un plugin, desde QGIS2 a QGIS3, para rotar rasgos de diferente geometría y no tener éxito me dije: "vamos a simplificarlo al máximo y a ejecutar como paso previo en la Python Console la creación de una simple capa de puntos como memory layer". Del análisis de los errores me di cuenta que ahora existe una nueva clase, QgsPointXY, que aunque admite operaciones de geometría sus objetos no son geometrías como los QgsPoint. Asumo que esta decisión tiene como finalidad fomentar el uso de los formatos WKT; más manejables a la hora de considerar geometrías.

Plugin para extraer tiles georreferenciados de alta resolución con Google Satellite y PyQGIS3

En un post anterior se introdujo un procedimiento para conectarse al servicio de Google Satellite (que incluía la nueva versión de QGIS3), grabar una imagen de alta resolución del Map Canvas y, posteriormente, georreferenciarla de forma adecuada mediante gdal_translate.

Plugin para producir rásteres con valores enteros aleatorios en QGIS 3

En la versión anterior de QGIS se produjo un complemento (plugin) que permitía producir rásteres con valores enteros aleatorios y cuyo algoritmo se basaba en este post. Ésto es muy útil porque permite obtener pequeños rásteres, alineados con un ráster base, donde los cambios de sus valores enteros, producto de diferentes operaciones, pueden ser fácilmente corroborados.

QgsMapLayerComboBox con filtros en QGIS 3

En el post anterior se consideró la inclusión de objetos Qt del tipo QFileDialog porque hasta ese momento había comprobado que era uno de los que tenía los mayores cambios para la migración a la nueva versión de QGIS 3. En el post actual voy a considerar las QgsMapLayerComboBox con filtros.

QFileDialog del tipo 'getSaveFileName' en un plugin con PyQGIS3

En estos primeros días de trabajo con PyQGIS3 se ha podido comprobar que si no se asume una estrategia de "divide y vencerás" tendremos problemas en la migración de nuestros viejos plugins a la nueva versión de QGIS. La adaptación del código Python puro y de las clases de QGIS no reviste tanta dificultad como la relacionada a los elementos PyQt; los cuales abordaremos a continuación.

Compilando recursos para PyQGIS3 mediante pyrcc4

En un post precedente referí la imposibilidad de compilar los recursos para PyQGIS3 en Windows porque la utilidad pyrcc5 no estaba disponible. Esto me llevó a hacerlo desde Linux.

Creando buffers cuadrados alrededor de puntos con PyQGIS3

Este es un tópico que ya sido considerado aquí pero con la versión anterior de QGIS. Lo rescato en este momento para que se observe que no toda la transición a la nueva versión es difícil. El único cambio en el código señala que la clase QgsMapLayerRegistry ha sido eliminada y sus prestaciones incluidas en QgsProject.

Primer plugin funcional en QGIS3

Como es bien sabido por los usuarios de QGIS, el viernes 23/02/2018 fue liberada la versión 3 (Girona). No obstante, sólo ayer 25/02/2018 estuvo disponible para ser bajada de los servidores para el sistema operativo Windows.

Moviendo bounding box de imagen, basada en el centroide, hasta la posición contigua con PyQGIS

En post anteriores (1, 2) se consideró la conexión al servicio de Google Satellite y la automatización en un plugin con el fin de obtener tiles de alta resolución georreferenciados. En este post se tratará uno de los algoritmos para que ello fuese posible.

Plugin de QGIS para extraer tiles georreferenciados de alta resolución con Google Satellite

En el post anterior se introdujo un procedimiento para conectarse al servicio de Google Satellite, grabar una imagen de alta resolución del Map Canvas y, posteriormente, georreferenciarla de forma adecuada mediante gdal_translate.

Añadiendo Google Maps Satellite Service con PyQGIS

Añadir el servicio de Google Maps Satellite a través de código PyQGIS es muy sencillo; tal como se evidencia a continuación. Los detalles de la conexión pueden visualizarlos en este link.

Espesor mínimo de un polígono no convexo con agujeros mediante PyQGIS

En este hilo de gis.stackexchange.com se consideran, aparentemente sin éxito o con un tiempo de cómputo excesivamente largo, diferentes procedimientos para determinar el espesor mínimo de un polígono no convexo con agujeros.

Introducción de objetos tipo polígono (círculos, cuadrados, rectángulos) y texto en imágenes con OpenCV

En este artículo se adaptó un código para incrementar el contraste de una imagen RGB y mejorar su nitidez. Se tiene en mente como objetivo la posibilidad de identificar objetos de una misma clase y contarlos (tales como plantas de cultivo).

Cómo manipular objetos QgsScaleComboBox con PyQGIS

En esta pregunta de gis.stackexchange.com se refiere un comportamiento extraño de los objetos del tipo QgsScaleComboBox en el sentido de que las escalas supuestamente añadidas no podían ser seleccionadas.

Reordenar rasgos en un vectorial de línea mediante PyQGIS

El vectorial de línea de la imagen siguiente es de partes sencillas (singleparts) con la particularidad de que sus rasgos, de izquierda a derecha y en orden ascendente, no están ordenados secuencialmente como se espera. Esta falta de secuencia puede producir errores a la hora de ejecutar ciertas consultas o algoritmos.

Tratamiento de imágenes con openCV en Python

El post anterior incluye una referencia de la cual adapté el procedimiento para obtener los subarrays a los cuales allí se hacía mención y cuya temática principal era el tratamiento de imágenes.

El artículo referencia tenía como objetivo entender el significado y la aplicación de la convolución de imágenes para difuminarlas, incrementar su contraste o delimitar bordes a través de la aplicación de diferentes filtros que allí se denominaban kernels empleando OpenCV con Python.

Cómo acceder a los subarrays de píxeles vecinos, en bloques 5x5, mediante el módulo cv2 de OpenCV

OpenCV es una biblioteca libre de visión artificial originalmente desarrollada por Intel. Se ha utilizado en infinidad de aplicaciones que abarcan desde sistemas de seguridad con detección de movimiento, aplicaciones de control de procesos donde se requiere reconocimiento de objetos y, por qué no, análisis de imágenes en el campo SIG.

En un post anterior se usó ndimage, del módulo python scipy, para acceder a subarrays de bloques 3x3. Sin embargo, con el módulo cv2 de OpenCV y numpy el procedimiento es más directo.

Determinando área superficial a partir de un DEM con Python mediante el gradiente de la pendiente (Slope Gradient)

En esta referencia también existe una descripción para aproximar el área superficial, por píxel, de un ráster DEM mediante el gradiente de la pendiente (Slope Gradient). También está basada en la extracción de todos los valores de elevación para una ventana 3x3 para cada píxel para así determinar las áreas 3D de los 8 rectángulos resultantes.

Esto puede observarse con algo más de detalle (vista cenital) en la imagen siguiente:

Determinando área superficial a partir de un DEM con Python mediante el procedimiento SHR (surface to horizontal area ratio)

En esta referencia existe una descripción más o menos pormenorizada de cómo aproximar el área superficial, por píxel, de un ráster DEM mediante el procedimiento SHR (surface to horizontal area ratio). Esta basado en la extracción de todos los valores de elevación para una ventana 3x3 para cada píxel y así determinar las áreas 3D de los 8 triángulos resultantes.

Esto puede observarse con más detalle (vista cenital) en la imagen siguiente:

Reproyectando y guardando un shapefile tipo polígono con GDAL/OGR

El codigo siguiente corrige los problemas de ejecución que presenta este otro para reproyectar un shapefile con base en el sistema de referencia espacial que es tomado de un ráster.

Cómo dividir una línea mediante método 'splitFeatures' de QgsVectorlayer con PyQGIS

El método 'splitFeatures' de QgsVectorLayer usa una lista de QgsPoint de una línea de corte para dividir, por ejemplo, otra línea. La división se hará en el punto de intersección de ambas. Para probarlo se utilizarán las capas que se visualizan en la imagen siguiente:

Usando getFeatureForm de QgisInterface (iface) en PyQGIS

En QGIS existen varias formas prediseñadas que pueden ser invocadas con código PyQGIS. Una de ellas es la que se utiliza para obtener rasgos (features) y se se llama mediante el método 'getFeatureForm' de QgisInterface (iface). Corresponde a un objeto del tipo QgsAttributeDialog al cual se le pasan como parámetros la capa vectorial y el rasgo que se desee explorar.

Empleando Processing gdal:cliprasterbymasklayer en QGIS 2.99

Para finalizar esta visión exploratoria de Processing en QGIS 2.99 voy a seleccionar gdal:cliprasterbymasklayer porque no aparece en la oferta de algoritmos de Processing invocadas con:

Usando Processing qgis:intersection en QGIS 2.99 (Windows)

Siguiendo con las pruebas en QGIS 2.99 con Windows hoy le toca el turno a Processing qgis:intersection. Escogí esta herramienta porque tenía unos parámetros (INPUT_FIELDS y OVERLAY_FIELDS) novedosos para mi que imaginé se pasaban como lista y así fue.

El conjunto completo de parámetros a usar es el siguiente:

Usando Processing qgis:creategridpolygon en QGIS 2.99 (Windows)

En post anteriores he estado haciendo pruebas con la versión preliminar 2.99 de QGIS en Windows antes de que salga la versión definitiva (supuestamente casi exenta de errores) 3.0.0. He podido comprobar, por ahora, que no está suficientemente madura como para la producción de plugins. Sin embargo, se pueden probar por separado los algoritmos que estarán dentro de los futuros plugins una vez se resuelvan los problemas de estabilidad.

Creando plugin para capturar coordenadas del Map Canvas con un click del ratón en QGIS 2.99

En un post anterior se publicó el procedimiento completo para crear un plugin que permitía capturar, en unidades de mapa, las coordenadas del Map Canvas con un click del ratón en QGIS 2.x. En este se va a explorar la factibilidad de hacer lo mismo en QGIS 2.99 (para Windows); a pocas semanas de la liberación definitiva de QGIS 3.0.0.

Usando algunas funcionalidades de PyQGIS en QGIS 3 (2.99) para Windows

Como es del conocimiento general y si se cumple la hoja de ruta, el próximo 18 de diciembre será el lanzamiento de QGIS 3.0.0. Para adelantarme a este acontecimiento y saber a que atenerme en el futuro con relación a PyQGIS, bajé e instalé la versión actual de QGIS 2.99 para Windows.

Ya había leido al respecto de que los cambios son numerosos y el reto es ahora afrontarlos. Con relación a la transición de Python 2.7.x a Python 3.0.x algunas cosas he hecho en este Blog y probablemente allí no radicará la dificultad.

Moviendo geometría con Python shapely

El código siguiente usa el método 'translate', de shapely.affinity, para mover una geometría que está solapando dos linestrings (ver imagen siguiente) desde init_point hasta final_point; ambos especificados en el código.

Crear ruta de mínimo costo con GDAL/Python

En la documentación de Python GDAL/OGR Cookbook 1.0 existe un procedimiento para crear una ruta de mínimo costo empleando un ráster DEM. Para reutilizar el código me propuse probarlo con mi propio DEM y dos puntos arbitrarios; tal como se presentan en la imagen siguiente:

Estadística zonal robusta con PyQGIS

Uno de los problemas con las herramientas de estadística zonal que vienen generalmente incorporadas con los SIGs es que producen resultados aproximados cuando los rasgos (features) son mucho menores que las celdas del ráster. Esto se debe a que se pueden solapar hasta 4 de ellas, con diferente grado, y no lo ponderan sino que tienden a considerar el de mayor proporción ignorando los otros.

Esto hace que la estadística no sea robusta y se procuren métodos con ejecución de código personalizado para solventar este problema.

Cómo reclasificar un ráster basado en cuantiles y descartando los no data values con Python

En el código siguiente los nodata values del array de un ráster se convierten en valores NaN (Not a Number) para aprovechar el método 'nanpercentile' de numpy que permite determinar estos estadísticos fácilmente excluyendo estos valores (algo que no se produce con 'percentile' y los nodata values).

Comparando datos en una matriz con Python

En esta pregunta de stackoverflow.com se requiere asistencia para comparar datos en una matriz con Python con el fin de seleccionar los rasgos comunes a las letras del abecedario. Para ello se puede hacer uso de un diccionario para asignar el código correspondiente al rasgo común.

Rasterizando con el modulo GDAL/OGR de Python modificando el valor por defecto para los nodata values

En el post anterior se consideró la rasterización de capas vectoriales, con uno o varios rasgos, donde el valor por defecto más allá de éstos era cero. Para modificarlo hay que emplear el método 'Fill' del módulo gdal y posteriormente el método 'SetNoDataValue' para fijar los nodata values.

El código a continuación emplea estos aspectos.

Rasterizando con el modulo GDAL/OGR de Python

Con el módulo GDAL/OGR es posible acceder a una herramienta para rasterizar capas vectoriales y usarlas como máscaras ráster. El código que se facilita a continuación permite realizar este proceso dándole al rasgo rasterizado el valor constante de uno.

Generando elipse con sus ecuaciones paramétricas y PyQGIS

En un post anterior se generaron buffers empleando las ecuaciones parámetricas de la circunferencia. Las de la elipse son muy similares y basta una pequeña modificación en el código, tal como se muestra a continuación, para producir estas curvas cerradas y sus respectivos polígonos.

Cómo configurar un QFileDialog en un plugin de QGIS para que sólo solicite el directorio

En un post anterior se implementó un QFileDialog con QtDesigner para QGIS. Éste permitía solicitar el nombre del archivo con el cual se deseaba grabar nuestro resultado. Sin embargo, cuando se tiene un lote de archivos o un directorio lo adecuado es que solicite un directorio completo.

Cómo poblar una QTableWidget con items en PyQGIS

Las QTableWidget son objetos Qt que pueden ser incorporados fácilmente en los Dialog a través del QtDesigner. Una vez añadidas restaría añadirles funcionalidad permitiendo que las filas y columnas de éstas sean llenadas con información útil.

En el caso que se tratará aquí se tiene pensado añadir una QTableWidget empotrada dentro de una QTabWidget para desplegar el nombre y el tipo de capas que se encuentran en la interface de legendas de QGIS.

Generando buffer con ecuaciones paramétricas de la circunferencia y PyQGIS

En el artículo anterior se consideró como un ejercicio de programación la generación de un buffer empleando las ecuaciones cartesianas de la circunferencia. En este se van a emplear las ecuaciones paramétricas más que todo para ver que nos estamos "perdiendo" a la hora de usar las aplicaciones ya disponibles en los SIGs.

El código completo se encuentra a continuación:

Generando buffer "cartesiano" con PyQGIS

La circunferencia es el lugar geométrico de los puntos de un plano que equidistan de otro punto fijo llamado centro. Su ecuación general, en coordenadas cartesianas, puede ser encontrada aquí.

A partir de la referida ecuación puede despejarse "y" como función de "x" para luego generar diferentes valores de "x", igualmente espaciados, y determinar cuales serían sus correspondientes valores de "y".

Cómo recuperar puntos rasterizados con el orden como value y construir una bounding box orientada

En la imagen a continuación se tienen unos puntos rasterizados con una resolución 10x10 donde como value se ha incorporado el orden de los puntos. El objetivo es vectorizar nuevamente esos puntos, en el orden correcto, para contruir con ellos una bounding box orientada.

Para ello se va a emplear una mezcla de procedimientos de GDAL/OGR y PyQGIS.

Reproyectando un ráster con processing gdalogr:warpreproject

Una forma expedita de reproyectar un ráster con PyQGIS es mediante la herramienta gdalogr:warpreproject de Processing.

La información sobre los parámetros a ser empleados se encuentran en la imagen siguiente:

Suma de rásteres con pygeoprocessing evitando la generación de nodata values

Generalmente, cuando se utiliza cualquier versión de Raster Calculator (processing, pygeoprocessing, etc) proveniente del software libre uno de los requerimientos es que los rásteres tengan la misma resolución y estén perfectamente alineados.

Cuando se piensa en comenzar una rutina de trabajo con la rasterización de un vectorial como máscara, la limitación que se tiene es que, a pesar de tener control sobre la resolución, los rásteres resultantes no estarán alineados entre si para diferentes features y se producen nodata values que dificultan el álgebra de mapas en aquellas regiones donde aparecen.

Extrayendo valores ráster dentro de shapefile con pygeoprocessing, gdal, shapely y fiona

El módulo "third party" pygeoprocessing de python facilita algunas funciones que pueden realizarse con GDAL e internamente emplea fiona y shapely por lo que si logran instalarlo sin problemas mediante pip tendrán acceso también a estos módulos.

Lo que si he podido detectar es que no tengo acceso a muchos de los métodos descritos en el manual por lo que sospecho que ha sido pensado más bien para Python 3 o debo forzar la instalación de la última versión con pip en Python 2.7.

Cómo desactivar el Dialog de introducción de valores de atributos mediante PyQGIS

Cuando estamos digitando una capa y necesitamos apremio en la introducción de los puntos, nodos o vértices, se nos presenta un Dialog de introducción de valores de atributos en el que necesariamente debemos hacer click en OK para que estos se añadan a la capa; lo cual enlentece el proceso. Si no se rellena la forma y se hace click en OK los valores serán NULL y pueden ser editados posteriormente.

Para desactivar este comportamiento mediante PyQGIS es necesario recurrir al siguiente par de intrucciones en la Python Console de QGIS:

Usando pygeoprocessing.geoprocessing.raster_calculator

El módulo pygeoprocessing de python tiene la opción de códificar una herramienta de cálculo ráster (raster_calculator) de una manera mucho más amigable que la de PyQGIS y equiparable a las de Processing. Como es "third part" puede instalarse con pip o easy_install.

Si importan el módulo en la Python Console (ver código siguiente), un help(geop.raster_calculator) les dará información detallada acerca de los parámetros a usar.

Cómo conectar una QComboBox para actualizar adecuadamente las capas mediante PyQGIS en un plugin

La actualización automática de las capas (vectoriales o ráster) en objetos del tipo Combo Box ("persiana desplegable") puede realizarse con objetos del tipo QgsMapLayerComboBox en PyQGIS. Sin embargo, siempre existe aquel que quiere hacerlo todo desde cero empleando los precursores Qt denominados QComboBox.

En este caso, cada vez que se detecta una situación o un cambio en el número de capas en el Map Canvas, el registro o en la interface de leyendas debería conectarse al slot (función) para que la QComboBox se actualice debidamente.

Cómo detectar solapamiento en conjunto de glóbulos de apariencia circular

La necesidad de esta tarea surge de una pregunta realizada en el site de gis.stackexchange.com referida a una imagen. La imagen es binaria y, por tanto, fácilmente vectorizable.

Los vectores obtenidos serían cuerpos globulares, de apariencia cuasi circular, aislados o agrupados; en estos últimos con evidencia de solapamiento. Por tanto, la pregunta que surge es cómo detectar solapamiento en los grupos de glóbulos.

Cómo calcular la diferencia máxima en elevación entre un punto y las direcciones cardinales a su alrededor

El código que se presenta a continuación permite determinar la diferencia en elevación entre un punto y las direcciones cardinales a su alrededor. Inicialmente, emplea un método de numpy para generar puntos correspondientes a un polígono de ocho lados alrededor de cada punto original y luego agruparlos por pares para producir cada dirección cardinal como memory layer.

Posteriomente, cada dirección cardinal es interpolada por el tamaño de la resolución del ráster y cada punto es usado para obtener los raster values a lo largo de las referidas direcciones para finalmente seleccionar la del valor máximo con su índice respectivo.

Cómo acceder a los subarrays de píxeles vecinos, en bloques 3x3, mediante ndimage del módulo scipy

En un artículo anterior se hizo mención a una manera expedita para determinar la estadística de píxeles vecinos, en bloques 3x3, mediante ndimage del módulo scipy. En este post se va a considerar dos maneras de acceder a los subarrays que permitieron determinar tales estadísticas.

Como puede observarse en la documentación de ndimage.generic_filter, el segundo parámetro es una función que puede ser invocada externamente. Desde allí se se puede acceder a los valores individuales de cada subarray e imprimirlos a un archivo de texto en disco para ser usados más adelante en el código principal. Sería la primera manera.

Campos múltiples con qgis:fieldcalculator de PyQGIS Proccessing

La generación múltiple de campos es posible a través de qgis:fieldcalculator de PyQGIS Processing; donde las opciones de los parámetros pueden incluirse como una plantilla en un diccionario. A continuación, se presentan cuáles son las referidas opciones en la imagen siguiente:

Determinación de la sinuosidad de una línea con PyQGIS Processing

La sinuosidad de una línea se define como el cociente de su distancia total y la distancia euclidiana entre su punto de comienzo y su punto final; tal como se ejemplifica aquí. En el link anterior también se señala como soslayar el inconveniente de acceder al resultado de un commando de GRASS (v.to.db; option=sinuous), imposible directamente a través de Processing, pero si a través del 'fieldcalculator' de QGIS (y por ende de PyQGIS Processing).

El código que se presenta a continuación fue ligeramente modificado para permitir la carga directa de la capa resultante en un sólo paso mediante el método 'runandload'.

Estadística de píxeles vecinos, en bloques 3x3, mediante ndimage del módulo scipy

Cuando se requiere determinar las estadísticas de píxeles vecinos en un ráster, el efecto a considerar cuando se recorre cada uno de los píxeles es el de borde. En los bordes, por ejemplo, un bloque de 3x3 estará truncado y hay que tomarlo en consideración al determinar las estadísticas.

Con Python y numpy una forma de soslayar esto es añadiendo un "anillo" de valores que se considerán como NoData; tal como se presenta en el código siguiente:

Generando y rotando rectángulos a partir de puntos con atributos largo, ancho y ángulo de rotación mediante PyQGIS

Cuando se quiere generar y rotar rectángulos con base a parámetros que se encuentran en la tabla de atributos de un vectorial de puntos una buena opción es mediante un script de PyQGIS. El ancho y el largo serán usados para producir un objecto de la clase QgsRectangle que será convertido en geometría y rotado con respecto al punto (que también actúa como centroide del rectángulo).

Para ejecutar el procedimiento se consideró el shapefile de la imagen siguiente donde también se puede observar la tabla de atributos con los campos largo, ancho y ángulo de rotación ya referidos.

Generando memory layer de bordes, para capa tipo polígono, e información de interacciones en tabla de atributos

El código que se presenta a continuación produce como salida una memory layer tipo MultiLineString para cada uno de los features que representen bordes entre los rasgos adyacentes de una capa tipo polígono single parts.

En la tabla de atributos de la MultiLineString se crean dos campos que albergan información de la interaccion entre los features, es decir, se imprimen los nombres de los rasgos adyacentes en la capa tipo polígono que dieron lugar al borde.

Plugin para dividir líneas por puntos o por partes iguales

En diferentes posts anteriores (1, 2, 3) se exploró la posibilidad de dividir líneas por puntos o en partes iguales. En este se va a condensar la información que permite la creación de un plugin que divide líneas por puntos o en partes iguales.

Como en el último caso se imprime la magnitud del intervalo se puede obtener un espaciamiento aproximado a alguno deseado mediante la técnica de ensayo y error.

Creación de buffer en coordenadas geográficas con shapely y pyproj

Por alguna razón, varios usuarios de SIGs se rehusan a reprojectar su data en coordenadas geográficas a proyecciones en metros (o pies) y luego, cuando se ven en la necesidad de determinar algunas propiedades geométricas (áreas, longitudes) o producir cierto tipo de capas como los buffer, se les presentan dificultades.

En el caso de los buffer, si se trabaja con coordenadas geográficas, es necesario pasar previamente las geometrías a coordenadas proyectadas y luego, una vez obtenida, reproyectar al sistema de origen.

Porcentaje de intersección de areas de polígonos mediante fiona y shapely con Python3 en Debian

Continuando con la ejecución de código compatible con Python3 en SIGs se va a considerar el porcentaje de intersección de áreas de polígonos empleando los módulos python fiona y shapely instalados mediante pip3. En este caso, la lógica del algoritmo sigue una sintaxis muy similar a la ejecutada en un sistema con PyQGIS.

La compatibilidad con Python 2.7.x se logra encerrando entre paréntesis el argumento de los 'print' correspondientes. No obstante, la primera ejecución arrojó el error siguiente:

Dividir vectoriales tipo línea en partes iguales mediante algoritmo basado en azimuths con Python3 en Debian

Con el advenimiento de QGIS 3 el próximo 29 de septiembre de 2017, si se cumple exactamente el cronograma de liberación, habrán varios cambios que afectarán la compatibilidad de todas las aplicaciones que hasta ahora se han realizado en QGIS 2.x. La razón principal es que QGIS dejará de usar Python 2.7.x en favor de Python 3.x y el framework Qt4/PyQt4 para dar paso a Qt5/PyQt5. Por tanto, conviene estar preparado.

Como en el post anterior se empleó un algoritmo basado en azimuths para dividir vectoriales tipo línea en partes iguales, el cual utilizaba una mezcla de librerías third party de python (fiona y shapely) conjuntamente con PyQGIS, se pensó adaptar dicho script para ser funcional con Python 3.

Dividir vectoriales tipo línea en partes iguales mediante algoritmo basado en azimuths

En el post anterior se consideró la división de vectoriales tipo línea con puntos mediante un algoritmo basado en azimuths. En éste se va tratar la misma división del vectorial pero en partes iguales. Por tanto, los puntos deberían estar igualmente espaciados.

Como se puede preveer, en este caso no se requiere una capa explícita de puntos sino que se pueden generar mediante el método 'interpolate' de shapely.geometry. El código completo, para una división en 15 partes iguales, es el siguiente:

Dividir vectoriales tipo línea con puntos mediante algoritmo basado en azimuths

En el post anterior se consideró un algoritmo para agrupar puntos por segmentos de recta mediante listas Python. En éste lo vamos a complementar con otro basado en azimuths para dividir rectas mediante puntos.

La lectura del archivo vectorial se va a realizar con fiona y las coordenadas y la geometría se conforman con shapely. El código completo se presenta a continuación e incluye los puntos de corte:

Algoritmo para agrupar puntos por segmentos de recta mediante listas Python

Si Uds buscan en Processing de QGIS se darán cuenta que no encontrarán una aplicación para dividir rectas mediante puntos. La aplicación que aparece es la de dividir rectas con rectas, que funciona como se desea, pero hay que generar manualmente las rectas que cortan (o dividen) a la recta en los puntos deseados.

Tratando de indagar el porqué de esta carencia me di cuenta que el algoritmo para dividir mediante puntos no era tan sencillo como esperaba. En principio, se trata de posicionar estos puntos sobre la recta en las zonas de corte y mientras mayor sea el número de partes en las cuales se desee dividir mayor será la cantidad de éstos a posicionar.

Grid hexagonal con MMQGIS

El plugin MMQGIS es multifuncional y permite, entre otras, producir rejillas (grids) hexagonales. La interface pide como parámetros valores (x, y) que no están muy claramente establecidos a que se refieren. Estos valores están encadenados, es decir, si se fija el valor de x el valor de y queda determinado o viceversa. Generalmente, la caracterización de un polígono hexagonal regular, que descansa sobre uno de sus lados (distancia individual L), se hace con base a la distancia entre el centro y la mitad del lado superior y la dimensión de cualquiera de sus lados.

Después de algunas comprobaciones, se encontró que los valores (x,y) para el plugin MMQGIS, en el caso de las grid hexagonales, guardan la relación que se encuentra en la figura siguiente:

Snapping puntos de un rasgo a otro en un vectorial tipo polígono mediante PyQGIS

Una forma para realizar esto es generando primero todo los vértices para cada rasgo debido a que el método 'moveVertex' de QgsVectorLayer tiene como parametros un QgsPoint del rasgo destino (target) y el id del rasgo fuente (source) y el id del vértice en dicho rasgo. Tales vértices se almacenan en una memory layer de puntos.

El código completo se añade a continuación:

Ejemplo de QgsFieldComboBox.setFilters() en la creación de un plugin con PyQGIS

Los objetos de QgsFieldComboBox (menús tipo persiana para campos de archivos vectoriales) aceptan filtros de la clase QgsFieldProxyModel para desplegar sólo aquellos que tengan un tipo determinado (All, Date, Double, Int, LongLong, Numeric, String, Time). El único cuidado que hay que tener es establecer la debida conexión al slot (función) que permita actualizar los campos cada vez que cambia la capa vectorial.

El código siguiente ha sido preparado para ejecutarse en la Python Console de QGIS. La colocación de las líneas en las funciones respectivas del plugin (__init__, initGui, run, etc) queda por parte del lector.

Establecer estilo de borde a 'no pen' empleando un QgsGraduatedSymbolRendererV2 con PyQGIS

Aunque puedan parecer similares los objetos QgsGraduatedSymbolRendererV2, a diferencia de los QgsCategorizedSymbolRendererV2, no pueden ser instanciados de la misma forma. Para crear el renderer en un sólo paso es necesario obtener primero una rampa de colores (objeto de la clase QgsVectorGradientColorRampV2) que automáticamente generará los símbolos de acuerdo al campo elegido en la tabla de atributos y el número de clases establecidos. El método para colocar el estilo de borde a 'no pen' está en los símbolos (QgsFillSymbolV2 para capas de tipo polígono) y corresponde, para esta tarea, a 'setOutputUnit(1)'. El código completo se encuentra a continuación:

Añadiendo opción de 'offset', al renderer de líneas que se solapan en la misma capa, con PyQGIS

Cuando se tienen rasgos solapados en una misma capa la opción que funciona para separarlos es mediante un renderer de tipo QgsCategorizedSymbolRendererV2. Para ello, primero hay que crear los símbolos y después las categorías correspondientes a éstos. Para instanciar el renderer se le pasa como parámetro el label del campo objeto de la categorización. Finalmente, se añaden las categorías al renderer, este último a la capa y se "refresca" (método 'triggerRepaint' de QgsVectorLayer) para visualizar los resulatdos.

Clase personalizada en PyQGIS para generar tooltips con values de ráster y registros de tablas atributivas de vectoriales

Con base en esta respuesta de gis.stackexchange.com, modifiqué la clase para incorporar como funcionalidades adicionales la posibilidad de visualizar e imprimir no sólo los values de los ráster sino también los atributos de vectoriales tipo punto, línea o polígono. El código completo se encuentra a continuación.

Obtener coordenadas de un click del ratón mediante una clase personalizada en PyQGIS

En un post anterior se hizo mención a la forma de recuperar las coordenadas de un punto mediante un click del ratón empleando la clase QgsMapToolEmitPoint de PyQGIS. La forma como está allí expresada se basa en una analogía con relación a un código tomado del libro de Gary Sherman para la clase QgsMapToolEmitPoint. Sin embargo, ésto es mucho más fácil con esta nueva versión simplificada del código.

Cómo medir la distancia media entre puntos, para un radio fijo, mediante PyQGIS

El código siguiente permite determinar la distancia media, en un radio de 500 m, para todos los rasgos de un vectorial de puntos. Para evitar repeticiones innecesarias en las determinaciones de distancias se emplea el método 'combinations' del módulo itertools. Para verificar que el código se comporta de la manera esperada se determinan los índices correspondientes a cada grupo de distancias que satifacen el requerimiento.

Ráster de atenuación de ruido obtenido mediante PyQGIS para una fuente lineal

En el post anterior se consideró la obtención de un ráster de atenuación de ruido obtenido mediante PyQGIS para una fuente puntual. En éste se tomará en cuenta una fuente lineal de ruido; tal como corresponde a una autopista con mucho tráfico donde los valores pueden ser tan altos como de 90 dBA (Id1) a una distancia d1 de sólo 1 m.

Ráster de atenuación de ruido obtenido mediante PyQGIS para una fuente puntual

La atenuación del ruido, tal como ya se ha señalado con anterioridad, depende de si la fuente emisora es puntual o lineal. En ausencia de obstáculos, se refiere que cada vez que se dobla la distancia con relación a una fuente puntual el sonido se atenua en 6 dBA (decibelios), mientras que en el segundo caso, cada vez que se dobla la distancia con relación a una fuente lineal (por ejemplo, una autopista con mucho tráfico automotor) la atenuación del sonido será sólo de 3 dBA. Generalmente, los reportes de Tabla para la intensidad del sónido (Id1) producida por una determinada fuente puntual se hacen con base a una distancia fija que denominaremos d1. Por tanto, para una taladradora de construcción, es común que se reporte que produce una intensidad de 110 dBA (Id1) a una distancia d1 de 10 m.

Obtener el valor de un atributo de una capa vectorial mediante un click del ratón con PyQGIS

Esto puede ser realizado mediante la clase QgsMapToolEmitPoint la cual permite generar, al inicio, las coordenadas de un punto a cada click del ratón en la Map View de QGIS. Estas coordenadas se emplean para generar un QgsPoint y comprobar posteriormente si está dentro o fuera de algún rasgo del vectorial. Si está dentro del feature, se recupera su id para acceder entonces al value del atributo empleando el nombre del campo correspondiente. El código completo se tiene a continuación:

Leer el valor de un ráster y cambiarlo según condiciones dadas mediante PyQGIS

El código que se presenta a continuación lee todos los valores de un ráster mediante un objeto de la clase QgsRasterBlock y los cambia según condiciones establecidas para imprimirlos en un nuevo ráster. Para facilitar la ubicación de tales valores, complementariamente, se crean memory layers de puntos, según cada condición, y se colocan en el medio de las celdas del ráster.

Dividiendo círculos en 12 secciones mediante PyQGIS

Para dividir un círculo en 12 doce secciones se puede recurrir a la obtención de un buffer con 12 lados, de un vectorial de punto, para luego producir cada una de las divisiones empleando las coordenadas de los puntos exteriores y las de su centroide (este último común a todas ellas). Como la visualización de la capa resultante no es enteramente circular, paralelamente mediante el método buffer de QgsGeometry, se produce un buffer algo menor para que al ser intersectado con cada rasgo 1/12 se obtenga el efecto deseado.

Instalar fiona y geopandas en un sistema GNU/Debian estable recien instalado

Recientemente, me vi en la necesidad de instalar un nuevo sistema GNU/Debian estable (Debian 8) porque la actualización de su predecesor transcurrió con un corte de energía eléctrica y los daños fueron irrecuperables. Posteriormente, cuando en consola (como superusuario) me dispuse a instalar fiona y geopandas con easy_install, el cual se encuentra disponible en el paquete python-setuptools de Debian, se produjo un error inesperado. Es de hacer notar que el único paquete SIG que había instalado hasta el momento era QGIS a través de su repositorio respectivo.

Investigando la posible causa encontré que fiona requiere compilar código C++ de GDAL\OGR para instalarse (al igual que geopandas), por lo que resultaba evidente la posibilidad de dependencias insatisfechas, es decir, la necesidad de un compilador g++. Una investigación algo más exhaustiva me llevó a que la instalación del compilador y sus dependencias estaba garantizada con:

Contar el número de celdas de cada tipo por bloque en QGIS

En una pregunta de gis.stackexchange.com se consideró la forma de contar el número de celdas de cada tipo por bloque; pero referido al software ArcGis. Obviamente, una manera de hacer esto es con código y para ello se pueden usar las prestaciones del módulo python de GDAL o las clases de PyQGIS. Sin embargo, lo que me llamó la atención fue la ingeniosa solución aritmética de esta respuesta.

Interpolación de colores con PyQGIS

La interpolación de colores es un aspecto importante en la simbolización de capas vectoriales y raster porque permite visualizar rasgos (features) o píxeles según un color asignado a la clase a la que pertenecen. El método de interpolación más sencillo que existe es el lineal, sin embargo, para rampas con sólo dos colores, tiene la dificultad (sobre todo para ráster) de establecer buenas gradaciones entre ambos. No obstante, esto se puede mitigar con la incorporación de un color intermedio y así mejorar la gradación.

Corrigiendo geometrías con PyQGIS: segunda parte

En el post anterior se consideró la corrección de una geometría con problemas en el sentido de que no se podía generar el poligono correspondiente a partir de los rasgos de línea. Se determinó la existencia de varios gaps que fueron corregidos mediante v.clean de la Processing Tool Box. Sin embargo, esto no era la causa de los problemas.

Corrigiendo geometrías con PyQGIS: primera parte

En un post anterior se escribió acerca de la validación y corrección de geometrías y de este link se puede bajar un shapefile de cierta zona de Malasia el cual no permite convertirlo adecuadamente en el polígono esperado a pesar de no presentar, aparentemente, problemas de geometría. Sin embargo, de manera subyacente, presenta muchas inconsistencias.

Validando y corrigiendo geometrías con PyQGIS y plugin Processing LWGEOM Provider en GNU/Linux Debian

La validación de las geometrías es fácilmente realizable en PyQGIS con el método 'isGeosValid' de QgsGeometry. Sin embargo, la corrección una vez detectados los problemas no es tan directa porque los procedimientos disponibles en Processing a veces no funcionan. Un método que es prácticamente infalible es ST_MakeValid de PostGis; pero cuenta con la necesidad de que hay que tener instalado PostgreSQL+PostGis en el sistema.

Selección de features de puntos con distancia mínima a features tipo polígono en PyQGIS

Estos pueden ser seleccionados mediante la función 'distance' de QgsGeometry para las sucesivas interacciones entre rasgos en un double loop. La condición de distancia mínima se incluye en el loop (en este caso 10000 m = 10 km) lo que sirve para poblar las listas con las distancias y los ids (o los nombres) de los rasgos seleccionados.

Cómo colocar puntos a lo largo de una línea usando una lista de distancias con PyQGIS

Existe un procedimiento en processing (qgis:createpointsalonglines) que permite realizar la tarea y, posiblemente, se pueda programar para diferentes separaciones. No obstante, a continuación, expondré un código muy sencillo que emplea PyQGIS. La base del mismo es el método 'interpolate' de QgsGeometry. Se usa para generar puntos irregularmente espaciados sobre una línea con base en una lista de separaciones entre los puntos. Por tanto, las distancias se determinan como suma de las respectivas separaciones.

Cómo imprimir un punto a cada click del ratón sobre el Map Canvas con PyQGIS

La impresión de un punto a cada click del ráton es una acción muy útil que puede ser aprovechada, por ejemplo, para conformar un vectorial de puntos con el plugin QuickWKT, determinar los índices de (fila, columna) de un ráster o posicionar el cursor en una determinada posición del Map Canvas. Emplea objetos y métodos de la clase QgsMapToolEmitPoint para conectar a una función que permite desplegar las coordenadas de tales puntos en unidades de mapa, coordenadas de Map Canvas o coordenadas globales.

Cómo copiar a una columna el nombre del color para un vectorial con Graduated Symbol Renderer en PyQGIS

En esta pregunta de gis.stackexchange.com se indaga acerca de cómo guardar el color de un rasgo en un campo de la tabla de atributos para un vectorial que ha sido clasificado con un renderizado "Graduated Symbol". La razón de ésta se debe a que el script empleado directamente de otra pregunta no funciona porque es válido para un Categorized Symbol Renderer.

Uso de processing gdalogr:cliprasterbymasklayer con PyQGIS

Cortar (clip) un ráster por máscara (vectorial tipo polígono) es otra de las opciones también disponibles en processing a través del método gdalogr:cliprasterbymasklayer. Sin embargo, no produce una capa perfectamente alineada con el ráster base; algo que posteriormente habría que solucionar en el parámetro 'EXTRA'.

Uso de processing 'grass:r.lake.coords' con PyQGIS

El algoritmo de processing 'grass:r.lake.coords' permite generar el espejo de agua de un lago a partir de un ráster dem utilizando principalmente como parámetros de entrada la cota de llenado y las coordenadas de un punto dentro del referido espejo de agua. Para que la ejecución del algoritmo tenga sentido es necesario que el ráster dem incluya un relieve encajante, es decir, que evite que el agua se "derrame" y abarque toda la superficie del ráster.

Determinación del rasgo central (feature) con base en la suma de distancias en PyQGIS

En el post anterior se consideró un algoritmo que permite reducir el tiempo de cómputo de la suma de distancias porque las realiza sólo en la porción triangular superior de la matriz de distancias. En este post el referido algoritmo se incluye en un codigo que permite determinar el feature central para la capa activa. Se ha escogido una capa de puntos con 700 rasgos; tal como se observa a continuación:

Suma de distancias en matriz triangular de distancias con Python

La suma de distancias entre rasgos es un elemento que puede ser usado para establecer el rasgo central de una capa porque es la que presenta el valor mínimo. En los SIGs estas distancias generalmente se determinan, por defecto, para capas tipo punto; aunque cualquier geometría es admisible. Sin embargo, cuando el número de features es muy elevado, el tiempo de computo de las distancias se incrementa considerablemente.

Usando processing gdalogr:rastercalculator para determinar NDVI con PyQGIS

El empleo de cocientes o índices para identificar masas vegetales tiene su base en que una masa vegetal en óptimas condiciones posee una firma espectral que se caracteriza, en especial, por un claro contraste entre la banda del rojo (0.6 a 0.7 µm) y el infrarrojo cercano (0.7 a 1.1 µm). Esto se debe a que la mayor parte de la radiación solar recibida por la planta en el visible es absorbida por los pigmentos de las hojas y éstos apenas afectan a la radiación recibida en el infrarrojo cercano. En el caso del NDVI (Indice de Vegetación de Diferencias Normalizadas; por sus siglas en inglés), éste se determina dividiendo la diferencia de la banda infrarroja (NIR) menos la roja (RED) entre la suma de ambas (NIR+RED); expresadas en términos de reflectividad.

Algoritmo de Ramer–Douglas–Peucker con PyQGIS

El algoritmo de Ramer–Douglas–Peucker (RDP)¹, ² permite reducir el número de puntos utilizados en la aproximación de una curva. Se fundamenta en la búsqueda de puntos críticos a partir de una tolerancia lineal. La primera línea base corresponde al primer (anclaje) y último punto (flotante) de la línea original. Luego se calculan las distancias perpendiculares de todos los puntos intermedios. Si ninguna de estas distancias es mayor a la tolerancia sólo quedarán retenidos los puntos inicial y final de la línea. Sí se supera la tolerancia el punto con mayor distancia será retenido como punto crítico subdividiendo la línea original en dos secciones. En cada una se repite el proceso de manera independiente y así, sucesivamente, hasta que no haga falta efectuar subdivisión alguna de las líneas.

Cambiando la capa activa en una Combo Box (PyQGIS)

Aunque existe un método directo y automático para seleccionar capas en la programación con PyQGIS, mediante el uso de un objeto QgsMapLayerComboBox, también es útil conocer cómo puede realizarse ésto empleando un objeto Qt representado por una QComboBox.

Usando Processing qgis:creategrid con PyQGIS

En este post se van a probar diferentes opciones correspondientes a la creacción de retículas mediante el método 'creategrid' de QGIS Processing. Para ello se va usar como base para la obtención de la extensión un ráster que no necesita estar cargado en la Map View de QGIS porque la referencia al objeto se obtiene a partir de una URI (uniform resource identifier) mediante el método 'getObjectFromUri' de processing.

Estadística zonal con rasgos que se solapan usando PyQGIS

Para determinar la estadística zonal en un vectorial cuyos rasgos se solapan sobre un ráster, se pueden usar los métodos 'unary_union' y 'polygonize' del módulo 'shapely' de Python. El uso combinado de estos métodos permite individualizar las zonas solapadas y facilitar el cálculo de las estadísticas. Para probar esta aproximación se usaron el shapefile y el ráster que se viasualizan en la imagen siguiente:

Graphic Modeler en QGIS para determinar cuantiles y reclasificar un ráster con base en ellos

El Graphic Modeler de QGIS permite crear modelos complejos combinando los algoritmos que ya se encuentran en la Processing Toolbox. Este presenta un Canvas hacia donde la estructura del modelo y el flujo de trabajo puede añadirse según los 9 parámetros de entrada y los algoritmos que se encuentran en la parte izquierda del Canvas. Los elementos de entrada y los algoritmos se añaden con doble click y los primeros se nombran de la manera adecuada para que al usarse dentro de estos últimos se créen los enlaces correspondientes dentro del esquema.

Processing taudem:peukerdouglas en GNU/Linux Debian

La instalación y ejecución de algoritmos TauDEM en Windows fue considerada en un post anterior. En Linux, la instalación puede ser automatizada utilizando el script obtenido de esta página. A pesar de que el nombre del script sugiera que sólo puede instalarse en Ubuntu, si miran dentro del script verán que fue desarrollado inicialmente para Debian y es de validez universal para cualquier sistema derivado de Debian.

Buffering pixels en un array de python

En esta pregunta de gis.stackexchange se indaga sobre la posibilidad de un algoritmo que permita producir un anillo de ceros (buffer) alrededor de cada cero en un ráster binario (values 0 y 1). Una vía posible para hacer esto es generar todas las tuplas de índices para los cuales se desean los ceros, almacenarlos en una lista (sin repetición) y luego usar esta para cambiar los unos por ceros en una matriz con values 1 generada con la misma dimensión del array original.

Processing taudem:d8flowdirections para determinar mapas de pendiente y dirección de flujo

TauDEM (Terrain Analysis Using Digital Elevation Models) es una suite de herramientas para Modelos de Elevación Digital (DEM por sus siglas en inglés) que permite la extracción y análisis de información hidrólogica de la topografía que viene representada por el DEM. A pesar de que viene supuestamente disponible para ser usada directamente en Processing de QGIS, lo cierto es que debe ser instalada previamente, habilitada en las opciones de Processing y establecidas las rutas correspondientes a las herramientas y sus dependencias.

Rotación de vectoriales con processing grass:v.transform en PyQGIS

El comando grass:v.transform de processing permite, mediante una transformación afin, realizar translaciones y rotaciones de archivos vectoriales; independientemente de su tipo y número de rasgos. Las translaciones pueden implementarse de una manera directa pero las rotaciones involucran un grado de complejidad adicional. Ello se debe a que las rotaciones se realizan con relación al eje (0,0) y para implementarlas con relación a otro eje (por ejemplo el centroide de un vectorial) es necesario un cambio del sistema vectorial de referencia.

Usando grass:v.buffer.distance en PyQGIS

El comando grass:v.buffer.distance es otra de las opciones de GRASS disponible en 'processing' de QGIS y sus parámetros, donde la interpretación de algunos de ellos puede encontrarse en el manual en línea, se visualizan en la imagen siguiente:

Processing gdalogr:cliprasterbyextent en PyQGIS para cortar un ráster por extensión

En esta ocasión se va a probar en PyQGIS el método de processing gdalogr:cliprasterbyextent para cortar un ráster por extensión. Para el "corte" se va a emplear la extensión de un vectorial tipo polígono; tal como se presenta en la imagen siguiente:

Utilizando gdalogr:translate en PyQGIS para convertir values a nodata

Continuando con los métodos de Processing, hoy se van a considerar los de GDAL/OGR para trabajar por vez primera en estos posts con archivos de tipo ráster. En este caso, se va a probar el método 'gdalogr:translate' para transformar en 'no data' los values iguales a cero en un ráster de 20 x 20 con values aleatorios entre 0 y 10. El plugin de 'Processing Information' (ver imagen siguiente) permite corroborar la presencia de 44 geoalgoritmos en este renglon; entre los cuales se encuentra el de nuestro interés: 'gdalogr:translate' (número 42).

Utilizando grass:v.voronoi en PyQGIS

Siguiendo con los métodos de Processing, hoy se van a considerar los de GRASS. Estos tienen la particularidad de que para hacerlos funcionar adecuadamente hay que saber cómo introducir el parámetro correspondiente a la región de GRASS; que no es más que una simple extensión. En la imagen siguiente se despliegan, a través del plugin, los 160 algoritmos que de GRASS se tienen a la disposición en 'processing'.

Utilizando saga:linepolygonintersection en PyQGIS

Siguiendo con los métodos de Processing, hoy se va a considerar 'linepolygonintersection'. Este produce, a diferencia del anterior, un vectorial de línea. No obstante, se va a cambiar la forma de visualizar la capa automatizando la carga al Map Canvas. Para ello, se utiliza el paso generado alaeatoriamente cuando se usa como parámetro None en la opción correspondiente.

Utilizando saga:polygonlineintersection en PyQGIS

Una de las situaciones que nos obliga a no explorar con más detalle las opciones que ofrece 'Processing' en QGIS es la dificultad que supone el acceso a su documentación. Aunque existe, ésta es muy escueta y se limita a unos pocos ejemplos. Por otra parte, la documentación que ofrece la ayuda de la Python Consola a través de la ejecución de los comandos 'processing.alglist' y 'processing.alghelp' tiene el inconveniente de que no pueden ser asignadas a una variable; a menos que se redirija el flujo de salida estándar. Esto último facilitaría la evaluación de los posibles métodos de 'Processing' mediante el módulo de expresiones regulares.

Redirigiendo la escritura de la salida estándar por defecto (consola) en Python a una variable

La mayoría de los resultados que en Python imprimimos a través de la consola pueden ser redireccionados facilmente a una variable, a un archivo en memoria o en disco, o a un objeto de visualización de PyQt4; como por ejemplo una QTextBrowser. No obstante, existen algunos pocos comandos que, por defecto, no lo hacen y hay que definir la salida estándar (stdout). Entre ellos tenemos la salida, en la Python Consola de QGIS, del comando 'processing.alglist()'; que requiere importar primero el módulo 'processing'.

Obtener promedios ponderados por área usando PyQGIS

En la situación que se tiene en la imagen siguiente se desea obtener el promedio ponderado por área del campo 'val', perteneciente al vectorial tipo polígono, cuando se intersecta con el buffer del vectorial tipo línea.

Estadística zonal con inclusión de píxeles recubiertos sólo parcialmente

La estadística zonal se refiere a la determinación de los parámetros estadísticos de un ráster que subyacen a un vectorial. Cuando el tamaño de estos últimos es comparable al tamaño de celda del ráster entonces los efectos de borde del vectorial que tienden a excluir el centroide de las celdas del ráster pueden llegar a ser importantes porque sus values no serán considerados en las estadísticas.

Intersecciones con método 'overlay' de GeoPandas

El método 'overlay' de GeoPandas permite realizar intersecciones (y otras operaciones de geoproceso) en la misma capa (auto intersección) o en capas diferentes; aunque en la misma capa puede ser difícil de interpretar. Por tanto, para comenzar, se va a realizar la operación con los shapefiles de la imagen siguiente:

Intersecciones en la misma capa con GeoPandas

Cuando se desea efectuar la intersección entre rasgos de la misma capa es conveniente, primero, usar el método 'combinations' del módulo 'itertools' para excluir las repeticiones. La situación que se va a considerar se encuentra a continuación; donde la capa tiene 50 % de transparencia para facilitar la observación de los solapamientos.

Muestreo ráster con el módulo rasterio (python)

El módulo python 'rasterio' es una librería que simplifica la manipulación con archivos ráster. Aunque en ambientes Windows puede ser difícil tenerla disponible en la Python Console de QGIS, en mi GNU/Linux Debian se instala fácilmente a través de 'easy_install'.