Planeta SIG - Portugal

Prezado leitor,

Integrar o GeoServer a um ambiente DevOps permite transformar a publicação e manutenção de dados geoespaciais em um processo automatizado, rastreável e seguro. Com pipelines CI/CD (Continuous Integration / Continuous Deployment), é possível validar, versionar e publicar camadas geoespaciais de forma confiável, garantindo que novas versões de dados e estilos cheguem ao servidor sem intervenção manual.

1. Conceito de CI/CD para GeoServer

O objetivo do CI/CD é automatizar a entrega de software ou dados. No contexto do GeoServer, podemos aplicar CI/CD para:

• Publicação automática de camadas vetoriais e rasters.
• Aplicação de estilos (SLD/SE) versionados em repositórios Git.
• Validação de dados antes do deploy.
• Rollback automático em caso de falhas.

Combinando REST API do GeoServer e pipelines CI/CD, conseguimos ter controle total sobre a atualização de dados geoespaciais.

2. Estrutura do pipeline DevOps

Um pipeline típico para GeoServer + PostGIS em CI/CD inclui:

• Repositório Git: versionamento de SLDs, scripts de publicação e, quando aplicável, dados GeoJSON ou shapefiles pequenos.
• Serviço de CI/CD: GitHub Actions, GitLab CI/CD ou Jenkins para executar scripts de publicação.
• Servidor GeoServer: alvo do deploy automático, com REST API habilitada e credenciais de acesso seguras.
• Banco PostGIS: para integração de dados vetoriais, garantindo consistência com o GeoServer.

Visualmente, o fluxo pode ser resumido assim:

Git Repo (dados e SLDs) 
      │
      ▼
CI/CD Pipeline (GitHub Actions / GitLab CI / Jenkins)
      │
      ▼
Scripts de automação → GeoServer REST API
      │
      ▼
Publicação automática de camadas e estilos

3. Exemplo de GitHub Actions para publicar SLDs

Podemos criar um workflow simples que envia estilos ao GeoServer sempre que houver uma atualização no repositório:

name: Deploy GeoServer Styles

