Posts com Tag ‘GeoServer’

1. Um recorte de código
Veja o recorte de código abaixo:


    var saveStrategy = new OpenLayers.Strategy.Save();   
    wfs = new OpenLayers.Layer.Vector("Editable Features", {
        strategies: [new OpenLayers.Strategy.BBOX(), saveStrategy],
        projection: new OpenLayers.Projection("EPSG:4326"),
        protocol: new OpenLayers.Protocol.WFS({
            version: "1.1.0",
            srsName: "EPSG:4326",
            url: "endereço-servidor:8080/geoserver/wfs/",
            featureNS :  "endereço-servidor/catalogteste",
            featureType: "escolas",
            geometryName: "the_geom",
            schema: "endereço-servidor:8080/geoserver/wfs/DescribeFeatureType?version=1.1.0&typename=teste:escolas"
        })
    });    
    mapa.addLayer(wfs);

a)Onde:

  • featureNS : {String} Feature namespace (opcional).
  • featureType : {String} feature typeName local (sem prefixo) (obrigatório).
  • geometryName: {String} Opcional, nome do atributo geometry. Se não fornecido, será utilizado o nome default que é ‘the_geom’.

b)Como identificar os parâmetros?
Basta acessar o Geoserver como administrador e verificar os parâmetros dos layers criados:

  • featureNS: no Geoserver –> Edit Workspace –> Namespace URI. O que será colocado em featureNS deve ser igual ao que temos neste campo do Geoserver.
  • geometryName: não fizemos citação porque utilizamos o nome default. Para verificar isto, no Geoserver –> Edit Layer (no caso o layer escolas) –> Feature Type Details (que está no final da página). São encontradas aí o nome dos campos do layer. Para a geometria, vemos que o que está no geoserver é “the_geom”.

c) Para entender um pouco mais

  • Strategy Class: vide post OpenLayers: compreendendo melhor um “Layer Vetorial”. Em síntese, a classe Strategy é utilizada com dois objetivos: construir a requisição e determinar o que fazer com os dados.
    • Strategy.Save: uma estratégia que “commit” as features recém-criadas ou modificadas. Por padrão, antes de persistir as mudanças a “strategy” espera por uma chamada de “salvar”. Ao configurar a estratégia com a opção “auto”, as mudanças podem ser salvas automaticamente.
    • Função Save: diz ao “protocol” para realizar o “commit” das features não salvas. Se a projeção do layer difere da projeção do mapa, as features serão transformadas na projeção do layer antes do “commit”.
  • Protocol Class: vide post OpenLayers: compreendendo melhor um “Layer Vetorial”. Em síntese, a classe Protocolo se refere a comunicação, ou seja, controla como o layer vetorial se comunica com o servidor de dados. Existem 2 (duas) subclasses: Protocol.HTTP e Protocol.WFS.

Observação: Para carregar/salvar dados de alguma fonte de dados externa ao script, necessita-se no mínimo definir as classes Protocol e Strategy.
Referências:
1- OpenLayers: utilizando o protocolo WFS para requisitar features de servidor remoto Geoserver
2- OpenLayers: compreendendo melhor um “Layer Vetorial”
3- OpenLayers.Strategy.Save

Anúncios

O primeiro desafio é saber especificar os parâmetros exigidos pela classe OpenLayers.Protocol.WFS para se fazer a requisição. Dois parâmetros são essenciais:

  • featureNS : {String} Feature namespace (opcional).
  • featureType : {String} feature typeName local (sem prefixo) (obrigatório).

Parâmetros adicionais:

  • geometryName: {String} Opcional, nome do atributo geometry. Se não fornecido, será utilizado o nome default que é ‘the_geom’.
  • outputFormat:  {String} Opcional, formato de saída para uso do WFS GetFeature requests. Pode ser de qualquer formato presente na WFS’s GetCapabilities response.

No nosso caso, utilizaremos a seguinte chamada:

var wfs = new OpenLayers.Layer.Vector("States", {
strategies: [new OpenLayers.Strategy.BBOX()],
protocol: new OpenLayers.Protocol.WFS({
version: "1.1.0",
url: "HTTP://endereço-servidor:8080/geoserver/wfs",
featureType: "ra31_df",
featureNS: "http://endereço-servidor/catalogcdes",
srsName: "EPSG:4326"
})
});

