Mais

Como atualizar PostGIS 2.1 para usar 'ST_DelaunayTriangles ()'

Como atualizar PostGIS 2.1 para usar 'ST_DelaunayTriangles ()'


O erro "lwgeom_delaunay_triangulation: GEOS 3.4 ou superior necessário" chega no meu terminal, correndopsqlcom

SELECT PostGIS_Lib_Version (); - 2.1.4 SELECT postgis_version (); - 2.1 USE_GEOS = 1 USE_PROJ = 1 USE_STATS = 1

e quando usar use ST_DelaunayTriangles () (ex. neste script).

Então, qual é o problema, como reinstalar PostGis ou contornar isso?


EDITAR para sugestão de @janechii,

selecione PostGIS_full_version (); POSTGIS = "2.1.4 r12966" GEOS = "3.3.3-CAPI-1.7.4" PROJ = "Rel. 4.7.1, 23 de setembro de 2009" GDAL = "GDAL 1.9.0, lançado em 29/12/2011" LIBXML = "2.8.0" LIBJSON = RASTER DE TOPOLOGIA "DESCONHECIDO"

PostGIS foi instalado por padrãoapt-getno meu Debian Stable esta semana, e agora refaça (tente reinstalar GEOS para usar 3.4 não 3.3) com

sudo apt-get -y install postgis postgresql-9.3 libgeos-3.4 libgeos-c1 libgeos-dev

mas nenhum efeito.


Depois de todas as pistas @janechii ... e eliminando todos os resíduos possíveis,

sudo apt-get purge build-essential libgeos-3.4 libgeos-c1 libgeos-dev libxml2-dev libgdal-dev libproj-dev libjson0-dev xsltproc docbook-xsl docbook-mathml sudo apt-get purge postgis

Eu começo com (adaptando!) As receitas deste link:

wget http://download.osgeo.org/geos/geos-3.4.2.tar.bz2 tar xfj geos-3.4.2.tar.bz2 cd geos-3.4.2 ./configure make sudo make install cd…

Aqui ok geos 3.4 lá (!). Então…

wget http://download.osgeo.org/postgis/source/postgis-2.1.3.tar.gz tar xfz postgis-2.1.3.tar.gz cd postgis-2.1.3 ./configure sudo make install

esse últimofaçotrigg a "configure: erro: o PGXS Makefile (…) não pode ser encontrado. Instale os pacotes de desenvolvimento do servidor PostgreSQL e execute novamente o configure". Então, como mais algumas pistas aqui

sudo apt-get install postgresql-server-dev-9.3

configuração tão vermelha,

./configure

então ok, uma boa mensagem:

PostGIS agora está configurado para x86_64-unknown-linux-gnu -------------- Compiler Info ------------- Compiler C: gcc -g -O2 C ++ compilador: g ++ -g -O2 Pré-processador SQL: / usr / bin / cpp -w -traditional-cpp -P -------------- Dependências ----------- --- Configuração do GEOS: / usr / local / bin / geos-config versão do GEOS: 3.4.2… --------------- Extensões ----------- ---- PostGIS Raster: habilitado Topologia PostGIS: habilitado Suporte SFCGAL: desabilitado -------- Geração de documentação -------- xsltproc: / usr / bin / xsltproc…

Então, continue:

make # PostGIS foi construído com sucesso. Pronto para instalar. sudo make install sudo ldconfig sudo make comments-install sudo ln -sf / usr / share / postgresql-common / pg_wrapper / usr / local / bin / shp2pgsql sudo ln -sf / usr / share / postgresql-common / pg_wrapper / usr / local / bin / pgsql2shp sudo ln -sf / usr / share / postgresql-common / pg_wrapper / usr / local / bin / raster2pgsql psql -h localhost -U postgres postgres CRIAR EXTENSÃO postgis; CRIAR EXTENSÃO postgis_topology;  q

Então, testando com esse script… OK !!!!


Eu tive uma questão semelhante. Mesmo recompilar com o novo GEOS não ajudou quando você tem 2 versões. Ele continuou tentando usar a versão mais antiga.

Em primeiro lugar, tente desinstalar a biblioteca antiga e veja se funciona. Caso contrário, tente seguir as instruções deste link usando um repositório PostgreSQL personalizado.

Se tudo mais falhar, verifique seu ldconfig para ver se a versão mais antiga do libgeos ainda está instalada e com link simulado em algum lugar e remova-os:

ldconfig -p | grep libgeos

Caso contrário, recompilar PostGIS do zero é muito simples. Siga a documentação oficial e você deve estar pronto para ir. Você provavelmente precisará de pacotes dev do postgres, proj4, geos e gdal. Veja a tabela de compatibilidade.

Espero que isto ajude!


Apêndice A. Apêndice

Apenas as alterações desde 3.1.0alpha2 são listadas. Esta versão requer PostgreSQL 9.6-13 e GEOS & gt = 3.6+ Recursos e aprimoramentos adicionais habilitados se você estiver executando Proj6 +, PostgreSQL 12+ e GEOS 3.9.0dev

Quebrando mudanças

4214, ST_Count obsoleto (tablename.), ST_ApproxCount (tablename,.) ST_SummaryStats (tablename, ..), ST_Histogram (tablename,.), ST_ApproxHistogram (tablename,.), ST_Quantile (tablename,.), ST_ApproxQuantile (tablename,.). removido. (Darafei Praliaskouski)

Aprimoramentos

4801, ST_ClusterKMeans suporta pesos em geometrias POINT [Z] M (Darafei Praliaskouski)

4804, ST_ReducePrecision (GEOS 3.9+) permite a redução de precisão válida (Paul Ramsey)

4805, _ST_SortableHash exposto para contornar o problema de desempenho de soring paralelo no Postgres. Se sua tabela for grande, use ORDER BY _ST_SortableHash (geom) em vez de ORDER BY geom para tornar a classificação paralela mais rápida (Darafei Praliaskouski)

