Posts com Tag ‘postGIS’

Neste conjunto de posts disponibilizamos informações práticas sobre GIS, especialmente OpenLayers, Geoserver e PostGIS.  Na medida do possível, agregaremos receitas (pequenos tutoriais na forma de programas exemplos), de forma a facilitar o entendimento das tecnologias e poder ajudar a quem deseja programar.

Conceitos:
Os padrões WMS e WFS do consórcio OGC – Open Geospatial Consortium
Análise dos dois padrões definidos pela OGC: WMS e WFS, com exemplos da utilização de suas requisições.

OpenLayers: objeto Feature. Que bicho é este?
Análise de como criar as features, associá-lo a um layer vetorial e criar controles de interatividade usuário-features.

OpenLayers: eventos
Informações práticas para utilizar de forma estruturada eventos com a biblioteca OpenLayers.

OpenLayers: as bibliotecas JavaScript GeoExt e ExtJS
Entendendo as bibliotecas, instalando e utilizando.

Receitas com o OpenLayers:

Receita-1: OpenLayers: compreendendo melhor as features – Feature.Vector –
Nesta receita pretende-se explorar os aspectos iniciais de funcionamento da classe feature, layer vetorial e um pouco de estilo de uma feature.

  • Classes utilizadas: OpenLayers.Geometry.Point; OpenLayers.Geometry.LineString; OpenLayers.Layer.Vector; OpenLayers.Feature.Vector; OpenLayers.Util.applyDefaults e OpenLayers.StyleMap.
  • Métodos utilizados: geom_point1.distanceTo(; geom_point1.clone()

Receita-2: OpenLayers: compreendendo melhor um “Layer Vetorial”
Nesta receita pretende-se explorar o protocolo Protocol.HTTP com arquivo GeoJSON para buscar dados remotos no servidor. Com estes dados, serão mostradas as geometrias no mapa.

  • Classes utilizadas: OpenLayers.Protocol.HTTP; OpenLayers.Format.GeoJSON; OpenLayers.Strategy.Fixed e OpenLayers.LonLat.

Receita-3: OpenLayers: compreendendo melhor as features – Control.SelectFeature –
Nesta receita pretende-se explorar o “controle SelectFeature” sobre geometrias tais como: pontos, linhas e polígonos. O usuário selecionará uma ou várias features simultaneamente com um click do mouse.

  • Classes utilizadas: OpenLayers.Geometry.Point; OpenLayers.Geometry.LineString; OpenLayers.Geometry.LinearRing; OpenLayers.Layer.Vector; OpenLayers.Feature.Vector; OpenLayers.Control.SelectFeature e OpenLayers.LonLat.

Receita-4: OpenLayers: compreendendo melhor as features – Control.SelectFeature e eventos
Nesta receita pretende-se explorar o “controle SelectFeature”, mais eventos gerados pelos clicks do mouse “events.register(‘featureselected’, this, selected_feature)” sobre geometrias tais como: pontos, linhas e polígonos. O usuário selecionará uma ou várias features simultaneamente com um click do mouse.

  • Classes utilizadas: OpenLayers.Geometry.Point; OpenLayers.Geometry.LineString; OpenLayers.Geometry.LinearRing; OpenLayers.Geometry.Polygon; OpenLayers.Feature.Vector; OpenLayers.Layer.Vector; OpenLayers.Control.SelectFeature e OpenLayers.LonLat.
  • Métodos utilizados: selected_feature(event); getElementById e events.register(.

Receita-5: OpenLayers: compreendendo melhor as features – controle GetFeature – WFS
Nesta receita pretende-se demostrar como usar o controle GetFeature, utilizando Protocol.WFS, para buscar no servidor features na localização sobre o cursor do mouse.

  • Classes utilizadas: OpenLayers.Layer.Vector; OpenLayers.Feature.Vector.style; OpenLayers.Control.GetFeature; OpenLayers.Protocol.WFS.fromWMSLayer e OpenLayers.LonLat.
  • Métodos utilizados: control.events.register

Receita-6: OpenLayers: utilizando o protocolo WFS para requisitar features de servidor remoto Geoserver
Nesta receita pretende-se mostrar como buscar features em um servidor remoto, adicionando estas informações em um layer vetorial de forma a torná-las visíveis em um mapa.

  • Classes utilizadas: OpenLayers.Layer.Vector, OpenLayers.Strategy.BBOX e OpenLayers.Protocol.WFS

Sobre o Geoserver:
Instalar Geoserver no Linux – Debian
Tutorial para instalar o GeoServer utilizando tanto o container Jetty como o Tomcat numa máquina Linux – Debian. Aspectos de segurança são explorados.

Utilizar o GeoServer
São abordados aspectos referente a configuração do GeoServer para ter acesso a arquivos Shapefile e tabelas do PostGIS, e como trabalhar com arquivos Styled Layer Descriptor (SLD), entre outros.

Instalar a suíte OpenGEO no Linux – Ubuntu
O foco é a instalação da suíte OpenGeo – Community Edition, explorando: acesso a tabelas do PostGIS, instalação e utilização do PgAdminIII e PhpPgAdmin, importação de arquivos Shapefiles para o PostGis, entre outros.

O Geoserver em produção e com segurança
Aspectos importantes para o perfeito funcionamento do servidor de mapas Geoserver em ambiente de produção com Linux – Debian.

Sobre o PostGIS:
Instalar PostGIS no Linux Debian
Instalar extensão PostGIS, comentários sobre a tabela SPATIAL_REF_SYS (e sistemas de referencia espacial); quanto a utilização da extensão PostGIS aborda-se a criação de base de dados, criação de perfis de grupos e usuários, atribuições de permissões as tabelas; detalhamento de como realizar o carregamento de base de dados com arquivos shapes; e detalhes do processo de instalação de bibliotecas complementares (cpmo a Proj.4).

Instalar PostgreSQL + PostGIS no CenTOS
instalar o PostgreSQL e PostGIS no CenTOS, instalar as bibliotecas PROJ.4 e OSGEO, configurar o serviço PostgreSQL e criação de banco de dados espacial.

Ferramentas:
Debug de scripts com Firefox
O Firefox tem extensões que trazem várias falicidades para debug de códigos JavaScript e PHP.

Extensões do PostgreSQL

Publicado: 27/09/2012 em Programação
Tags:,

PostgreSQL dá a possibilidade ao usuário de estender suas funcionalidades através da instalação de módulos adicionais. Os módulos disponíveis para o release 9.1 do Postgresql pode ser encontrado no diretório contrib da distribuição do PostgreSQL.  Estes incluem ferramentas de portabilidade, utilitários análise e plugins que não são parte do “core” do sistema PostgreSQL, principalmente porque eles são dirigidos a um público limitado ou são considerados experimentais para ser parte da sua árvore principal. Embora estes fatores não impessam a sua utilização.

Entre eles está o módulo hstore. Este módulo implementa o tipo de dados hstore para armazenar conjuntos de pares do tipo “key => value” separados por vírgulas, dentro de um valor único PostgreSQL.  Pode ser muito útil para guardar dados desestruturados, tais como tags e tabelas de hashs. Este tipo de dados é similar ao conceito de “associative arrays” do PHP.

1. Baixar as extensões
# apt-get install postgresql-contrib

2. Instalar o módulo hstore
O comando “CREATE EXTENSION” carrega uma nova extensão na base de dados corrente. Carregar uma extensão equivale essencialmente a execução de arquivos de scripts da extensão. O script irá tipicamente criar novos objetos SQL tais como funções, tipos de dados, operadores e suporte a métodos de indexação.

Para usar o comando de criação de uma extensão, deve-se conectar com a base de dados desejada e ter autoridade de “superuser”:
postgres$ psql minha_base
minha_base=# CREATE EXTENSION hstore;
CREATE EXTENSION

Agora pode-se utilizar este tipo de dados normalmente, como no exemplo abaixo de criação de uma tabela:
minha_base=# CREATE TABLE meu_esquema.minha_tabela (gid integer NOT NULL, geom geometry, contador integer, tags hstore);

Referências:
1. Additional PostgreSQL Modules
2. Instalar extensões no PostgreSQL

Neste post estaremos focando a OpenGeo Suite –  Community Edition.   A suíte OpenGeo, Community Edition, é uma versão completa da suíte OpenGeo. Está licenciada através da GNU General Public License (GPL). A OpenGeo é uma divisão geoespacial da OpenPlans, uma organização sem fins lucrativos que tem a proposta de usar a tecnologia para contribuir com a mudança da maneira com que as cidades e os cidadãos interagem. A opção pelo código aberto, dados abertos e mobilidade sustentável é entendida como possibilidade para melhorar milhões de vidas. A organização tem oferecido assistência técnica a órgãos públicos, e construído comunidades em torno de iniciativas que semeiam um ecossistema aberto de ferramentas de tecnologias de interesse público.

No momento da publicação deste post, o download do OpenGeo Community Edition pode ser obtido aqui.  Existe também instruções para instalação da suíte através do apt para o Linux/Ubuntu 10.04 e 10.10 (e mais recentes) em http://suite.opengeo.org/opengeo-docs/usermanual/installation/linux/suite.html:

1. Iniciar importando a chave GPG OpenGeo:

# wget -qO- http://apt.opengeo.org/gpg.key | apt-key add -

2. Adicionar o repositório APT OpenGeo:

# echo "deb http://apt.opengeo.org/ubuntu lucid main" >> /etc/apt/sources.list

3. Atualizar APT:

# apt-get update


4. Instalar o pacote da suíte OpenGeo (opengeo-suite):

# apt-get install opengeo-suite

5. Lançar o  “Dashboard OpenGeo Suite”
Com isto pode-se verificar se a instalação teve sucesso. Acessar a seguinte URL:
http://localhost:8080/dashboard/

6. Acessar as aplicações web

Application URL
OpenGeo Suite Dashboard  http://localhost:8080/dashboard/
GeoServer  http://localhost:8080/geoserver/
OpenGeo Suite Documentation  http://localhost:8080/docs/
GeoExplorer  http://localhost:8080/geoexplorer/
Styler  http://localhost:8080/styler/
GeoEditor  http://localhost:8080/geoeditor/
OpenGeo Recipe Book  http://localhost:8080/recipes/

No caso da aplicação GeoServer, para fazer login, utilize:
usuário: admin
Password: geoserver

Uma verificação interessante é requisitar o serviço WFS (GetCapabilities) do servidor:
http://<ip-servidor&gt;:8080/geoserver/wfs?request=GetCapabilities

7. Accessar o PostGIS

O acesso ao PostGIS pode ser feito de duas maneiras: via linha de comando atarvés da aplicação psql, ou via uma interface gráfica com a aplicação pgadmin3. No caso do usuário ser não familiar com o PostGIS, iniciar com o pgadmin3.  A versão atual do PostGIS é acessível através da porta 5432, com usuário e senha de administrador opengeo / opengeo.

8. Iniciar/Parar a suíte OpenGeo e PostGIS

GeoServer, GeoExplorer, e todos os outros containers web-based incluindo a documentação estão instalados dentro da instância Tomcat existente. Iniciar e parar estas aplicações são, portanto, realizadas gerenciando a instância padrão do Tomcat. Tomcat é instalado como um serviço de nome tomcat6, e pode ser gerenciado da seguinte forma:

/etc/init.d/tomcat6 start
/etc/init.d/tomcat6 stop

PostGIS é instalado também como um serviço, com o nome postgresql, e pode ser gerenciado da mesma maneira que o Tomcat:

/etc/init.d/postgresql-8.4 start
/etc/init.d/postgresql-8.4 stop

Ambos os serviços são iniciados e configurados para serem executados automaticamente quando a suíte OpenGeo é instada.

9. Usando o PgAdminIII
a) Se desejar utilizar o PgAdminIII a partir da própria máquina em que está instalado o Opengeo-suite, utilize inicialmente a seguinte configuração:
Máquina: localhost
porta:   5432
Manutenção do BD: postgres
Nome de usuário: opengeo
Senha: opengeo

b) Utilizando o PgAdminIII de outra máquina e tentando acessar o postgres como usuário opengeo (com a mesma configuração do caso anterior), ocorrerá um erro conforme ilustra a figura a seguir.
Erro de acesso do PgAdminIII