on:
  push:
    paths:
      - 'styles/**'

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Enviar SLDs para GeoServer
        run: |
          for file in styles/*.sld; do
            curl -u ${{ secrets.GEOSERVER_USER }}:${{ secrets.GEOSERVER_PASS }} \
                 -XPUT -H "Content-type: application/vnd.ogc.sld+xml" \
                 --data-binary @$file \
                 http://localhost:8080/geoserver/rest/workspaces/cite/styles/$(basename $file .sld)
          done

Esse workflow garante que qualquer atualização de estilo seja aplicada automaticamente no GeoServer sem intervenção manual.

4. Automação de publicação de camadas

Além de estilos, podemos publicar camadas vetoriais e rasters via scripts Python ou Bash integrados ao CI/CD:

• Verificação de novos arquivos em pastas específicas ou repositórios de dados.
• Validação de CRS, atributos e integridade dos dados.
• Uso da REST API para criar stores, featureTypes e coverages.

Exemplo rápido em Python para publicar um shapefile:

import requests
import json

GEOSERVER_URL = "http://localhost:8080/geoserver/rest"
AUTH = ("admin", "geoserver")

# Criar ou atualizar store
store_json = {"dataStore": {"name": "biomas_postgis", "connectionParameters":{"entry":[{"@key":"url","$":"file:data/biomas.shp"}]}}}
requests.post(f"{GEOSERVER_URL}/workspaces/cite/datastores", auth=AUTH, headers={"Content-type":"application/json"}, data=json.dumps(store_json))

# Publicar camada
layer_json = {"featureType":{"name":"biomas","title":"Biomas do Brasil","srs":"EPSG:4674"}}
requests.post(f"{GEOSERVER_URL}/workspaces/cite/datastores/biomas_postgis/featuretypes", auth=AUTH, headers={"Content-type":"application/json"}, data=json.dumps(layer_json))

5. Boas práticas em pipelines CI/CD para GeoServer

• Versionamento de estilos e scripts em Git, permitindo rollback fácil.
• Testes automáticos antes de publicar novos dados ou estilos.
• Segurança: use variáveis de ambiente ou secrets para credenciais da API.
• Monitoramento de logs do GeoServer para detectar erros em tempo real.
• Divisão de ambientes: dev, staging e produção para evitar impactos em serviços críticos.

Conclusão

Integrar o GeoServer a pipelines DevOps transforma o gerenciamento de dados geoespaciais em um processo confiável, repetível e rastreável. CI/CD permite aplicar estilos, publicar camadas e atualizar dados automaticamente, mantendo serviços WMS e WFS sempre consistentes e disponíveis.

Hoy, Bentley Systems y Enactus anunciaron los equipos ganadores del iTwin4Good Challenge 2025, la competencia internacional que reúne a estudiantes universitarios para aplicar la tecnología de gemelos digitales y resolver desafíos del mundo real. Los competidores de este año buscaron aprovechar el poder de la innovación digital para abordar desafíos críticos de sostenibilidad, demostrando cómo […]

Prezado leitor,

Monitorar o GeoServer é fundamental para garantir a estabilidade dos serviços e antecipar falhas. A REST API do GeoServer oferece endpoints que permitem criar healthchecks, consultar status de camadas, conexões e até acompanhar logs em tempo real — tudo de forma automatizada.

1. Healthcheck simples do GeoServer

O endpoint /about/version retorna informações básicas do servidor. É ideal para um healthcheck inicial:

curl -u admin:geoserver \
http://localhost:8080/geoserver/rest/about/version.json

A resposta inclui versão do GeoServer, build e dados do ambiente. Se este endpoint responder com sucesso (HTTP 200), sabemos que o servidor está no ar.

2. Consultando camadas e stores

Para monitorar se um workspace ou store está ativo, podemos listar camadas ou stores disponíveis. Exemplo para listar todos os stores do workspace cite:

curl -u admin:geoserver \
http://localhost:8080/geoserver/rest/workspaces/cite/datastores.json

A resposta retornará a lista de stores configurados. Um script pode percorrer essa lista para verificar se conexões com PostGIS ou arquivos shapefile estão acessíveis.

3. Consultando Logs do GeoServer

O GeoServer permite acessar os logs via REST API, mas esse recurso não vem habilitado por padrão.

Para ativá-lo, siga os passos:

1. Acesse a interface web do GeoServer (http://localhost:8080/geoserver).
2. Vá em Serviços → Logging.
3. Certifique-se de escolher um perfil de log (por exemplo, DEFAULT_LOGGING ou GEOSERVER_DEVELOPER_LOGGING).
4. Marque a opção Enable REST access to logs (se disponível na versão do seu GeoServer).
5. Salve a configuração.

Após habilitar, você poderá consultar os logs via REST:

curl -u admin:geoserver \
http://localhost:8080/geoserver/rest/logs.json

A resposta retorna mensagens recentes do log do servidor, úteis para detectar falhas em publicações de camadas, erros de conexão ou problemas de configuração.

4. Monitoramento em Python

Podemos criar um script em Python para automatizar healthchecks e alertas:

import requests

GEOSERVER_URL = "http://localhost:8080/geoserver/rest"
AUTH = ("admin", "geoserver")

# Healthcheck
r = requests.get(f"{GEOSERVER_URL}/about/version.json", auth=AUTH)
print("Status GeoServer:", r.status_code)

# Listar stores do workspace cite
r = requests.get(f"{GEOSERVER_URL}/workspaces/cite/datastores.json", auth=AUTH)
if r.status_code == 200:
    stores = r.json()
    print("Stores encontrados:", [s["name"] for s in stores["dataStores"]["dataStore"]])

Esse script pode ser integrado a ferramentas de monitoramento como cron jobs, Prometheus ou até sistemas de alerta via Slack/Telegram.

Conclusão

Monitorar o GeoServer via REST API permite detectar problemas rapidamente e automatizar verificações essenciais, reduzindo falhas em produção.

La inteligencia artificial ha transformado la manera en que creamos mapas, haciéndolo más fácil, rápido e intuitivo. En este artículo descubrirás cómo generar mapas con inteligencia artificial de forma sencilla, con ayuda de distintas aplicaciones basadas en IA. 1. BetterMaps.ai Bettermaps.ai es la primera plataforma del mundo para crear mapas con lenguaje natural. Basta con escribir lo ...

Leer más

7 aplicaciones para crear mapas con inteligencia artificial

<figure class="wp-block-image size-large"></figure>

Los Sistemas de Información Geográfica (SIG) se han convertido en una herramienta clave para transformar datos en conocimiento y mejorar la manera en que se gestionan proyectos en todo tipo de sectores. Desde la planificación urbana hasta la gestión de emergencias, los SIG permiten tomar decisiones mejor fundamentadas y estratégicas.

Mañana miércoles 10 de septiembre a las 10:00 a.m. (hora de Panamá) tendrás la oportunidad de participar en un webinar en el que hablaremos de nuestra experiencia práctica sobre cómo los SIG apoyan procesos de gestión y decisión en contextos reales.

¿Por qué asistir?

• Conocerás casos de uso reales de SIG en diferentes ámbitos.
• Descubrirás cómo las herramientas de la Suite gvSIG ayudan a optimizar recursos y anticipar problemas.
• Obtendrás una visión clara de por qué los SIG son aliados estratégicos en la transformación digital.

Fecha: Miércoles 10 de septiembre, 2025
Hora: 10:00 a.m.

Regístrate gratis aquí: Formulario de inscripción

Prezado leitor,

No dia a dia, é comum termos diversos workspaces configurados, cada um com seus stores, layers e estilos associados. Em ambientes de produção, manter cópias de segurança é fundamental para prevenir perdas em caso de falhas ou para replicar configurações em outro servidor.

1. Exportar (backup) um workspace

O GeoServer expõe endpoints REST que permitem exportar a configuração completa de um workspace em formato .zip.

# Exporta o workspace "meu_workspace"
# -u admin:geoserver → autenticação no GeoServer (usuário:senha)
# -XGET → método HTTP utilizado
# -H "Accept: application/zip" → define que a resposta será um arquivo ZIP
# URL do endpoint com ?recurse=true → inclui stores, layers e estilos associados
# -o meu_workspace_backup.zip → salva o backup no arquivo ZIP local

curl -u admin:geoserver -XGET \
  -H "Accept: application/zip" \
  http://localhost:8080/geoserver/rest/workspaces/meu_workspace?recurse=true \
  -o meu_workspace_backup.zip

Como resultado você terá um arquivo meu_workspace_backup.zip contendo toda a estrutura do workspace desejado.

2. Importar (restore) um workspace

Para restaurar, basta enviar o .zip de volta ao GeoServer via POST:

# Restaura o workspace a partir do backup ZIP
# -u admin:geoserver → autenticação no GeoServer
# -XPOST → método HTTP utilizado
# -H "Content-type: application/zip" → indica que o arquivo enviado é ZIP
# --data-binary @meu_workspace_backup.zip → envia o arquivo binário
# URL do endpoint /workspaces → local onde o workspace será recriado

curl -u admin:geoserver -XPOST \
  -H "Content-type: application/zip" \
  --data-binary @meu_workspace_backup.zip \
  http://localhost:8080/geoserver/rest/workspaces

Esse processo recriará o workspace no GeoServer de destino, com toda a configuração previamente exportada.

3. Conclusão

Com poucos comandos, conseguimos automatizar o processo de backup e restore de workspaces via REST API. Essa prática é indispensável para migrações, ambientes de testes e recuperação rápida em caso de falhas.

¿Alguna vez has querido preguntarle a tu aplicación qué datos tiene o qué puede hacer con ellos, usando tus propias palabras? Esa fue la pregunta que me hice a principios de este año cuando empecé a ver que los modelos de lenguaje (LLMs, Large Language Models o Modelos de Lenguaje Grande) podían hacer cosas increíbles… pero siempre desde un navegador web, lejos de la aplicación de escritorio.

Como muchos sabéis, llevo años trabajando en gvSIG Desktop, una aplicación Java de escritorio con mucha historia y mucho código. La idea de integrar capacidades de IA directamente en la aplicación me pareció fascinante, pero tenía un problema: todo lo que veía requería frameworks complejos de Python o soluciones en la nube que no encajaban con nuestra realidad, requerian versiones modernas de java o python con las que no podia contar.

Así que me dije “voy a intentar hacerlo a mi manera”. Voy a contaros cómo, en unos dias, conseguí que gvSIG desktop empezara a conversar con Gemini usando poco más que las librerías HTTP de Java y Jython.

El primer paso, un chat simple pero funcional

Lo primero que necesitaba era lo más básico, una ventana de chat dentro de gvSIG desktop que pudiera enviar mensajes a la API de Gemini y mostrar las respuestas.

Para mantener las cosas simples, usé el entorno de scripting y Jython para prototipar rápidamente la interfaz de usuario, y para la comunicación con la API, me bastó con las librerías HTTP de Java.

El núcleo de la comunicación se reducía a esto: construir el payload JSON correcto y enviarlo.

from java.net import URL, HttpURLConnection
from java.io import BufferedReader, InputStreamReader, OutputStreamWriter
from javax.json import Json

class GeminiClient:
    def __init__(self):
        self.history = []
        self.api_key = "tu_api_key"
        self.api_url = "https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent"

    def send_message(self, user_prompt):
        # Construir la solicitud HTTP
        url = URL(self.api_url + "?key=" + self.api_key)
        conn = url.openConnection()
        conn.setRequestMethod("POST")
        conn.setRequestProperty("Content-Type", "application/json")
        conn.setDoOutput(True)

        # Construir el payload JSON
        payload = {
            "contents": [{
                "parts": [{"text": user_prompt}]
            }]
        }

        # Enviar la solicitud
        output_stream = conn.getOutputStream()
        writer = OutputStreamWriter(output_stream, "UTF-8")
        writer.write(Json.createObjectBuilder(payload).build().toString())
        writer.flush()

        # Leer la respuesta
        reader = BufferedReader(InputStreamReader(conn.getInputStream()))
        response = ""
        line = reader.readLine()
        while line is not None:
            response += line
            line = reader.readLine()

        return response

La magia estaba en construir el Json correcto que espera la API de Gemini. Pero una vez resuelto esto, en pocas horas ya tenía una ventana de chat funcionando dentro de gvSIG.

El primer prototipo era sencillo, pero funcionaba. Podía escribir preguntas y obtener respuestas.

El desafío real, más allá del chat conversacional

Un chat conversacional está bien para hacer pruebas, pero no es muy útil en una aplicación de escritorio. El verdadero reto era cómo usar el LLM para algo práctico. En nuestro caso, se me ocurrió que podría ayudar con la ficha de búsqueda de gvSIG, que aunque es potente, puede resultar compleja para los usuarios.

Pero aquí aparecía otro problema ¿cómo le pido al LLM que trabaje con mis datos sin enviarle información sensible, sin enviarle los datos de las capas que tengo cargadas la la aplicación? La solución fue enseñarle a entender la estructura de mis datos, no darle los datos en sí.

El arte del prompting estructurado, enseñándole las reglas del juego

La verdadera magia no estaba en la conexión HTTP o en la cacharreria Json que habia que hacer para hablar con el LLM, sino en el diseño del system prompt que conseguiría que el LLM entendiera exactamente cómo tenía que comportarse, estaba programando con palabras. El prompt se convirtió en el cerebro del sistema, las reglas del juego que transformaban un modelo de lenguaje genérico en un especialista de gvSIG desktop.

El desafío era triple:

1. Contexto: Darle al LLM información suficiente sobre la estructura de los datos
2. Comportamiento: Definir exactamente cómo debía responder para cada tipo de consulta
3. Formato: Forzar una salida estructurada y parseable

El prompt base tenía que establecer las reglas fundamentales.

La estructura del esqueleto principal del prompt que construí fue algo parecido a esto:

BASE_PROMPT = u"""
Eres un asistente especializado en gvSIG Desktop. 
Responde EXCLUSIVAMENTE en castellano con objetos JSON válidos.

TIPOS DE CONSULTA SOPORTADOS:
- "text": Para consultas generales
- "sql": Para consultas SQL sobre las tablas
- "plantuml": Para diagramas de entidad-relación

REGLAS ESTRICTAS PARA SQL:
- ⛔ Nunca incluyas esquemas en las consultas
- ✅ Usa solo SQL-92 estándar  
- 🌍 Solo funciones espaciales de SQL/MM y OGC SFS
- 🚫 Evita sintaxis no estándar
- 📏 Limita a 1000 resultados

ESTRUCTURA DE RESPUESTA OBLIGATORIA:
{
  "type": "tipo_de_respuesta",
  // campos adicionales según el tipo
}

EJEMPLO SQL:
{
  "type": "sql",
  "sql": "SELECT * FROM tabla WHERE condición LIMIT 1000;",
  "title": "Descripción clara",
  "esValorEscalar": false
}

EJEMPLO PLANTUML:
{
  "type": "plantuml", 
  "diagram": "@startuml\\nentity Tabla\\n@enduml",
  "title": "Diagrama de entidades"
}
"""

Con estas reglas, el LLM ya no solo conversaba, sino que generaba instrucciones. La aplicación actuaba como un intérprete: recibía un JSON, miraba el campo “type” y sabía exactamente qué hacer. Si recibía {“type”: “sql”, …}, sabía que debía mostrar un botón que, al pulsarlo, ejecutaría la consulta SQL. Si recibía {“type”: “plantuml”, …}, generaría un botón para visualizar el diagrama.

Los resultados, cuando todo empezó a encajar

La primera vez que probé el sistema completo me resulto impactante. El LLM dejó de ser un simple chatbot para convertirse en un motor de análisis que respondía a mis preguntas con acciones concretas. Una conversación natural se traducía en operaciones reales dentro de gvSIG:

En esta captura se ve cómo el usuario pregunta “Puedes generarme un modelo entidad relación con las tablas a las que tienes acceso?” y el sistema responde con un botón que al hacer clic muestra el diagrama solicitado.

Aquí vemos cómo la orden de “Muestrame las placas que tienen un soporte de acero” el sistema genera una consulta SQL y responde con un botón que al hacer clic muestra el resultado en una tabla.

Finalmente, una solicitud más compleja como un gráfico de barras se traduce en la visualización de este en la aplicación.

Cada respuesta del sistema correspondía a un Json estructurado que el LLM generaba y que la aplicación parseaba y ejecutaba, mostrando los resultados en tablas o gráficos según el caso.

Detalles de implementación para desarrolladores

La comunicación con la API de Gemini

Implementé un cliente Gemini en Jython que maneja el historial de conversación.

def send_message(self, user_prompt, initial_prompt=None):
    # Añadir mensajes al historial
    if not self.history and initial_prompt is not None:
        self.history.append({"role": "user", "parts": [{"text": initial_prompt}]})

    self.history.append({"role": "user", "parts": [{"text": user_prompt}]})

    # Construir y enviar payload
    payload = self._build_payload()
    response = self._send_request(payload)

    # Procesar respuesta
    generated_text = self._parse_response(response)
    self.history.append({"role": "model", "parts": [{"text": generated_text}]})

    return generated_text

Procesamiento de respuestas Json

Una de las partes más críticas fue el parseo de las respuestas Json del LLM. Muchas veces el LLM mezclaba la respuesta estructurada junto con comentarios, preguntas o peticiones de aclaraciones o información, y habia que separar la respuesta extructurada, el Json, del resto de la conversación.

def extraer_json_de_markdown(texto_completo):
    marca_inicio = u'```json'
    marca_fin = u'```'

    pos_inicio = texto_completo.find(marca_inicio)
    if pos_inicio != -1:
        pos_contenido_inicio = pos_inicio + len(marca_inicio)
        pos_fin = texto_completo.find(marca_fin, pos_contenido_inicio)

        if pos_fin != -1:
            json_encontrado = texto_completo[pos_contenido_inicio:pos_fin].strip()
            return json_encontrado, texto_completo[:pos_inicio] + texto_completo[pos_fin + len(marca_fin):]

    return None, texto_completo

Reflexiones… y una pregunta incómoda

Este primer prototipo me demostró varias cosas importantes:

1. No necesitas frameworks complejos para empezar a integrar IA en aplicaciones legacy.
2. El prompting estructurado es la clave: Puedes “programar” el comportamiento de un LLM con instrucciones precisas.
3. Java/Jython y las librerías estándar son suficientes para comunicarse con APIs modernas.

Tenía una prueba de concepto que funcionaba. Pero mientras veía las respuestas de la IA aparecer en la pantalla, una pregunta empezó a rondarme la cabeza, una que podia convertir este experimento en un simple juguete personal.

Cada una de esas respuestas “mágicas” requería una llamada a una API de pago. ¿Cómo iba a compartir esto con alguien sin que ni ellos ni yo nos arruinásemos en el intento? ¿Pedirle a los usuarios que consiguieran su propia API Key solo para probar mi herramienta? No parecia realista.

De repente, el mayor desafío ya no era técnico, sino de distribución. Pero antes de poder resolver ese problema, necesitaba que la herramienta fuera tan útil, tan indispensable, que mereciera la pena luchar por ella. Tenía que dejar de ser un chat para convertirse en un verdadero asistente que entendiera el contexto de lo que el usuario estaba haciendo en gvSIG desktop.

De eso, y de cómo el contexto lo cambió todo, hablaré en el siguiente artículo.

Un saludo.

Prezado leitor,

Neste tutorial você vai aprender, passo a passo, como enviar um shapefile diretamente para o GeoServer usando a REST API. A diferença aqui é que, em vez de o arquivo ser salvo na pasta data_dir, ele será importado automaticamente para o PostGIS, utilizando o plugin Importer do GeoServer.

Esse fluxo é extremamente útil para automatizar processos de ingestão de dados em ambientes de produção, evitando a manipulação manual da pasta data_dir.

Além disso, com a REST API, você pode integrar esse processo em scripts Python, pipelines de ETL ou até em rotinas de integração contínua (CI/CD).

Vamos ao passo a passo:

1. Criação do Store

Antes de importar o shapefile, precisamos garantir que existe um store configurado apontando para o banco PostGIS.

Isso pode ser feito pela própria REST API, com o seguinte comando:

curl  -u admin:geoserver -XPOST -H "Content-type: application/json" -d @postgis.json "http://localhost:8080/geoserver/rest/workspaces/cite/datastores.json"

O comando acima cria um novo Store no GeoServer, e as configurações ficam no arquivo postgis.json, quem contem as informações de conexão da base de dados que você deseja utilizar no GeoServer, conforme o exemplo a abaixo:

{
  "dataStore": {
    "name": "postgis",
    "type": "PostGIS",
    "workspace": {
      "name": "cite"
    },
    "connectionParameters": {
      "entry": [
        {"@key": "schema","$": "public"},
        {"@key": "database","$": "postgres"},
        {"@key": "host","$": "localhost"},
        {"@key": "port","$": "5432"},
        {"@key": "passwd","$": "postgres"},
        {"@key": "dbtype","$": "postgis"},
        {"@key": "user","$": "postgres"},
        {"@key": "Estimated extends","$": "true"},
        {"@key": "encode functions","$": "true"},
        {"@key": "Loose bbox","$": "true"},
        {"@key": "Method used to simplify geometries","$": "PRESERVETOPOLOGY"},
        {"@key": "Support on the fly geometry simplification","$": "true"},
        {"@key": "validate connections","$": "true"},
        {"@key": "Connection timeout","$": "20"},
        {"@key": "min connections","$": "1"},
        {"@key": "max connections","$": "10"},
        {"@key": "Evictor tests per run","$": "3"},
        {"@key": "Test while idle","$": "true"},
        {"@key": "Max connection idle time","$": "300"}
      ]
    },
    "_default": true
  }
}

2. Definição para importação

É importante ressaltar que para executar o comando abaixo, é necessário que o plugin Importer esteja instalado no seu GeoServer, pois é ele que fará a importação do shapefile para o banco de dados. O primeiro passo é preparar a tarefa através do seguinte comando:

curl.exe -u admin:geoserver -XPOST -H "Content-type: application/json" -d @import.json "http://localhost:8080/geoserver/rest/imports"

O arquivo import.json deve conter as informações de onde você deseja armazenar o arquivo shapefile, no caso workspace e store:

{
   "import": {
      "targetWorkspace": {
         "workspace": {
            "name": "cite"
         }
      },
      "targetStore": {
         "dataStore": {
            "name": "postgis"
         }
      }
   }
}

O comando acima irá retornar um ID (no nosso exemplo é o 0), que você irá inserir no link de resposta ao GeoServer. Após a execução do comando acima temos uma importação vazia, sem tarefas. Para adicionar uma tarefa, publique o shapefile na lista de tarefas:

curl.exe -u admin:geoserver -F name=biomas_srv.zip -F filedata=@biomas_srv.zip "http://localhost:8080/geoserver/rest/imports/0/tasks"

3. Apontar para o Store

Como enviamos um shapefile, o importador assume que o destino será um repositório de shapefiles. Para importar para o PostGIS, precisaremos redefini-lo, e faremos isso através do arquivo target.json:

{
  "dataStore": {
    "name":"postgis"
  }
}

Coloque esse arquivo na requisição abaixo:

curl.exe -u admin:geoserver -XPUT -H "Content-type: application/json" -d @target.json "http://localhost:8080/geoserver/rest/imports/0/tasks/0/target"

4. Realizar a importação

Por fim, executamos a importação enviando um POST da seguinte forma:

curl.exe -u admin:geoserver -XPOST "http://localhost:8080/geoserver/rest/imports/0"

Se tudo correr bem, o shapefile será carregado diretamente no seu banco PostGIS e publicado no GeoServer.

5. BÔNUS

Para quem deseja automatizar o processo, segue um exemplo de um Script Python usando a biblioteca requests. Veja como usar:

1. Salve o script em um arquivo, por exemplo import_shapefile.py.
2. Certifique-se de instalar a biblioteca necessária:

pip install requests

3. Ajuste os parâmetros de conexão (usuário, senha, banco, shapefile, workspace etc.) conforme seu ambiente.
4. Agora execute o script: python import_shapefile.py

# Script import_shapefile.py

import requests
import json

# Configurações
GEOSERVER_URL = "http://localhost:8080/geoserver/rest"
AUTH = ("admin", "geoserver")  # usuário e senha
WORKSPACE = "cite"
DATASTORE = "postgis"
SHAPEFILE = "biomas_srv.zip"

# 1. Criar o DataStore (caso ainda não exista)
postgis_json = {
    "dataStore": {
        "name": DATASTORE,
        "type": "PostGIS",
        "workspace": {"name": WORKSPACE},
        "connectionParameters": {
            "entry": [
                {"@key": "schema", "$": "public"},
                {"@key": "database", "$": "postgres"},
                {"@key": "host", "$": "localhost"},
                {"@key": "port", "$": "5432"},
                {"@key": "passwd", "$": "postgres"},
                {"@key": "dbtype", "$": "postgis"},
                {"@key": "user", "$": "postgres"}
            ]
        }
    }
}

resp = requests.post(
    f"{GEOSERVER_URL}/workspaces/{WORKSPACE}/datastores",
    auth=AUTH,
    headers={"Content-type": "application/json"},
    data=json.dumps(postgis_json)
)

print("Criação do DataStore:", resp.status_code)

# 2. Criar importação
import_json = {
    "import": {
        "targetWorkspace": {"workspace": {"name": WORKSPACE}},
        "targetStore": {"dataStore": {"name": DATASTORE}}
    }
}

resp = requests.post(
    f"{GEOSERVER_URL}/imports",
    auth=AUTH,
    headers={"Content-type": "application/json"},
    data=json.dumps(import_json)
)

import_id = resp.json()["import"]["id"]
print("ID da importação:", import_id)

# 3. Adicionar o shapefile à importação
with open(SHAPEFILE, "rb") as f:
    resp = requests.post(
        f"{GEOSERVER_URL}/imports/{import_id}/tasks",
        auth=AUTH,
        files={"filedata": f},
        data={"name": SHAPEFILE}
    )

print("Upload shapefile:", resp.status_code)

# 4. Ajustar destino para PostGIS
target_json = {"dataStore": {"name": DATASTORE}}

resp = requests.put(
    f"{GEOSERVER_URL}/imports/{import_id}/tasks/0/target",
    auth=AUTH,
    headers={"Content-type": "application/json"},
    data=json.dumps(target_json)
)

print("Redefinição destino:", resp.status_code)

# 5. Executar importação
resp = requests.post(
    f"{GEOSERVER_URL}/imports/{import_id}",
    auth=AUTH
)

print("Execução da importação:", resp.status_code)

GeoDa (Geographic Data Analysis) es un software gratuito y de código abierto creado por el Dr. Luc Anselin para la introducción a la ciencia de datos espaciales. Su objetivo es facilitar el análisis y modelado de patrones espaciales a través de una interfaz gráfica sencilla y potente. No viene a sustituir ningún software GIS, sino ...

Leer más

GeoDa: Una introducción a la ciencia de datos espaciales

Este tutorial mostra como configurar um script que atualiza automaticamente as camadas do GeoServer no GeoNode, utilizando um checksum para detectar alterações.

1. Instalar o checksumdir dentro do container do GeoServer

1.1 Entrar no container do GeoServer

docker exec -it geoserver4my_geonode bash

1.2 Instalar o checksumdir

pip install checksumdir

2. Gerar o checksum (código único) da pasta do GeoServer

O comando checksumdir cria um hash único com base no conteúdo de todos os arquivos da pasta especificada. Isso significa que qualquer alteração em uma camada, SLD ou arquivo dentro do workspace do GeoNode fará o checksum mudar, permitindo que o script detecte automaticamente essas modificações e atualize as camadas no GeoNode.

2.1 Executar o comando:

checksumdir /geoserver_data/data/workspaces/geonode

Anote o código gerado, pois ele será usado na etapa seguinte.

3. Criar um arquivo para armazenar o checksum

3.1 Criar o arquivo:

sudo mkdir /opt/updatelayers
sudo chown geocursos /opt/updatelayers
sudo chgrp www-data /opt/updatelayers
cd /opt/updatelayers
touch layers_updated_md5

3.2 Inserir o código do checksum

nano layers_updated_md5

Cole o checksum gerado na etapa anterior e salve o arquivo.

4. Criar o script de execução automática

4.1 Criar o arquivo do script:

touch cron_updatelayers.sh

4.2 Adicionar o código no script:

geoserver="geoserver4my_geonode"
geonode="django4my_geonode"

md5=$(docker exec -i $geoserver checksumdir /geoserver_data/data/workspaces/geonode)

if [[ $md5 != $(cat /opt/updatelayers/layers_updated_md5) ]]; then
    echo "Atualizando camadas"
    echo $md5 > /opt/updatelayers/layers_updated_md5
    docker exec -i $geonode python3 manage.py updatelayers
fi

4.3 Agora você precisa tornar o arquivo executável:

chmod +x /opt/updatelayers/cron_updatelayers.sh

5. Configurar o cron para execução automática

5.1 Abrir o arquivo crontab:

sudo nano /etc/crontab

5.2 Adicionar a linha para executar o script a cada 5 minutos

Lembre-se de alterar o caminho do script conforme a sua configuração:

*/5 * * * * geocursos bash /opt/updatelayers/cron_updatelayers.sh