4625, Estatísticas de correlação agora calculadas. Execute ANALYZE para índices BRIN para começar a fazer efeito. (Darafei Praliaskouski)

Corrigir problema de pedido de eixo com urn: ogc: def: crs: EPSG em ST_GeomFromGML () (Even Roualt)


Usando a extensão PostGIS em bancos de dados gerenciados

PostGIS é uma extensão do sistema de gerenciamento de banco de dados PostgreSQL que permite armazenar e gerenciar objetos de Sistemas de Informações Geográficas (GIS) em PostgreSQL. Ele está disponível em bancos de dados gerenciados Scaleway. Foi desenvolvido pela empresa canadense Refractions Research Inc. PostGIS foi publicado sob a licença GNU GPL, o que significa que a solução está disponível como software de código aberto, ao contrário de muitos outros sistemas GIS que são software de código fechado. Os tipos de dados espaciais referem-se a formas como ponto, linha e polígono. Os bancos de dados espaciais integram totalmente os dados espaciais com um banco de dados relacional de objetos. PostGIS inclui suporte para índices espaciais R-Tree baseados em GiST e funções para análise e processamento de objetos GIS.

A que distância fica a estação de metrô mais próxima do meu escritório? Qual é o caminho mais curto da minha casa até o shopping? Onde um novo hospital deve ser construído para ficar o mais próximo possível da população de uma cidade?

Essas perguntas e outras semelhantes são feitas todos os dias por pessoas de todo o mundo. As respostas a essas perguntas foram historicamente fornecidas por aplicativos especializados de GIS (Sistemas de Informação Geográfica). Embora seja perfeitamente adequado para responder a algumas perguntas, não é uma solução para nossas vidas modernas, onde enormes conjuntos de dados espaciais precisam ser tratados, como todas as rotas na Europa em um único conjunto de dados. É aqui que entram os sistemas modernos como PostGIS.

Criando um novo banco de dados para PostGIS

As etapas a seguir pressupõem que você já criou uma instância de banco de dados. Para obter mais informações sobre como criar e configurar uma instância de banco de dados gerenciado, você pode seguir a documentação do banco de dados.

1 Conecte-se ao console do Scaleway e entre no Base de dados seção.

2 Escolha sua instância de banco de dados clicando em seu nome.

3 Clique no Bancos de dados guia, depois em + Criar Banco de Dados.

4 Digite o nome do novo banco de dados, neste tutorial usamos townssurvey.

5 Clique no Comercial guia, seguido por e Permissões de atualização.

6 Conceda as permissões para o banco de dados townssurvey recém-criado ao seu usuário.

Habilitando a extensão PostGIS

1 Conecte-se ao seu banco de dados gerenciado usando o cliente psql:

Digite a senha do usuário do banco de dados quando solicitado.

Você pode encontrar rdb_host e rdb_port na página de informações do banco de dados.

2 Uma vez conectado, habilite a extensão postgis para o banco de dados:

3 Verifique se tudo correu bem, executando o seguinte comando:

Você verá uma saída como o exemplo a seguir, que indica que a extensão foi instalada corretamente no banco de dados:

4 O banco de dados está pronto, saia do shell PostgreSQL agora:

Otimizando a instância do banco de dados para objetos de banco de dados GIS

O PostgreSQL foi projetado para ser executado em configurações muito diferentes, desde pequenas configurações de teste ou desenvolvimento até grandes bancos de dados que lidam com milhões de linhas. Os objetos de banco de dados GIS são grandes em comparação com os dados de texto simples. Os bancos de dados do Scaleway Managed são otimizados para desempenho por padrão, mas é possível ajustá-los para alguns parâmetros.

1 Entre na seção de configuração de sua instância de banco de dados no console do Scaleway

2 Escolha sua instância de banco de dados na lista e clique nela para ver a página de informações do banco de dados. Então clique em Configurações avançadas.

3 A guia de configurações avançadas é exibida. Clique em Adicionar configurações avançadas para configurar os parâmetros do seu servidor PostgreSQL.

O parâmetro work_mem define a quantidade de memória que as operações de classificação interna e tabelas de hash podem consumir na RAM, defina este valor para 16 MB.

4 Salve a configuração clicando no símbolo de verificação (✔). A configuração de sua instância de banco de dados está sendo atualizada:

Sua instância de banco de dados está configurada agora e é hora de carregar alguns dados espaciais.

Baixando e convertendo um conjunto de dados

Para se familiarizar com os dados espaciais, baixe alguns dados de demonstração e insira-os no banco de dados.

Observação: Você pode executar os comandos a seguir em um computador local executando o Ubuntu ou em uma instância de nuvem virtual.

1 Instale o software necessário para as seguintes etapas usando apt:

2 Crie um diretório para armazenar os dados baixados e insira o diretório recém-criado:

3 Baixe um conjunto de dados. Usamos uma amostra fornecida pelo MassGIS Data que contém informações sobre os limites legais para cada um dos 351 municípios em Massachusetts.

4 Descompacte os dados baixados e liste os dados descompactados para visualizá-los:

5 Você notará vários arquivos .dbf, .prj, .shx e .shp na pasta. Esses arquivos juntos são chamados de ShapeFile, um formato de armazenamento vetorial digital comum para armazenar a localização geométrica e informações de atributo associadas para software GIS legado.

Para importar os dados para o banco de dados, eles devem ser convertidos para SQL. Para conseguir isso, o PostGIS fornece uma ferramenta chamada shp2pgsql que pode converter automaticamente arquivos .shp em arquivos .sql legíveis. Converta o arquivo TOWNSSURVEY_POLY.shp em um arquivo SQL executando o seguinte comando:

6 Importe o arquivo SQL gerado em seu banco de dados usando o cliente psql:

Uma saída como a seguinte é exibida na tela:

A importação foi concluída com sucesso quando a palavra ANALYZE for exibida.

Consulta de dados espaciais

Agora, como alguns dados de demonstração estão disponíveis no banco de dados, você pode começar a consultá-los.

1 Conecte-se ao console psql:

2 Liste as tabelas disponíveis no banco de dados:

O comando acima retornará uma lista de duas tabelas:

3 A tabela a ser consultada é townssurvey_poly. Para visualizar uma lista de todas as colunas disponíveis na tabela, execute o seguinte comando:

O que retorna uma lista da seguinte forma:

O tipo de dados geom coulum contém dados espaciais do tipo MultiPolygon.

Como os dados estão prontos, podemos encontrar respostas para perguntas como “Quais são as 10 cidades localizadas na parte mais ao norte de Massachusetts?

Para obter a resposta a esta pergunta, é possível consultar os dados espaciais no banco de dados. Como os limites da cidade não são lineares, há mais de um valor para a latitude. Portanto, para obter a latitude de cada cidade, o centróide de cada cidade deve ser coletado usando a função ST_Centroid do PostGIS. O valor do centróide Y é então extraído usando a função ST_Y e este valor pode ser usado como latitude.

Como várias cidades têm mais de uma entrada no banco de dados, os resultados são filtrados usando a função DISTINCT ON do PostgreSQL.

A consulta a seguir retorna uma lista das 10 cidades mais ao norte de Massachusetts:


Como desenhar um polígono PostGIS com furos no Blender usando Python

gostaria de desenhar polígonos no Blender. As posições dos vértices são fornecidas como um texto no formato PostGIS. Exemplo :

Já criei um script que funciona muito bem para qualquer polígono sem buracos. No entanto, também preciso desenhar alguns polígonos com orifícios. Exemplo (o segundo polígono define o buraco):

Aqui está o script python até agora para desenhar qualquer sequência de polígonos sem buracos:

Executar este script no Blender criará dois quadrados, um dentro do outro:

Minha pergunta é: como remover o quadrado interno do grande quadrado (e resultando em um buraco)

Tentei adicionar um modificador booleano no quadrado grande, aplicado ao objeto quadrado interno, mas recebo uma mensagem "Não é possível executar a operação booleana".

Existe alguma outra maneira de fazer isso a partir do Blender e que pode ser programada em Python?


Deslizamento de terra para PostGIS com arquivos KML

Neste post vou mostrar, em etapas repetíveis, como instalar PostGIS, carregar dados geoespaciais encontrados em um arquivo KML e executar consultas nesses dados. O foco desses dados geoespaciais serão os deslizamentos de terra e nosso banco de dados resultante nos permitirá consultar, usando coordenadas de longitude e latitude, o status do deslizamento de um ponto geográfico específico. O status retornado para as coordenadas fornecidas será “Principalmente deslizamentos de terra”, “Poucos deslizamentos de terra”, “Terreno plano”, “Não mapeado”.

Os arquivos KML definem, em XML, dados geográficos em três dimensões. UMA KMZ arquivo é simplesmente um arquivo KML compactado.

Você pode encontrar muitos arquivos KML estranhos e maravilhosos na Internet, por meio da Pesquisa Google ou da Galeria do Google Earth.

Keyhole Markup Language (KML) é um esquema XML para expressar anotações geográficas e visualização em mapas bidimensionais baseados na Internet e navegadores tridimensionais da Terra. O KML foi desenvolvido para uso com o Google Earth, originalmente denominado Keyhole Earth Viewer. Foi criado pela Keyhole, Inc, que foi adquirida pelo Google em 2004. O nome "Keyhole" é uma homenagem aos satélites de reconhecimento KH, o sistema de reconhecimento militar original lançado em 1976. KML é um padrão internacional do Open Geospatial Consortium. O Google Earth foi o primeiro programa capaz de visualizar e editar graficamente arquivos KML.
- KML Wikipedia

PostGIS é a arquitetura número um para lidar com dados geoespaciais em um banco de dados relacional. Ele funciona dentro do PostgreSQL.

Enquanto trabalhava com o netSIGN, tive a oportunidade de trabalhar brevemente com PostGIS, que fornece suporte para objetos geográficos dentro do PostgreSQL. Nesse caso, eu estava identificando precisamente os locais dos imóveis a partir das coordenadas de longitude e latitude usando o arquivo KML do limite da área da cidade de Vancouver. Desta vez, estaremos olhando para os deslizamentos de terra na área da baía de São Francisco.

No Mac OS X você pode instalar o PostGIS, e sua dependência do PostgreSQL, com o Homebrew. Para simplificar, presumimos que você já tenha o PostgreSQL instalado.

Faça login como o postgres do utilizador.

Criar um banco de dados de modelos PostGIS

Agora vamos criar um banco de dados modelo para PostGIS dentro do PostgreSQL a partir do qual podemos criar nosso próprio banco de dados PostGIS.

Crie o banco de dados a partir do modelo

Preparando os dados geoespaciais para PostGIS

Vou usar alguns dados de teste de deslizamentos de terras da área da baía de São Francisco. Em earthquake.usgs.gov, podemos baixar um arquivo KMZ que contém as informações geográficas, na forma de polígonos 2-D, das áreas de deslizamento.

Convertendo arquivo KML em arquivo de forma ESRI usando Ogr2ogr

Precisamos instalar o ogr2ogr ferramenta de conversão de linha de comando. Isso está incluído com gdal e FWTools. Se você instalar gdal-bin no Linux via apt-get então você provavelmente obterá uma versão mais antiga que não decodifica arquivos KML 2.2 (necessários neste exemplo). Eu recomendo construir gdal-bin a partir da fonte no Linux.

No meu Mac, instalarei gdal e, portanto, ogr2ogr, usando o Homebrew.