Como identificar os parâmetros? Basta acessar o Geoserver como administrador e verificar os parâmetros dos layers criados:
a)  featureNS: no Geoserver –> Edit Workspace –> Namespace URI. O que será colocado em featureNS deve ser igual ao que temos neste campo do Geoserver.
b) geometryName: não fizemos citação porque utilizamos o nome default. Para verificar isto, no Geoserver –> Edit Layer (no caso o layer ra31_df) –> Feature Type Details (que está no final da página). São encontradas aí o nome dos campos do layer. Para a geometria, vemos que o que está no geoserver é “the_geom”.

<!DOCTYPE html> 
<html lang='pt'> 
<head> 
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <script type='text/javascript' src='http://localhost/js/OpenLayers-2.12/OpenLayers.js'></script>
    <title>WFS</title>
    <script type='text/javascript'>
    var map;
    const HOSTNAME = "HTTP://nome-servidor:8080/geoserver/wms";
    //
    function init() {
        map = new OpenLayers.Map('map', {
            controls: [
                new OpenLayers.Control.PanZoom(),
                new OpenLayers.Control.MousePosition({}),
                new OpenLayers.Control.LayerSwitcher(),
                new OpenLayers.Control.Navigation()
            ]
        });
    //WMS Layer - baseLayer
    layer = new OpenLayers.Layer.WMS(
    'DF:RIDE',
    HOSTNAME,
    {layers: 'cdes:ride_df', transparent:true},{attribution:'Ride',visibility: true, 
      isBaseLayer:true,opacity:1,displayInLayerSwitcher:true}
    );
    //
    map.addLayer(layer);
    //
    map.setCenter(new OpenLayers.LonLat(-47.85,-15.80),10);
//
 var wfs = new OpenLayers.Layer.Vector("RAs", {
        strategies: [new OpenLayers.Strategy.BBOX()],
        protocol: new OpenLayers.Protocol.WFS({
            version: "1.1.0",
            url: "HTTP://nome-servidor:8080/geoserver/wfs",
            featureType: "ra31_df",
            featureNS: "http://nome-servidor/catalogcdes",
            srsName: "EPSG:4326"
        })
 }); 
 map.addLayer(wfs);
//
    }
    </script>
  </head>
  <body onload="init()">
<h1 id="title">WFS: Protocol.WFS</h1>
<p id="shortdesc">
    Demostra como usar o protocol WFS para buscar features em um servidor remoto e colocar estas informações
 em um layer vetorial tornando-as visiveis em um mapa.
</p>
<div id="map" style='width: 800px; height: 400px;'></div>
</body>
</html>

Referências:
OpenLayers: utilizando o protocolo WFS para salvar features no servidor remoto Geoserver

Nesta receita pretende-se demostrar como usar o controle GetFeature, utilizando Protocol.WFS, para selecionar features de um layer WMS.

A classe OpenLayers.Control.GetFeature realiza busca por features para a localização sobre o cursor do mouse. Pode ser configurado para agir com o click, hover ou caixas de arrasto. Usa a classe OpenLayers.Protocol (HTTP ou WFS), a qual suporta filtros espaciais para adquirir features do servidor e disparar eventos que notificam aplicações associadas a feature selecionada.