Pronto! Agora seu GeoServer irá verificar periodicamente alterações nas camadas e atualizar automaticamente no GeoNode quando houver mudanças.

Se você quiser conferir se o comando está sendo executando, basta executar:

sudo grep CRON /var/log/syslog

Por último, mas não menos importante, gostaria de agradecer ao Diego Varela por disponibilizar esse script.

Prezado leitor,

Se você está implantando o GeoNode na sua infraestrutura e deseja conectar um banco de dados já existente, este tutorial irá guiá-lo passo a passo para realizar a configuração corretamente.

1. Descobrir o endereço IP da Rede Docker

Para identificar a rede que está rodando o seu GeoNode, execute:

/opt/geonode_custom/my_geonode> docker network inspect my_geonode_default | grep Subnet

2. Descobrir o IP da máquina Linux

Para descobrir o endereço IP da máquina onde o Docker está rodando:

/opt/geonode_custom/my_geonode> ifconfig

3. Certificar que os containers Docker estejam inativos

docker-compose down

4. Desabilitar o banco de dados interno do GeoNode

Edite o arquivo docker-compose.yml e comente as linhas referentes ao PostGIS interno, para evitar conflitos com o banco externo:

# PostGIS database.
  #db:
  #  image: ${COMPOSE_PROJECT_NAME}/postgis:${POSTGRES_BASE_IMAGE_VERSION}
  #  build:
  #    context: ./docker/postgresql
  #    dockerfile: Dockerfile
  #    args:
  #      - BASE_IMAGE_VERSION=${POSTGRES_BASE_IMAGE_VERSION}
  #  command: postgres -c "max_connections=${POSTGRESQL_MAX_CONNECTIONS}"
  #  container_name: db4${COMPOSE_PROJECT_NAME}
  #  env_file:
  #    - .env
  #  volumes:
  #    - dbdata:/var/lib/postgresql/data
  #    - dbbackups:/pg_backups
  #  restart: unless-stopped
  #  healthcheck:
  #    test: "pg_isready -d postgres -U postgres"
  # uncomment to enable remote connections to postgres
  #ports:
  #  - "5432:5432"

  # dbdata:
  #    name: ${COMPOSE_PROJECT_NAME}-dbdata
  #  dbbackups:
  #    name: ${COMPOSE_PROJECT_NAME}-dbbackups

Você precisa desabilitar a dependência do Django ao banco para que não dê erro ao tentar subir o container novamente:

django:
#  depends_on:
#   - db

E também a dependência do GeoServer e Celery ao Django:

#  depends_on:
#   - django:
#      condition: service_healthy

5. Parâmetros necessários no banco de dados externo

Quanto ao banco de dados externo, espera-se que ele tenha os seguintes parâmetros:

• Usuário com senha para conexão
• Base de dados para as tabelas Django do GeoNode
• Base de dados para os dados espaciais
• Endereço IP do servidor de banco externo
• Porta de acesso ao banco
• Endereço IP da rede Docker

6. Preparar o banco de dados externo

O GeoNode precisa de duas bases de dados: uma para o Django (geonode) e outra para os dados espaciais (geonode_data). Veja:

-- Criar usuário com senha forte
CREATE USER geonode_user WITH PASSWORD 'geonode123';

-- Criar os bancos com ownership do usuário

CREATE DATABASE geonode OWNER geonode_user;
CREATE DATABASE geonode_data OWNER geonode_user;

-- ==============================
-- Configuração no banco geonode
-- ==============================
-- Abra o banco geonode e execute:

CREATE EXTENSION IF NOT EXISTS postgis;