Primeiro, temos que instalar libkml, que é uma dependência de gdal se quisermos ler arquivos KML 2.2. libkml é um mecanismo de análise de arquivo KML escrito pelo Google e é usado no Google Earth e Google Maps. Ogr2ogr pode usar libkml para ler os arquivos KML. Ele tem seu próprio analisador KML, mas isso não funcionará com o arquivo KML 2.2 que tentaremos converter e geralmente não é tão bom quanto o libkml na leitura de arquivos KML. Normalmente, eu instalaria o libkml usando o Homebrew, mas descobri que você só pode instalar o libkml 1.2 e o gdal 1.8.0beta1 requer o libkml 1.3. Portanto, irei instalar a libkml do repositório de fontes libkml, que atualmente é a única maneira de obter a libkml 1.3.

Isso é libkml instalado. Agora, vamos usar o Homebrew para instalar a versão mais recente do gdal.

eu uso -completo para instalar todos os analisadores de formato de arquivo adicionais.

-CABEÇA é usado para baixar a versão mais recente do repositório gdal Subversion. Eu uso –HEAD porque, no momento em que escrevo isto, a versão estável atual é 1.7.3 e não fornece suporte a libkml, que é necessário para ler arquivos KML 2.2. A versão atual do Subversion é 1.8.0beta1.

Agora o ogr2ogr o utilitário de conversão deve ser instalado. KMZ é um arquivo KML compactado. É apenas um arquivo zip normal, portanto, podemos descompactá-lo simplesmente usando o comando unzip. libkml reconhece a extensão kmz, portanto, normalmente não precisaríamos fazer esta etapa, mas landslides.kmz não contém os dados que queremos, apenas referências a eles por meio de vários NetworkLinks para outros arquivos KMZ.

Se você tiver problemas para descompactar um arquivo .kmz, basta renomear para ter uma extensão .zip

Quando descompactamos landlides.kmz, descobrimos que ele contém apenas um arquivo chamado doc.kml. Aqui está a aparência do doc.kml ...

Você notará vários blocos & # x3CNetworkLink> que contêm um bloco & # x3CLink> que contém tags & # x3Chref> que contêm um link da web para outro arquivo KMZ. Idealmente, eles seriam sugados em libkml quando analisamos o arquivo KML / KMZ, mas como o Google diz em sua documentação ...

Em sua forma mais simples, os links de rede são uma maneira útil de dividir um grande arquivo KML em arquivos menores e mais gerenciáveis ​​no mesmo computador.

Apesar do nome, um & # x3CNetworkLink> não carrega necessariamente arquivos da rede.

- Cortesia da documentação KML do Google

Para este exemplo, vou apenas pegar o primeiro desses arquivos KMZ referenciados, Landslides_Aetna_Springs.kmz.

Primeiro, converteremos este KMZ em um Shapefile ESRI usando ogr2ogr.

Embora tenhamos recebido alguns avisos, obtivemos nosso arquivo de forma (na verdade, vários arquivos).

O ESRI Shapefile é composto por esses arquivos, embora normalmente só precisemos fazer referência ao arquivo .shp.

Convertendo ESRI Shapefile em SQL usando Shp2pgsql

Como o PostGIS é executado dentro do PostgreSQL, vamos precisar de algum SQL, então vou converter esse arquivo de forma ESRI para SQL usando o shp2pgsql ferramenta de linha de comando. O shp2pgsql A ferramenta vem com a instalação do PostGIS, para que você possa executá-la de qualquer lugar onde o PostGIS esteja instalado.

Isso gera landslide.sql que contém os dados de geolocalização de Landslides_Aetna_Springs.kmz como instruções SQL.

-s especifica o campo SRID. Como o Google Maps usa SRID 4326 (“WGS84 ″) para isso, usaremos o mesmo.

Um Identificador de Sistema de Referência Espacial (SRID) é um valor exclusivo usado para identificar inequivocamente as definições de sistema de coordenadas espaciais projetadas, não projetadas e locais. Esses sistemas de coordenadas formam o coração de todos os aplicativos GIS.
- Wikipedia

Nós também especificamos deslizamentos de terra como o nome da tabela do banco de dados que iremos inserir. landslides.sql conterá uma instrução de criação de tabela usando este nome e as instruções INSERT subsequentes dentro de landslides.sql serão inseridas nesta tabela.

Aqui estão as outras opções que usei para o shp2pgsql comando.

-c Cria uma nova tabela e a preenche, este é o padrão se você não especificar nenhuma opção.
-EU Crie um índice espacial na geocoluna.
-S Gere geometrias simples em vez de geometrias MULTI.
-C & ltencoding & gt Especifique a codificação de caracteres da coluna de atributos da forma. (padrão: “WINDOWS-1252 ″)

Anteriormente, também usei o -S alternar com shp2pgsql, mas para este arquivo KMZ, recebi a seguinte mensagem.

-S Gere geometrias simples em vez de geometrias MULTI.

Vamos dar uma olhada no SQL gerado ...

Os comandos INSERT são muito longos, então eu os truncei aqui, mas você pode ter uma ideia geral.

Agora podemos carregar o SQL que geramos em nosso banco de dados. Esta é uma etapa fácil.

Você vê algo assim, se tudo correr bem.

Executando consultas SQL em nosso banco de dados PostGIS

Nosso banco de dados de deslizamentos tem quatro definições de deslizamentos, cada um mapeando para um conjunto complexo de polígonos (a coluna da tabela “the_geom” é TIPO: MULTIPOLYGON). Aqui estão seus nomes.

Vamos procurar deslizamentos de terra nas posições de latitude e longitude -122.3800, 38.7499. Aqui encontramos uma localização ruim (o que significa que você não construiria sua casa lá), pois fica nos limites de “Principalmente Deslizamento”.

Vamos encontrar um lugar com menos deslizamentos de terra. Talvez -122.3752, 38.7321?

