DeepSeek es el nuevo modelo de Inteligencia Artificial de origen chino y código abierto que ya está a nuestra disposición. En esta entrada vamos a ver cómo crear mapas en QGIS fácilmente con Deepseek.

El potencial de la Inteligencia Artifcial es realmente grande en el ámbito geoespacial, lo que puede ayudar tanto a los principiantes a iniciarse en el mundo de los SIG, como a los usuarios avanzados, ahorrándonos mucho tiempo en nuestro trabajo diario.

¿Qué es DeepSeek?

DeepSeek es una empresa china que se dedica a la inteligencia artificial, especialmente en el desarrollo de modelos extensos de lenguaje (LLM) de código abierto y aplicaciones relacionadas con IA. También es el nombre de su chat de IA, una alternativa propia a Copilot, Gemini o ChatGPT.

DeepSeek vs ChatGPT

1. DeepSeek tiene un enfoque de código abierto, es totalmente gratuito y no requiere de ninguna suscripción para utilizar su modelo más avanzado.
2. En teoría han conseguido que cueste entre un 5% y un 3% del gasto de ChatGPT, lo que la hace la inteligencia artificial más eficiente energéticamente que existe en el mundo.  Esta afirmación ha durado una semana.
3. Si lo comparamos con ChatGPT haciendo las mismas preguntas, DeepSeek puede ser un poco más escueto a la hora de responder. Sin embargo, tiene la misma flexibilidad que otros modelos, y puedes pedirle que explique las cosas más ampliamente o que las adapte a ti.
4. Una semana después de la publicación de este artículo se ha lanzado el nuevo modelo o3-mini de OpenAI, que es más inteligente que DeepSeek y cuesta tres veces menos:

Creando mapas en QGIS con ayuda de DeepSeek

En este artículo nos vamos a centrar en el chatbot de inteligencia artificial. Vamos a ver cómo DeepSeek nos puede ayudar a crear mapas detallados y de calidad en QGIS simplemente haciendo las preguntas correctas.

En primer lugar debemos acceder a la web de Deepseek y hacer clic sobre el enlace de la izquierda: Start Now

Nos pedirá registrarnos y a continuación se abrirá la ventana del chat en la que podeemos escribir las preguntas. La primera pregunta que vamos a hacerle es la siguiente:

Me gustaría ver las coordenadas de los pueblos más importantes de León (España). ¿Puedes proporcionarme un código en python que pueda ejecutar en la consola de python y ver los resultados en QGIS?

DeepSeek nos proporciona el código necesario:

from qgis.core import QgsVectorLayer, QgsFeature, QgsPointXY, QgsProject, QgsField, QgsFields
from qgis.PyQt.QtCore import QVariant

# Definir la lista de pueblos con sus coordenadas
pueblos = [
    {"nombre": "León", "latitud": 42.5987, "longitud": -5.5671},
    {"nombre": "Astorga", "latitud": 42.4588, "longitud": -6.0636},
    {"nombre": "Ponferrada", "latitud": 42.5466, "longitud": -6.5962},
    {"nombre": "Villablino", "latitud": 42.9396, "longitud": -6.3196},
    {"nombre": "La Bañeza", "latitud": 42.2978, "longitud": -5.9018},
    {"nombre": "Sahagún", "latitud": 42.3713, "longitud": -5.0325},
    {"nombre": "Cacabelos", "latitud": 42.6000, "longitud": -6.7333},
    {"nombre": "Valencia de Don Juan", "latitud": 42.2936, "longitud": -5.5172},
    {"nombre": "Bembibre", "latitud": 42.6167, "longitud": -6.4167},
    {"nombre": "Santa María del Páramo", "latitud": 42.3550, "longitud": -5.7486}
]

# Crear una capa de puntos en memoria
capa = QgsVectorLayer("Point?crs=EPSG:4326", "Pueblos de León", "memory")
provider = capa.dataProvider()

# Definir los campos de la capa
fields = QgsFields()
fields.append(QgsField("id", QVariant.Int))
fields.append(QgsField("nombre", QVariant.String))
provider.addAttributes(fields)
capa.updateFields()

# Añadir los puntos a la capa
for i, pueblo in enumerate(pueblos):
    punto = QgsPointXY(pueblo["longitud"], pueblo["latitud"])
    feature = QgsFeature()
    feature.setGeometry(QgsGeometry.fromPointXY(punto))
    feature.setAttributes([i + 1, pueblo["nombre"]])
    provider.addFeature(feature)

# Añadir la capa al proyecto de QGIS
QgsProject.instance().addMapLayer(capa)

print("Capa de pueblos de León creada y añadida al proyecto.")

1. Vamos al menú Complementos > Consola Python.
2. En la consola de Python, pegamos el código anterior.
3. Ejecutamos el código y vemos el resultado:

La verdad es que este primer mapa es poco representativo, ya que no sabemos dónde estan dichos pueblos. Pero podemos pedirle que nos modifique el script indicando que añada una capa base:

¿En el script puedes añadir una capa base de openStreetMap para poder conocer mejor dónde estamos?

from qgis.core import (
    QgsVectorLayer, QgsFeature, QgsPointXY, QgsProject,
    QgsField, QgsFields, QgsGeometry, QgsRasterLayer,
    QgsCoordinateReferenceSystem
)

# 1. AÑADIR CAPA BASE (OPENSTREETMAP)
url_osm = "type=xyz&url=https://tile.openstreetmap.org/{z}/{x}/{y}.png&zmax=19&zmin=0"
capa_base = QgsRasterLayer(url_osm, "OpenStreetMap", "wms")

if capa_base.isValid():
    QgsProject.instance().addMapLayer(capa_base)
    print("Capa base de OpenStreetMap cargada correctamente.")
else:
    print("Error: No se pudo cargar la capa base.")

# 2. CONFIGURAR EL SISTEMA DE COORDENADAS DEL PROYECTO (WEB MERCATOR)
QgsProject.instance().setCrs(QgsCoordinateReferenceSystem("EPSG:3857"))

# 3. CREAR CAPA DE PUEBLOS (COORDENADAS EN WGS84 - EPSG:4326)
pueblos = [
    {"nombre": "León", "latitud": 42.5987, "longitud": -5.5671},
    {"nombre": "Astorga", "latitud": 42.4588, "longitud": -6.0636},
    {"nombre": "Ponferrada", "latitud": 42.5466, "longitud": -6.5962},
    {"nombre": "Villablino", "latitud": 42.9396, "longitud": -6.3196},
    {"nombre": "La Bañeza", "latitud": 42.2978, "longitud": -5.9018},
    {"nombre": "Sahagún", "latitud": 42.3713, "longitud": -5.0325},
    {"nombre": "Cacabelos", "latitud": 42.6000, "longitud": -6.7333},
    {"nombre": "Valencia de Don Juan", "latitud": 42.2936, "longitud": -5.5172},
    {"nombre": "Bembibre", "latitud": 42.6167, "longitud": -6.4167},
    {"nombre": "Santa María del Páramo", "latitud": 42.3550, "longitud": -5.7486}
]

# Crear capa de puntos en WGS84 (se reproyectará automáticamente al CRS del proyecto)
capa_pueblos = QgsVectorLayer("Point?crs=EPSG:4326", "Pueblos de León", "memory")
provider = capa_pueblos.dataProvider()

# Definir campos de la capa
fields = QgsFields()
fields.append(QgsField("id", QVariant.Int))
fields.append(QgsField("nombre", QVariant.String))
provider.addAttributes(fields)
capa_pueblos.updateFields()

# Añadir puntos
for i, pueblo in enumerate(pueblos):
    punto = QgsPointXY(pueblo["longitud"], pueblo["latitud"])  # Coordenadas en WGS84
    feature = QgsFeature()
    feature.setGeometry(QgsGeometry.fromPointXY(punto))
    feature.setAttributes([i + 1, pueblo["nombre"]])
    provider.addFeature(feature)

# Añadir capa al proyecto
QgsProject.instance().addMapLayer(capa_pueblos)

print("Capa de pueblos añadida sobre la capa base.")

Volvemos a ejecutar este código en la ventana de Python y ya podemos ver la capa base de OSM de fondo:

Ahora vamos a pedirle que calcule los polígonos de voronoy para la capa de puntos:

from qgis.core import (
    QgsVectorLayer, QgsFeature, QgsPointXY, QgsProject,
    QgsField, QgsFields, QgsGeometry, QgsRasterLayer,
    QgsCoordinateReferenceSystem, QgsProcessing, QgsProcessingAlgorithm,
    QgsProcessingFeatureSource, QgsProcessingOutputVectorLayer,
    QgsProcessingParameterFeatureSource, QgsProcessingParameterFeatureSink,
    QgsProcessingUtils, QgsWkbTypes
)
from qgis.analysis import QgsVectorLayerDirector, QgsGraphBuilder, QgsGraphAnalyzer
from qgis.utils import iface

# 1. AÑADIR CAPA BASE (OPENSTREETMAP)
url_osm = "type=xyz&url=https://tile.openstreetmap.org/{z}/{x}/{y}.png&zmax=19&zmin=0"
capa_base = QgsRasterLayer(url_osm, "OpenStreetMap", "wms")

if capa_base.isValid():
    QgsProject.instance().addMapLayer(capa_base)
    print("Capa base de OpenStreetMap cargada correctamente.")