Este erro significa que a tentativa de conexão ao servidor de banco Postgres foi bloqueada. Isto se deve ao fato de que o arquivo de configuração do Postgres não está permitindo conexão remota. Altere esta configuração em /etc/postgresql/8.4/main/postgresql.conf:

DE:
#listen_addresses = 'localhost'
PARA:
listen_addresses = '*'

Reinicie e Postgres:
# /etc/init.d/postgresql-8.4 restart

Agora, após a alteração do arquivo postgresql.conf, e tentando fazer a mesma conexão de uma máquina remota, obtemos um outro erro conforme ilustra a figura abaixo:

Erro do PgAdminIII devido configuração do pg_hba.conf

Isto se deve ao fato que no arquivo de configuração pg_hba.conf não foi previsto o acesso as bases do postgres a partir da máquina remota em uso. Há necessidade de habilitar o acesso a partir da máquina em uso (IP 192.168.0.106). Altere este arquivo em /etc/postgresql/8.4/main/pg_hba.conf inserindo a seguinte linha:

host all all 192.168.0.106/32 md5

Reiniciar o Postgres:
# /etc/init.d/postgresql-8.4 restart

Agora obtem-se sucesso na tentativa de acesso do PgAdminIII a partir de uma máquina remota a base de dados do Postgres (usando opengeo/opengeo).