<!DOCTYPE html> 
<html lang='pt'> 
<head> 
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <!-- Indicação da localização da bilbioteca OpenLayers -->
    <script type='text/javascript' src='./js/OpenLayers-2.12/OpenLayers.js'></script>
    <title>WFS: exemplo GetFeature (GeoServer)</title>
    <script type='text/javascript'>
    //    var map, layer, select, hover, control;
    var map, layer, select, control;
    const HOSTNAME = "HTTP://endereco_servidor:8080/geoserver/wfs";
    //
    function init() {
        map = new OpenLayers.Map('map', {
            controls: [
                new OpenLayers.Control.PanZoom(),
                new OpenLayers.Control.MousePosition({}),
                new OpenLayers.Control.LayerSwitcher(),
                new OpenLayers.Control.Navigation()
            ]
        });
    //WMS Layer: Ride-DF
    layer = new OpenLayers.Layer.WMS(
        'DF:Ride',
        HOSTNAME,
        {layers: 'cdes:ride_df', transparent:true},{attribution:'RIDE-DF',visibility: true, 
          isBaseLayer:true,opacity:.5,displayInLayerSwitcher:true}
    );
    //
    select = new OpenLayers.Layer.Vector("Selection", {styleMap: 
            new OpenLayers.Style(OpenLayers.Feature.Vector.style["select"])
    });
/*  Se desejar adicionar a facilidade hover, descomentar estas duas instruções e
    adicionar o layer hover ao mapa.
    Neste exemplo iremos deixar a opção "hover" desabilitada.
    Observer que o "hover" habilitado provoca um adicional de pedidos GetFeature 
    para ser emitido ao servidor de mapas.
    hover = new OpenLayers.Layer.Vector("Hover");
    map.addLayers([layer, hover, select]);
*/
    map.addLayers([layer, select]);
    control = new OpenLayers.Control.GetFeature({
        protocol: OpenLayers.Protocol.WFS.fromWMSLayer(layer),
        box: true,  // permite selecao de feature desenhando uma caixa
        hover: false,  // Se true, envia um pedido de feature quando mouse over.
        multipleKey: "shiftKey",
        toggleKey: "ctrlKey"
    });
    control.events.register("featureselected", this, function(e) {
        select.addFeatures([e.feature]);
    });
    control.events.register("featureunselected", this, function(e) {
        select.removeFeatures([e.feature]);
    });
/*
    Só necessário de facilidade hover habilitada
    control.events.register("hoverfeature", this, function(e) {
        hover.addFeatures([e.feature]);
    });
    control.events.register("outfeature", this, function(e) {
        hover.removeFeatures([e.feature]);
    });
*/
    map.addControl(control);
    control.activate();
    //
    map.setCenter(new OpenLayers.LonLat(-47.85,-15.80),8);
    }
    </script>
  </head>
  <body onload="init()">
<h1 id="title">WFS: exemplo de GetFeature (GeoServer)</h1>
<p id="shortdesc">
    Demostra como usar o controle GetFeature para selecionar features de um layer WMS.
</p>
<div id="map" style='width: 800px; height: 400px;'></div>
<div id="docs">
    <p>
        "Click" ou "drag" uma caixa para selecionar features, use a tecla "Shift" para adicionar
        features a seleção, use a tecla "Ctrl" para chavear o status da feature.
    </p>
</div>
</body>
</html>

Referências:
1- OpenLayers: API Documentation
2- OpenLayers Library Documentation
Veja Também:
3- Um pouco de OpenLayers, Geoserver e 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.

Neste post vamos tratar de algumas complementariedades importantes para o perfeito funcionamento do servidor de mapas Geoserver no Linux/Debian. Seguiremos uma linha de roteiro de instalação do ambiente e do aplicativo, com enfoque na segurança. Este post complementa os demais posts que fizemos abordando o servidor Geoserver.

1. Instalar o Java

O primeiro passo para o colocar o Geoserver em funcionamento é a instalação da máquina virtual Java, que pode ser realizado através de apt-get. Existe um post neste blog que descreve a instalação do Java, e isto pode ser verificado aqui.

2. Instalar o Tomcat
A maneira mais fácil é utilizando o apt-get. Existe um post neste blog que descreve a sua instalação do Tomcat, e isto pode ser verificado aqui.

Chamamos a atenção aos seguintes espectos:

  • a instalação default do Tomcat é na porta 8080. Se desejar alterar, por exemplo para a porta 8085, deve-se alterar o arquivo /etc/tomcat6/server.xml
  • para uma maior segurança, alterar os usuários iniciais e perfis em /etc/tomcat6/tomcat-users.xml, conforme post referenciado acima.
  • para verificar o bom funcionamento do Tomcat acessando a URL http://server-IP:8085/manager/html , com user/passw: admin / admin