GRANT ALL ON geometry_columns TO PUBLIC;
GRANT ALL ON spatial_ref_sys TO PUBLIC;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO geonode_user;

-- ==============================
-- Configuração no banco geonode_data
-- ==============================
-- Abra o banco geonode_data e execute:

CREATE EXTENSION IF NOT EXISTS postgis;

GRANT ALL ON geometry_columns TO PUBLIC;
GRANT ALL ON spatial_ref_sys TO PUBLIC;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO geonode_user;

7. Atualizar o arquivo .env com os dados do banco externo

Lembre-se de alterar o número do IP e a porta de acordo com a sua realidade (onde seu banco de dados está instalado), no meu caso o IP do meu banco é o 192.168.0.245.

# -------------------------------
# Backend
# -------------------------------
GEONODE_DATABASE=geonode
GEONODE_DATABASE_USER=geonode_user
GEONODE_DATABASE_PASSWORD=geonode123
GEONODE_GEODATABASE=geonode_data
GEONODE_GEODATABASE_USER=geonode_user
GEONODE_GEODATABASE_PASSWORD=geonode123
GEONODE_DATABASE_SCHEMA=public
GEONODE_GEODATABASE_SCHEMA=public
DATABASE_HOST=192.168.0.245
DATABASE_PORT=5432
DATABASE_URL=postgis://geonode_user:geonode123@192.168.0.245:5432/geonode
GEODATABASE_URL=postgis://geonode_user:geonode123@192.168.0.245:5432/geonode_data

8. Alterar o arquivo pg_hba.conf

Agora é necessário inserir no arquivo do PostgreSQL as permissões de acesso a máquina e a rede onde está rodando o docker, da seguinte forma:

# -------------------------------
# GeoNode connections
# -------------------------------

# Permite que a rede dos containers Docker do GeoNode acesse o PostgreSQL
host   geonode        geonode_user   172.18.0.0/16        md5
host   geonode_data   geonode_user   172.18.0.0/16        md5

# Permite que a VM Linux (192.168.186.137) e qualquer host da sub-rede 192.168.0.0/24 acessem o PostgreSQL
host   geonode        geonode_user   192.168.186.137/32   md5
host   geonode_data   geonode_user   192.168.186.137/32   md5
host   geonode        geonode_user   192.168.0.0/24       md5
host   geonode_data   geonode_user   192.168.0.0/24       md5

Observações:

• 172.18.0.0/16 → rede Docker
• 192.168.186.137/32 → IP da VM Linux

Após alterado o arquivo, você deve reiniciar o serviço do PostgreSQL. Se for no Linux, faça da seguinte forma:

sudo service postgresql restart

9. Reiniciar o docker

Para finalizar o processo, faça um novo build e depois suba o docker:

/opt/geonode_custom/my_geonode> docker-compose build 
/opt/geonode_custom/my_geonode> docker-compose up -d

Agora é só testar e ver se funcionou.

10. Ambiente

Para esse teste eu utilizei:

– Máquina com Windows 11 e PostgreSQL 16 (IP 192.168.0.245)
– Ubuntu 22.04 rodando no VMWare, dentro da máquina Windows (IP 192.168.186.137)

En el mundo de los SIG, elegir el lenguaje adecuado es clave para sacar el máximo partido a nuestros datos espaciales. Entre los lenguajes más utilizados destacan Python, R y JavaScript, cada uno con sus puntos fuertes y débiles. En MappingGIS ofrecemos cursos especializados en cada lenguaje aplicado a los SIG, para que puedas aprender ...

Leer más

¿Qué lenguaje de programación es mejor para GIS: Python, R o JavaScript?

Mapas interativos têm o poder de quebrar barreiras.

Eles tornam dados complexos acessíveis a qualquer pessoa com um navegador sem precisar instalar software, nem entender de SIG. É inclusão digital aplicada à geoinformação!

Seja em projetos sociais, pesquisas acadêmicas ou iniciativas governamentais, os mapas interativos são essenciais para democratizar o acesso à informação espacial, permitindo que cidadãos, técnicos e gestores entendam e se posicionem com base em dados reais.

E você? Está preparado para criar mapas que informam, educam e mobilizam?

A Geocursos possui um Curso de WebGIS onde você aprende a publicar seus dados na web com ferramentas livres e intuitivas. Tudo passo a passo, para você sair do curso criando seu WebGIS.

Verifique se estamos com inscrições abertas e leve seus dados espaciais para o mundo online!

Se você trabalha com grandes volumes de dados geoespaciais, sabe o valor de uma apresentação clara, interativa e atualizável em tempo real. É aí que os dashboards entram:

Análise espacial facilitada
Consolide camadas, filtros e gráficos em uma única interface interativa.

Ganho de tempo
Dashboards eliminam a necessidade de gerar relatórios estáticos e manuais.

Tomada de decisão orientada por dados
Monitore indicadores geográficos em tempo real, com base em fontes dinâmicas.

Compartilhamento online seguro
Distribua informações em portais web, com permissões personalizadas.

Seja para gestão urbana, meio ambiente, negócios ou emergências, um dashboard geográfico é a ferramenta ideal para transformar dados em ação.

Você sabia que pode fazer tudo isso no GeoNode? Que ele é uma plataforma aberta que te permite disponibilizar, mapas, dashboards e geostories?

Clique aqui e saiba mais.

El libro «Análisis espacial con R: Usa R como un Sistema de Información Geográfica» ha sido escrito por JEAN-FRANCOIS MAS, publicado en julio de 2025 y está bajo licencia libre CC. R es una plataforma de análisis estadístico con herramientas gráficas muy avanzadas y es un referente en el análisis estadístico desde hace muchos años. A ...

Leer más

Análisis espacial con R: Usa R como un Sistema de Información Geográfica (2025)

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Hoje, muitos mapas são criados e usados em computadores, usando Sistemas de Informação Geográfica (SIG).

o SIG é um conjunto de procedimentos (manual ou computacional) usado para armazenar e manipular dados georreferenciados.

o Em SIG, os dados geográficos são organizados em "camadas" ou "planos de informação", como se fossem transparências que podem ser sobrepostas. Cada camada geralmente tem o mesmo tipo de geometria (ponto, linha, polígono) e atributos.

o Entender conceitos como projeções e sistemas de referência de coordenadas (SRC) é fundamental em SIG para garantir que as camadas "encaixem" corretamente. O datum é parte desse sistema de referência.

o Os dados geográficos (geometria e atributos) podem ser armazenados em bancos de dados geográficos. A geometria e os atributos podem ser armazenados juntos ou separados e relacionados por identificadores.

o SIGs nos permitem analisar dados geográficos (Análise Espacial) e criar mapas para responder perguntas complexas, realizando operações como consultas por atributo ou junções espaciais. A simbologia e os rótulos baseados em atributos são importantes para visualizar os resultados da análise. Também permitem medir distâncias, áreas, calcular centróides, etc..

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

Se você trabalha com dados geográficos, já deve ter enfrentado desafios como:

Dificuldade para publicar dados espaciais online
Compartilhar informações com equipes ou instituições
Criar mapas interativos sem precisar programar

É aí que entra o GeoNode, uma plataforma open source que facilita a publicação, visualização e compartilhamento de dados geoespaciais pela web!

Veja como o GeoNode pode ser útil na prática:

Gerenciamento Centralizado de Dados
Você pode armazenar shapefiles, GeoTIFFs, layers WMS/WFS e outros formatos em um só lugar — com controle de acesso e metadados bem organizados.

Visualização Interativa
Crie mapas interativos arrastando camadas, sem escrever uma linha de código. Ideal para equipes multidisciplinares que precisam explorar os dados.

Compartilhamento Facilitado
Com poucos cliques, você pode compartilhar um mapa com sua equipe, com a comunidade ou até incorporá-lo em um site ou portal institucional.

Controle de Acesso e Permissões
Defina quem pode ver, editar ou publicar dados. Isso é essencial em projetos colaborativos, inclusive entre diferentes órgãos públicos.

Catálogo de Dados com Metadados Padronizados
GeoNode segue padrões internacionais (como ISO/INSPIRE), o que garante mais interoperabilidade e transparência.

Ideal para:
Órgãos públicos
Universidades e centros de pesquisa
ONGs ambientais
Projetos colaborativos com dados espaciais

Você sabia que ferramentas WebGIS já são usadas no Brasil para melhorar a gestão pública, promover a transparência e apoiar ações em tempo real?

Confira alguns exemplos que mostram como o WebGIS transforma dados geográficos em soluções práticas no nosso dia a dia:

Monitoramento de queimadas e desmatamento
O INPE e o Ibama utilizam plataformas com mapas interativos para acompanhar o avanço de queimadas e do desmatamento na Amazônia e Cerrado. Tudo em tempo real e acessível ao público!

Painéis da COVID-19
Durante a pandemia, estados e municípios criaram dashboards WebGIS para mostrar a evolução dos casos, taxa de vacinação, ocupação de leitos e muito mais — tudo com base na localização geográfica.

Gestão de recursos hídricos
Agências como a ANA (Agência Nacional de Águas) oferecem mapas interativos para monitorar rios, represas e bacias hidrográficas — essenciais para a gestão ambiental e prevenção de crises hídricas.

Planejamento urbano e obras públicas
Prefeituras como as de São Paulo, Belo Horizonte e Curitiba usam plataformas WebGIS para divulgar projetos urbanos, obras em andamento e alertas de trânsito — promovendo transparência e participação social.

Turismo e patrimônio cultural
Estados como o Ceará e Rio de Janeiro já criaram mapas interativos com pontos turísticos, rotas e informações culturais para turistas e moradores explorarem melhor suas regiões.

O WebGIS está cada vez mais presente em políticas públicas e iniciativas privadas no Brasil. É tecnologia a favor da informação, da gestão e da cidadania!

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Mapas Gerais (ou Topográficos): Fornecem informações genéricas, de uso não particularizado. Mostram uma variedade de características naturais e artificiais (relevo, rios, estradas, cidades). São a "base".

o Mapas Especiais: Registram informações específicas para uma única classe de usuários (ex: náutico, aeronáutico, meteorológico).

o Mapas Temáticos: Apresentam um ou mais fenômenos específicos (ex: mapa de população, mapa de solos, mapa de uso da terra). Eles geralmente usam uma base cartográfica para situar o tema. Um mapa temático associa a cada medida um número ou nome ligando a observação a um tema ou classe.

o A escolha do tipo de mapa depende do que você quer analisar ou comunicar.

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

Gleo es una librería JavaScript de visualización de mapas web impulsada ​​​​por WebGL. Gleo es una biblioteca para mostrar mapas geográficos, que aprovecha WebGL1 mediante la biblioteca de abstracción Glii. Su objetivo es cubrir los casos de uso de Leaflet, OpenLayers o MapboxGL / MaplibreGL. Según su creador, Iván Sánchez Ortega, «es como reinventar la rueda ...

Leer más

Gleo: reinventando los mapas WebGL

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Um bom mapa tem vários elementos para ser útil e compreensível.

o Elementos essenciais: Título (O que o mapa mostra?), Corpo do Mapa (O desenho principal), Legenda (Explica os símbolos/convenções), Escala (Numérica e/ou Gráfica), Seta Norte (Onde fica o Norte? Orientação do mapa), Fonte dos Dados (Quem fez o mapa e de onde vieram os dados?), Data da Edição, nome da projeção e seus dados definidores.

o Outras informações marginais incluem diagramas de articulação das folhas, nome da entidade editora, número da edição, e a borda/moldura do mapa. Mapas podem conter encartes para mostrar áreas em escalas diferentes ou locais fora da área principal.

o A forma como esses elementos são organizados (o layout) é importante para a clareza.

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