Isso é muito bom, mas um terreno plano seria melhor.

Bingo! Encontramos alguns terrenos planos sem deslizamentos de terra. Este parece ser um lugar seguro para concluir esta postagem do blog.

Nesta postagem do blog, passei pelas etapas necessárias para converter e carregar um arquivo KML 2.2 em um banco de dados PostgreSQL habilitado para PostGIS. Instalamos o PostGIS e todas as ferramentas necessárias para converter nosso arquivo KML em um arquivo ESRI Shapefile e, em seguida, em instruções SQL que poderiam ser executadas no PostgreSQL. Agora podemos executar consultas SQL em nosso banco de dados que retornarão o status do deslizamento para qualquer longitude e latitude dentro da área de foco.


Importando Dados Espaciais¶

Esta seção mostrará como importar o shapefile das fronteiras mundiais para o banco de dados via modelos GeoDjango usando o utilitário de importação de dados LayerMapping.

Existem muitas maneiras diferentes de importar dados para um banco de dados espacial - além das ferramentas incluídas no GeoDjango, você também pode usar o seguinte:

    : Um utilitário de linha de comando incluído no GDAL que pode importar muitos formatos de dados vetoriais para bancos de dados PostGIS, MySQL e Oracle. : Este utilitário incluído no PostGIS importa arquivos de forma ESRI para o PostGIS.

Interface GDAL¶

Anteriormente, você usou ogrinfo para examinar o conteúdo do arquivo de forma das fronteiras do mundo. GeoDjango também inclui uma interface Pythônica para a poderosa biblioteca OGR da GDAL que pode funcionar com todas as fontes de dados vetoriais que OGR suporta.

Primeiro, invoque o shell Django:

Se você fez o download dos dados da World Borders anteriormente no tutorial, pode determinar seu caminho usando pathlib do Python.Path:

Agora, abra o arquivo de forma das fronteiras do mundo usando a interface DataSource do GeoDjango:

Objetos de fonte de dados podem ter diferentes camadas de recursos geoespaciais, no entanto, os shapefiles só podem ter uma camada:

Você pode ver o tipo de geometria da camada e quantos recursos ela contém:

Infelizmente, o formato de dados do arquivo de forma não permite uma maior especificidade com relação aos tipos de geometria. Este arquivo de forma, como muitos outros, na verdade inclui geometrias MultiPolygon, não polígonos. É importante usar um tipo de campo mais geral em modelos: um GeoDjango MultiPolygonField aceitará uma geometria de polígono, mas um PolygonField não aceitará uma geometria de tipo MultiPolygon. É por isso que o modelo WorldBorder definido acima usa um MultiPolygonField.

A camada também pode ter um sistema de referência espacial associado a ela. Em caso afirmativo, o atributo srs retornará um objeto SpatialReference:

Este arquivo de forma está no popular sistema de referência espacial WGS84 - em outras palavras, os dados usam pares de longitude e latitude em unidades de graus.

Além disso, os shapefiles também oferecem suporte a campos de atributos que podem conter dados adicionais. Aqui estão os campos na camada de Fronteiras Mundiais:

O código a seguir permitirá que você examine os tipos de OGR (por exemplo, inteiro ou string) associados a cada um dos campos:

Você pode iterar sobre cada recurso na camada e extrair informações tanto da geometria do recurso (acessada por meio do atributo geom) quanto dos campos de atributo do recurso (cujo valores são acessados ​​por meio do método get ()):

E recursos individuais podem ser recuperados por seu ID de recurso:

As geometrias de limite podem ser exportadas como WKT e GeoJSON:

LayerMapping ¶

Para importar os dados, use um LayerMapping em um script Python. Crie um arquivo chamado load.py dentro do aplicativo world, com o seguinte código:

Algumas notas sobre o que está acontecendo:

  • Cada chave no dicionário world_mapping corresponde a um campo no modelo WorldBorder. O valor é o nome do campo do arquivo de forma do qual os dados serão carregados.
  • A chave mpoly para o campo de geometria é MULTIPOLYGON, o tipo de geometria como GeoDjango irá importar o campo. Até mesmo polígonos simples no arquivo de forma serão automaticamente convertidos em coleções antes de serem inseridos no banco de dados.
  • O caminho para o shapefile não é absoluto - em outras palavras, se você mover o aplicativo mundial (com subdiretório de dados) para um local diferente, o script ainda funcionará.
  • A palavra-chave de transformação é definida como False porque os dados no arquivo de forma não precisam ser convertidos - já estão em WGS84 (SRID = 4326).

Depois, invoque o shell Django a partir do diretório do projeto geodjango:

Em seguida, importe o módulo de carregamento, chame a rotina de execução e observe o LayerMapping fazer o trabalho:

Experimente o ogrinspect ¶

Agora que você viu como definir modelos geográficos e importar dados com o utilitário de importação de dados LayerMapping, é possível automatizar ainda mais esse processo com o uso do comando de gerenciamento ogrinspect. O comando ogrinspect inspeciona uma fonte de dados vetorial com suporte de GDAL (por exemplo, um arquivo de forma) e gera uma definição de modelo e um dicionário de mapeamento de camadas automaticamente.

O uso geral do comando é o seguinte:

data_source é o caminho para a fonte de dados compatível com GDAL e model_name é o nome a ser usado para o modelo. As opções de linha de comando podem ser usadas para definir melhor como o modelo é gerado.

Por exemplo, o comando a seguir quase reproduz o modelo WorldBorder e o dicionário de mapeamento criado acima, automaticamente:

Algumas notas sobre as opções de linha de comando fornecidas acima:

  • A opção --srid = 4326 define o SRID para o campo geográfico.
  • A opção --mapping diz ao ogrinspect para gerar também um dicionário de mapeamento para uso com LayerMapping.
  • A opção --multi é especificada para que o campo geográfico seja um MultiPolygonField em vez de apenas um PolygonField.