3. Instalar o Geoserver
Existe um post neste blog que descreve a instalação do Geoserver, e isto pode ser verificado aqui. É baixar o arquivo do sitio do próprio aplicativo e descompactá-lo na pasta apropriada de forma ao Tomcat poder servir.

Para verificar o bom funcionamento do ambiente Java, Tomcat e o Geoserver, acessar a URL http://server-IP:8085/manager/html   (ou porta 8080 se não houve modificação). O usuário/senha default para login após a instalação é admin/geoserver.

Chamamos a atenção aos seguintes aspectos:

  • no momento da instalação também é gerado um outro usuário chamado “root”. Que deve ser utilizado em caso de alguma emergência, quando o login pelo administrador não for possível. A senha para este usuário estará disponibilizada no arquivo /var/lib/tomcat6/webapps/geoserver/data/security/masterpw.info
  • se não for utilizar os serviços WCS e WFS, desabitá-los:
    Retirar serviços desnecessários: services -> WCS (desmarcar “Enable WCS”) e services -> WFS (desmarcar “Enable WFS”).
  • alterar as informações de contato através de: About & Status –> Contact Information
  • é importante fazer a alteração da senha default do usuário admin através do menu Security -> Users,Groups,Rules -> admin
  • remover arquivo users.properties.olg: rm /var/lib/tomcat6/webapps/geoserver/data/security/users.properties.old
  • remover arquivo masterpw.info em /var/lib/tomcat6/webapps/geoserver/data/security/masterpw.info , após tomar conhecimento da senha do usuário “root” contido neste arquivo.
  • limitar a lista de SRS do serviço WMS apenas aqueles de necessidade: services -> WMS -> Limited SRS list. Esta caixa, por exemplo, poderia ser preenchida por: 4326, 4674, 3857, 4269
  • Quanto aos logs: em produção, fixar o perfil de logs Settings –> Global –> LoggingProfile –> PRODUCTION_LOGGING.properties
    • relatório de logs que obtemos em About&Status –> GeoserverLogs é oriundo do arquivo /var/lib/tomcat6/webapps/geoserver/data/geoserver.log
    • profile de logs:  Settings –> Global –> LoggingProfile   são os arquivos depositados  em /var/lib/tomcat6/logs

4. Geoserver atrás de um proxy
Não é uma boa política expor na internet o Geoserver, mesmo que se esteja usando o Tomcat ou o Jetty. Uma opção mais segura é utilizar um servidor web mais estável, como o Apache. Uma boa solução é lançar mão de um proxy através do servidor Apache. Este servidor redirecionaria as requisições para o Tomcat, que estaria mais seguro numa rede protegida interna. É isto que vamos descrever nesta parte deste post.
4.1 Habilitar protocolo ajp na máquina do Geoserver
Editar o arquivo /var/lib/tomcat6/conf/server.xml e descomentar a linha:

<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

Com isto cria-se um conector na porta 8009 para o protocolo ajp.
Não esquecer de reiniciar o tomcat:
# /etc/init.d/tomcat6 restart

AJP: “Apache JServ Protocol” – trata-se de um protocolo binário que pode redirecionar requisições de entrada de um servidor web para um servidor de aplicação que fica por trás do servidor web. Implementadores da Web normalmente usam o AJP em uma implantação de balanceamento de carga, onde um ou mais servidores Web de front-end alimentam pedidos para um ou mais servidores de aplicação. Tanto o container Apache Tomcat servlet como o container Jetty servlet suportam o AJP.

4.2 Instalar o Apache na máquina front-end
Existe um post neste blog que descreve a instalação do Apache, e isto pode ser verificado aqui.

4.3 Instalar módulos proxy do Apache na máquina front-end
# a2enmod proxy proxy_ajp
# /etc/init.d/apache2 restart

Existe um post neste blog que descreve os procedimntos para instalação de módulos do Apache, e isto pode ser verificado aqui.

4.4 Configurar o funcionamento do proxy
Editar o arquivo /etc/apache2/apache2.conf e inserir as seguintes linhas:

# ProxyPass
ProxyPass /geoserver   ajp://192.168.1.101:8009/geoserver
<Location /geoserver>
Order deny,allow
Deny from all
Allow from all
</location>