10. Usando o PhpPgAdmin
Adicionalmente, caso se queira, pode ser instalado também o PhpPgAdmin. Neste caso, proceda da seguinte forma:
a) Instalar o Apache e PHP
Detalhes desta tarefa podem ser encontrados no post deste blog “Instalar servidor LAMP (Linux + Apache + PHP + MySQL) no Debian“. Em resumo:

# apt-get install apache2 php5
# /etc/init.d/apache2 restart

b) Testar o Apache
Acessar o endereço http://<IP_servidor&gt; . Se uma mensagem “It Works” for mostrada, como a figura abaixo, o Apache está funcionando bem.

Tela inicial do Apache

Tela inicial do Apache

c) Testar o funcionamento do Apache + PHP

Para isto, basta criar o arquivo /var/www/index.php com o seguinte conteúdo:

<?php
phpinfo();
?>

Acessar o endereço http://<IP_servidor>/index.php . Se as informações de configuração do PHP forem mostradas, isto significará que o Apache e o interpretador PHP foram instalados corretamente e estão funcionando.

d) Instalar o PhpPgAdmin

# apt-get install phppgadmin

Acessar o endereço http://<IP_servidor>/phppgadmin/
Uma mensagem de erro deve ser mostrada, caso não se esteja trabalhando em “localhost” (mas sim, quando instalando o PhpPgAdmin numa máquina remota): “client denied by server configuration: /usr/share/phppgadmin/”.

A mensagem de erro é fruto de uma regra de segurança: a configuração default é só permitir acesso ao PhpPgAdmin em localhost. Para solucionar este erro, edite o arquivo /etc/apache2/conf.d/phppgadmin da seguinte forma:

COMENTAR A LINHA: “allow from 127.0.0.0/255.0.0.0”
DESCOMENTAR A LINHA:  “#allow from all”

OBS: ou de uma forma mais segura, restrinja mais o acesso utilizando a notação CIDR:
allow from 192.168.0.100/24 (neste exemplo, permitindo apenas as máquinas em uma rede classe C 192.168.0.xxx fazerem acesso ao PhpPgAdmin.

E claro, falta reiniciar o Apache pelo comando “# /etc/init.d/apache2 restart“.
Pronto, através do navegador acessar a URL do PhpPgAdmin. Obtendo a tela abaixo significa que está tudo pronto para o aplicativo ser utilizado normalmente.

Tela inicial do PhpPgAdmin

e) Fazer login no PhpPgAdmin
Fornecer as mesmas informações quando do login no uso do PgAdminIII:
Nome do usuário: opengeo
Senha: opengeo

11. Importar arquivos shapefiles para o PostGis
Instalada a suíte OpenGeo, deve-se importar os arquivos shapes para o banco de dados PostGIS e visualizá-los com a suíte.

a) Criar uma nova base de dados para deter as informações dos arquivos shapes

postgres$ createdb -T template_postgis -O opengeo teste

No caso acima, utilizou-se a tabela template “template_postgis” que já é padrão na instalação da suíte OpenGeo para criar um banco intitulado “teste”. No caso, o proprietário deste banco é o usuário “opengeo” (que também é o default da instalação da suíte OpenGeo).

b) Criar os arquivos .sql
Após criar a nova base de dados espacial, vamos inserir dados no banco de dados PostGIS/PostgreSQL usando o carregador/descarregador de arquivos ESRI Shape (shp2pgsql). O carregador de dados shp2pgsql converte arquivos ESRI Shape em declarações adequadas SQL para inserção em seguida em um banco de dados PostGIS/PostgreSQL (executando este arquivo sql) tanto no formato de geometria como no de geografia. Vejamos um exemplo:

$ shp2pgsql -s 4674 -W LATIN1 VARJAO_PDAD.shp > varjao.sql
$ psql -d teste -h localhost -U opengeo -f varjao.sql

OBS:
i) a chave “-s”:
Dará ao PostGIS a informação do “Spatial Reference System Identifier” (SRID) dos dados. É um valor único usado para identificar inequivocamente definições de sistemas de coordenadas espaciais locais, projetadas e não projetadas. Estes sistemas de coordenadas formam o coração de todas as aplicações de SIG. O “Sistema de Referência Geocêntrico para as Américas” (SIRGAS) é o sistema de referenciamento espacial padrão do Brasil, definido pelo IBGE. Seu SRID, num sistema geográfico, é EPSG: 4674. Na prática o SIRGAS utiliza o mesmo elipsóde de referência do WGS84 – GRS 1980.

ii) a chave “-W”:
Especifica a codificação dos caracteres utilizada nos atributos dos arquivos shapes. Se esta opção é utilizada, a saída será codificada em UTF-8. A forma como fora utilizada no exemplo acima é muito comum quando se importa arquivos que foram gerados utilizando máquinas com sistema operacional Windows.

12. Automatizar a importação de arquivos para o PostGis
a) Gerar um arquivo texto “lista_arquivos_shp.txt” com o nome de todos os arquivos shapes (que devem estar dentro de uma única pasta).
Existindo uma grande quantidade de arquivos shapes, é mais prático criar um script para gerar todos os arquivos sql em lote. Execute o seguinte comando:
$ find <caminho>  -iname "*.shp" > lista_arquivos_shp.txt

Onde caminho é o endereço onde estão os arquivos shapes.  Exemplos:
$ find ../  -iname "*.shp" > lista_arquivos_shp.txt  ; se os arquivos estiverem na pasta superior
$ find  -iname "*.shp" > lista_arquivos_shp.txt      ; se os arquivos estiverem na pasta atual

b) Com o arquivo anterior criado, vamos gerar os arquivos sql de forma automática, correspondentes a cada arquivo shape existente.
Primeiro, vamos criar um arquivo de script com o seguinte conteúdo:

#!/bin/bash
if [ -e $geracao_sql.log ]; then
rm geracao_sql.log
fi
while read linha; do
novo=$(basename $linha)
novo=${novo%%.*}
echo "\n ------ Gerando o arquivo "$novo".sql"
echo "gerando o arquivo "$novo".sql" >> geracao_sql.log
shp2pgsql -s 4674 -W LATIN1 "$linha" > $novo."sql"
done < lista_arquivos_shp.txt

Agora é só mandar executar o script.   Mensagens serão enviadas para a tela, e será gerado um arquivo de log do processo de geração dos arquivos sql (geracao_sql.log) .

Se desejar verificar a quantidade de arquivos na pasta, comparando as quantidades de arquivos .shp e .sql utilize os comandos:


$ ls <caminho>/*.shp | wc -l
$ ls <caminho>/*.sql | wc -l

c) Com os arquivos sql criados, executar estes arquivos para inserir os dados dos shapes no banco PostGIS.  Como podem existir vários arquivos sql, vamos realizar esta tarefa executando um arquivo de lote:

c.1) Gerar um arquivo texto “lista_arquivos_sql.txt” contendo o nome de todos os arquivos sql (os quais devem estar dentro de uma única pasta). Execute o seguinte comando:
$ find <caminho>  -iname "*.sql" > lista_arquivos_sql.txt

Onde caminho é o endereço onde estão os arquivos shapes.  Exemplos:
$ find ../  -iname "*.sql" > lista_arquivos_sql.txt  ; se os arquivos estiverem na pasta superior
$ find  -iname "*.sql" > lista_arquivos_sql.txt      ; se os arquivos estiverem na pasta atual

c.2) Preparar arquivo de autenticação (password) para que o arquivo de lote contendo comandos psql não seja interrompido a cada arquivo para solicitar ao usuário a senha de acesso ao banco.
O arquivo .pgpass no diretório home do usuário é um arquivo que pode conter senhas para ser usado para conexão que requer senha de acesso (e se nenhuma senha tenha sido especificada de outra forma). Desta forma o usuário PostgreSQL pode conectar no banco em localhost sem informar senha, pois a mesma já estará informada neste arquivo. Veja mais detalhes no manual do PostgreSQL.  O formato deste arquivo é o seguinte:

hostname:port:database:username:password

No nosso caso, o seu conteúdo será:

localhost:5432:*:opengeo:opengeo

Se for executar o arquivo de lote (descrito logo abaixo) como root, criar este arquivo em /root/.pgpass

ATENÇÃO: este arquivo deve ter obrigatoriamente a permissão 0600 (comando “$chmod 0600 .pgpass”). Se a permissão for mesnos restritiva que isto, o arquivo será ignorado.

c.3) Executar o arquivo de lote
Crie o arquivo de lote abaixo, e execute-o (comando “$sh inserir_postgis.sh”).  Dê atribuição de execução ao mesmo (comando “$chmod +x inserir_postgis.sh”).

#!/bin/bash
# script para inserir shape no banco PostGIS
# inserir_postgis.sh
if [ -e $inserir_postgis.log ]; then
rm inserir_postgis.log
fi
while read linha; do
novo=$(basename $linha)
# psql -a -L inserir_postgis.log -d teste -h localhost -U opengeo -f $novo
# psql -L inserir_postgis.log -d teste -h localhost -U opengeo -f $novo
psql -d teste -h localhost -U opengeo -f $novo
done < lista_arquivos_sql.txt

OBS: as duas linhas comentadas acima no comando psql se referem a opções do comando para gerar arquivo de log ou uma saída no console mais detalhada. Veja o manual do comando psql para mais detalhes (comando “$man psql”).
Bom proveito!

Referências:
1- Autenticação no PostgreSQL
2- PostgreSQL Prático
3- Documentação do PostgreSQL 8 – Autenticação de clientes
4- CIDR: Classless Inter-Domain Routing
5- Sistema de Referenciamento Espacial


1. Introdução

PostGIS adiciona suporte para objetos geográficos ao banco de dados objeto-relacional PostgreSQL. A primeira versão do PostGIS foi liberada em 2001 sob licença GPL.Com efeito, PostGIS “habilita espacialmente” o servidor PostgreSQL, permitindo a ele seja utilizado como um banco de dados espacial back-end (servidor de retaguarda) para sistemas de informação geográfica (SIG).

PostGIS segue o OpenGIS “Simple Features Specification for SQL” e foi certificado como compatível com os perfis de “Tipos e funções”. Diversas ferramentas trabalham com PostGIS, tais como uDIG, Mapserver, GeoTools, GeoServer, GRASS, OpenJUMP, gvSIG e QGIS. E naturalmente qualquer linguagem que trabalha com PostgreSQL pode trabalhar com PostGIS — a lista inclui Perl, PHP, Python, TCL, C, C++, Java, C#, e outras.

2. Exigências
Para detalhes de instalação do PostgreSQL no Linux Debian, veja o post “Tutorial PostgreSQL ( instalar em ambiente Linux – Debian )“.

3. Instalar extensão PostGIS
Após ter instalado o PostgrSQL, realizar os seguintes procedimentos:

3.1) Verificar instalações e versões disponiveis de postgreSQL e postGIS

$ apt-cache policy postgresql
postgresql:
Instalado: 8.4.10-0squeeze1
Candidato: 8.4.10-0squeeze1
Tabela de versão:
*** 8.4.10-0squeeze1 0

$ apt-cache policy postgis
postgis:
Instalado: (nenhum)
Candidato: 1.5.1-5
Tabela de versão:
1.5.1-5 0

Com a resposta aos dois comandos acima, conclui-se que PostgreSQL está instalado na máquina alvo (versão 8.4), mas que o PostGIS não está instalado. A versão do PostGIS disponível no repositório Debian candidata à instalação é a 1.5.

3.2) Instalar o PostGIS referente a versão 8.4 do PostgreSQL

# apt-get install postgis postgresql-8.4-postgis

Onde:

  1. postgis :contém binários do PostGIS em nível usuário, arquivos comuns e documentação. Sugere postgresql-8.4-postgis
  2. postgresql-8.4-postgis :contém suporte a objetos geográficos para o PostgreSQL 8.4. Depende de postgis e de postgresql-8.4

Após a instalação descrita acima, o manual do PostGIS ficará depositado em file:///usr/share/doc/postgis/postgis/postgis.html , com mais detalhes quanto a sua instalação e configuração.

3.3) Criar perfil de grupo e usuário
Usualmente, a melhor maneira de manipular dados GIS no banco de dados PostgreSQL é usando papel e usuário diferentes do default “postgres”, que deve ser usado apenas para tarefas administrativas. No exemplo deste post, será criado o papel e usuário “gis” para a manipulação de dados no servidor PostgreSQL. Para se obter um ambiente mais seguro, podem ser criados outros usuários com diferentes direitos (SELECT, INSERT, UPDATE, DELETE) sobre as diferentes classes SIG.

Conectar ao servidor PostgreSQL (como usuário postgres), criar os papeis “gisgroup” e “gis” (se desejado, escolha menos permissões por razões de segurança), e atribuir a função de login “gis” para o papel do grupo “gisgroup”:

# su - postgres
postgres$ psql
psql=# CREATE ROLE gisgroup NOSUPERUSER NOINHERIT CREATEDB NOCREATEROLE;
psql=# CREATE ROLE gis LOGIN PASSWORD 'minhasenha' NOINHERIT;
psql=# GRANT gisgroup TO gis;

Observe que agora o usuário “gis” já pode fazer login no servidor PostgreSQL com senha “minhasenha”. Uma maneira fácil de fazer isto é fazer login no servidor PostgreSQL através do aplicativo phpPgAdmin.

a) Verificar o que fora criado

psql=# \dg
                         Lista de roles
+--------------+------------------------+-----------------------+
| Nome da role |       Atributos        |       Membro de       |
+--------------+------------------------+-----------------------+
| gis          | Nenhuma herança        | {gisgroup}            |
| gisgroup     | Nenhuma herança        | {}                    |
|              : Cria BD                                        |
|              : Não pode efetuar login                         |
| postgres     | Super-usuário          | {}                    |
|              : Cria role                                      |
|              : Cria BD                                        |
+--------------+------------------------+-----------------------+


3.4) Criar um template de base de dados PostGIS
Isto é prático, tornando fácil a criação das bases de dados GIS no servidor. Sem a criação deste template, o usuário teria que repetir todos os passos abaixo todas as vezes que necessitasse criar uma base de dados PostGIS. O template é a mesma coisa de uma base de dados normal, mas é marcada como template para não ser removida ou alterada inadvertidamente. O resultado deste comando são as funções do PostGIS carregadas dentro deste template de banco de dados:


# su - postgres
postgres$ psql
psql=# create database postgistemplate with template = template1 encoding = 'utf8' owner = gis;
psql=# COMMENT ON DATABASE postgistemplate IS 'postgis template database';
psql=# UPDATE pg_database SET datistemplate=true WHERE datname='postgistemplate';
psql=# \c postgistemplate
psql=# create language plpgsql;
psql=# \i /usr/share/postgresql/8.4/contrib/postgis-1.5/postgis.sql
psql=# \i /usr/share/postgresql/8.4/contrib/postgis-1.5/spatial_ref_sys.sql
psql=# \q

Ou ainda de outra forma:

# su - postgres
postgres$ createdb postgistemplate -T template1 -E utf-8 -O gis "postgis template database"
postgres$ createlang plpgsql postgistemplate
postgres$ psql -d postgistemplate -f /usr/share/postgresql/8.4/contrib/postgis-1.5/postgis.sql
postgres$ psql -d postgistemplate -f /usr/share/postgresql/8.4/contrib/postgis-1.5/spatial_ref_sys.sql
postgres$ psql
psql=# UPDATE pg_database SET datistemplate=true WHERE datname='postgistemplate';
psql=# COMMENT ON DATABASE postgistemplate IS 'postgis template database';
psql=# \q

Onde:

  1. createdb :cria uma nova base de dados PostgreSQL. O usuário que executa este comando se torna o proprietário desta nova base de dados (no caso “postgres”).
  2. createlang :PostGIS requer a extensão de linguagem procedural PL/pgSQL, pois muitas das funções PostGIS são escritas nesta linguagem. Para habilitar a PL/pgSQL, deve-se usar este comando “createlang”. É um utilitário que adiciona uma nova linguagem de programação para um banco de dados PostgreSQL. É apenas um invólucro em torno do comando CREATE LANGUAGE.
  3. createlang -d :banco de dados para instalar linguagem psql.
  4. psql :trata-se de um terminal “front-end” interativo para o PostgreSQL. Ele permite que se digite os comandos interativamente, enviá-los para o servidor PostgreSQL e ver os resultados dos comandos.
  5. psql -d :especifica o nome do banco de dados para conectar-se.
  6. psql -f :usa o arquivo descrito após a chave como a fonte de comandos, em vez de ler comandos interativamente.
  7. postgis.sql :arquivo com definições de funções e objetos do PostGIS.
  8. spatial_ref_sys.sql :arquivo de definições utilizado para um sistema completo de identificadores de definições de coordenadas EPSG. Permitirá que se execute operações ST_Transform() em geometrias.
  9. UPDATE pg_database :marcar a nova base de dados postgistemplate como um template.

OBS: opcionalmente, se desejar um “help”(comentários) das descrições das funções incluídas no PostGIS, instalar o arquivo “postgis_comments.sql”. Os comentários poderão ser vistos simplesmente digitando \dd [function_name] a partir de uma janela de terminal psql. Proceder assim:

postgres$ psql -d postgistemplate -f /usr/share/postgresql/8.4/contrib/postgis_comments.sql

O template já está pronto: fora criada o banco de dados “postgistemplate”, com várias funções disponíveis e com duas tabelas (“geometry_columns” e “spatial_ref_sys”). Agora podemos testar o funcionamento do banco de dados postgistemplate que acabamos de criar:

postgres$ psql -d postgistemplate -c "SELECT postgis_full_version();"
postgis_full_version
——————————————————————————————————-
POSTGIS=”1.5.1″ GEOS=”3.2.0-CAPI-1.6.0″ PROJ=”Rel. 4.7.1, 23 September 2009″ LIBXML=”2.7.7″ USE_STATS
(1 registro)

Como mostra a resposta ao comando, vemos o PostGIS em funcionamento com sua versão 1.5. Se a máquina estiver com o phpPgAdmin, acesse este “front-end” (se o phpPgAdmin estiver instalado na máquina local clique aqui para fazer o acesso) e observe o banco de dados criado, as tabelas e as funções espaciais já disponíveis.

Verificar o que fora criado

psql=# \l+
                                                             Lista dos bancos de dados
+-----------------+----------+-------------+-------------+-------------+-----------------------+---------+------------+---------------------------+
|      Nome       |   Dono   | Codificação |  Collation  |    Ctype    | Privilégios de acesso | Tamanho | Tablespace |         Descrição         |
+-----------------+----------+-------------+-------------+-------------+-----------------------+---------+------------+---------------------------+
| postgistemplate | gis      | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 |                       | 9494 kB | pg_default | postgis template database |
| postgres        | postgres | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 |                       | 5510 kB | pg_default |                           |
| template0       | postgres | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 | =c/postgres           | 5408 kB | pg_default |                           |
|                                                                      : postgres=CTc/postgres                                                    |
| template1       | postgres | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 | =c/postgres           | 5510 kB | pg_default | default template database |
|                                                                      : postgres=CTc/postgres                                                    |
+-----------------+----------+-------------+-------------+-------------+-----------------------+---------+------------+---------------------------+

3.5) Atribuir permissões as tabelas
Atribuir permissões para as tabelas do banco de dados “postgistemplate” (“geometry_columns” e “spatial_ref_sys”), que terão como proprietário o usuário “gis”). Sair da conexão anterior (digite \q), e se conectar ao banco de dados “postgistemplate” ainda como usuário postgres e: atribuir permissões, criar um esquema para os dados gis (não se deve criar os dados gis em esquema “public”) e, por último, desfazer a conexão com o banco de dados. Para isto, realizar os seguintes comandos:

postgres$ psql -d postgistemplate
psql=# ALTER TABLE geometry_columns OWNER TO gis;
psql=# ALTER TABLE spatial_ref_sys OWNER TO gis;
psql=# CREATE SCHEMA gis_schema AUTHORIZATION gis;
psql=# \q

4) A tabela SPATIAL_REF_SYS Table e sistemas de referencia espacial
Existem duas tabelas de meta-dados do OpenGIS: SPATIAL_REF_SYS e GEOMETRY_COLUMNS. Estas tabelas de sistema do PostGIS são criadas automaticamente quando da criação de uma base de dados. A tabela SPATIAL_REF_SYS carrega os identificadores numéricos e descrições textuais de sistemas de coordenadas utilizadas no banco de dados espacial.

A tabela spatial_ref_sys é uma inclusão do PostGIS e compatível com a tabela de base de dados da OGC que lista mais de 3000 sistemas de referência espacial conhecidos e possibilita realizar diferentes combinações de projeções e “datums”, necessárias para mostrar com precisão dados geográficos de todas as áreas do planeta. Deve-se ter em mente que a maioria dos sistemas de referência espaciais são regionais e não têm significado quando usado fora dos limites que foram destinados.

Uma excelente fonte de informações para encontrar sistemas de referência espacial não definidos de forma centralizada e pública pode ser encontrado em http://spatialreference.org/

Quando instalado o PostGIS, a sua documentação disponível localmente em file:///usr/share/doc/postgis/postgis/postgis.html#id313360 traz mais detalhes sobre estas tabelas.

5) Criar base de dados
Após os procedimento anteriores, podem ser criados os bancos de dados necessários. Como exemplo neste post, será criado o banco de dados “gisdb”, cujo proprietário será o usuário “gis”, utilizando o template “postgistemplate”:

  • Do shell:
    • postgres$ createdb gisdb -T postgistemplate -E utf-8 -O gis "postgis database"
  • Do psql:
    • postgres$ psql
      psql=# CREATE DATABASE gisdb with TEMPLATE = postgistemplate OWNER = gis ENCODING = 'utf8';
      psql=# COMMENT ON DATABASE gisdb IS 'postgis database';
      psql=# \q

Para verificar:

psql=# \l+
                                                             Lista dos bancos de dados
+-----------------+----------+-------------+-------------+-------------+-----------------------+---------+------------+---------------------------+
|      Nome       |   Dono   | Codificação |  Collation  |    Ctype    | Privilégios de acesso | Tamanho | Tablespace |         Descrição         |
+-----------------+----------+-------------+-------------+-------------+-----------------------+---------+------------+---------------------------+
| gisdb           | gis      | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 |                       | 9486 kB | pg_default | postgis database          |
| postgistemplate | gis      | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 |                       | 9486 kB | pg_default | postgis template database |
| postgres        | postgres | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 |                       | 5510 kB | pg_default |                           |
| template0       | postgres | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 | =c/postgres           | 5408 kB | pg_default |                           |
|                                                                      : postgres=CTc/postgres                                                    |
| template1       | postgres | UTF8        | pt_BR.UTF-8 | pt_BR.UTF-8 | =c/postgres           | 5510 kB | pg_default | default template database |
|                                                                      : postgres=CTc/postgres                                                    |
+-----------------+----------+-------------+-------------+-------------+-----------------------+---------+------------+---------------------------+



5.1) Carregar base de dados

  • Gerar o arquivo .sql
    O carregador de dados shp2pgsql converte arquivos ESRI Shape em declarações adequadas SQL para inserção posterior em um banco de dados PostGIS/PostgreSQL tanto no formato de geometria como no de geografia. A título de exemplo, seria realizado da seguinte forma:
    shp2pgsql -s 4674 -W LATIN1 12UFE250GC_SIR.dbf ufe12250 > ufe12250.sql
    O que resulta o comando acima? Um arquivo sql com comandos para criar uma tabela entitulada “ufe12250” e tendo também uma coluna com o mesmo nome.
    OBS: é importante que o nome da tabela que irá ser gerada posteriormente na base de dados não inicie com um dígido, e sim por um caracter alfabético. A razão disto é que algumas transações XML exigem que os nomes dos layers/tabelas estejam iniciados por este tipo de caracter.
  • Carregar os dados no banco de dados “gisdb”
    $ psql -d gisdb -U gis -f ufe12250.sql
    OBS: para evitar erro de conexão neste comando (conforme melhor descrito no post “Tutorial PostgreSQL:instalar em ambiente Linux – Debian“), certificar-se que no arquivo de configuração do PostgreSQL /etc/postgresql/8.4/main/pg_hba.conf possui uma entrada semelhante a:

    local   all         all			md5
    

6) Um pouco sobre “Sistema de Referência Espacial” (SRS)
Sistema de referência espacial (SRS) é um mecanismo para situar mensurações sobre um corpo geométrico, tal como a terra; estabelece um ponto de origem, orientação de eixos de referência, e significado geométrico das mensurações, assim como unidades de medida. De outra forma, um SRS é um conjunto de parâmetros usado para representar uma geometria.

É comum utilizar apenas um número para nos referir a uma referência espacial. Este número, é o SRID. Veja estes dois exemplos: EPSG 4326 e EPSG 4674. Nestes casos, temos:

  • EPSG 4326 se refere ao GCS WGS84;
  • EPSG 4674 se refere ao GCS SIRGAS-2000.

Obs:
i) GCS – geographic coordinate system;
ii) EPSG – é uma codificação definida pelo “European Petroleum Survey Group” que associa uma codificação numérica a um sistema de coordenadas cartográficas.

O CGS WGS84 é o sistema geodésico desenvolvido pelo Departamento da Defesa dos Estados Unidos da América. É o sistema de referência atualmente utilizado pelo GPS. A origem das coordenadas deste sistema geodésico é o centro da Terra, obtendo-se um erro é inferior a 2cm.

O GCS SIRGAS-2000, Sistema de Referencia Geocêntrico para as Américas, é o sistema de referenciamento espacial padrão do Brasil, definido pelo IBGE. Foi oficialmente adotado como Referencial Geodésico Brasileiro em 2005, através da Resolução do IBGE N°1/2005. Na prática o SIRGAS-2000 utiliza o mesmo elipsóde de referência do WGS84 – GRS 1980. O mesmo ocorre com o posicionamento do elipsóide, com seus centros situando-se bem próximos um do outro. Isto significa que as medidas dados pelo SIRGAS-2000 são quase iguais aos dados pelo WGS84, onde uma diferença entre as medidas pode ser menor que o erro aproximado de um instrumento GPS pessoal, pois esta diferença está na ordem de centímetros. Desta forma, para fins práticos, ou seja, para todos os usuários que não precisam de qualidade superior ao centímetro, é indiferente usar WGS84 ou SIRGAS-2000.

Sobre este tópico, existem boas referências na internet, entre as quais:
FAQ IBGE
Sistema de Referenciamento Espacial

7) A malha digital de municípios publicado pelo IBGE
O IBGE publica a malha digital de municípios a cada censo realizado. No momento deste post, o último censo demográfico fora realizado em 2010 e a malha digital referente pode ser baixada de ftp://geoftp.ibge.gov.br/malhas_digitais/municipio_2010/ . As bases cartográficas disponibilizadas são compatíveis com a escala 1:250.000, sem supressão de pontos.

Este produto cartográfico do IBGE apresenta as seguintes unidades territoriais: municípios, microrregiões, mesorregiões e unidades da Federação. As bases cartográficas utilizam as seguintes referência geodésica e cartográfica:
– Sistema Geográfico – Sistema de Coordenadas Lat / Long – não projetado
– Sistema Geodésico – SIRGAS2000

Os arquivos shapefiles disponibilizados pelo IBGE estão em 3D, e para facilitar sua utilização pelo serviço WFS com o Geoserver (a partir de clientes como o OpenLayers, QGIS e outros) sugerimos fazer ajustes nos arquivos shapefiles. É que o Geoserver parece ainda se mostrar imaturo para tratar o 3D, pelo menos no momento da publicação deste post. No serviço WMS a terceira dimensão é removida, porém o mesmo código de remoção parece que ainda não está disponível para o caso do WFS.

O ajuste sugerido é transformar as fontes shapefiles de 3D para 2D antes de subir as informações cartográficas para o banco de dados. Um método fácil para esta transformação 3D/2D é utilizando a biblioteca GDAL (Geospatial Data Abstraction Library). GDAL é uma biblioteca de tradução para formatos de dados raster geospatial. Está incluída nesta biblioteca o código da biblioteca OGR que possui funcionalidades semelhantes às da GDAL, só que destinada para se trabalhar com dados vetorias (Simple Features). É esta biblioteca OGR que iremos utilizar.

/* instalar a biblioteca GDAL */
# apt-get install gdal-bin
/* se a bilbioteca OGR fora instalada com sucesso, o comando a seguir trará a seguinte resposta: */
$ ogrinfo
Usage: ogrinfo [--help-general] [-ro] [-q] [-where restricted_where]
               [-spat xmin ymin xmax ymax] [-fid fid]
               [-sql statement] [-al] [-so] [-fields={YES/NO}]
               [-geom={YES/NO/SUMMARY}][--formats]
               datasource_name [layer [layer ...]]