O comando produz a seguinte saída, que pode ser copiada diretamente para o models.py de um aplicativo GeoDjango:


Nosso blog

Em uma postagem de blog anterior, descrevi um método que usei para digerir estatísticas brutas do órgão de estatísticas do governo mexicano, INEGI, quantificando o nível educacional relativo dos residentes na Cidade do México. Na postagem, eu dividi esses dados em quadrados geograficamente e criei uma visualização KML consistindo em polígonos, onde a cor e altura de cada polígono refletia o nível educacional dos residentes na área correspondente. Onde os dados originais se mostraram lentos para renderizar e difíceis de interpretar, o resultado após o processamento foi visualmente atraente, intuitivamente significativo e com desempenho consideravelmente maior. Além disso, pude revisitar um programa de TV favorito, examinar as expressões de tabela comuns do SQL e demonstrar seu uso na construção de consultas complexas.

Mas a postagem deixou algumas pontas soltas desamarradas. Por exemplo, a postagem do blog construiu a visualização usando apenas uma grande consulta. Embora seu design baseado em CTE o tenha tornado razoavelmente legível, a consulta permaneceu muito complexa e muito lenta, pelo menos para uso geral. Fazer tudo em uma consulta torna às vezes um exercício mental agradável, mas também significa que a consulta deve começar do zero, toda vez que for executada, portanto, o desenvolvimento iterativo fica paralisado rapidamente, pois a consulta deve recalcular a cada nova iteração todas as coisas caras que ela já foi trabalhado em corridas anteriores. Além disso, a consulta nesse post calculou suas coordenadas de grade por conta própria. Há um método mais fácil que prometi apresentar, que gostaria de demonstrar aqui.

Rasters

Os bancos de dados GIS contêm informações de (pelo menos) dois tipos diferentes: dados vetoriais e dados raster. Os dados vetoriais descrevem pontos, conectados a linhas e curvas, e vários objetos derivados deles, como polígonos e cadeias de linhas. Os raster, por outro lado, representam uma matriz bidimensional de pixels, onde cada pixel corresponde a uma determinada área geográfica. Cada pixel no raster terá dois conjuntos de coordenadas associadas: primeiro, os valores de latitude e longitude que descrevem o quadrado geográfico que este pixel representa e, segundo, as coordenadas do pixel dentro do raster, que em PostGIS começam com (1,1) na origem . Rasters organizam seus dados em “bandas”, coleções de valores booleanos ou numéricos, com no máximo um valor por pixel. Uma banda pode representar a elevação acima do nível do mar para cada pixel ou a temperatura da superfície. As imagens aéreas geralmente são fornecidas como rasters: uma imagem colorida pode ter uma banda para o canal vermelho, outra para o verde e uma terceira para o azul. As bandas também podem não conter nenhum valor para determinados pixels, e usaremos essa capacidade mais tarde para tornar transparentes algumas partes de nossa imagem final.

Os dados

Os dados do INEGI que apresentei em minha postagem anterior contêm pontos que representam todas as escolas do México e, continuando com o tema da educação, achei que seria um exercício interessante fazer uma imagem do país, onde a cor varia de acordo com a concentração de escolas da região. Isso se assemelha ao meu trabalho anterior de muitas maneiras: estou dividindo a área em consideração em pequenas partes, gerando um valor para cada uma dessas partes e representando o resultado visualmente. Aqui, porém, em vez de desenhar e extrudar polígonos, vou simplesmente colorir um pixel raster. Essa renderização mais simples, onde o sistema de exibição deve simplesmente projetar uma imagem estática, em vez de uma matriz de polígonos, significa que posso suportar uma grade de resolução muito mais alta do que em meu post anterior, sem sobrecarregar o hardware de exibição.

Criando a imagem

Tendo aprendido minha lição com o trabalho com os dados da Cidade do México, optei por criar esta imagem com várias consultas. No final, envolvi essas consultas em um script Perl, construindo nele inteligência suficiente para recriar quaisquer bits do banco de dados que eu pudesse ter simplesmente descartado, enquanto desenvolvia o script, e pular o reprocessamento de quaisquer etapas para as quais ele encontre resultados atuais por aí .

PostGIS oferece suporte a um tipo de dados chamado raster e, prevendo que eu possa querer vários rasters em meu banco de dados, cada um usando uma variedade de configurações e modificações de script, criei uma tabela para armazenar esses rasters e alguns dados extras sobre eles.

O campo de pixels contém o número de pixels ao longo de uma borda do raster, que o script presume ser um quadrado. Isso é redundante, pois posso extrair esse número do próprio raster, mas tê-lo armazenado aqui tornou as coisas mais fáceis para meus objetivos.

Para calcular um raster, preciso encontrar um valor para cada um de seus pixels, ou confirmar que o pixel não deve ter valor, e para isso eu queria outra tabela. Esta tabela contém as coordenadas geográficas e euclidianas para cada pixel em cada raster, o id da entrada associada na tabela raster, um campo para o número de escolas que contei neste quadrado, campos para a cor RGB atribuída ao pixel , e uma bandeira booleana me informando se eu terminei ou não de calcular tudo para este pixel ou não.

A primeira etapa do script é criar um raster vazio, o que ele faz com a função ST_MakeEmptyRaster () do PostGIS, e adicionar quatro bandas a ele, uma para cada um dos valores vermelho, verde, azul e alfa dos pixels. O tipo de dados para cada banda é fornecido como 8BUI, linguagem PostGIS para um inteiro sem sinal de 8 bits. As várias bandas de cores padronizadas para valores NULL e a banda alfa para zeros. O código é parecido com este:

A consulta se refere aos limites e tabelas de parâmetros (na verdade, eles são expressões de tabela de outro lugar na consulta da qual este snippet é extraído). Essas tabelas fornecem valores para numpixels, o número de pixels ao longo de uma borda do raster, fornecido pelo usuário na linha de comando do script, e para st_xmin, st_xmax, st_ymin e st_ymin, que são valores de latitude e longitude que descrevem uma caixa delimitadora ao redor território mexicano.

Antes que possamos fazer muita experimentação e desenvolvimento de consultas, precisamos encontrar uma maneira de inspecionar nossos resultados, convertendo o raster do banco de dados em um arquivo de imagem real. This is one place where having a Perl wrapper script comes in handy, because doing this in pure SQL is actually something of a pain..

This uses ST_AsPng to create an image file under whatever path is stored in $filename , and it’s helpful for reviewing incremental results as the script develops, and of course for rendering the final product. Here we’ve told it to use band 1 for the red values, band 2 for green, 3 for blue, and 4 for alpha. The alpha channel is important: eventually we’ll want to feed the result to Google Earth, and the transparency will mean we can see the ocean surrounding Mexico, without any unimportant raster data getting int he way.

Without any values in the bands, there’s nothing to look at yet—​so let’s make some data.

Finding Polygons

We need to find the polygon corresponding to each pixel in the raster, and PostGIS gives us two ways to do it. The first is ST_PixelAsPolygons(), which returns a set of values, including the geographic rectangle the pixel represents, called geom , and its x and y coordinates. The other function, ST_PixelAsCentroids(), also accepts a single raster as its sole argument and returns a set of similar results, except that instead of a geographic rectangle, it returns only the point at the geographic center of the pixel. I used both as I experimented to make this visualization. The simplicity of these functions makes them far superior to the manual calculation I did in the previous blog post I’ve referred to.

This query fills the polys table with polygons for a particular raster:

One step that proved critical for decent performance was to filter the set of polygons so that I calculate values only for those pixels that actually intersect some part of Mexico. PostGIS rasters are regular rectangles, so a substantial portion of this raster lies over open ocean. Since we’re counting schools of people, and not of fish, we can skip all those ocean pixels, and though filtering them out takes considerable processing, we earn back that cost and more in savings later when calculating schools within each pixel. This modified version of the query above does that filtering.

This query refers to a table called mexico , which contains geographic representations of each of Mexico’s 31 states and the region of Mexico City, which I didn’t previously know wasn’t a state. It’s this table that gave us st_xmin , st_xmax , etc., when we made the original raster, and now we use it to filter out all pixels from our raster that don’t intersect some portion of Mexico.

At this point it would be nice to see a visual representation of our raster, to make sure the filtering worked the way we intended. We still haven’t filled the raster with any data, but we could fill it with dummy values and render the image, just to get a look at our progress. This raster modification we achieve with the ST_SetValues() function, which accepts a raster as input and returns the raster, with updated values in one of its bands. The function comes in several forms the one we’ll use accepts an array of geomval objects, each of which contains a PostGIS geometry, and a single double precision value. Internally, the function finds the pixel or pixels corresponding to the geometry objects provided, and sets those pixels’ values in the given band accordingly. We make sure to provide POINT values here—​ the center point for each pixel’s corresponding polygon—​gc as ST_SetValues is considerably faster that way than when given POLYGON values themselves.

For a raster with many pixels, this takes a bit of time to accomplish. For my initial testing, I used rasters with only 50 pixels per side, which my wimpy laptop can churn out fairly rapidly. Here’s the first visual confirmation that we’re headed down the right path. Because of the low resolution, the image is small, but it’s obvious that our result follows the basic shape of Mexico, which means our polygon generation and filtering has worked.

I mentioned transparency above. Note that in the default format of this blog, it would be impossible to tell that the transparency in this image was correct, so I’ve post-processed all the rendered raster images in this article to replace the transparency with a gray checkerboard pattern.

Counting schools

Now all that remains is to count the schools in each pixel, and assign corresponding color values.

This query finally refers to the actual INEGI data set I started with, a table called sip , in which each record includes a POINT object and a label. We’re interested in labels marked “Escuela”, Spanish for “School”. I tried a few different techniques here, as shown by the two different JOIN variants in the schoolcounts portion of the query. The version shown here simply counts schools within each square pixel. Later I’ll try counting schools within a certain radius of the center of the pixel. The two give different results, of course which one is more useful depends on the end goal for these data.

Note the use of the processed field, and the 100 item limit in the polygons section of the query. Together with some logic in the surrounding Perl, this allows me to process pixels in small batches, interrupt processing when necessary, and later, resume more or less where I left off.

Color assignment

After counting schools, I need to assign colors to the pixels. Initially I imagined this would be fairly easy, but in fact it took some detective work to get it right. My plan was to get a gradient of colors, divide the school counts into histogram-like buckets according to school density, and assign a color to each bucket. Building your own decent color gradient is surprisingly difficult, and I got mine from an online service. As with the last blog post, I figured a relatively small number of colors would be easiest. These I encoded as a PostgreSQL array, and I used PostgreSQL’s ntile window function to return the right bucket for each polygon. The results surprised me, shown here in a raster with 500 pixels on each side:

It’s easy to see in that image that some pixels are colored to represent schools, but where did all the vertical bands come from? Much of Mexico is very sparsely populated, so vast swaths of our pixels have no schools at all. This means that the pixels with a school count of zero fill most of the available buckets. Pixels with schools in them are so much in the minority, for any raster of sufficient resolution, as to place all non-zero pixels in a single bucket. So I modified my approach slightly: I made my histogram only from those pixels with non-zero school counts. That query is below.

A second, very simple query not included here found any pixels with zero schools and colored them white.

Packaging the result

The final bit of required scripting to generate a usable image is to use ST_SetValues again, in a somewhat more complex form than last time, creating an array of geomval objects and using them to update the original raster.