ProxyPass /meumapa    ajp://192.168.1.101:8009/meumapa
<Location /meumapa>
Order deny,allow
Deny from all
Allow from all
</location>

Os dois comandos de redirecionamento acima fará com que:
– toda requisição para /geoserver será redirecionada para o host 192.168.1.101, na porta 8009, utilizando o protocolo ajp
– toda requisição para /meumapa será redirecionada para o host 192.168.1.101, na porta 8009, utilizando o protocolo ajp

Não esquecer de reiniciar o apache:
# /etc/init.d/apache2 restart

4.5 Fazer requisições normalmente
utilizando um navegador, acessar normalmente o servidor de front-end através das seguintes URL:
http://<IP-servidor_front-end>/geoserver
http://<IP-servidor_front-end>/meumapa
Observe que o servidor de front-end é acessado normalmente pela porta 80.

5. Mensagem Importante
Se este post fora útil para você, não deixe de comentar. Além de ser um estímulo importante, pode melhorar este trabalho. Com certeza é muito mais trabalhoso fazer uma boa documentação do que implementar.

Sucesso!

Referências:
1- Instalar Geoserver no Linux – Debian

Neste exemplo é mostrado uma camada de informações servida pelo servidor de mapas Geoserver em projeção ESPG:4326, camadas do Google que estão em ESPG:900913 e uma camada oriunda do OpenStreet que também está em ESPG:900913.

<!DOCTYPE html>
<html lang='en'>
<head>
<meta charset='utf-8' />
<script src="http://maps.google.com/maps/api/js?sensor=false&v=3.2"></script>
<script type='text/javascript' src='OpenLayers.js'></script>
<script type='text/javascript'>
var map;
//
function init() {
//
//Criar o "objeto" mapa
map = new OpenLayers.Map('map_element',{
maxExtent: new OpenLayers.Bounds(
-128 * 156543.0339,
-128 * 156543.0339,
128 * 156543.0339,
128 * 156543.0339),
maxResolution: 156543.0339,
units: 'm',
projection: new OpenLayers.Projection('EPSG:900913'),
//                displayProjection: new OpenLayers.Projection("EPSG:4326"),
});
//OpenStreetMap
var map_osm = new OpenLayers.Layer.OSM(
'OpenStreetMap Layer'
);
//Google streets is the normal map type, so we don't need to pass in a type
var google_streets = new OpenLayers.Layer.Google(
"Google Streets",
{numZoomLevels: 20}
);
//Camada do "tipo" Google satellite
var google_satellite = new OpenLayers.Layer.Google(
"Google Satellite",
{type: google.maps.MapTypeId.SATELLITE},
{numZoomLevels: 20}
);
//WMS Layer - Meu layer criado e servido pelo Geoserver
var wms_layer = new OpenLayers.Layer.WMS(
'WMS Meu Layer específico',
'http://192.168.0.108:8080/geoserver/wms/',
{layers: 'minha_base:minha_camada', transparent: true},{isBaseLayer:false,opacity:.5}
);
//
//Criar Layer Vetorial
var vector_layer = new OpenLayers.Layer.Vector(
'Editable Vectors');
//Adicionar um controle (menu) para edição vetorial
map.addControl(new OpenLayers.Control.EditingToolbar(vector_layer));
//
//Adicionar os layers criados ao mapa
map.addLayers([map_osm, google_streets, google_satellite,wms_layer, vector_layer]);
//
//Adicionar um controle para visualizar a posição do mouse
map.addControl(new OpenLayers.Control.MousePosition());
//
// Adicionar um layer de "switcher control"
map.addControl(new OpenLayers.Control.LayerSwitcher({}));
//
// Deixar o centro do mapa no Distrito Federal
map.setCenter(new OpenLayers.LonLat(-5330000,-1780000),10);
//
// Zoom the map to the max extent
if(!map.getCenter()){
map.zoomToMaxExtent();
}
}
//
</script>
</head>
<body onload='init();'>
<div id='map_element' style='width: 1200px; height: 500px;'></div>
</body>
</html>

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