Para alterar o arquivo shapefile de 3D para 2D e já disponibilizar as informações numa tabela do PostgreSQL, poderia ser executado o seguinte comando:
$ogr2ogr -update -append -f PostgreSQL PG:"dbname=nome_BD user='usuario_BD' password='senha_BD'" 12UFE250GC_SIR.shp -s_srs EPSG:4674 -nln ufe12250b -nlt MULTIPOLYGON

Onde:
-f nome do formato do arquivo de saída. No caso, PostgreSQL.
-update: abrir a fonte de dados exitente de saída no modo “update”, em vez de tentar criar uma nova.
-append: anexa as informações para o layer existente em vez de criar um novo
-overwrite: apaga o layer de saída e recria um novo (embora que não fora utilizado neste exemplo)
-s_srs: substitui a fonte SRS na saída
-nln: nome do novo layer, ou seja, um nome para a tabela que será criada.
-nlt: define o tipo da geometria para o layer que será criado. Pode ser: NONE, GEOMETRY, POINT, LINESTRING, POLYGON, GEOMETRYCOLLECTION, MULTIPOINT, MULTIPOLYGON or MULTILINESTRING.

Nos testes que realizei, fiz um procedimento mais “controlado” em 3 etapas, conforme abaixo. E funcionou tudo perfeitamente:
$ ogr2ogr -t_srs EPSG:4674 -nlt MULTIPOLYGON ma/arq_novo4674.shp ma/21UFE250GC_SIR.shp
$ shp2pgsql -s 4674 -W LATIN1 ma/arq_novo4674.shp ufemaranhao > ma/ufemaranhao.sql
$ psql -d nome_BD -U usuario_BD -f ma/ufemaranhao.sql

