Prof. Marcello Benigno

Reprojeção e Clip de Imagens "On the Fly" com o GRASS e GDAL

2012-01-31T10:03:00.016-03:00

Lendo o livro "Open Source GIS: A GRASS GIS Approach" (pág. 49) encontrei um procedimento muito útil para resolver o seguinte problema: recortar uma imagem SRTM e reprojetá-la para os mesmos parâmetros definidos no meu projeto. Dessa forma fica bem mais fácil importar a imagem gerada com o comando r.in.gdal. Segue o passo a passo:

1 - Verificar as informações da imagem a ser reprojetada e recortada:
GRASS 7.0.svn (gramame):~ > gdalinfo Geoprocessamento/raster/srtm/SB-25-Y-C.tif
Driver: GTiff/GeoTIFF
Files: Geoprocessamento/raster/srtm/SB-25-Y-C.tif
Size is 1800, 1200
Coordinate System is:
GEOGCS["WGS 84",
DATUM["WGS_1984",
SPHEROID["WGS 84",6378137,298.257223563,
AUTHORITY["EPSG","7030"]],
AUTHORITY["EPSG","6326"]],
PRIMEM["Greenwich",0],
UNIT["degree",0.0174532925199433],
AUTHORITY["EPSG","4326"]]
Origin = (-36.000415601243731,-7.000415916030761)
Pixel Size = (0.000833333353512,-0.000833333353512)
Metadata:
TIFFTAG_SOFTWARE=IMAGINE TIFF Support
Copyright 1991 - 1999 by ERDAS, Inc. All Rights Reserved
@(#)$RCSfile: etif.c $ $Revision: 1.10.1.9 $ $Date: 2003/11/13 19:25:49EST $
TIFFTAG_XRESOLUTION=1
TIFFTAG_YRESOLUTION=1
TIFFTAG_RESOLUTIONUNIT=1 (unitless)
AREA_OR_POINT=Area
Image Structure Metadata:
INTERLEAVE=BAND
Corner Coordinates:
Upper Left ( -36.0004156, -7.0004159) ( 36d 0' 1.50"W, 7d 0' 1.50"S)
Lower Left ( -36.0004156, -8.0004159) ( 36d 0' 1.50"W, 8d 0' 1.50"S)
Upper Right ( -34.5004156, -7.0004159) ( 34d30' 1.50"W, 7d 0' 1.50"S)
Lower Right ( -34.5004156, -8.0004159) ( 34d30' 1.50"W, 8d 0' 1.50"S)
Center ( -35.2504156, -7.5004159) ( 35d15' 1.50"W, 7d30' 1.50"S)
Band 1 Block=1800x2 Type=UInt16, ColorInterp=Gray

2 - Imprimir a região definida como padrão na location:
GRASS 7.0.svn (gramame):~ > g.region -p
projection: 1 (UTM)
zone: -25
datum: sam69
ellipsoid: sam69
north: 9206640
south: 9180540
west: 259380
east: 300780
nsres: 90
ewres: 90
rows: 290
cols: 460
cells: 133400

3 - Usar o comando "eval", para setar como variáveis, a saída do comando anterior (veja mais sobre esse comando em: http://goo.gl/70sAi):
GRASS 7.0.svn (gramame):~ > eval `g.region -g`

4 - Verificar o resultado do comando anterior com o comando "echo", observe que é exibido o retângulo envolvente da região definida como default:
GRASS 7.0.svn (gramame):~ > echo "$w $s $e $n"
259380 9180540 300780 9206640

5 - Verificar a projeção definida na location:
GRASS 7.0.svn (gramame):~ > g.proj -wf
PROJCS["UTM Zone 25, Southern Hemisphere",GEOGCS["sam69",DATUM["South_American_Datum_1969",SPHEROID["South_American_Datum_1969",6378160,298.25]],PRIMEM["Greenwich",0],UNIT["degree",0.0174532925199433]],PROJECTION["Transverse_Mercator"],PARAMETER["latitude_of_origin",0],PARAMETER["central_meridian",-33],PARAMETER["scale_factor",0.9996],PARAMETER["false_easting",500000],PARAMETER["false_northing",10000000],UNIT["Meter",1]]

6 - Usar o comando "gdalwarp" para recortar e reprojetar a imagem a partir da projeção definida no grass e do retângulo envolvente da region:
GRASS 7.0.svn (gramame):~ > gdalwarp -t_srs "`g.proj -wf`" -te $w $s $e $n \
Geoprocessamento/raster/srtm/SB-25-Y-C.tif \
Geoprocessamento/raster/srtm/srtm_clip_utm25.tif
Creating output file that is 450P x 283L.
Processing input file Geoprocessamento/raster/srtm/SB-25-Y-C.tif.
0...10...20...30...40...50...60...70...80...90...100 - done.

7 - Verificar a imagem reprojetada e cortada:
GRASS 7.0.svn (gramame):~ > gdalinfo Geoprocessamento/raster/srtm/srtm_clip_utm25.tif
Driver: GTiff/GeoTIFF
Files: Geoprocessamento/raster/srtm/srtm_clip_utm25.tif
Size is 450, 283
Coordinate System is:
PROJCS["UTM Zone 25, Southern Hemisphere",
GEOGCS["sam69",
DATUM["South_American_Datum_1969",
SPHEROID["South_American_Datum_1969",6378160,298.25,
AUTHORITY["EPSG","7036"]],
AUTHORITY["EPSG","6291"]],
PRIMEM["Greenwich",0],
UNIT["degree",0.0174532925199433]],
PROJECTION["Transverse_Mercator"],
PARAMETER["latitude_of_origin",0],
PARAMETER["central_meridian",-33],
PARAMETER["scale_factor",0.9996],
PARAMETER["false_easting",500000],
PARAMETER["false_northing",10000000],
UNIT["metre",1,
AUTHORITY["EPSG","9001"]]]
Origin = (259380.000000000000000,9206640.000000000000000)
Pixel Size = (92.000000000000000,-92.226148409893995)
Metadata:
AREA_OR_POINT=Area
Image Structure Metadata:
INTERLEAVE=BAND
Corner Coordinates:
Upper Left ( 259380.000, 9206640.000) ( 35d10'43.72"W, 7d10'19.95"S)
Lower Left ( 259380.000, 9180540.000) ( 35d10'47.83"W, 7d24'29.27"S)
Upper Right ( 300780.000, 9206640.000) ( 34d48'14.67"W, 7d10'25.80"S)
Lower Right ( 300780.000, 9180540.000) ( 34d48'18.07"W, 7d24'35.32"S)
Center ( 280080.000, 9193590.000) ( 34d59'31.09"W, 7d17'27.72"S)
Band 1 Block=450x9 Type=UInt16, ColorInterp=Gray

8 - Importar a imagem reprojetada e cortada:
GRASS 7.0.svn (gramame):~ > r.in.gdal input=Geoprocessamento/raster/srtm/srtm_clip_utm25.tif output=mde
Projection of input dataset and current location appear to match
100%
r.in.gdal complete. Raster map created.

Um abraço e até o próximo post :)

Paul Ramsey: Snapping Points in PostGIS

2011-04-23T19:50:00.000-03:00

Paul Ramsey: Snapping Points in PostGIS

Fim do mistério: Revista FOSSGIS Brasil é lançada

2011-04-04T09:33:00.009-03:00

Finalmente chegou a hora de acabar com o mistério e revelar o que realmente é o projeto FOSSGIS Brasil. Muitos apostaram que era um evento, ou uma organização, mas ninguém chegou a acertar o que realmente é este projeto.

Nos últimos anos as Geotecnologias Livres tem crescido e se destacado como real opção no mercado corporativo, e com isso houve um aumento na procura por essas tecnologias. Hoje existem diversos blogs, listas de discussão e fóruns em português que tratam de diversos assuntos relacionados e prestam suporte gratuito a essas tecnologias e, entre eles está o blog Geoparalinux. Porém até hoje não existia uma revista especializada nas Geotecnologias Livres.

Com esse intuito nasce a Revista FOSSGIS Brasil (http://www.fossgisbrasil.com.br/), na busca de preencher essa lacuna existente. Para viabilizar este projeto alguns dos principais nomes do cenário das Geotecnologias Livres se uniram para criar um material de alta qualidade, baseado nos princípios do software livre.

Nesta primeira edição falaremos sobre iniciativas como o OL4JSF, um projeto 100% brasileiro, que já está fazendo sucesso lá fora. Além dos padrões OGC, a história da Geotecnologias Livres, gvSIG, aplicativos GIS para dispositivos móveis, entre outros. Há também nesta edição uma entrevista exclusiva com Gilberto câmara, diretor geral do INPE (Instituto Nacional de Pesquisas Espaciais).

A revista é inteiramente grátis, sem necessidade de se realizar cadastros, pagar taxas ou algo do gênero. Para obter o seu exemplar da revista é necessário apenas realizar o download.

Esperamos que você goste dessa nova iniciativa.

Atenciosamente,

Equipe FOSSGIS Brasil

http://www.fossgisbrasil.com.br

revista@fossgisbrasil.com.br

E que rufem os tambores....

2011-03-15T17:12:00.000-03:00

Aguardem.... um grandioso projeto está para nascer.

Cursos de GIS e Webmapping

2011-01-10T07:29:00.000-03:00

A Acesso Livre Consultoria está oferecendo uma série de cursos na área de Geotecnologias. Vale a pena conferir nos links abaixo:

Ícones Customizados para o Google Maps

2011-01-03T17:18:00.001-03:00

Descobri a pouco no Google Code, uma biblioteca de ícones que podem ser usados com a API do Maps. fica aqui a sugestão para quem quiser modificar a aparência dos Marcadores.

Link do projeto: http://code.google.com/p/google-maps-icons/

Análise Espacial com o PostGIS e o GvSIG

2010-12-22T23:32:00.007-03:00

Uma das inúmeras vantagens de se trabalhar com o PostGIS é a possibilidade de criar views das análises espaciais, tornando os resultados das análises dinâmicas em função dos dados de entrada utilizados. Desta forma também evita-se a criação de novo layers em função de uma atualização da base.

Para exemplificar, vamos imaginar a seguinte situação: em uma determinada cidade foi definido que a área de influência de uma parada de ônibus é de 40 metros e que a prefeitura deve identificar quais são os lotes dentro de cada área de influência das paradas. Apesar da situação ser muito comum para quem já trabalha com SIG, surge a necessidade de se repetir a análise a cada nova parada inserida ou excluída no sistema, o que pode acabar gerando inconsistências na base em função do mal gerenciamento destes arquivos.

Com o uso do PostGIS e do GvSIG eu vou mostrar como resolver este problema sem a necessidade de ficar criando novas camadas a partir das análises desse problema, no caso, a criação do buffer de 40 metros e a consulta espacial (intersects).

No PgAdmin 3, crie um novo Banco de Dados Espacial com o nome cadastro (Figura 1), em seguida, baixe, descompacte e carregue no banco criado o arquivo SQL do link abaixo (Figura 2):

http://acessolivreconsultoria.com/curso_mapserver_gvsig_postgis/lote.zip

Figura 1 - Criação do Banco de Dados Espacial

Figura 2 - Carregando o Script SQL da tabela Lote

Agora vamos criar a tabela ponto_onibus a partir do script abaixo (Figura 3):

CREATE TABLE ponto_onibus(
 id serial PRIMARY KEY,
 observacao varchar(50)
 );

SELECT AddGeometryColumn (
 'public', -- esquema
 'ponto_onibus', -- nome da tabela
 'the_geom', -- nome da coluna
 '29185', -- SRID
 'POINT', -- tipo de geometria
 2 -- plano (2d)
 );

Figura 3 - Criação da tabela ponto_onibus no PgAdmin

Vamos criar duas views, uma para os buffers de 40 metros em torno das paradas de ônibus e a outra dos os lotes que estão dentro desta distância (função intersects).

-- Criando a view buffer_ponto_onibus
CREATE OR REPLACE VIEW buffer_ponto_onibus AS
SELECT id, buffer(the_geom, 40) AS the_geom 
FROM ponto_onibus;

-- Registrando a view na tabela de metadados geometry_columns
INSERT INTO geometry_columns(f_table_catalog, f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, "type")
VALUES ('', 'public', 'buffer_ponto_onibus', 'the_geom', 2, 29185, 'POLYGON');

-- Criando a view lotes_ponto_onibus
CREATE OR REPLACE VIEW lotes_ponto_onibus AS
SELECT l.*
FROM lote l,  buffer_ponto_onibus b
WHERE intersects(l.the_geom, b.the_geom);

-- Registrando a view na tabela de metadados geometry_columns
INSERT INTO geometry_columns(f_table_catalog, f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, "type")
VALUES ('', 'public', 'lotes_ponto_onibus', 'the_geom', 2, 29185, 'POLYGON');

Abra o GvSIG e mude a projeção do bloco para 29185 (Figura 4)

Figura 4 - Troca do sistema de projeção no GvSIG

Com o bloco aberto, clique no botão adicionar plano de informação e escolha a segunda aba (GeoDB), em seguida configure a conexão com o banco de dados "cadastro" (Figura 5).

Figura 5 - Configuração da conexão com o Banco de Dados

Configurada a conexão, adicione as tabelas "lote" e "parada_onibus" e as views "buffer_ponto_onibus" e "lotes_ponto_onibus" (Figura 6).

Figura 6 - Adicionando as camadas do BD

Inicie a edição da camada ponto_onibus clicando com o botão direito em cima desta camada e escolhendo a opção "Iniciar Edição" em seguida, adicione algumas paradas de forma aleatória. Termine a edição Salvando as alterações (Figura 7).

Figura 7 - Inserindo os pontos de ônibus

Para ver as modificações nas dias views, basta desligar e ligar uma das camadas "buffer_ponto_onibus" ou "lotes_ponto_onibus" (Figura 8).

Figura 8 - Resultado dinâmico das análises a partir dos pontos criados

A cada novo ponto criado ou excluído, as duas views são atualizadas automaticamente (Figura 9).

Figura 9 - Resultado das análises após modificar a camada ponto_onibus

Esperam que tenham gostado dessa dica, até a próxima!

Alternativa Open Source para o ArcCatalog e o ArcToolbox

2010-12-17T10:18:00.007-03:00

O wxGIS possui as mesmas características dos módulos ArcCatalog e ArcToolBox do ArcGIS, e o que é melhor, é open source :)

Para instalar o wxGIS no Ubuntu é necessário:

Adicionar o seu repositório a sources list: deb http://ppa.launchpad.net/bishop-gis/wxgis/ubuntu lucid main
Atualizar a lista de repositórios
e por último, instalar o pacote wxgis0

PostrgeSQL - dados para realização dos exercícios

2010-12-04T07:18:00.005-03:00

CREATE TABLE municipio (
   codmun serial,
   nomemun varchar(35),
   populacao numeric(10,0),
   --definindo a chave primária codmun
   PRIMARY KEY (codmun)
   );
--------------------------------------
CREATE TABLE proprietario (
   idprop serial,
   nomeprop varchar(30),
   telprop char(11),
   --definindo a chave primária idprop
   PRIMARY KEY(idprop)
   );
--------------------------------------
CREATE TABLE fazenda (
   idfaz serial, 
   nomefaz varchar(40),
   areafaz float,
   codmun int,
   dono int,
   --definindo a chave primária idfaz
   PRIMARY KEY(idfaz),
   --definindo a chave estrangeira codmun
   FOREIGN KEY(codmun) REFERENCES municipio(codmun)
   ON UPDATE CASCADE ON DELETE NO ACTION,
   --definindo a chave estrangeira dono que se chama idprop em faz.
   FOREIGN KEY(dono) REFERENCES proprietario(idprop)
   ON UPDATE CASCADE ON DELETE NO ACTION
   );
--------------------------------------
CREATE TABLE variedade (
   tipovar serial,
   descvar varchar(25),
   ProdMedTon numeric(11,5), 
   --definindo a chave primária id
   PRIMARY KEY(tipovar)
   );
--------------------------------------  
CREATE TABLE plantacao (
   id serial, 
   idfaz int,
   tipovar int,
   datplantio date,
   datultcolh date,
   --definindo a chave primária id
   PRIMARY KEY(id),
   --definindo a chave estrangeira idfaz
   FOREIGN KEY(idfaz) REFERENCES fazenda(idfaz)
   ON UPDATE CASCADE ON DELETE NO ACTION,
   --definindo a chave estrangeira tipovar
   FOREIGN KEY(tipovar) REFERENCES variedade(tipovar)
   ON UPDATE CASCADE ON DELETE NO ACTION
   );

--------------------------------------------------------------------------- 
-- DADOS DA TABELA municipio
---------------------------------------------------------------------------
INSERT INTO municipio (codmun, nomemun, populacao) VALUES (1,'Zumbi',5230);
INSERT INTO municipio (codmun, nomemun, populacao) VALUES (2,'Campina Grande',10000); 
INSERT INTO municipio (codmun, nomemun, populacao) VALUES (3,'Pedras de Fogo',2030);
INSERT INTO municipio (codmun, nomemun, populacao) VALUES (4,'João Pessoa',35000);
INSERT INTO municipio (codmun, nomemun, populacao) VALUES (5,'Patos',9840); 
---------------------------------------------------------------------------
-- DADOS DA TABELA proprietario
---------------------------------------------------------------------------
INSERT INTO proprietario (idprop, nomeprop, telprop) VALUES (201,'José Dumont',8332247845); 
INSERT INTO proprietario (idprop, nomeprop, telprop) VALUES (202,'Carlos Nascimento',8332210066);
INSERT INTO proprietario (idprop, nomeprop, telprop) VALUES (207,'Maria da Silva',83341779911);
INSERT INTO proprietario (idprop, nomeprop, telprop) VALUES (215,'Carlos Silva',84341459924); 
INSERT INTO proprietario (idprop, nomeprop, telprop) VALUES (244,'Pedro Luiz',81344458700);
INSERT INTO proprietario (idprop, nomeprop, telprop) VALUES (274,'Alessandro Gomes',83322150607);
--------------------------------------------------------------------------- 
-- DADOS DA TABELA Fazenda
---------------------------------------------------------------------------
INSERT INTO Fazenda (IdFaz,NomeFaz,AreaFaz, CodMun, Dono) VALUES (501, 'Gado Bravo', 130.41, 1, 274);
INSERT INTO Fazenda (IdFaz,NomeFaz,AreaFaz, CodMun, Dono) VALUES (513, 'Bixinho', 50.02, 2, 274);
INSERT INTO Fazenda (IdFaz,NomeFaz,AreaFaz, CodMun, Dono) VALUES (512, 'Horizonte', 45.21, 5, 201);
INSERT INTO Fazenda (IdFaz,NomeFaz,AreaFaz, CodMun, Dono) VALUES (559, 'Riacho Azul', 60.00, 3, 244); 
INSERT INTO Fazenda (IdFaz,NomeFaz,AreaFaz, CodMun, Dono) VALUES (560, 'Papa Léguas', 245.44, 3, 202);
INSERT INTO Fazenda (IdFaz,NomeFaz,AreaFaz, CodMun, Dono) VALUES (578, 'Maravilha', 200.10, 4, 207);
INSERT INTO Fazenda (IdFaz,NomeFaz,AreaFaz, CodMun, Dono) VALUES (545, 'Boquim', 78.00, 2, 207);
---------------------------------------------------------------------------
-- DADOS DA TABELA variedade
---------------------------------------------------------------------------
INSERT INTO variedade (tipovar, descvar, prodmedton) VALUES (1, 'Cana de Açúcar', .5); 
INSERT INTO variedade (tipovar, descvar, prodmedton) VALUES (2, 'Abacaxi', .1);
INSERT INTO variedade (tipovar, descvar, prodmedton) VALUES (3, 'Feijão', .4);
--------------------------------------------------------------------------- 
-- DADOS DA TABELA Plantacao
---------------------------------------------------------------------------
INSERT INTO plantacao (idfaz, tipovar, datplantio, datultcolh) VALUES (501,1,'2005/04/02', '2005/06/13');  
INSERT INTO plantacao (idfaz, tipovar, datplantio, datultcolh) VALUES (513,2,'2005/01/12', '2005/09/04');  
INSERT INTO plantacao (idfaz, tipovar, datplantio, datultcolh) VALUES (560,2,'2005/02/02', '2005/10/26');  
INSERT INTO plantacao (idfaz, tipovar, datplantio, datultcolh) VALUES (578,3,'2005/04/01', '2005/10/13');
INSERT INTO plantacao (idfaz, tipovar, datplantio, datultcolh) VALUES (578,2,'2005/6/07', '2005/12/29');

Tutorial CodeIgniter - Parte 5

2010-10-11T09:33:00.001-03:00

Vamos finalizar a nossa aplicação desenvolvendo o CRUD para a tabela rio, grande parte do código utilizado nas postagens anteriores será reutilizado.

Vamos começar com o rio_model.php:

<?php
class Rio_model extends Model
{

    function __construct()
    {
        parent::model();
    }

    function get_rio()
    {
        $this->db->order_by('nome_rio', 'asc');
        //junção com a tabela bacia_hidrografica
        $this->db->join('bacia_hidrografica', 'bacia_hidrografica.id_bacia = rio.id_bacia');
        $query = $this->db->get('rio');
        if ($query->num_rows() > 0)
        {
            return $query->result();
        }
        else
        {
            return false;
        }
    }

    function insert()
    {
        $data = $_POST;
        return $this->db->insert('rio', $data);
    }

    function get_where($id)
    {
        $this->db->where('id_rio', $id);
        $this->db->join('bacia_hidrografica', 'bacia_hidrografica.id_bacia = rio.id_bacia');
        $query = $this->db->get('rio');
        return $query->row();
    }

    function update($id)
    {
        $data = $_POST;
        $this->db->where('id_rio', $id);
        $this->db->update('rio', $data);
    }

    function delete($id)
    {
        $this->db->where('id_rio', $id);
        return $this->db->delete('rio');
    }

}

O nosso controllador rio.php vai carregar dois model´s, já que teremos nos formulários de inserção e de atualização uma lista das bacias cadastradas:

<?php

class Rio extends Controller
{

    function __construct()
    {
        parent::controller();
        $this->load->model(array('rio_model', 'bacia_model'));
        $this->load->library('form_validation');
    }

    function index()
    {
        $data['titulo'] = "SIRH";
        $data['cabecalho'] = "Rios";

        $data['rios'] = $this->rio_model->get_rio();

        $this->load->view('rio_view', $data);
    }

    function criar()
    {
        $data['titulo'] = "SIRH - Novo Rio";
        $data['cabecalho'] = "Criar novo Rio";

        $data['bacias'] = $this->bacia_model->get_bacia();

        $this->load->view('rio_new', $data);
    }

    function insere()
    {

        $data['titulo'] = "SIRH - Novo Rio | Erro na Validação, preencha corretamente!";
        $data['cabecalho'] = "Criar novo Rio | Preencha Corretamente!";

        $data['bacias'] = $this->bacia_model->get_bacia();

        $this->form_validation->set_rules('nome_rio', 'Nome do Rio', 'required|alpha');
        $this->form_validation->set_rules('comprimento_km', 'Comprimento', 'required|numeric');
        $this->form_validation->set_rules('id_bacia', 'Bacia Hidrográfica', 'required');

        if ($this->form_validation->run() == FALSE)
        {
            $this->load->view('rio_new', $data);
        }
        else
        {
            $this->rio_model->insert();
            $this->session->set_flashdata('msg', 'Registro Criado com Sucesso!');
            redirect('rio');
        }
    }

    function editar($id)
    {
        $data['titulo'] = "SIRH - Editar Rio";
        $data['cabecalho'] = "Editar Rio";

        $data['registro'] = $this->rio_model->get_where($id);

        $data['bacias'] = $this->bacia_model->get_bacia();

        $this->load->view('rio_new', $data);
    }

    function atualizar()
    {
        $id = $this->input->post('id_rio');

        $data['titulo'] = "SIRH - Editar Rio | Erro na Validação, preencha corretamente!";
        $data['cabecalho'] = "Editar Rio | Preencha Corretamente!";

        $data['registro'] = $this->rio_model->get_where($id);

        $data['bacias'] = $this->bacia_model->get_bacia();

        $this->form_validation->set_rules('nome_rio', 'Nome do Rio', 'required|alpha');
        $this->form_validation->set_rules('comprimento_km', 'Comprimento', 'required|numeric');
        $this->form_validation->set_rules('id_bacia', 'Bacia Hidrográfica', 'required');

        if ($this->form_validation->run() == FALSE)
        {
            $this->load->view('rio_new', $data);
        }
        else
        {
            $this->rio_model->update($id);
            $this->session->set_flashdata('msg', 'Registro Atualizado com Sucesso!');
            redirect('rio');
        }
    }

    function deletar($id)
    {
        if ($this->rio_model->delete($id))
        {
            $this->session->set_flashdata('msg', 'Registro Deletado com Sucesso!');
        } else
        {
            $this->session->set_flashdata('msg', 'ERRO - Não foi possível deletar este registro!');
        }
        redirect('rio');
    }

}

A página de exibição dos rios (rio_view.php):

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title><?= $titulo ?></title>
    </head>

    <body>
        <h2><?= $cabecalho ?></h2>

        <p><?= anchor('bacia', 'Ver Bacias Hidrográficas')?> &nbsp; <?= anchor('rio', 'Ver Rios')?></p>

        <p><?= anchor('rio/criar', 'Criar Rio') ?></p>

        <p><?= @$this->session->flashdata('msg'); ?></p>

        <table border="1">
            <thead>
                <tr>
                    <th>
                        Nome do rio
                    </th>
                    <th>
                        Comprimento (km)
                    </th>
                    <th>
                        Nome da bacia
                    </th>
                    <th>
                        Ações
                    </th>
                </tr>
            </thead>
            <tbody>
                <?php if ($rios != false): ?>
                <?php foreach ($rios as $rio): ?>
                        <tr>
                           <td>
                                <?= $rio->nome_rio ?>
                           </td>
                           <td>
                                <?= $rio->comprimento_km ?>
                           </td>
                           <td>
                                <?= $rio->nome_bacia ?>
                           </td>
                    <td>
                        <?= anchor('rio/editar/' . $rio->id_rio, 'Editar') ?> |
                        <?= anchor('rio/deletar/' . $rio->id_rio, 'Deletar') ?>
                    </td>
                </tr>
                <?php endforeach; ?>
                <?php else: ?>
                            <p>Não há registros cadastrados!</p>
                <?php endif ?>
            </tbody>
        </table>
    </body>
</html>

Da mesma forma como fizemos nas bacias, teremos um único arquivo responsável pelo cadastramento e atualização dos dados referentes a esta tabela (rio_new.php):

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title><?= $titulo ?></title>
    </head>
    <body>
        <h2><?= $cabecalho ?></h2>

        <p><?= validation_errors(); ?></p>

        <?php
        //verifica se o form vai ser usado para insert ou update
        if (!isset($registro->id_rio))
        {
            echo form_open('rio/insere');
        }
        else
        {
            echo form_open('rio/atualizar');

            echo form_hidden('id_rio', $registro->id_rio);
        }
        ?>
        <p>
            <label>Nome do rio:</label>
            <input name="nome_rio" type="text" id="nome_rio" size="40" value="<?= @$registro->nome_rio ?>" />
        </p>

        <p>
            <label>Comprimento (km): </label>
            <input name="comprimento_km" type="text" id="comprimento_km" size="40" value="<?= @$registro->comprimento_km ?>" />
        </p>

        <p>
            <label>Bacia Hidrográfica</label>
            <select name="id_bacia">
                <option value="<?= @$registro->id_bacia; ?>"> <?= @$registro->nome_bacia; ?> </option>
                <?php foreach ($bacias as $bacia): ?>
                <option value="<?= $bacia->id_bacia; ?>"> <?= $bacia->nome_bacia; ?> </option>
                <?php endforeach; ?>
            </select>
        </p>
        <p>
             <input type="submit" id="Enviar" value="Enviar" />
        </p>
               <?= form_close() ?>
    </body>
</html>

Finalizamos o CRUD das duas tabelas, no nosso próximo post, vou mostrar como habilitar o mod_rewrite e retirar da url o index.php, e também fazer algumas pequenas melhorias visuais com CSS. Até lá!

Tutorial CodeIgniter - Parte 4

2010-10-10T08:13:00.001-03:00

Vamos agora adicionar a validação no formulário de criação das Bacias Hidrográficas e em seguida, no próximo post, finalizar a aplicação com o CRUD dos rios.

A validação no CodeIgniter é feita através da biblioteca "form_validation", o único problema que eu tive com ela, foi o fato da mesma não aceitar acentos da língua portuguesa, para resolvermos isso, vamos extender a classe do core realizando uma modificação no código da função alpha().

Para ver as mensagens dos erros de validação em português, é necessário baixar este arquivo, em seguida descompactar a pasta pt_br em sirh/system/language, feito isso, agora abra o arquivo config.php (dentro da pasta config) e mude a linha 69 para: $config['language'] = "pt-br";

Temos então que copiar o arquivo Form_validation.php da pasta /system/libraries para a pasta /system/application/libraries, agora abra o arquivo copiado e procure pela função alpha(), comente o return dela, e faça a seguinte alteração:

function alpha($str)
{
    //return ( ! preg_match("/^([a-z])+$/i", $str)) ? FALSE : TRUE;
    return (!preg_match("/^([A-Za-zá-úÁ=Ú.\s])+$/i", $str)) ? FALSE : TRUE;
}

Modificada a expressão regular, agora é possível trabalhar com palavras acentuadas.

Abra o controller bacia.php, vamos adicionar a validação nas funções insere() e atualizar(). Para isso é necessário Carregar a biblioteca form_validation no método construtor do controlador:

function __construct()
{
    parent::controller();
    $this->load->model('bacia_model');
    $this->load->library('form_validation');
}

A função insert() ficará assim:

function insere()
{
    // o campo é requerido e deve ser uma string (alpha)
    $this->form_validation->set_rules('nome_bacia', 'Nome da Bacia', 'required|alpha');
    // caso a validação não passe,  carregue a view com o array $data
    if ($this->form_validation->run() == FALSE)
    {
        $data['titulo'] = "SIRH - Nova Bacia Hidrográfica | Erro na Validação, preencha corretamente!";
        $data['cabecalho'] = "Criar Bacia Hidrográfica | Preencha Corretamente!";

        $this->load->view('bacia_new', $data);
    }
    else
    {
        $this->bacia_model->insert();
        $this->session->set_flashdata('msg', 'Registro Criado com Sucesso!');
        redirect('bacia');
    }
}

e a update():

function atualizar()
{
    $id = $this->input->post('id_bacia');

    $this->form_validation->set_rules('nome_bacia', 'Nome da Bacia', 'required|alpha');

    // caso a validação não passe, carregue a view com o array $data
    if ($this->form_validation->run() == FALSE)
    {
        $data['titulo'] = "SIRH - Editar Bacia Hidrográfica | Erro na Validação, preencha corretamente!";
        $data['cabecalho'] = "Editar Bacia Hidrográfica | Preencha Corretamente!";

        $data['registro'] = $this->bacia_model->get_where($id);

        $this->load->view('bacia_new', $data);
    }
    else
    {
        $this->bacia_model->update($id);
        $this->session->set_flashdata('msg', 'Registro Atualizado com Sucesso!');
        redirect('bacia');
    }
}

A regra adicionada não permite que o campo "nome" da Bacia Hidrográfica fique sem preenchimento (required), e será permitido apenas o preenchimento com texto (alpha). Para sinalizar as mensagens de erro, Abra a view bacia_new.php e adicione a função abaixo, logo depois do cabeçalho:

<p><?= validation_errors(); ?></p>

É isso... no próximo post vou mostrar como ficará o CRUD da tabela rio. Um abraço e até lá!

Tutorial CodeIgniter - Parte 3

2010-09-28T14:12:00.021-03:00

Neste post, vamos criar as funções que irão realizar as operações inserir, atualizar e deletar os registros da tabela bacia_hidrografica.

Antes de começarmos a criar as funções, vamos habilitar a biblioteca "session" do codeigniter e o helper "form", para isso, abra o arquivo autoload.php e modifique as linhas 42 e 54, respectivamente para:

$autoload['libraries'] = array('database', 'session');

$autoload['helper'] = array('url', 'form');

Vamos começar definindo uma função no model que será responsável por inserir os registros na tabela, abra o arquivo bacia_model.php e adicione a seguinte função:

function insert()
{
  $data = $_POST;
  return $this->db->insert('bacia_hidrografica', $data);
}

Já a função abaixo, retorna a linha da tabela com o id_bacia informado, ela será usada para povoar o campo "nome da bacia" do formulário de atualização:

function get_where($id)
{
    $this->db->where('id_bacia', $id);
    $query = $this->db->get('bacia_hidrografica');
    return $query->row();
}

Para realizar o update, usaremos a função abaixo:

function update($id)
{
    $data = $_POST;
    $this->db->where('id_bacia', $id);
    $this->db->update('bacia_hidrografica', $data);
}

Para deletar um registro desta tabela, primeiro faz-se necessário verificar se a mesma não possui nenhum rio vinculado, pois isso vai gerar uma mensagem de erro vinda do banco de dados, em função da constraint foreign key, logo criaremos a função abaixo que fará essa verificação de vínculo:

function verifica_fk($id)
{
    $this->db->where('id_bacia', $id);
    $query = $this->db->get('rio');
    if ($query->num_rows > 0)
    {
        // se houver fk, retorne falso
        return false;
    } else
    {
        return true;
    }
}

De posse da função acima, criaremos a função delete():

function delete($id)

{
   // se for verdadeiro, pode apagar o registro
   if ($this->verifica_fk($id))
   {
      $this->db->where('id_bacia', $id);
      return $this->db->delete('bacia_hidrografica');
   }
   else
   {
      return false;
   }

Agora, vamos criar duas funções no controller bacia.php, uma para chamar o formulário que será utilizado para a inserção de novos registros, e a outra, que será responsável por efetivar esta operação, através da função definida no model anteriormente (função insert() ):

OBS: Não vamos usar nenhuma função de validação dos dados nesse momento, este será um assunto abordado em um próximo post.

function criar()
{
    $data['titulo'] = "SIRH - Nova Bacia Hidrográfica";
    $data['cabecalho'] = "Criar nova Bacia Hidrográfica";
    $this->load->view('bacia_new', $data);
}

function insere()
{
    $this->bacia_model->insert();
    $this->session->set_flashdata('msg', 'Registro Criado com Sucesso!');
    redirect('bacia');
}

Seguindo o mesmo raciocínio, para realizar a atualização dos registros, vamos criar mais duas funções no controller, editar() e atualizar():

function editar($id)
{
    $data['titulo'] = "SIRH - Editar Bacia Hidrográfica";
    $data['cabecalho'] = "Editar Bacia Hidrográfica";

    $data['registro'] = $this->bacia_model->get_where($id);

    $this->load->view('bacia_new', $data);
}

function atualizar()
{
    $id = $this->input->post('id_bacia');

    $this->bacia_model->update($id);
    $this->session->set_flashdata('msg', 'Registro Atualizado com Sucesso!');
    redirect('bacia');
}

Criamos então a view bacia_new.php, que tanto servirá para inserir, quanto para atualizar, isso é feito através da verificação da existência da variável $registro->id_bacia:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title><?= $titulo ?></title>
    </head>
    <body>
        <h2><?= $cabecalho ?></h2>
        <?php
            //verifica se o form vai ser usado para insert ou update
            if (!isset($registro->id_bacia))
            {
                echo form_open('bacia/insere');
            }
            else
            {
                echo form_open('bacia/atualizar');
                echo form_hidden('id_bacia', $registro->id_bacia);
            }
        ?>
        <p><label>Nome da Bacia:</label>
            <input name="nome_bacia" type="text" id="nome_bacia" size="40" value="<?= @$registro->nome_bacia ?>" />
        </p>

        <p>
            <input type="submit" id="Enviar" value="Enviar" />
        </p>

        <?= form_close() ?>
    </body>
</html>

Finalizando o controller bacia.php, adicionamos a função deletar(), que vai chamar a função delete() do model:

function deletar($id)
{
    if ($this->bacia_model->delete($id))
    {
        $this->session->set_flashdata('msg', 'Registro Deletado com Sucesso!');
    }
    else
    {
        $this->session->set_flashdata('msg', 'ERRO - Não foi possível deletar este registro!<br/>
                                              Primeiro apague os Rios que se relacionam com esta Bacia');
    }
    redirect('bacia');
}

Para terminar, abra o arquivo bacia_view.php e logo abaixo do cabeçalho, chame a função que irá exibir as mensagens para as operações realizadas pelo usuário:

 <p><?=@$this->session->flashdata('msg');?></p>

Pronto!!! Já temos um CRUD funcional para a tabela bacia_hidrografica, porém sem a validação dos formulários, isso será o assunto da próxima postagem, até lá!

Tutorial CodeIgniter - parte 2

2010-09-26T19:17:00.006-03:00

Vamos dar continuidade ao desenvolvimento da aplicação usando o CodeIgniter, na pasta sirh/system/application/controllers crie o arquivo bacia.php com o conteúdo abaixo:

<?php
class Bacia extends Controller
{

    function __construct()
    {
        parent::controller();
    }

    function index()
    {
        echo "<h1>Testando... 1, 2, 3</h1>";
    }
}

No código anterior, criamos o controlador bacia, com a função index, que é exibida por default quando o controlador é chamado. Logo ao digitarmos a url: http://localhost/sirh/index.php/bacia, veremos a mensagem de teste (Figura 1).

Figura 1 - teste do controlador bacia

Testado o funcionamento do controller bacia, vamos adicionar o cabeçalho e título da nossa página, modificando o código da função index:

function index()
{
  $data['titulo'] = "SIRH";
  $data['cabecalho'] = "Bacias Hidrográficas";

  $this->load->view('bacia_view', $data);
}

agora, dentro da pasta views, em sirh/system/application/, crie um arquivo com o nome bacia_view.php, com o seguinte conteúdo:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" 
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
   <head>
       <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
       <title><?=$titulo?></title>
   </head>

   <body>
      <h2><?=$cabecalho?></h2>
   </body>
</html>

Abra mais uma vez o endereço http://localhost/sirh/index.php/bacia , o resultado deve ser o da Figura 2

Figura 2 - definidos o título e o cabeçalho da página

Está na hora de inserirmos alguns dados para a visualização, execute o script abaixo no banco, para povoar as duas tabelas:

-- INSERINDO 3 Bacias Hidrográficas
INSERT INTO bacia_hidrografica(nome_bacia) VALUES ('Abiaí');
--
INSERT INTO bacia_hidrografica(nome_bacia) VALUES ('Mamanguape');
--
INSERT INTO bacia_hidrografica(nome_bacia) VALUES ('Gramame');

-- INSERINDO 6 Rios nas suas respectivas Bacias
INSERT INTO rio(nome_rio, comprimento_km, id_bacia) VALUES ('Papocas', 9, 1);
INSERT INTO rio(nome_rio, comprimento_km, id_bacia) VALUES ('Graú', 12, 1);
--
INSERT INTO rio(nome_rio, comprimento_km, id_bacia) VALUES ('Mogeiro', 23, 2);
INSERT INTO rio(nome_rio, comprimento_km, id_bacia) VALUES ('Gavião', 9, 2);
--
INSERT INTO rio(nome_rio, comprimento_km, id_bacia) VALUES ('Guarabira',31, 3);
INSERT INTO rio(nome_rio, comprimento_km, id_bacia) VALUES ('Jacaré', 7, 3);

vamos agora exibir os dados que foram inseridos na tabela bacia_hidrografica, para isso será necessário criar um model (dentro de sirh/system/application/model) , que chamaremos de bacia_model.php, com o seguinte conteúdo:

<?php
class Bacia_model extends Model
{
    function  __construct()
    {
        parent::model();
    }

    function get_bacia()
    {
        $this->db->order_by('nome_bacia', 'asc');
        $query = $this->db->get('bacia_hidrografica');
        if ($query->num_rows() > 0)
        {
            return $query->result();
        }
        else
        {
            return false;
        }
    }
}

Agora, vamos modificar o nosso controlador, carregando o model criado e povoando uma variável com um array de objetos, obtidos através da função get_bacia():

<?php
class Bacia extends Controller
{

    function __construct()
    {
        parent::controller();
        $this->load->model('bacia_model');
    }

    function index()
    {
        $data['titulo'] = "SIRH";
        $data['cabecalho'] = "Bacias Hidrográficas";

        $data['bacias'] = $this->bacia_model->get_bacia();

        $this->load->view('bacia_view', $data);
    }
}

Para finalizar esta postagem, vamos agora modificar a nossa view, basicamente vamos varrer o array de objetos $data['bacias'] e exibir os resultados, também vamos utilizar a função anchor() do CodeIgniter para definir os links desta página, que serão finalizados no próximo Post:

<h2><?=$cabecalho ?></h2>

<p><?=anchor('bacia/criar', 'Criar Bacia Hidrográfica') ?></p>

<table border="1">
    <thead>
        <tr>
            <th>
                Nome da Bacia
            </th>
            <th>
                Ações
            </th>
        </tr>
    </thead>
    <tbody>
        <?php if ($bacias != false): ?>
        <?php foreach ($bacias as $bacia): ?>
            <tr>
            <td>
                <?=$bacia->nome_bacia ?>
            </td>
            <td>
                <?=anchor('bacia/editar/' . $bacia->id_bacia, 'Editar') ?> |
                <?=anchor('bacia/deletar/' . $bacia->id_bacia, 'Deletar') ?>
            </td>
        </tr>
        <?php endforeach; ?>
        <?php else: ?>
        <p>Não há registros cadastrados!</p>
        <?php endif ?>
    </tbody>
</table>

Salve todos os arquivos e abra o navegador e veja o resultado: http://localhost/sirh/index.php/bacia

Figura 3 - Exibição das Bacias Hidrográficas

Bem pessoal, por hoje é só, para ajudar no entendimento deste exemplo, sugiro dar uma boa olhada na série de screencasts do Nettus+ sobre o CodeIgniter (item 5 do link).

Tutorial CodeIgniter - parte 1

2010-09-26T09:45:00.017-03:00

O CRUD é definido como acrônimo da expressão inglesa (Create Retrieve Update and Delete), para as quatro operações básicas utilizadas em um bancos de dados relacionais (RDBMS).

Nesta série de postagens, criaremos uma aplicação Web com CRUD através da linguagem PHP, para as duas tabelas do modelo lógico da Figura 1, utilizando o Framework CodeIgniter. Para codificar, sugiro o uso do Netbeans com o autocomplete do CodeIgniter, este último pode ser baixado no link: http://rhasan.com/blog/2009/09/codeigniter-auto-complete-with-netbeans/ . Já o banco que irei utilizar nesse exemplo, será o PostgreSQL.

OBS: É necessário que o leitor tenha uma base em PHP OO, pois não vou entrar em muitos detalhes, também sugiro, dar uma boa lida no Manual do CodeIgniter em português.

Figura 1 – modelo lógico do exemplo

1^oPasso: criar o banco no PostgreSQL

Crie um banco com o nome sirh com a codificação UTF-8 e rode o modelo físico abaixo, observe que as chaves primárias foram definidas como serial, criando automaticamente o auto-incremento para esses dois campos:

CREATE TABLE bacia_hidrografica (
id_bacia serial PRIMARY KEY,
nome_bacia varchar(40)
);

CREATE TABLE rio (
id_rio serial PRIMARY KEY,
nome_rio varchar(40),
comprimento_km int,
id_bacia int,
FOREIGN KEY(id_bacia) REFERENCES bacia_hidrografica (id_bacia)
ON UPDATE CASCADE );

Após rodar o script acima, o seu banco ficará da seguinte forma (Figura 2):

Figura 2 - Banco com as duas tabelas criadas (PgAdmin)

2^oPasso: download do CodeIgniter

Vá até o endereço: http://codeigniter.com/downloads/ e baixe a última versão do CI (nesse post, usei a versão 1.7.2), a instalação é bem simples, descompacte o arquivo zipado na pasta de publicação do seu servidor web, no meu caso “/var/www/”, para quem usa o MS4W (Mapserver for Windows), descompacte na pasta htdocs do servidor.

Agora, vamos mudar o nome da pasta que foi descompactada para sirh (abreviação de “sistema para recursos hídricos”).

3^oPasso: configurar a url do sistema e a conexão com o banco PostgreSQL

Abra o arquivo config.php, dentro de sirh/system/application/config. Mude a linha 14 para http://localhost/sirh/ , salve o arquivo em seguida.

Abra o arquivo database.php (na mesma pasta) e configure a conexão com o banco (em seguida salve o arquivo):

$db['default']['hostname'] = "localhost";

$db['default']['username'] = "postgres";

$db['default']['password'] = "postgres";

$db['default']['database'] = "sirh";

$db['default']['dbdriver'] = "postgre";

4° Passo: configurar as bibliotecas e os helpers que serão carregados de forma automática

Abra o arquivo autoload.php, modifique a linha 42 para:

$autoload['libraries'] = array(‘database’);

e a 54 para:

$autoload['helper'] = array(‘url’);

5° Passo: testar a instalação

Abra o seu navegador e digite a url: http://localhost/sirh, você verá a tela da Figura 3, caso a mesma não seja exibida dessa forma, verifique os passos anteriores. No próximo Post continuaremos a desenvolver esta aplicação, até lá!

figura 3 - tela de boas vindas do codeigniter

Manual do CodeIgniter em português

2010-08-14T09:13:00.008-03:00

Apesar de desatualizada (a versão atual do CI é a 1.7.2), esta tradução pode ser útil para quem tem dificuldade com a língua do tio Sam, bons estudos : )

PostGIS: conversão de coordenadas em graus decimais para graus, minutos e segundos (e vice-versa)

2010-07-07T16:26:00.056-03:00

Recentemente tive que implementar uma solução, onde através de um formulário, o usuário informava as coordenadas em graus, minutos e segundos, logo em seguida era mostrado em um mapa, se essa coordenada caía em uma área válida da aplicação.

Acontece que por padrão, o PostGIS armazena as geometrias no formato decimal, logo eu teria que tratar as coordenadas digitadas (no código PHP ou no Banco), transformando-as em graus decimais, foi aí que eu encontrei duas funções muito úteis na lista de discussão do PostGIS. Fiz uma pequena modificação na segunda função, que aumenta a quantidade de casas decimais dos minutos e segundos, caso do resultado seja um número inteiro nesses dois elementos.

Para utilizá-las é necessário carregá-las em um banco com o PostGIS instalado.

Create or Replace Function DMS2DD(  dDeg In Float,
                                    dMin In Float, 
                                    dSec In Float )                                
Returns Float
AS
$BODY$
Declare
   dDD Float;
BEGIN
   dDD := ABS(dDeg) + dMin / 60::float + dSec / 3600::float;
   Return SIGN(dDeg) * dDD;
End;
$BODY$
  LANGUAGE 'plpgsql' IMMUTABLE STRICT
  COST 100;

create or Replace Function DD2DMS(  dDecDeg in Float,
                                    pDegreeSymbol in VarChar(1),
                                    pMinuteSymbol in VarChar(1),
                                    pSecondSymbol in VarChar(1) )
Returns varchar(50)
AS
$BODY$
DECLARE
   iDeg Int;
   iMin Int;
   dSec Float;
   
BEGIN

   iDeg := Trunc(dDecDeg)::Int;
   iMin := Trunc(   (Abs(dDecDeg) - Abs(iDeg)) * 60)::Int;
   dSec := Round(((((Abs(dDecDeg) - Abs(iDeg)) * 60) - iMin) * 60)::numeric, 3)::float;
   
Return trim(to_char(iDeg,'9999')) || pDegreeSymbol::text ||
       trim(to_char(iMin,'99.00')) || pMinuteSymbol::text || 
       case when dSec = 0::Float
       then '00' else replace(trim(to_char(dSec,'99.999')),'.000','') 
       end || pSecondSymbol::text;
END;
$BODY$
  LANGUAGE 'plpgsql' IMMUTABLE STRICT
  COST 100;

Utilizando as funções:

-- Converter as coordenadas da geometria 
-- POINT(-38.4969 -6.4026) para graus, minutos e segundos: 
 
SELECT DD2DMS(x(geometryFromText('POINT(-38.4969 -6.4026)')), '°','\'','\"' ) as Longitude,
DD2DMS(y(geometryFromText('POINT(-38.4969 -6.4026)')), '°','\'','\"' ) as Latitude;

Resultado:

Longitude | Latitude
--------------------------+-----------------------
-38°29.00'48.840" | -6°24.00'9.360"

-- Converter as coordenadas (-34° 10' 50", -7° 33' 30")
-- para graus decimais:
 
SELECT DMS2DD(-34,10,50) as longitude,
DMS2DD(-7,33,30) as latitude;

Resultado:

Longitude | Latitude
----------------------------+-----------------------
-34.1805555555556 | -7.55833333333333

Corrigindo a Codificação na Exportação de Shapefiles para SQL

2009-09-25T09:58:00.009-03:00

No processo de exportação de Shapefiles para SQL já podemos modificar a codificação do arquivo gerado para a mesma codificação do Banco, evitando a inserção de caracteres estranhos nas tabelas (�). Também é comum nos depararmos com o erro abaixo quando tentamos importar um arquivo .sql na codificação LATIN1 (ou ISO-8859-1) para um Banco de Dados em UTF-8:

ERRO: sequência de bytes é inválida para codificação "UTF8": 0xed7269
HINT: Este erro pode acontecer também se a sequência de bytes não corresponde a codificação esperado pelo servidor, que é controlada por "client_encoding".

Para evitar este problema, use o comando shp2psql junto com o comando iconv, que é responsável por fazer esta modificação. A sintaxe é a seguinte:

shp2pgsql -s SRID shapefile nome_da_tabela | iconv -f codificacao_de_origem -t codificacao_de_destino > arquivo_sql.sql

Exemplo:

shp2pgsql -s 4291 municipios_ibge.shp municipios | iconv -f LATIN1 -t UTF-8 > municipios.sql

Em seguida, use psql -f municipios.sql -d seu_banco_utf8 para criar a tabela com seus registros.

Utilizando Javascript e CSS em aplicações Mapserver via CGI

2009-09-17T16:26:00.057-03:00

Para finalizar a postagem “Integrando o Mapserver com o PostGIS” vou disponibilizar aqui uma aplicação Mapserver CGI que utiliza algumas funções Javascript em um layout baseado em CSS (Cascading Style Sheets – CSS).

Esta aplicação também roda no Windows através do pacote MS4W. Veja como configurá-la através do arquivo como_instalar.txt.

Link para baixar o arquivo

Fico a disposição de vocês caso haja alguma dúvida sobre o código.

Sistema de Informações dos Recursos Hídricos do Ceará

2009-02-03T16:18:00.014-03:00

Depois de um bom tempo sem postar, resolvi comentar uma consultoria que realizei recentemente para a Secretaria de Recursos Hídricos do Ceará, utilizando as seguintes tecnologias: PHP, Linux (Fedora), PostgreSQL/PostGIS, Mapserver e o Framework Pmapper.

Realmente foi um desafio desenvolver este projeto em tão pouco tempo (cerca de dois meses e meio). Tivemos que migrar e remodelar a base de dados que estava no Microsoft SQL Server para o PostgreSQL, já a base de dados espaciais estava em Shapefile e também foi exportada para o Banco através da extensão espacial PostGIS. Só a tabela de poços possuía mais de 16 mil registros!

Para minha surpresa e felicidade, o Atlas SRH ainda foi escolhido como o melhor Software Livre da edição 2009 do Prêmio Ceará de Cidadania Eletrônica.

O esforço valeu a pena, me sinto hoje realizado, além de ter aprendido muito com este trabalho. Acredito que o resultado ficou a contento da SRH, que venham os novos desafios!!!

Integrando o Mapserver com o PostGIS

2008-03-02T11:06:00.017-03:00

Com base nos posts anteriores (1 e 2) podemos criar uma aplicação Webmapping que utilize dados armazenados em um BDE. Para este primeiro tutorial, os dados utilizados estão disponíveis neste link.

1. Carregando os sripts SQL no BDE.

No terminal, navegue até a pasta onde você salvou e descompactou os arquivos e digite: psql -f lotes.sql -d gis (enter), em seguida digite novamente psql -f vias.sql -d gis (enter), desta forma você criará duas tabelas no Banco, lotes e vias.

2. Criando o arquivo Mapfile:

Abra um editor de texto qualquer e digite o seguite conteúdo:

MAP
NAME 'Mapa 1'
SIZE 600 400
EXTENT 295090 9211971 296291 9212708
UNITS meters
IMAGECOLOR 247 247 247

LAYER
NAME 'lotes'
STATUS Default
TYPE Polygon
CONNECTIONTYPE postgis
CONNECTION "dbname=geo user=postgres host=localhost password=postgres"
DATA "the_geom FROM lotes USING UNIQUE gid USING SRID=29185"
CLASS
NAME 'lotes'
STYLE
COLOR 255 234 190
OUTLINECOLOR 0 0 0
END #style
END #class
END #layer

END #Fim do Mapfile

Salve este arquivo como postgis.map em seguida feche-o.

3. Visualizando o mapa de forma estática

Abra Browser e digite: http://localhost/cgi-bin/mapserv?map=/var/www/postgis.map&mode=map

Como resultado será exibido o mapa da figura abaixo:

4. Adicionando a camada vias, diferenciado-a por tipo de pavimento

Altere o Mapfile, adicionando as linhas mostradas em vermelho, a seguir:

MAP
NAME 'CTM'
SIZE 600 400
EXTENT 295090 9211971 296291 9212708
UNITS meters
IMAGECOLOR 247 247 247

# Símbolo criado para mudar a espessura dos arcos (camada vias)
SYMBOL
NAME 'linha'
TYPE ELLIPSE
POINTS
1 1
END
END

LAYER
NAME 'lotes'
STATUS Default
TYPE Polygon
CONNECTIONTYPE postgis
CONNECTION 'dbname=gis user=marcello host=localhost password=x'
DATA 'the_geom FROM lotes'
CLASS
NAME 'lotes'
STYLE
COLOR 255 234 190
OUTLINECOLOR 0 0 0
END #style
END #class
END #lotes

#Aqui começa o segundo layer
LAYER
NAME 'vias'
STATUS Default
TYPE Line
CONNECTIONTYPE postgis
CONNECTION "dbname=gis user=marcello host=localhost password=x"
DATA "the_geom FROM vias USING UNIQUE gid USING SRID=29185"

CLASSITEM 'pavimentac'

CLASS
NAME 'Asfalto'
EXPRESSION 'Asfalto'
STYLE
SYMBOL linha
SIZE 3
COLOR 168 0 0
END #style
END #class

CLASS
NAME 'Paralelepípedo'
EXPRESSION 'Paralelepípedo'
STYLE
SYMBOL linha
SIZE 2
COLOR 0 38 115
END #style
END #class

CLASS
NAME 'Solo'
EXPRESSION 'Solo'
STYLE
SYMBOL linha
SIZE 1
COLOR 255 85 0
END #style
END #class

END #vias

END #Fim do Mapfile

Abra o browser novamente, digite a mesma URL anterior e observe a nova camada criada:

Utilização do Mapserver no gerenciamento dos Recursos Hídricos do Estado da Paraíba

2007-09-27T16:43:00.002-03:00

1. Introdução

A escassez da oferta hídrica é um dos problemas mais graves enfrentados a nível mundial. Na região nordeste do Brasil, este problema se agrava em função da variação climática, do crescimento da demanda e dos usos múltiplos da água, além da má distribuição dos Recursos hídricos no espaço e no tempo.

A Agência Executiva de Gestão das Águas do Estado da Paraíba (AESA) tem como principal atribuição, gerenciar com racionalidade os recursos hídricos do Estado, assegurando as demandas dos usuários, fazendo uso dos instrumentos das leis federal e estadual, resguardando o meio ambiente e o bem estar do homem, de forma a garantir o desenvolvimento sustentável.

Como ferramenta de apoio à tomada de decisão, os Sistemas de Informações Geográficas (SIG), possibilitam aos gestores uma série de funcionalidades que contribuem diretamente em um melhor gerenciamento dos recursos hídricos. Através do SIG é possível gerar mapas e cartas que mostrem, por exemplo, quais áreas estão desabastecidas, ou onde estão as localidades que necessitam de uma maior oferta hídrica, e a partir daí, realizar análises espaciais e estatísticas visando amenizar tais problemas.

No entanto, o usuário final deve ter acesso às informações processadas de um SIG de uma forma rápida e fácil em uma interface amigável. Neste contexto, os programas de Webmapping disponibilizam dados espaciais na Web, permitindo que qualquer pessoa, através de um navegador (browser), possa interagir com mapas dinâmicos através de comandos como zoom, pan, realizar consultas, além criar mapas temáticos e relatórios.

Com o objetivo de possibilitar ao visitante do Portal AESA acesso de forma rápida e fácil a diversas informações georreferenciadas do Estado, foi desenvolvida uma aplicação Webmapping utilizando Mapserver e o framework Pmapper. Através da interface deste aplicativo, batizado de SIGAESA-WEB qualquer pessoa pode consultar informações sobre bacias hidrográficas, sistemas aqüíferos, pluviometria média, adutoras, além das informações qualitativas e quantitativas sobre os rios e açudes, dentre outros níveis de informação.

2. Tecnologias Utilizadas

A base cartográfica disponibilizada pelo aplicativo é composta de elementos que foram obtidos junto ao IBGE, tais como: limites estaduais, divisão municipal e sedes municipais. Outras feições como, rios, açudes, bacias hidrográficas, postos fluviométricos, dentre outros, foram confeccionados na própria agência através de técnicas de digitalização e de classificação de imagens de satélite, utilizando imagens CBERS 2 CCD (2006), LANDSAT 7 (2006) e SRTM (2006).

Já os programas utilizados foram os seguintes:

Sistema operacional: Linux Fedora Core 7;
Servidor Apache com PHP;
Editor Web: NVU;
Editor de arquivos Mapfile: Scite;
Banco de Dados: PostgreSQL/PostGIS;
Pmapper v.3.1

3. Implementação do Sistema

A configuração do aplicativo iniciou-se com a instalação e configuração do servidor Apache com o PHP no Fedora, em seguida foram instalados a partir dos fontes as seguintes bibliotecas: proj, gd, libpng, libgeotiff, zlib, geos, postgresql, postgis, gdal e o mapserver, a medida que eram requeridas algumas dependências destas bibliotecas no processo de compilação, outros pacotes também foram baixados e instalados utilizando o comando yum, presente nesta distro.

O próximo passo foi exportar as feições geográficas que estavam no formato shapefile para o Banco de Dados Espaciais, tal procedimento foi realizado através do comando shp2pgsql, que gera um script SQL a partir da leitura dos arquivos shapes. Em seguida entrou em cena a configuração do pmapper, que é um framework de fácil configuração, já que para colocarmos a aplicação para “rodar”, necessitamos apenas criar o arquivo mapfile, o qual define a forma como os níveis de informação serão exibidos, e em seguida configurar a aplicação através dos arquivos de configuração do próprio pmapper. O tempo total gasto durante todo este processo, se somarmos a isso a customização do pmapper, foi de aproximadamente 70 horas de trabalho.

A figura 1 mostra o esquema de funcionamento do aplicativo SIGAESA-WEB.

Figura 1 – Esquema do funcionamento do aplicativo SIGAESA-WEB

4. Resultados

Através da interface do aplicativo, qualquer usuário tem acesso imediato a uma série de informações, dentre as quais destacam-se o monitoramento diário do volume dos açudes (figura 2).

Figura 2 – Consulta ao volume de um açude

Estão também disponíveis dados sobre a qualidade da água dos rios e açudes monitorados pela Superintendência de Administração do Meio Ambiente do Estado – SUDEMA (figura 3).

Figura 3 – Consulta à qualidade da água de um rio

5. Conclusões

Antes da disponibilização deste aplicativo Webmapping no portal da AESA, não havia oportunidades de análise e identificação dos problemas hídricos pela população em geral. Porém após sua implementação, observou-se um crescente interesse da sociedade e também de outros órgãos do estado por tais informações, que antes estavam disponíveis apenas para os técnicos da agência, ou a pesquisadores e estudantes que tinham que se deslocar até a mesma. Desta forma o aplicativo também contribuiu para diminuir a burocracia de acesso a essas informações.

Do ponto de vista financeiro, a solução adotada utilizou apenas softwares livres, proporcionando uma grande economia na aquisição das licenças de programas proprietários similares.

O SIGAESA-WEB destacou-se como uma ferramenta de fácil manuseio, e alcançou seu principal objetivo, que é o de disseminar informações espaciais na Web para a sociedade de forma mais fácil e rápida, tanto para os gestores quanto para a sociedade como um todo.

Como trabalho futuro, deseja-se incluir no aplicativo os pontos outorgados e cadastrados dos usuários de recursos hídricos do estado.

Por fim, a AESA espera tornar-se em alguns anos um modelo regional na gestão de recursos hídricos através de ações que possibilitem avançar em torno do desenvolvimento sustentável e da gestão participativa.

Site do SIGAESA-WEB: http://www.aesa.pb.gov.br/geoprocessamento/

Criando uma aplicação Webmapping com o Alov map

2007-09-27T15:24:00.000-03:00

O Alov map é um publicador de mapas gratuito, desenvolvido através da linguagem Java que pode ser implementado na forma de applet ou servlet. Na versão servlet os dados ficam armazenados em um SGBD e são enviados ao cliente de forma incremental, através do botão de “ligar/desligar camada”, já na versão applet, todos os dados são enviados ao cliente no momento em que a página é carregada no browser.

Embora a versão servlet seja mais flexível, neste tutorial vamos trabalhar inicialmente na versão applet deste programa, que é bem mais fácil de configurar para usuários iniciantes. Mais detalhes sobre o alov podem ser encontrados no site http://alov.org

Para visualizar a página que será criada neste tutorial é necessário que você tenha a máquina virtual Java (JVM), ou o JRE instalados no seu computador.

1^o Passo – Download do Alov Map:

Para baixar o Alov é necessário que o usuário faça um registro na página de downloads do site, após este registro, baixe a versão applet do programa, como mostra a figura 1 abaixo:

Figura 1 – baixando a versão Applet.

Os dados deste tutorial podem ser baixados no site: http://geo.marcello.googlepages.com/municipios.zip

2^oPasso – Preparando a aplicação:

Coloque os arquivos baixados em uma mesma pasta de sua escolha, não é necessário descompactar o arquivo shapefile zipado (municipios.zip). A seguir vamos criar dois arquivos para que o aplicativo funcione, um no formato XML e outro no formato HTML.

3^o Passo – Criando o arquivo XML de configuração dos layers:

Neste arquivo iremos definir a forma na qual os dados serão apresentados no Alov, à medida que fomos passando para os outros tutoriais, este arquivo irá sendo alterado de forma gradativa. Através de um editor de texto de sua escolha, crie um arquivo chamado config.xml com o conteúdo abaixo:

<?xml version="1.0" encoding="ISO-8859-1"?>
<project zoomunits="km" mapunits="degrees">
<layer name="Municipios" visible="yes" showlegend="yes">
<dataset url="municipios.zip" />
<renderer>
<symbol fill="211:255:190" outline="38:115:0" />
</renderer>
</layer>
</project>

Explicando...

A linha 1 indica que este arquivo é um XML, e qual é a sua codificação.

Na linha 2 inicia-se a tag projeto, todos os dados que serão mostrados no aplicativo devem ser declarados em algum lugar dentro do projeto, também foram definidos dois atributos para essa tag, um indicando que as unidades de zoom estão em quilômetros (zoomunits="km") e outro indicando que as unidades do mapa estão em graus decimais (mapunits="degrees"). A linha 9 fecha o projeto iniciado na linha 2.

Na linha 3 inicia-se um layer, onde o seu nome foi definido como municípios (name="Municipios"), que estará visível quando o Alov for inicializado (visible="yes") e terá uma legenda mostrando a sua cor e/ou símbolos utilizados (showlegend="yes"). A linha 8 indica o final da definição do layer.

Na linha 4 é definido o local e nome do arquivo shapefile desta camada (url="municipios.zip"), observe que não é necessário descompactá-lo, já que o Alov é capaz de ler arquivos no formato zip.

A linha 5 inicia a tag renderer onde dentro dela, definiremos a aparência do layer através da tag symbol. Os atributos fill e outline definem respectivamente as cores de preenchimento e da cor da borda do polígono na escala RGB. A linha 8 fecha a tag renderer.

4^o Passo – Criando o arquivo HTML:

No arquivo HTML será colocado a diretiva applet, responsável por carregar a janela do aplicativo. Para isso, crie um arquivo chamado mapa.html com o conteúdo abaixo:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Webmapping</title>
</head>
<body>
<applet codebase ="."
code="org.alov.viewer.SarApplet"
archive="alov_applet.jar"
width="650" height="400" align="center">
<param name="pid" value="config.xml">
</applet>
</body>
</html>

Explicando...

As linhas 1 e 2 indicam o doctype do arquivo HTML, a linha 3 inicia a tag html com o atributo namespace e a linha 16 fecha o tag html.

A linha 4 inicia a tag do cabeçalho (head), onde é definido o título do documento através da tag title, na linha 6. A linha 7 fecha a tag head.

O conteúdo da página é definido dentro do corpo (body), ou seja, entre as linhas 8 e 15.

A linha 9 inicia a tag applet, indicando que o arquivo alov_applet.jar está na mesma pasta em que o HTML se encontra (codebase =”.”), em seguida são informados o nome da classe java (linha 10) e o nome do arquivo que deve ser carregado (linha 11).

Na linha 12 são passados os parâmetros de largura, altura e alinhamento da janela do applet.

Por fim, na linha 13 temos a tag param, que informa o nome do applet (name=”pid”) e o nome do arquivo XML (value=”config.xml”), já a linha 14 fecha a tag applet.

5^o Passo – Visualizando a aplicação:

Abra o arquivo mapa.html e veja como ficou sua primeira aplicação Alov Map, se não aparecer a página mostrada abaixo, verifique se não há algum erro no seu código, ou se a máquina virtual Java não está instalada no seu computador. No próximo post veremos como construir alguns mapas temáticos e como habilitar o modo de consulta por atributos. Um Abraço!

Instalando o Mapserver com PHP Mapscript no Ubuntu

2007-03-09T13:58:00.001-03:00

Umas das formas mais fáceis de se instalar o Mapserver no Ubuntu é através do gerenciador de pacotes synaptic, neste tutorial vamos ver que este processo, ao contrário do que muita gente acha, é bastante simples.

1. Instalando o Apache com PHP

No Gnome, clique em Sistema > Administração > Gerenciador de Pacotes Synaptic. Clique em procurar e digite apache, selecione os pacotes: apache2, apache2-common, apache2-doc. Clique em aplicar, e em aplicar novamente. Aguarde o download dos pacotes e a instalação. Repita o procedimento para instalar o PHP, escolhendo os pacotes: php5, libapache2-mod-php5, php5-cgi e php5-common.

2. Instalando o Mapserver com PHP mapscript

Ainda no Synaptic, clique em procurar e digite mapserver, selecione os seguintes pacotes para instalação: cgi-mapserver, mapserver-bin, mapserver-doc e php5-mapscript. Reinicie o servidor apache digitando no Terminal sudo /etc/init.d/apache2 restart .

Mude as permissões para a pasta onde serão armazenadas as páginas a serem criadas, digitando no Terminal sudo chmod 775 /var/www (enter).

3. Verificando a Instalação

Abra o seu navegador e digite: http://localhost/cgi-bin/mapserv, você verá uma página em branco com a seguinte mensagem:

No query information to decode. QUERY_STRING is set, but empty.

Isto indica que o mapserver foi instalado corretamente. Vamos agora verificar se o módulo PHP Mapscript também está OK, abra um editor de texto qualquer (gedit, VI, etc.) e digite o seguinte conteúdo:

<?php
phpinfo();
?>

Salve este arquivo em /var/www com o nome phpinfo.php. Para finalizar, digite no navegador http://localhost/phpinfo.php , ao carregar a página, procure pelo quadro mostrado na figura abaixo, contendo as informações sobre o módulo Mapscript.

No próximo post, vou mostrar como criar uma aplicação com Mapserver e PostGIS. Até lá!

Usando o Postgis com o Quantum Gis no Ubuntu

2007-03-06T16:24:00.000-03:00

Dando seqüência ao último post, vamos agora importar um arquivo shapefile contendo o mapa do Brasil para o nosso BDG, depois iremos visualizar esta tabela no QGIS. Para este tutorial faça o download do arquivo que se encontra no link abaixo:

http://www.gismaps.com.br/divpol/divisao_politica.zip

Após baixar o arquivo, é só descompactá-lo em um diretório da sua escolha.

1. Utilizando o comando shp2pgsql para converter os shapes

No Terminal, vá até a pasta em que você salvou o arquivo e depois digite shp2pgsql -s 4291 BRASIL.shp estados_br > estados_br.sql (enter)
Onde:
-s 4291 indica o SRID (Identificação do Sistema de Referência Espacial) referente ao Datum SAD69 e as coordenadas geográficas.
BRASIL.shp é o nome do arquivo shapefile que iremos converter em sql.
estados_br é o nome da tabela que será criada no banco.
estados_br.sql é o nome do arquivo sql a ser gerado neste mesmo diretório.

Se você não errou nada, verá a mensagem abaixo, indicando que o arquivo sql foi criado.
Shapefile type: Polygon
Postgis type: MULTIPOLYGON[2]

Criado o arquivo estados.sql, vamos importá-lo para o banco, digite psql -f estados_br.sql -d gis (enter).

2. Vizualizando a tabela no QGIS

Baixe e instale o QGIS pelo synaptic, após sua instalação, abra-o, e vá até o ícone Add a PostGIS Layer. Agora clique em novo e informe os parâmetros da conexão, como mostra a figura abaixo:

Clique agora em conectar, escolha a tabela e clique em adicionar para visualizar o mapa do Brasil, como mostra a figura abaixo:

Instalando a Extensão Espacial PostGIS no Ubuntu – Guia Rápido

2007-03-05T17:05:00.003-03:00

Este passo a passo mostra uma das formas de se instalar o PostgreSQL + PostGIS no Ubuntu.

1. Editando a lista de repositórios:

No Gnome, vá até Aplicações > Acessórios > Terminal e digite sudo gedit /etc/apt/sources.list (enter) em seguida informe a senha de root.
Retire agora o caractere # das linhas que começam com a palavra deb para "descomentá-las", salve e feche o arquivo.
No Terminal digite sudo apt-get update (enter) para atualizar a lista de repositórios. Terminado a atualização, vamos agora até o Synaptic começar o processo de instalação dos pacotes.

2. Baixando e instalando os pacotes:

Vamos abrir o Synaptic, para isso siga até Preferências > Administração > Gerenciador de Pacotes Synaptic, em seguida entre com a senha de root (caso seja requisitada).
No Synaptic, clique em procurar, e digite postgis. Aparecerá as opções da figura abaixo:

Selecione os pacotes para instalação postgresql-x-postgis (onde x é a versão mais recente) e postgis, bem como as dependências sugeridas, clique em aplicar e aguarde o download e instalação dos pacotes.
Terminado a instalação destes pacotes, instale agora o pgadmin3 através do mesmo procedimento anterior.

3. Criando um Banco de Dados e um usuário:

Nesta etapa voltaremos até o Terminal para configurar o banco que será criado, para isso digite sudo su (enter), entre com a senha de root, depois su postgres (enter). Agora com o usuário postgres poderemos criar nosso primeiro BD.
Digite createdb gis (enter), onde gis é o nome do nosso banco.
Agora vamos criar um usuário do postgresql, digite createuser nome_do_usuario (enter), onde nome_do_usuario pode ser o seu login do Linux, no meu caso o comando ficou assim: createuser marcello, surgirá a seguinte pergunta no Terminal:
A nova role poderá criar um super-usuário? (s/n) digite s (enter).
CREATE ROLE
Agora volte para o seu usuário digitando su seu_login (enter), em seguida digite psql gis (enter) para acessar o banco criado.
Já no banco, vamos definir uma senha para o usuário criado anteriormente, no meu caso foi feito da seguinte forma:
gis=# ALTER USER marcello PASSWORD 'nova_senha' ; (enter)
ALTER ROLE
Finalizada esta estapa, vamos agora instalar a extensão geográfica.

4. Carregando a Extensão PostGIS

Vá até o diretório onde se encontram os arquivos SQL necessários para carregar a extensão PostGIS, para isso, digite no terminal cd /usr/share/postgresql/8.4/contrib/postgis-x (enter).
Em seguida criaremos a linguagem plpgsql necessária para o funcionamento do PostGIS, digite createlang plpgsql gis (enter)
Para carregar as extensões digite os comandos: psql -f postgis.sql -d gis (enter) e para finalizar psql -f spatial_ref_sys.sql -d gis (enter).
Caso não tenha ocorrido nenhum problema nos passos anteriores, o postgis foi instalado corretamente.