El programa Copernicus ha hecho accesible la observación de la Tierra a través de la constelación Sentinel-2, compuesta por dos satélites gemelos: Sentinel-2A y Sentinel-2B (desde septiembre de 2024 se ha incorporado un tercer satélite, Sentinel-2C, que va a substituir a Sentinel-2A en breve). Un cambio clave por parte del programa Copernicus en el procesamiento ...

Leer más

Armonización de imágenes Sentinel-2 previas y posteriores al 25 de enero de 2022: claves para análisis comparables

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Mapas podem representar a altimetria, mostrando o relevo detalhadamente.

o A forma mais comum de mostrar o relevo em mapas topográficos são as curvas de nível. Curvas de nível são linhas que conectam pontos da superfície com o mesmo valor de elevação (altitude). A altitude é a distância medida acima ou abaixo de uma superfície de referência, geralmente o nível médio do mar (que se aproxima do geoide).

o As curvas de nível são determinadas a partir da interseção da superfície do terreno com planos horizontais e a projeção dessas interseções no plano do mapa. Elas não se cruzam.

o Quanto mais próximas as curvas, mais inclinado é o terreno. Quanto mais afastadas, mais plano. Existem curvas mestras (traço mais grosso) e intermediárias, além de auxiliares.

o Outras formas incluem sombreamento ou cores de altitude. Mapas que mostram altimetria e planimetria são chamados de cartas.

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

No dia 4 de junho de 2025, a Comunidade QGIS Brasil realizou mais uma edição do Encontro de Usuários QGIS durante o MundoGEO Connect, no Expo Center Norte, em São Paulo. O evento reuniu profissionais, estudantes, desenvolvedores e entusiastas do QGIS de todas as regiões do país, consolidando-se como um dos principais espaços de troca de experiências e fortalecimento da comunidade no Brasil.

A programação contou com palestras sobre aplicações do QGIS em áreas como Inteligência Artificial, Pesquisa Socioambiental, Consultoria Ambiental, Planejamento de Voos com Drones, e Gestão de Saneamento, além de momentos de debate e interação entre os participantes.

Se você não pôde participar presencialmente ou deseja rever os conteúdos apresentados, todos os vídeos das palestras estão disponíveis gratuitamente no nosso canal do YouTube!

Acesse agora a playlist completa:
youtube.com/playlist?list=PLzKam0lvXworikfwwcQ31oIj1RUp__aNv

<figure class="wp-block-embed aligncenter is-type-video is-provider-youtube wp-block-embed-youtube"></figure>

Este evento foi organizado pela Comunidade QGIS Brasil com apoio da OSGeo Brasil, reforçando nosso compromisso com a promoção do software livre e o avanço das geotecnologias no país.

Continue acompanhando nossas redes sociais e site para ficar por dentro dos próximos encontros, oficinas e oportunidades de capacitação!

La seguridad ciudadana representa uno de los principales desafíos en las grandes urbes contemporáneas, donde el análisis espacial ha emergido como una herramienta fundamental para comprender y prevenir la delincuencia. Los Sistemas de Información Geográfica han revolucionado la forma en que abordamos el estudio del crimen urbano, permitiendo identificar patrones espaciales y zonas de riesgo ...

Leer más

Identificación de zonas de riesgo de asalto con QGIS

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Além da localização e do tipo (ponto, linha, polígono), os objetos no mapa (feições) têm informações extras ligadas a eles, chamadas atributos.

o Esses atributos descrevem as propriedades das feições. Além das coordenadas, outros dados não espaciais (atributos) podem ser arquivados para indicar de que tipo de ponto ou linha se está tratando.

o Os atributos podem ser armazenados em uma tabela, que é como uma planilha. Cada coluna é um campo (representa uma propriedade, como altura, cor da cobertura), e cada linha é um registro (corresponde a uma feição).

o Exemplo: Para um ponto "Cidade", os atributos podem ser "Nome" (Rio de Janeiro), "População", "Estado". Para uma linha "Estrada", pode ser "Tipo" (Asfaltada, Terra), "Nome". Para uma sala de aula (polígono), pode ser o número de alunos.

o Em sistemas de informação geográfica (SIG), esses atributos ficam em tabelas, permitindo buscar e analisar informações. O SIG vincula o registro da tabela à feição geométrica. Consultas por atributo são operações comuns em SIG.

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Como saber o que cada ponto, linha ou polígono representa? Usamos símbolos.

o Símbolos são desenhos, cores ou padrões que comunicam o tipo de objeto. Uma linha azul pode ser um rio, uma linha vermelha pode ser uma estrada principal. Um polígono verde pode ser uma área florestada. Catálogos de letras indicam tipos de caracteres para o letreiro. O mapa deve ter um quadro de convenções empregadas (legenda).

o Escolher bons símbolos torna o mapa fácil de entender. A simbologia pode ser baseada em atributos.

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