Neste exemplo acima, tem-se:
– arq_novo4674: arquivos shapefiles que serão gerados (.dbf, .prj, .shp, .shx) pelo comando ogr2ogr, já na forma 2D;
– ma/21UFE250GC_SIR.shp: arquivo de entrada, referente ao estado do Maranhão, que tomamos a partir do original fornecido pelo IBGE. Esse arquivo está na pasta “ma” logo abaixo do diretório corrente de trabalho do usuário;
– ufemaranhao: nome da tabela que será gerada posteriormente no banco de dados PostgreSQL, qundo da execução do psql a seguir;
– ufemaranhao.sql: nome do arquivo com comandos SQL que será gerado pela execução do shp2pgsql.

Obs: sobre como o PostgreSQL trata os conjuntos de caracteres (ISO-8859 e UTF-8, por exemplo), ver o manual do PostgreSQL na sessão Character Set Support.

7.1 Tamanho dos arquivos
Sempre se deve ter cuidado com o tamanho dos arquivos. Quanto maior a escala, maior o arquivo. Veja o resultado comparativo para o estado de Pernambuco entre as malhas digitais fornecidas pelo IBGE da escala 1:250k e 1:2500k, conforme abaixo:

IBGE-2010 (1:250k) IBGE-2007 (1:2500k)
shapefile 26MUE250GC_SIR.shp 1608kB shapefile 26mu2500gsr.shp 261kB
download para serviço WFS de 1100kB download para serviço WFS de 278kB