else:
    print("Error: No se pudo cargar la capa base.")

# 2. CONFIGURAR EL SISTEMA DE COORDENADAS DEL PROYECTO (WEB MERCATOR)
QgsProject.instance().setCrs(QgsCoordinateReferenceSystem("EPSG:3857"))

# 3. CREAR CAPA DE PUEBLOS (COORDENADAS EN WGS84 - EPSG:4326)
pueblos = [
    {"nombre": "León", "latitud": 42.5987, "longitud": -5.5671},
    {"nombre": "Astorga", "latitud": 42.4588, "longitud": -6.0636},
    {"nombre": "Ponferrada", "latitud": 42.5466, "longitud": -6.5962},
    {"nombre": "Villablino", "latitud": 42.9396, "longitud": -6.3196},
    {"nombre": "La Bañeza", "latitud": 42.2978, "longitud": -5.9018},
    {"nombre": "Sahagún", "latitud": 42.3713, "longitud": -5.0325},
    {"nombre": "Cacabelos", "latitud": 42.6000, "longitud": -6.7333},
    {"nombre": "Valencia de Don Juan", "latitud": 42.2936, "longitud": -5.5172},
    {"nombre": "Bembibre", "latitud": 42.6167, "longitud": -6.4167},
    {"nombre": "Santa María del Páramo", "latitud": 42.3550, "longitud": -5.7486}
]

# Crear capa de puntos en WGS84
capa_pueblos = QgsVectorLayer("Point?crs=EPSG:4326", "Pueblos de León", "memory")
provider = capa_pueblos.dataProvider()

# Definir campos de la capa
fields = QgsFields()
fields.append(QgsField("id", QVariant.Int))
fields.append(QgsField("nombre", QVariant.String))
provider.addAttributes(fields)
capa_pueblos.updateFields()

# Añadir puntos
for i, pueblo in enumerate(pueblos):
    punto = QgsPointXY(pueblo["longitud"], pueblo["latitud"])  # Coordenadas en WGS84
    feature = QgsFeature()
    feature.setGeometry(QgsGeometry.fromPointXY(punto))
    feature.setAttributes([i + 1, pueblo["nombre"]])
    provider.addFeature(feature)

# Añadir capa al proyecto
QgsProject.instance().addMapLayer(capa_pueblos)

# 4. CREAR POLÍGONOS DE VORONOI
# Usar el algoritmo de procesamiento de Voronoi
params = {
    'INPUT': capa_pueblos,
    'BUFFER': 50,  # Extensión del área de Voronoi (en % del tamaño de la capa)
    'OUTPUT': 'memory:'  # Guardar en memoria
}

resultado_voronoi = processing.run("qgis:voronoipolygons", params)

# Obtener la capa de Voronoi
capa_voronoi = resultado_voronoi['OUTPUT']
capa_voronoi.setName("Polígonos de Voronoi - Pueblos de León")

# Añadir capa de Voronoi al proyecto
QgsProject.instance().addMapLayer(capa_voronoi)

print("Polígonos de Voronoi creados y añadidos al proyecto.")

Ejecutamos de nuevo este código en la ventana de Python y ya vemos los polígonos de Voronoy:

A continuación vamos a pedir un poco de personalización al mapa, modificando la simbología de la capa de puntos y creando un etiquetado con el nombre de los lugares:

¿Puedes modificar la simbología de los pueblos a una estrella y crear una etiqueta con el nombre?

from qgis.core import (
    QgsVectorLayer, QgsFeature, QgsPointXY, QgsProject,
    QgsField, QgsFields, QgsGeometry, QgsRasterLayer,
    QgsCoordinateReferenceSystem, QgsMarkerSymbol,
    QgsSimpleMarkerSymbolLayer, QgsSingleSymbolRenderer,
    QgsPalLayerSettings, QgsTextFormat, QgsTextBufferSettings,
    QgsVectorLayerSimpleLabeling
)
from qgis.PyQt.QtCore import QVariant
from qgis.PyQt.QtGui import QColor, QFont

# 1. AÑADIR CAPA BASE (OPENSTREETMAP)
url_osm = "type=xyz&url=https://tile.openstreetmap.org/{z}/{x}/{y}.png&zmax=19&zmin=0"
capa_base = QgsRasterLayer(url_osm, "OpenStreetMap", "wms")

if capa_base.isValid():
    QgsProject.instance().addMapLayer(capa_base)
    print("Capa base de OpenStreetMap cargada correctamente.")
else:
    print("Error: No se pudo cargar la capa base.")

# 2. CONFIGURAR EL SISTEMA DE COORDENADAS DEL PROYECTO (WEB MERCATOR)
QgsProject.instance().setCrs(QgsCoordinateReferenceSystem("EPSG:3857"))