Un Atlas desde el punto de vista de QGIS es una herramienta que permite crear mapas de forma automática. La creación de estos mapas se realiza en base a una plantilla, que por lo general será una capa vectorial. Es una herramienta útil para crear mapas temáticos individuales por entidad (por ejemplo, un mapa por ...

Leer más

Cómo crear un Atlas en QGIS

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o No mapa, representamos as coisas do mundo real (rios, estradas, casas) usando elementos gráficos chamados feições geográficas.

o No caso da representação vetorial, os elementos gráficos básicos são pontos, linhas poligonais (arcos) e áreas (polígonos).

o Um Ponto é um par ordenado de coordenadas (x, y). Pode representar localizações ou ocorrências específicas (ex: localização de crimes, estações de medição de temperatura, mastro da escola, locais de torneiras).

o Uma Linha (linha poligonal, arco, ou elemento linear) é um conjunto de pontos conectados. É usada para guardar feições unidimensionais (ex: rios, estradas, trilhas dentro e ao redor da escola).

o Uma Área (ou Polígono) é a região do plano limitada por uma ou mais linhas poligonais conectadas que formam um contorno fechado. Polígonos são usados para representar unidades (ex: um lago, um edifício, um país, um campo de futebol, salas de aula).

o A escolha do tipo de geometria depende do tamanho real do objeto e da escala do mapa. Além das coordenadas, dados não espaciais (atributos) podem ser arquivados para descrever o tipo de ponto ou linha.

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

Una de las amenazas más actuales y desconocidas debido al desconocimiento sobre cómo afectará a largo plazo a los sistemas biológicos es la contaminación por plástico, y en especial los microplásticos, aquellos a los que apenas vemos y por tanto, su eliminación de los ecosistemas naturales, especialmente en los océanos, es bastante complicada y todo un reto para la comunidad científica y los gestores.

Fuente: https://www.grida.no/resources/13339

Cada vez hay un mayor conocimiento al respecto y prueba de ello es la proliferación de bases de datos relacionadas y, por suerte, puestas a disposición del público para su consulta y descarga. Esto ayuda a la concienciación y visualización del problema. Voy a hacer una selección de las que considero que poseen una información más completa, pero por supuesto existen muchas más , tenlo en cuenta si estás interesad@ en este tema.

Atlas of Ocean Microplastics (AOMI): El Atlas de Microplásticos Oceánicos (AOMI) es una base de datos global de microplásticos superficiales de los océanos. Han contribuido unos 18 países, entre ellos se encuentra España.

Puedes descargar los datos directamente de los visores que aporta AOMI, por ejemplo, desde el dedicado a la densidad de partículas y descargarlo en diferentes formatos:

También podemos encontrar este tipo de información en Litterbase: este portal engloba datos más generales relacionados con la basura marina pero también puedes encontrar información muy interesante sobre microplásticos y, sobre todo, estudios relacionados. Además también puedes consultar un visor sobre el impacto de estas basuras marinas sobre los seres vivos.

El programa de la NOAA sobre basuras marinas por supuesto también es destacable y aporta mucha información sobre esta problemática.

Si conoces algún proyecto relacionado te animo a que lo incluyas en comentarios así englobaremos más información al respecto.

Nota: Hay una valoración incrustada en esta entrada, por favor, visita esta entrada para valorarla.

Formación de calidad impartida por profesionales

La entrada Bases de datos sobre microplásticos en los océanos se publicó primero en Cursos GIS | TYC GIS Formación.

En esta entrada de nuestro blog vamos a comentarte las mejoras y novedades más destacadas de la nueva versión de QGIS, la 3.44 que lleva como nombre Solothurn. QGIS se encuentra bajo la General Public License (GPL), lo cual permite al usuario modificar su código fuente y garantizar la existencia y acceso a un programa GIS gratuito. Detrás del proyecto hay ...

Leer más

QGIS 3.44: el final de una saga

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Existem diferentes "famílias" de projeções (cilíndrica, cônica, planar/azimutal), baseadas em superfícies auxiliares.

o Cada projeção tenta preservar alguma coisa (formas/ângulos - conforme, áreas - equivalente, ou distâncias - equidistante), mas sempre distorce outras coisas.

o Algumas preservam formas (úteis para navegação, como a Projeção de Mercator), outras preservam áreas (úteis para comparar distribuições de fenômenos). A escolha da projeção depende do objetivo do mapa e da área representada (por exemplo, áreas equatoriais se encaixam bem em projeções equatoriais, áreas polares em projeções polares).

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

A floresta amazônica vem sendo monitorada há décadas, mas há um detalhe importante frequentemente ignorado: a vegetação secundária, aquela que ressurge após o desmatamento e pode capturar carbono e recuperar biodiversidade, também está sendo destruída – e em ritmo alarmante. Nesse novo estudo que tive participação pontual, publicado na revista Environmental Research Letters revela que […]

Un mapa es la representación métrica y gráfica de una porción del territorio sobre una superficie bidimensional. Esta representación métrica nos permite realizar mediciones de distancias, ángulos o superficies sobre el mismo, resultado que puede relacionarse con las medidas realizadas en el mundo real. La representación gráfica permite representar la información de forma atractiva, atrayendo ...

Leer más

Cómo crear una composición de mapa con QGIS

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Vimos que não dá para achatar a Terra sem deformar.

o As Projeções Cartográficas são os métodos usados para transferir a superfície curva da Terra para um plano.

o Elas criam uma "regra" ou fórmula para saber onde cada ponto da Terra vai parar no mapa.

o Imagine usar uma lanterna para "projetar" a Terra em uma folha de papel - isso dá a ideia de projeção.

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

Uno de los grandes avances en los Sistemas de Información Geográfica (SIG) es la integración de lenguajes de programación para agilizar y automatizar las tareas. En el caso de ArcGIS Pro de Esri nos podemos encontrar con lenguajes como Arcade, SQL, o Python que es el que nos ocupa en esta ocasión.

Fuente: Imagen creada a través de la IA

La idea de este tutorial es sencilla, crear una Feature Class de tipo punto y añadirle una serie de puntos aleatorios en una zona de mi interés, esto lo haré con la herramienta “Create Random Points” de ArcGIS Pro. Le digo que quiero un total de 50 puntos.

Por supuesto esa FC se guardará en la geodatabase de mi proyecto, en la siguiente imagen se visualiza el resultado:

El siguiente paso es abrir un notebook para escribir nuestro script con Python, para ello nos dirigimos a la pestaña “Análisis” de ArcGIS Pro:

E introducimos nuestro código, antes que nada, importamos la librería arcpy y apuntar a la geodatabase de nuestro proyecto y a nuestra FC:

A continuación, le decimos el Sistema de Referencia de Coordenadas (SRC) con el que estamos trabajando y el punto que nos interesa incluir en nuestra FC así como su geometría.

Con “Insert Cursor” podemos darle la premisa de que nos incluya ese punto en nuestra FC gracias a arcpy.da que te permite acceder a dichos datos y realizar dicha acción.

Y ya lo tendremos, no te olvides de guardar la edición.

Si quieres aprender más sobre cómo trabajar con Python en ArcGIS Pro desde TYC GIS te ofrecemos varios cursos y también puedes consultar los tutoriales que se han redactado en nuestro blog.

Nota: Hay una valoración incrustada en esta entrada, por favor, visita esta entrada para valorarla.

Formación de calidad impartida por profesionales

 

La entrada Cómo trabajar con Python en ArcGIS Pro para añadir datos a tu “Feature Class” se publicó primero en Cursos GIS | TYC GIS Formación.

Olá pessoal,

Na aula de hoje abordaremos os temas a seguir:

o Uma escala grande (ex: 1:1.000) mostra pequenas áreas com muito detalhe. Pense em um mapa de um bairro.

o Uma escala pequena (ex: 1:1.000.000) mostra grandes áreas com pouco detalhe. Pense em um mapa do Brasil.

o A escolha da escala depende do que você quer representar.

e>

Este conteúdo foi gerado com auxílio de inteligência artificial e você poderá acessar os materiais base utilizados no link.

Hebert Guilherme de Azevedo - Consultor em Geotecnologias

Adquira nosso curso sobre customização de formulários no QGIS pelo link https://www.udemy.com/course/customizacao-de-formulario-qgis/?referralCode=658DB6242221F6D7BFD7

Veja nossos cursos na plataforma Udemy: https://www.udemy.com/user/hebert-azevedo-2/

Inscreva-se e acompanhe nosso blog: http://bit.ly/2CL63UZ

Inscreva-se e acompanhe nosso canal Youtube: http://bit.ly/2J0H2Wa

Curta e acompanhe nossa página no Facebook: http://bit.ly/2yGErMp

Los Sistemas de Información Geográfica están presente en muchos ámbitos de nuestra vida, en esta entrada os vamos a mostrar una serie de ejemplos para trabajar con programas como ArcGIS Pro o QGIS en el ámbito marino. Si tienes alguna duda al respecto sobre cómo puedes aplicar tu idea o tienes un ejemplo más puedes escribirnos en comentarios.

A continuación, os dejo una relación de aplicaciones:

Realización de mapas de vulnerabilidad costera: el cambio global nos exige el estudio y determinación de vulnerabilidades de nuestras zonas costeras a fenómenos imprevisibles. Es por ello que el estudio y conocimiento del Índice de Vulnerabilidad Costera a la subida del nivel del mar (Coastal Vulnerability Index, CVI) es necesario partir de diferentes tipos de variables sociales, económicas y físicas. Esto es posible gracias a los SIG y los visores cartográficos nos permiten mostrar al público en general de dicha información. Existe mucha bibliografía al respecto por si tienes más interés.

Visualización de dinámicas oceánicas: hoy en día gracias a las nuevas tecnologías y el avance en la teledetección ha permitido la suficiente capturas de datos para crear los modelos de corrientes y otras dinámicas oceánicas de gran interés para conocer cómo evoluciona por ejemplo el clima y predecir fenómenos como las Danas o los huracanes. Incluso para entender los upwellings o afloramientos, zonas de gran productividad de los océanos, La NASA está desarrollando un nuevo proyecto denominado ECCO que nos permite con mayor rigor entender el funcionamiento de estos fenómenos.

Mapa de aptitud para el baño en playas según la calidad del agua: existe mucha información que puedes chequear y descargar , como en la página web del MITERD, pero si quieres una información más detallada y actualizada de una zona de estudio, puedes dirigirte a fuentes de datos como por ejemplo del Proyecto Náyade y gracias a los SIG realizar tus propios análisis.

Creación de modelos de distribución de especies marinas, así como como su visualización: gracias a la gran cantidad de registros de especies que nos podemos encontrar en plataformas como GBIF (siempre realizando una depuración previa de los datos) podríamos realizar mapas de calor o estimaciones de densidad (Kernel) de especies de cetáceos, tortugas marinas, aves marinas, etc. para conocer su distribución espacial y tener una idea del uso del territorio de estos animales. Esto puede ser interesante a la hora de elaborar corredores ecológicos como el recién creado “Corredor de migración de cetáceos del Mediterráneo».

Impacto del tráfico marítimo: ligado al punto anterior, es interesante conocer las rutas de tráfico marítimo que actúan como enormes autopistas y a veces en zonas de gran congragación de especies marinas como es el caso del Estrecho de Gibraltar o Stellwagen Bank en Estados Unidos . Gracias a la información obtenida a través de los AIS (Sistema de Identificación Automática que transmite la ubicación, identidad, rumbo y velocidad de las embarcaciones) esto es posible.

Todos estos proyectos amparados gracias a la enorme disponibilidad de bases de datos gratuitas que existen en la actualidad las cuales favorecen y mejoran la investigación y divulgación de información, especialmente en el ámbito marino. El principal objetivo , la conservación de estas especies y hábitats para que exista una sintonía con el desarrollo económico y el establecimiento de nuevas actividades como la eólica marina o la minería de tierras raras en los océanos.

Nota: Hay una valoración incrustada en esta entrada, por favor, visita esta entrada para valorarla.

Formación de calidad impartida por profesionales

 

La entrada Ejemplos de uso para trabajar en Sistemas de Información Geográfica (ArcGIS Pro y QGIS) se publicó primero en Cursos GIS | TYC GIS Formación.

Últimamente se me ha cruzado este programa y me ha entrado la curiosidad. Así que he aprovechado y os escribo esta entrada con los principales aspectos a destacar.

DuckDB es una base de datos SQL utilizada para el análisis de datos e implementada para entornos R o Python,entre otros. A diferencia de PostgreSQL/PostGIS que está más enfocada a trabajar con datos geoespaciales. Así estas dos plataformas poseen grandes diferencias, la primera su instalación.

Como se muestra en su web, y hay abundante documentación, puedes instalar o trabajar con ella en Python en R instalándolo como una simple librería.

O descargarlo , y trabajar con ella desde la línea de comandos de manera sencilla.

A continuación te dejo un ejemplo sobre su uso en R:

Así si trabajas en este ámbito, puede ser una gran opción, y además es open source.

Nota: Hay una valoración incrustada en esta entrada, por favor, visita esta entrada para valorarla.

Formación de calidad impartida por profesionales

La entrada ¿Qué es DuckDB? se publicó primero en Cursos GIS | TYC GIS Formación.

Em nosso artigo publicado na Nature Communications, “Uncontrolled Illegal Mining and Garimpo in the Brazilian Amazon” (https://www.nature.com/articles/s41467-024-54220-2), revelamos, com base em análise geoespacial detalhada, que a expansão do garimpo na região é massiva, acelerada e muitas vezes invisibilizada pelas estatísticas oficiais. O estudo foi fruto de anos de trabalho conjunto e faz parte da tese […]

Nosso artigo “Google Earth Engine: A Global Analysis and Future Trends“, publicado na revista Remote Sensing em 2023, oferece uma análise abrangente do uso da plataforma Google Earth Engine (GEE) em pesquisas científicas globais. Examinamos a distribuição geográfica dos usuários, os principais temas abordados e as tendências emergentes no uso do GEE, destacando sua importância […]

<figure class="wp-block-image size-full is-resized"></figure>

El próximo 5 de junio, de 9:00 a 14:00 h, se celebrará en la Sala multiusos de La Harinera, en València Innovation Capital, La Jornada de Infraestructuras de Datos Espaciales en la Administración Local: Del Mapa a la Gestión. Este evento reunirá a diversos ayuntamientos que compartirán sus experiencias en la implementación de tecnologías libres para la gestión municipal.

Programa de la jornada:

• 09:00 – 09:15: Bienvenida y presentación.
• 09:15 – 10:00: Bloque 1: Gestión y organización de la información territorial
  Participan: Ayuntamiento de La Pobla de Vallbona, Ayuntamiento de Picassent.
• 10:00 – 11:00: Bloque 2: Conectividad entre gvSIG Online y otras plataformas de gestión municipal
  Participan: Ayuntamiento de Cullera, Ayuntamiento de Onda, Ayuntamiento de Cartagena.
• 11:00 – 11:40: Pausa para café.
• 11:40 – 13:00: Bloque 3: Proyectos diversos de implantación de IDE en contextos municipales
  Participan: Scolab, Ayuntamiento de Talavera, Ayuntamiento de Albacete.
• 13:00 – 13:30: Novedades: Presentación de nuevas funcionalidades de la Suite gvSIG.
  Mirada al futuro: Inteligencia artificial integrada en gvSIG Online.
• 13:30 – 14:00: Cierre.

Este evento es una oportunidad única para conocer de primera mano cómo diferentes municipios están aplicando las Infraestructuras de Datos Espaciales para mejorar la gestión interna, facilitar el acceso ciudadano y conectar sistemas de información, utilizando herramientas de la Suite gvSIG.

Modalidad de asistencia:

• Presencial: Aforo limitado. ¡Quedan pocas plazas disponibles!
• Streaming: Retransmisión en directo a través del canal de YouTube de gvSIG.

Inscripción gratuita:

Para asistir, es necesario completar el formulario de inscripción disponible en el siguiente enlace:

Formulario de inscripción

No pierdas la oportunidad de participar en esta jornada y conocer las experiencias de otros ayuntamientos en la implementación de tecnologías libres para la gestión municipal.

¡Te esperamos el 5 de junio en València!

<figure class="wp-block-image size-large"></figure>

Hoy he recibido una llamada que me ha emocionado. Era Cesáreo Bas Vivancos, ya jubilado tras muchos años de docencia en la Universidad Miguel Hernández. En las 11as Jornadas Internacionales de gvSIG, realizadas en 2015, presentó el excelente trabajo llevado a cabo para disponer de una nueva edición del plano de Toledo, elaborado por el Greco, digitalizada y que pudiera estar disponible para todo el mundo.

Cesáreo, decía, me llama para contarme que en el Museo del Prado, en la Galería Central del edificio Villanueva se reúnen, por primera vez desde su dispersión, ocho de las nueve obras que el Greco realizó para la iglesia del Monasterio de Santo Domingo el Antiguo de Toledo. Y que ahí está el Plano de Toledo, el elaborado con gvSIG. En el Museo del Prado.

<figure class="wp-block-image size-full"></figure>

Tecnologías libres y experiencias reales con la Suite gvSIG

Las Naves (València)
5 de junio
De 9:00 a 14:00 h

---

Presentación General

Esta jornada tiene como objetivo mostrar experiencias reales de implantación de Infraestructuras de Datos Espaciales (IDE) en el ámbito municipal, utilizando tecnologías libres como la Suite gvSIG. A través de casos concretos, se abordará cómo diferentes ayuntamientos han estructurado y aprovechado la información geográfica para mejorar la gestión interna, facilitar el acceso ciudadano y conectar sistemas de información.

---

09:00 – 09:15
Bienvenida y presentación institucional

9.15 a 10.00

Bloque 1: Gestión y organización de la información territorial. Participan:

• Ayuntamiento de La Pobla de Vallbona
• Ayuntamiento de Picassent

10.00 a 11.00

Bloque 2: Conectividad entre gvSIG Online y otras plataformas de gestión municipal. De la gestión de expedientes a la de cementerios.Una visión de la suite gvSIG en la administración local: diputaciones, ayuntamientos, mancomunidades, intendencias. Participan:

• Ayuntamiento de Cullera
• Ayuntamiento de Onda 
• Ayuntamiento de Cartagena

11:00 a 11:40
Coffee Break

11.40 a 13.00 

Bloque 3: Proyectos diversos de implantación de IDE en contextos municipales. Participan:

• Scolab –    La Suite gvSIG como motor de cambio en la administración local
• Ayuntamiento de Talavera
• Ayuntamiento de Albacete

---

13.00 a 13.30

Novedades: Presentación de nuevas funcionalidades de la Suite gvSIG

Mirada al futuro: Inteligencia artificial integrada en gvSIG Online

---

13.30 a 14:00

Cierre

---

¿Te interesa conocer cómo las tecnologías libres están transformando la gestión municipal? No pierdas la oportunidad de asistir a la jornada “Tecnologías libres y experiencias reales con la Suite gvSIG”.

Descubre casos reales de ayuntamientos que ya están aprovechando la Suite gvSIG para mejorar su gestión territorial, conectar sistemas y facilitar el acceso ciudadano. Además, podrás conocer las últimas novedades, incluyendo la integración de inteligencia artificial en gvSIG Online.¡No te quedes fuera!

Inscríbete ya y reserva tu plaza.

<figure class="wp-block-image size-large"></figure>

En la Jornada de IDE en la Administración Local del día 5 de junio vamos a conocer casos reales de integración entre gestores de expedientes e Infraestructuras de Datos Espaciales (IDE).

Veremos cómo diversos ayuntamientos como los de Albacete o Cartagena ya están aprovechando la potencia de gvSIG Online para conectar su información geográfica con los procedimientos administrativos, mejorando así la eficiencia y transparencia en la gestión municipal.

Integrar expedientes con mapas no es el futuro, es el presente… y en la jornada nos mostraran ejemplos concretos de integración de gvSIG Online con gestores de expedientes como Segex/Sedipualba o Gestiona.

Si trabajas en una administración local, ¡esto te interesa!

La inscripción es gratuita, pero las plazas son limitadas.
Formulario de inscripción

5 de junio en Las Naves, Valencia. Más información aquí.

<figure class="wp-block-image size-full is-resized"></figure>

El próximo 5 de junio celebramos en Las Naves (València) una jornada dirigida a ayuntamientos y entidades locales que están explorando o ya utilizan tecnologías libres para la gestión de su información geográfica.

A lo largo de la mañana, varios municipios compartirán experiencias reales de implantación de Infraestructuras de Datos Espaciales (IDE) basadas en la Suite gvSIG, mostrando cómo han estructurado y aprovechado sus datos espaciales para mejorar la gestión interna, conectar sistemas de información y facilitar el acceso ciudadano.

La jornada se organizará en tres bloques:
Gestión y organización de la información territorial
Integración de gvSIG con plataformas como SEDIPUALBA, GESTIONA, KEYCLOUD o aplicaciones específicas (como cementerios)
Casos de uso en ayuntamientos de distintos perfiles y tamaños

Entre otros, contaremos con la participación de:

• Ayuntamiento de Albacete → Visor IDE Albacete  
• Ayuntamiento de Cartagena → Visor IDE Cartagena  
• Ayuntamiento de Picassent → Visor IDE Picassent  
• Ayuntamiento de Onda → Visor IDE Onda

En los próximos días publicaremos el programa completo, con todos los ponentes y horarios detallados.

La inscripción es gratuita, pero las plazas son limitadas.
Formulario de inscripción

Será una oportunidad para compartir aprendizajes, resolver dudas, y conocer de primera mano cómo otros municipios están modernizando su gestión con herramientas libres y accesibles.

<figure class="wp-block-image size-large"></figure>

El próximo 11 de junio, la Asociación gvSIG participará en el evento “Del dato al impacto: cómo la inteligencia colectiva y la tecnología protegen vidas ante fenómenos meteorológicos adversos”, organizado por Innotransfer y el Parque Científico de la Universidad Miguel Hernández (UMH).

Participaremos como parte del panel de expertos que abordará el papel de la tecnología y la inteligencia colectiva en la prevención, monitorización y respuesta ante eventos meteorológicos extremos como inundaciones, lluvias torrenciales o tormentas intensas, cada vez más frecuentes en el contexto del cambio climático.

Desde gvSIG, venimos trabajando desde hace años en soluciones abiertas, interoperables y colaborativas que permiten integrar y analizar datos geoespaciales en tiempo real para mejorar la toma de decisiones en contextos de emergencia. Nuestra experiencia en proyectos relacionados con la gestión del riesgo y protección civil será uno de los focos de nuestra intervención.

Este evento se enmarca en el programa Innotransfer, una iniciativa que promueve el intercambio de conocimiento entre el mundo académico, las empresas y las administraciones públicas.

¿Por qué es importante?

Los fenómenos meteorológicos adversos no solo ponen en riesgo infraestructuras, sino también vidas humanas y ecosistemas completos. Apostar por soluciones tecnológicas y modelos de colaboración eficaces no es una opción: es una necesidad.

Invitamos a quienes trabajan en el ámbito de la gestión territorial, emergencias, medio ambiente o administración pública, a asistir o seguir el evento. Es una oportunidad para compartir visiones, generar sinergias y seguir construyendo un futuro más resiliente desde la ciencia abierta y la tecnología libre.

Más información e inscripciones en:

<figure class="wp-block-embed is-type-wp-embed is-provider-innotransfer wp-block-embed-innotransfer"></figure>

<figure class="wp-block-image size-large"></figure>

En plena era digital, donde la información es uno de los activos más valiosos, los ayuntamientos manejan a diario una enorme cantidad de datos vinculados al territorio: desde catastro y urbanismo hasta patrimonio, medio ambiente o movilidad. Sin embargo, muchas veces esta información está dispersa, duplicada o difícil de compartir entre departamentos. Aquí es donde entra en juego la Infraestructura de Datos Espaciales (IDE).

¿Qué es una IDE y por qué es clave?

Una IDE es una plataforma tecnológica que permite gestionar, visualizar y compartir datos espaciales (geográficos) de manera eficiente, interoperable y abierta. Utiliza estándares internacionales que garantizan la compatibilidad con otros sistemas y facilita el acceso tanto interno (entre áreas municipales) como externo (hacia la ciudadanía).

Más del 80% de la información que maneja una administración local tiene una componente geográfica. Desde una incidencia en la vía pública hasta un expediente urbanístico, todo tiene una ubicación. La IDE permite “conocer para gestionar”: visualizar esa información sobre un mapa facilita la toma de decisiones, mejora la transparencia y optimiza los recursos públicos.

Beneficios reales para los municipios

Implementar una IDE como gvSIG Online permite a los ayuntamientos:

• Disponer de una base cartográfica única que evite duplicidades y errores.
• Geolocalizar información como inventarios, censos o incidencias urbanas.
• Compartir datos entre departamentos, mejorando la eficiencia en la gestión.
• Crear visores de mapas personalizados accesibles para los ciudadanos, fomentando la participación y el gobierno abierto.
• Cumplir con normativas de datos abiertos, transparencia y reutilización (como la Directiva INSPIRE o la Ley 19/2013).

¿Qué se puede gestionar con una IDE?

Casi cualquier área municipal puede beneficiarse de una IDE:

• Urbanismo y catastro: gestión de expedientes, seguimiento de obras, cambios temporales.
• Turismo: mapas interactivos con rutas, eventos y patrimonio cultural.
• Medio ambiente y residuos: seguimiento de zonas verdes, contenedores, puntos limpios.
• Movilidad: red de transporte público, aparcamientos, carriles bici.
• Inventario municipal: alumbrado, bancos, señalización, fuentes…
• Emergencias y protección civil: localización de hidrantes, edificios críticos, rutas de evacuación.

gvSIG Online: tecnología libre y adaptable

Una de las soluciones más completas para IDE municipales es gvSIG Online, desarrollada bajo software libre. Esto significa:

• Sin costes de licencias, lo que reduce barreras económicas.
• Escalable y adaptable a las necesidades del municipio.
• Posibilidad de implantación como servicio (SaaS) o en los servidores propios del ayuntamiento (On-Premise).
• Integración con sensores, gestores de expedientes, portales de datos abiertos, padrón, etc.

Conclusión

Contar con una IDE no es solo una cuestión tecnológica, sino estratégica. Permite a los ayuntamientos avanzar hacia una gestión más eficiente, transparente y participativa. Es una herramienta clave para construir ciudades inteligentes y resilientes, donde la información espacial esté al servicio del bienestar colectivo.

Si tu municipio aún no cuenta con una IDE, quizá sea momento de dar el paso.

Si quieres saber más no dudes en apuntarte a esta jornada, el 5 de junio en Valencia, en la que distintas administraciones locales nos contarán como usan la Suite gvSIG:

Información completa sobre la jornada

Formulario de inscripción

Versão do conjunto de dados em análise: 01de Maio 2025

• Número total de features / polígonos [3]: 2615362
• Área total dos polígonos, em hectares [4]: 1255936.8
• Número de features / polígonos com geometrias inválidas [5]: 112282
• Número de features / polígonos repetidos [6]: 0
• Número de sobreposições [10] : 964584 (36,88 %)
• Área ocupada pelas sobreposições, em hectares: 30426.8 (2,42 %)

#### Operações Realizadas ####

[1]

ogrinfo -so opendata-rgg-01072024.gpkg opendata-rgg-01072024
INFO: Open of `opendata-rgg-01072024.gpkg'
      using driver `GPKG' successful.

Layer name: opendata-rgg-01072024
Geometry: Multi Polygon
Feature Count: 2255870
Extent: (-94062.316000, -41320.713000) - (162060.682800, 276013.258500)
Layer SRS WKT:
PROJCRS["ETRS89 / Portugal TM06",
    BASEGEOGCRS["ETRS89",
        ENSEMBLE["European Terrestrial Reference System 1989 ensemble",
            MEMBER["European Terrestrial Reference Frame 1989"],
            MEMBER["European Terrestrial Reference Frame 1990"],
            MEMBER["European Terrestrial Reference Frame 1991"],
            MEMBER["European Terrestrial Reference Frame 1992"],
            MEMBER["European Terrestrial Reference Frame 1993"],
            MEMBER["European Terrestrial Reference Frame 1994"],
            MEMBER["European Terrestrial Reference Frame 1996"],
            MEMBER["European Terrestrial Reference Frame 1997"],
            MEMBER["European Terrestrial Reference Frame 2000"],
            MEMBER["European Terrestrial Reference Frame 2005"],
            MEMBER["European Terrestrial Reference Frame 2014"],
            ELLIPSOID["GRS 1980",6378137,298.257222101,
                LENGTHUNIT["metre",1]],
            ENSEMBLEACCURACY[0.1]],
        PRIMEM["Greenwich",0,
            ANGLEUNIT["degree",0.0174532925199433]],
        ID["EPSG",4258]],
    CONVERSION["Portugual TM06",
        METHOD["Transverse Mercator",
            ID["EPSG",9807]],
        PARAMETER["Latitude of natural origin",39.6682583333333,
            ANGLEUNIT["degree",0.0174532925199433],
            ID["EPSG",8801]],
        PARAMETER["Longitude of natural origin",-8.13310833333333,
            ANGLEUNIT["degree",0.0174532925199433],
            ID["EPSG",8802]],
        PARAMETER["Scale factor at natural origin",1,
            SCALEUNIT["unity",1],
            ID["EPSG",8805]],
        PARAMETER["False easting",0,
            LENGTHUNIT["metre",1],
            ID["EPSG",8806]],
        PARAMETER["False northing",0,
            LENGTHUNIT["metre",1],
            ID["EPSG",8807]]],
    CS[Cartesian,2],
        AXIS["easting (X)",east,
            ORDER[1],
            LENGTHUNIT["metre",1]],
        AXIS["northing (Y)",north,
            ORDER[2],
            LENGTHUNIT["metre",1]],
    USAGE[
        SCOPE["Topographic mapping (medium scale)."],
        AREA["Portugal - mainland - onshore."],
        BBOX[36.95,-9.56,42.16,-6.19]],
    ID["EPSG",3763]]
Data axis to CRS axis mapping: 1,2
FID Column = fid
Geometry Column = geom
area: Real (0.0)

[2]

ogr2ogr -f PostgreSQL PG:"host=localhost dbname=geocatalogo user=*** password=*** active_schema=catalogo" opendata-rgg-01072024.gpkg opendata-rgg-01072024 -nln catalogo.ebupi -lco FID=gid -overwrite

[3]

geocatalogo=# SELECT count(*) FROM catalogo.ebupi;
  count
---------
 2255870
(1 row)

[4]

geocatalogo=# SELECT sum(ST_Area(geom))/10000 AS area FROM catalogo.ebupi;        
area
--------------------
1419771.2919224324
(1 row)

[5]

geocatalogo=# SELECT count(*) FROM catalogo.ebupi WHERE ST_IsValid(geom) IS FALSE;
 count
-------
     0
(1 row)

[6]

WITH repeated_polygons AS (
    SELECT 
        ARRAY_AGG(gid) AS id_list,    
        COUNT(*) AS count,            
        geom                          
    FROM 
        catalogo.ebupi
    GROUP BY 
        geom
    HAVING 
        COUNT(*) > 1                  
)

SELECT 
    ROW_NUMBER() OVER () AS id,         
    count,                              
    ARRAY_TO_STRING(id_list, '|') AS id_list,
    geom AS geom
FROM 
    repeated_polygons
	ORDER BY count DESC;

[7]

WITH polygon_repetitions AS (
    SELECT 
        COUNT(*) AS repetition_count
    FROM 
        catalogo.ebupi
    GROUP BY 
        geom
    HAVING 
        COUNT(*) > 1                
)

SELECT 
    repetition_count,               
    COUNT(*) AS num_polygons       
FROM 
    polygon_repetitions
GROUP BY 
    repetition_count
ORDER BY 
    repetition_count;

[8]

WITH repeated_polygons AS (
    SELECT 
        ARRAY_AGG(gid) AS id_list,          
        COUNT(*) AS count,                  
        ST_Area(geom) AS area,              
        geom                                
    FROM 
        catalogo.ebupi
    GROUP BY 
        geom
    HAVING 
        COUNT(*) > 1                        
)

SELECT 
    SUM(count - 1) AS total_extra_polygons,   
    SUM((count - 1) * area)/10000 AS total_extra_area
FROM 
    repeated_polygons;

[9]

CREATE TABLE catalogo.ebupi_no_duplicates AS
WITH ranked_polygons AS (
    SELECT 
        gid,                         
        geom,                        
        ROW_NUMBER() OVER (
            PARTITION BY geom        
            ORDER BY gid ASC         
        ) AS rank                    
    FROM 
        catalogo.ebupi
)

SELECT 
    gid,                             
    geom                              
FROM 
    ranked_polygons
WHERE 
    rank = 1;                         


ALTER TABLE catalogo.ebupi_no_duplicates
ADD CONSTRAINT ebupi_no_duplicates_pkey PRIMARY KEY (gid);

CREATE INDEX ebupi_no_duplicates_geom_idx
ON catalogo.ebupi_no_duplicates
USING GIST (geom);

[10]

CREATE TABLE catalogo.ebupi_partial_overlaps AS
WITH bbox_filtered AS (
    SELECT 
        a.gid AS gid_polygon1,
        b.gid AS gid_polygon2,
        a.geom AS geom1,
        b.geom AS geom2
    FROM 
        catalogo.ebupi_no_duplicates a,
        catalogo.ebupi_no_duplicates b
    WHERE 
        a.gid < b.gid  
        AND a.geom && b.geom  
)
SELECT 
    row_number() over() AS gid,
    gid_polygon1, 
    gid_polygon2, 
    ST_Area(ST_Intersection(geom1, geom2))/10000 AS area_hectares,
    ST_Multi(ST_Intersection(geom1, geom2)) AS geom
FROM 
    bbox_filtered
WHERE 
    ST_Intersects(geom1, geom2)  
    AND (ST_GeometryType(ST_Intersection(geom1, geom2)) = 'ST_Polygon'
    OR ST_GeometryType(ST_Intersection(geom1, geom2)) = 'ST_MultiPolygon');


ALTER TABLE catalogo.ebupi_partial_overlaps
ADD CONSTRAINT ebupi_partial_overlaps_pkey PRIMARY KEY (gid);

CREATE INDEX ebupi_partial_overlaps_geom_idx
ON catalogo.ebupi_partial_overlaps
USING GIST (geom);

5 de junio | 9:00–14:00 h | Las Naves, Valencia

<figure class="wp-block-image size-full"></figure>

Desde gvSIG Asociación te invitamos a participar en la Jornada de Infraestructuras de Datos Espaciales en la Administración Local: Del Mapa a la Gestión, un encuentro pensado para ayuntamientos y administraciones locales interesadas en aprovechar el potencial de las Tecnologías Libres de Información Geográfica (TIG libres) para mejorar la gestión pública.

Durante la jornada se presentarán casos de uso reales de la Suite gvSIG en distintos municipios, abordando aplicaciones concretas en áreas clave como:

• Integración con gestores de expedientes

• Urbanismo

• Cementerios

• y otros servicios municipales

Una oportunidad para conocer de primera mano cómo otras entidades locales ya están aplicando soluciones TIG libres para hacer su gestión más eficiente, transparente y sostenible.

Además de las presentaciones, la jornada será un espacio para el intercambio de experiencias y para explorar sinergias entre profesionales del ámbito municipal.

Ya puedes consultar la información general del evento y realizar tu inscripción gratuita: Información completa sobre la jornada Formulario de inscripción

Las plazas son limitadas, por lo que te animamos a reservar la tuya cuanto antes.

Nos vemos el 5 de junio en Las Naves.

QGIS es un Sistema de Información Geográfica (SIG) gratuito e instalable en varios tipos de sistemas operativos (Linux, Windows).

Es un ecosistema en constante evolución, prueba de ello es el inminente lanzamiento de la versión QGIS 4x con todo lo que ello representa a nivel de desarrollo (como ya lo fue en su momento la saga QGIS 3x) de sus complementos.

Esos complementos facilitan mucho la labor del usuario, en esta ocasión vamos a mostrar cómo modificar el nombre de un campo de una tabla de atributos, algo que, si no te ha pasado ya, te pasará. Y lo vamos a realizar de una manera sencilla, ojo, esto también va a variar según el formato datos que utilices.

Veamos cómo hacerlo, para ello vamos a trabajar con datos del Banco de la Naturaleza del MITERD de los Espacios Naturales Protegidos (ENP). Si lo cargamos en QGIS y chequeamos la tabla de atributos:

Observamos que los nombres de los campos no son muy comprensibles si quieres desarrollar un visor o crear un “dashboard” y mostrar dicha información en un “pop-up”.

Para editar la tabla, podemos utilizar la herramienta “Rehacer campos” y escribir los nombres de los campos que nos interese, además, podríamos modificar el tipo de datos, entre otras características.

Vamos a crear una capa temporal, ten en cuenta que en este caso, para guardar los cambios debemos exportarla. Si se abre la tabla de atributos comprobaremos los cambios llevados a cabo:

Y ya lo tendríamos, una manera rápida y sencilla de modificar dichos campos de manera que nos interese.

Nota: Hay una valoración incrustada en esta entrada, por favor, visita esta entrada para valorarla.

Formación de calidad impartida por profesionales

La entrada Cómo cambiar en QGIS el nombre de los campos en las tablas de atributos se publicó primero en Cursos GIS | TYC GIS Formación.

 

Te invitamos a formar parte de las Jornadas de SIG Libre, Geotech & Spatial Data Science que se celebrarán el 17 y 18 de septiembre de 2025 en Girona.

Las Jornadas de SIG Libre son un evento donde compartir e intercambiar conocimientos alrededor de las geotecnologías libres y la ciencia de datos espaciales y en estos momentos está abierta la convocatoria para presentar una comunicación, lightning talk o taller.

Si trabajas en el ámbito de las geotecnologías y la ciencia de datos espaciales, y deseas compartir un proyecto, una solución o impartir un taller, ¡envíanos tu propuesta!

Los temas aceptados incluyen:

• Visualización de datos

• Análisis espacial

• Desarrollo de software y aplicaciones

• Webmapping

• Observación de la Tierra

• Ciencia de datos

• Geoestadística

• Machine learning

• Datos abiertos

Las Jornadas de SIG Libre buscan la participación tanto de empresas como de organizaciones, universidades, investigadores y cualquier persona involucrada en el ámbito de las geotecnologías libres.

¡No pierdas la oportunidad de ser parte de este evento! La fecha límite para enviar la propuesta es el 24 de abril de 2025.

Más información: https://www.jornadassiglibre.org

Publicado por Laura Olivas Corominas.

Las bounding box corresponden a un vectorial tipo polígono de forma rectangular que engloban uno o un grupo de rasgos geográficos de un área de interés (puntos, líneas o polígonos). Se definen con base en las coordenadas mínimas y máximas … Continue reading →

En el post anterior se consideró el redimensionamiento de una imagen en un documento con Google Apps Script. En éste, adicionalmente, también se va a considerar la inclusión del link que apunta a la imagen correspondiente en Google Drive. Para ello, … Continue reading →

Tenemos Inteligencia Artificial hasta en la sopa y Anaconda no iba a ser menos. Por ello, si abres-instalas este programa verás que te aparece la opción de darte alta como usuario en su propio asistente de IA de ayuda en la programación.

Puedes incluso instalar un navegador específico para trabajar con la IA denominado “Anaconda AI Navigator”

Si lo lanzas verás que podrás trabajar con una variada selección de modelos:

Por otro lado, si nos logueamos en «Anaconda Cloud«:

Lanzamos un “Jupyter notebook”:

Y veremos que el asistente IA de Anaconda está en una ventana en el lado derecho de la interfaz, podemos empezar con una pregunta ejemplo, como, buscar y cargar los datos de volcanes del “Smithsonian Institute”:

Tras un par de correcciones del código, que el asistente realiza, conseguimos incluso visualizarlos:

Este es un ejemplo más de cómo esta ayuda integrada y muchos más específica para una materia determinada, como es el desarrollo de código Python, puede ayudar mucho tanto en la formación como en los proyectos de diferentes profesionales. Ahora a ver cómo responde con otros retos.

Nota: Hay una valoración incrustada en esta entrada, por favor, visita esta entrada para valorarla.

Formación de calidad impartida por profesionales

 

La entrada El uso de la Inteligencia Artificial en Anaconda a la hora de trabajar con Python se publicó primero en Cursos GIS | TYC GIS Formación.

Un problema que se presenta a la hora de añadir un objeto tipo imagen en un documento mediante Google Apps Script es encontrar un método que permita redimensionarla para hacerla visualmente atractiva dentro del documento. Después de buscar por algún … Continue reading →

En posts anteriores se ha considerado la exportación de la información geográfica almacenada en un Hoja de Cálculo como pares de coordenadas Latitud, Longitud a archivos kml de puntos (single o multipoint) o polígonos empleando variables plantilla mediante Google Apps … Continue reading →

La App GeoPosición, disponible en móviles Android, tiene una interfaz amigable para almacenar información geográfica directamente en Google Drive en formato de texto plano. La imagen siguiente contiene una captura de pantalla de la App configurada para abrirse por defecto … Continue reading →

En un post anterior se consideró la exportación de capas kml singlepoint mediante Google Apps Script tomando los datos geográficos de una Hoja de Cálculo en la nube y seleccionando manualmente los datos a ser incorporados en el kml. Si se nos olvida … Continue reading →

En el post anterior ya se mencionaron los cuadros de diálogo en una Hoja de Cálculo con Google Apps Script para introducir variables; en ese caso el nombre del archivo kml de salida. El método usado fue prompt de la … Continue reading →