8) O arquivo de Password .pgpass
Uma forma bastante prática de acessar o banco de dados PostgreSQL sem ter a necessidade de se digitar todas as vezes o password é criando o arquivo de autenticação (password) .pgpass, conforme orienta o manual do PostgreSQL na sessão The Password File. Isso pode ser um facilitador quando se utiliza recorrentemente comandos psql.

Este arquivo de password deve ser colocado no diretório home do usuário. Desta forma, o usuário PostgreSQL pode conectar ao banco sem informar senha, pois a mesma já estará informada neste arquivo. O formato deste arquivo é o seguinte:

hostname:port:database:username:password

Veja este exemplo: localhost:5432:*:jose:senha_jose
Onde deve ser observado:
– jose deve ser um usuário do banco PostgreSQL e não do S.O;
– no caso do usuário root, o arquivo deve estar em em /root/.pgpass
– este arquivo deve ter obrigatoriamente a permissão 0600 (comando “chmod 0600 .pgpass”). Se a permissão for menos restritiva que 0600, o arquivo será ignorado.

9) Bibliotecas complementares
As seguintes bibliotecas estão disponíveis, mas não são obrigatórias para um uso inicial do PostGIS:
# apt-get install proj libgeos-c1 libgeos-dev

Proj4 é uma biblioteca responsável por conversões de projeções.
GEOS (Geometry Engine – Open Source) és uma porta C++ da Java Topology Suite (JTS). Ela objetiva alcançar uma completa funcionalidade do JTS no C++. Ou seja, a total compatibilidade do PostGIS com a SFS.