# 3. CREAR CAPA DE PUEBLOS (COORDENADAS EN WGS84 - EPSG:4326)
pueblos = [
    {"nombre": "León", "latitud": 42.5987, "longitud": -5.5671},
    {"nombre": "Astorga", "latitud": 42.4588, "longitud": -6.0636},
    {"nombre": "Ponferrada", "latitud": 42.5466, "longitud": -6.5962},
    {"nombre": "Villablino", "latitud": 42.9396, "longitud": -6.3196},
    {"nombre": "La Bañeza", "latitud": 42.2978, "longitud": -5.9018},
    {"nombre": "Sahagún", "latitud": 42.3713, "longitud": -5.0325},
    {"nombre": "Cacabelos", "latitud": 42.6000, "longitud": -6.7333},
    {"nombre": "Valencia de Don Juan", "latitud": 42.2936, "longitud": -5.5172},
    {"nombre": "Bembibre", "latitud": 42.6167, "longitud": -6.4167},
    {"nombre": "Santa María del Páramo", "latitud": 42.3550, "longitud": -5.7486}
]

# Crear capa de puntos en WGS84
capa_pueblos = QgsVectorLayer("Point?crs=EPSG:4326", "Pueblos de León", "memory")
provider = capa_pueblos.dataProvider()

# Definir campos de la capa
fields = QgsFields()
fields.append(QgsField("id", QVariant.Int))
fields.append(QgsField("nombre", QVariant.String))
provider.addAttributes(fields)
capa_pueblos.updateFields()

# Añadir puntos
for i, pueblo in enumerate(pueblos):
    punto = QgsPointXY(pueblo["longitud"], pueblo["latitud"])  # Coordenadas en WGS84
    feature = QgsFeature()
    feature.setGeometry(QgsGeometry.fromPointXY(punto))
    feature.setAttributes([i + 1, pueblo["nombre"]])
    provider.addFeature(feature)

# Añadir capa al proyecto
QgsProject.instance().addMapLayer(capa_pueblos)

# 4. PERSONALIZAR LA SIMBOLOGÍA DE LOS PUNTOS (ESTRELLA)
# Crear un símbolo de marcador en forma de estrella
simbolo = QgsMarkerSymbol.createSimple({
    'name': 'star',          # Forma del marcador (estrella)
    'color': 'gold',         # Color del marcador
    'size': '8',             # Tamaño del marcador
    'outline_color': 'black',  # Color del borde
    'outline_width': '0.5'     # Grosor del borde
})

# Aplicar el símbolo a la capa de puntos
renderer = QgsSingleSymbolRenderer(simbolo)
capa_pueblos.setRenderer(renderer)

# 5. AÑADIR ETIQUETAS CON EL NOMBRE DE LOS PUEBLOS
# Configurar las etiquetas
etiquetas = QgsPalLayerSettings()
etiquetas.fieldName = "nombre"  # Campo que contiene el nombre
etiquetas.isExpression = False

# Formato del texto
formato_texto = QgsTextFormat()
formato_texto.setFont(QFont("Arial", 10))  # Fuente y tamaño
formato_texto.setColor(QColor("black"))    # Color del texto

# Añadir un borde al texto
buffer = QgsTextBufferSettings()
buffer.setEnabled(True)
buffer.setSize(0.5)  # Tamaño del borde
buffer.setColor(QColor("white"))  # Color del borde
formato_texto.setBuffer(buffer)

etiquetas.setFormat(formato_texto)

# Aplicar las etiquetas a la capa
capa_pueblos.setLabeling(QgsVectorLayerSimpleLabeling(etiquetas))
capa_pueblos.setLabelsEnabled(True)

# Refrescar la capa para aplicar los cambios
capa_pueblos.triggerRepaint()

print("Simbología de estrellas y etiquetas aplicada correctamente.")

Y el resultado al ejecutar el código anterior:

Conclusión

Podemos continuar realizando análisis espacial con la ayuda de DeepSeek y el código python que aquel genera, realizando cualquier tipo de geoproceso disponible en la caja de herrmientas de procesos.

Como has podido ver, la creación de mapas no requiere ningun esfuerzo y nos permite automatizar la creación de mapas complejos en QGIS con facilidad, ahorrando tiempo y mejorando el flujo de trabajo.

DeepSeek es una prueba de que el código abierto puede igualar e incluso superar en unos aspectos a empresas que utilizan código privado.

Aurelio Morales

Licenciado en Geografía. Máster en Sistemas de Información Geográfica. Consultor GIS desde el año 2004. En MappingGIS desde el año 2012 para ayudarte a impulsar tu perfil GIS y diferenciarte de la competencia. Echa un vistazo a todos nuestros cursos de SIG online.