This gives me something like the image below, with 500 pixels on each edge of the raster:

This image does the job, but contains an awful lot of empty space. I mentioned above that instead of calculating the exact number of schools within a pixel’s polygon, I thought I might try calculating the number of schools within a specific distance of the pixel’s center perhaps that technique would lead to a more visually appealing result. This is simple enough, using the ST_PixelAsCentroids() function to get the centroids of the pixels’ polygons, and then modifying the schoolcounts CTE as shown here. The key modification—​in fact, the only modification from the earlier version shown above—​is in the JOIN clause, which uses ST_Buffer to create a circle surrounding a point, in this case, with an arbitrarily chosen radius, and counts the number of schools found within that circle.

The resulting image, again with 500x500 pixel resolution, shows evidence of its circle-based counting heritage.

Obviously at this point, a person could mess with any number of variables to get all sorts of results. But for me it was enough to embed this as a GroundOverlay object within a simple KML file, to see the result in Google Earth:


Spatial Field Options¶

In addition to the regular Field options available for Django model fields, spatial fields have the following additional options. All are optional.

Sets the SRID [2] (Spatial Reference System Identity) of the geometry field to the given value. Defaults to 4326 (also known as WGS84, units are in degrees of longitude and latitude).

Selecting an SRID¶

Choosing an appropriate SRID for your model is an important decision that the developer should consider carefully. The SRID is an integer specifier that corresponds to the projection system that will be used to interpret the data in the spatial database. [3] Projection systems give the context to the coordinates that specify a location. Although the details of geodesy are beyond the scope of this documentation, the general problem is that the earth is spherical and representations of the earth (e.g., paper maps, Web maps) are not.

Most people are familiar with using latitude and longitude to reference a location on the earth’s surface. However, latitude and longitude are angles, not distances. In other words, while the shortest path between two points on a flat surface is a straight line, the shortest path between two points on a curved surface (such as the earth) is an arco of a great circle. [4] Thus, additional computation is required to obtain distances in planar units (e.g., kilometers and miles). Using a geographic coordinate system may introduce complications for the developer later on. For example, SpatiaLite does not have the capability to perform distance calculations between geometries using geographic coordinate systems, e.g. constructing a query to find all points within 5 miles of a county boundary stored as WGS84. [5]

Portions of the earth’s surface may projected onto a two-dimensional, or Cartesian, plane. Projected coordinate systems are especially convenient for region-specific applications, e.g., if you know that your database will only cover geometries in North Kansas, then you may consider using projection system specific to that region. Moreover, projected coordinate systems are defined in Cartesian units (such as meters or feet), easing distance calculations.

If you wish to perform arbitrary distance queries using non-point geometries in WGS84 in PostGIS and you want decent performance, enable the GeometryField.geography keyword so that geography database type is used instead.

    : A Django-powered database of spatial reference systems. : A website covering the various projection systems used in the United States. Much of the U.S. spatial data encountered will be in one of these coordinate systems rather than in a geographic coordinate system such as WGS84.

Spatial_index ¶

Defaults to True . Creates a spatial index for the given geometry field.

This is different from the db_index field option because spatial indexes are created in a different manner than regular database indexes. Specifically, spatial indexes are typically created using a variant of the R-Tree, while regular database indexes typically use B-Trees.


'ERROR: could not access file &ldquo$libdir/postgis-2.5&rdquo: No such file or directory' [closed]

Quer melhorar esta questão? Update the question so it's on-topic for Database Administrators Stack Exchange.

Dealing with PostGIS has been a nightmare from day one. Every single time I have to touch it in any way, or update PostgreSQL, it turns into a broken mess. The only reason I use it is because I need to be able to use "geography" columns and a few "st_" functions.

Until a few days ago, I had EnterpriseDB's PostgreSQL 11.5 installed on Windows 10. It had PostGIS installed. Then I installed EnterpriseDB's PostgreSQL 11.7 to update it. Now it somehow lost PostGIS, so I re-installed that as well. Everything has to be done manually for some reason.

Now, every query related to PostGIS gives this error:

I don't know why it says 2.5 when I installed postgis-bundle-pg11x64-setup-3.0.1-2.exe.

This doesn't work at all (doesn't exist):

I've seriously spent so much of my life just fighting with PostGIS that I truly hate it, and wish I could get rid of it forever. Or that they at least could get their act together and integrate it correctly into PostgreSQL so it doesn't lead to all these stupid problems all the time. I don't understand why it has to require so much manual work and fiddling. Why can't it just do these steps automatically?


(This will eventually be the topic of a new vignette now here to explain the last attribute of sf objects)

The standard documents about simple features are very detailed about the geometric aspects of features, but say nearly nothing about attributes, except that their values should be understood in another reference system (their units of measurement, e.g. as implemented in the package unidades) But there is more to it. For variables like air temperature, interpolation usually makes sense, for others like human body temperature it doesn’t. The difference is that air temperature is a field, which continues between sensors, where body temperature is an object property that doesn’t extend beyond the body – in spatial statistics bodies would be called a point pattern, their temperature the point marks. For geometries that have a non-zero size (positive length or area), attribute values may refer to the every sub-geometry (every point), or may summarize the geometry. For example, a state’s population density summarizes the whole state, and is not a meaningful estimate of population density for a give point inside the state without the context of the state. On the other hand, land use or geological maps give polygons with constant land use or geology, every point inside the polygon is of that class. Some properties are spatially extensive, meaning that attributes would summed up when two geometries are merged: population is an example. Other properties are spatially intensive, and should be averaged, with population density the example.

Simple feature objects of class sf have an agr attribute that points to the attribute-geometry-relationship, how attributes relate to their geometry. It can be defined at creation time:

When not specified, this field is filled with NA values, but if non- NA , it has one of three possibilities


Assista o vídeo: Polygon Triangulation 1 - Overview of Ear Clipping