Referências:
1- Tutorial PostgreSQL ( instalar em ambiente Linux – Debian )
2- Manual: installation PostGIS
3- GIS Tutorials
4- Installing PostGIS on debian GNU/Linux
5- Installing PostGIS on Ubuntu
6- Installing postgis and mapserver in Debian
7- Debian Postgis
8- Importando/Exportando dados vetoriais ao PostGIS
—-
9- OGR SQL
10- Malha geométrica dos municípios brasileiros
11- Reprojecting features using OGR
12- OGR to reproject, modify Shapefiles

1) No momento deste post, a versão 8.4.4 é a versão mais atual do PostgreSQL. Caso haja alguma versão postgres instalada na máquina, faça sua desinstalação antes seguir os  procedimentos aqui descritos.

2) Instalar versão mais recente do PostgreSQL:

# yum list | grep postgresql
# yum install postgresql-server.i686
# yum install postgresql-contrib.i686
# yum install postgresql.i386
# yum install postgresql-devel.i686

OBS: Ver documento /usr/share/doc/postgresql-8.4.4# cat README.rpm-dist

3) Baixar, desempacotar e instalar biblioteca PROJ.4 necessário ao PostGIS:
/usr/src/postgis# wget -c ftp://ftp.remotesensing.org/proj/proj-4.4.8-1.i386.rpm
/usr/src/postgis# rpm -ivh proj-4.4.8-1.i386.rpm
/usr/src/postgis# cd proj-4.7.0
/usr/src/postgis/proj-4.7.0# ./configure
/usr/src/postgis/proj-4.7.0# make && make install
/usr/src/postgis/proj-4.7.0# ldconfig

4) Baixar, desempacotar e instalar biblioteca libxml necessário ao PostGIS 5+:
/usr/src/postgis# wget ftp://xmlsoft.org/libxml2/libxml2-2.7.6.tar.gz
/usr/src/postgis# tar -xvf libxml2-2.7.6.tar.gz
/usr/src/postgis# cd libxml2-2.7.6
/usr/src/postgis/libxml2-2.7.6# ./configure
/usr/src/postgis/libxml2-2.7.6# make && make install
/usr/src/postgis/libxml2-2.7.6# ldconfig

5) Baixar, desempacotar e instalar biblioteca OSGEO necessário ao PostGIS:
/usr/src/postgis# wget http://download.osgeo.org/geos/geos-3.2.0.tar.bz2
/usr/src/postgis# tar -xvf geos-3.2.0.tar.bz2
/usr/src/postgis# cd geos-3.2.0
/usr/src/postgis/geos-3.2.0# ./configure
/usr/src/postgis/geos-3.2.0# make && make install
/usr/src/postgis/geos-3.2.0# ldconfig

6) Baixar, desempacotar e instalar versão 1.5 do postgis:

/usr/src/postgis/# yum list | grep postgis
/usr/src/postgis/# wget -c http://www.postgis.org/download/postgis-1.5.2.tar.gz
/usr/src/postgis/# tar -xvf postgis-1.5.2.tar.gz
/usr/src/postgis/postgis-1.5.2# aclocal
/usr/src/postgis/postgis-1.5.2# ./autogen.sh
/usr/src/postgis/postgis-1.5.2# ./configure
/usr/src/postgis/postgis-1.5.2# make && make install
/usr/src/postgis/postgis-1.5.2# ldconfig

7) Configurar e iniciar o serviço Postgresql após sua instalação:
# rm -rf /var/lib/pgsql/data/
# service postgresql initdb
# service postgresql start

8 ) Criar um template_postgis:
a) postgres=# create database template_postgis with template = template1 encoding = 'utf8';
CREATE DATABASE

b) postgres=# \c template_postgis;
You are now connected to database “template_postgis”.

c) template_postgis=# create language plpgsql;
CREATE LANGUAGE

9) Colocar o PostGIS em um banco de dados:
postgres=# \i /usr/src/postgis/postgis-1.5.2/postgis/postgis.sql;
postgres=# \i /usr/share/pgsql/contrib/postgis-1.5/spatial_ref_sys.sql;
postgres=# \i /usr/src/postgis/postgis-1.5.2/doc/postgis_comments.sql;

10) Preparar:
postgres=# update pg_database set datistemplate = true where datname = 'template_postgis';
postgres=# GRANT ALL ON geometry_columns to PUBLIC ;
postgres=# GRANT ALL ON spatial_ref_sys to PUBLIC ;

11) Criar um banco de dados para a sua aplicação:
postgres=# CREATE DATABASE cartcult with template = template_postgis;
CREATE DATABASE
OBS: no caso aqui chamei o banco de dados de ‘cartcult’

12) Alterar senha do banco para ‘postgres’ para facilitar os trabalhos (escolha uma outra posteriormente):
postgres=# ALTER USER postgres WITH PASSWORD 'postgres';

13) Reiniciar o postgres:
# /etc/init.d/postgresql restart

14) Verificar o funcionamento e as versões do PostgreSQL, PostGIS de bibliotecas:

a) PostgreSQL:
postgres=# SELECT version();

version
—————————————————————————————————————-
PostgreSQL 8.4.4 on i686-redhat-linux-gnu, compiled by GCC gcc (GCC) 4.1.2 20080704 (Red Hat 4.1.2-48), 32-bit

b) PostGIS:
postgres=# SELECT postgis_full_version();

postgis_full_version
——————————————————————————————————–
POSTGIS=”1.5.2″ GEOS=”3.2.2-CAPI-1.6.2″ PROJ=”Rel. 4.7.1, 23 September 2009″ LIBXML=”2.6.23″ USE_STATS

Referências:
1. Instalar PostGIS no Linux Debian
2. Tutorial CentOS
3. Manual: installation PostGIS
4. An almost idiot’s guide to Install and Upgrade to PostgreSQL 8.4 with Yum
5. Compiling PostGIS 1.5 and installing after Yum PostgreSQL Install