Tag opensource

Boas notícias sobre o GeoSampa, um dos projetos desenvolvidos e apoiados pela SIGMA Geosistemas.

O GeoSampa é um portal de informações geográficas, disponibilizado pela PRODAM e pela SMUL (Secretaria Municipal de Urbanismo e Licenciamento), contendo mais de 180 camadas de informações geográficas.

A prefeitura de São Paulo, oficializou a plataforma como base de dados oficial do município, aumentando ainda mais a relevância da mesma, através do decreto 57.770, editado pelo prefeito João Dória.

A plataforma já era bastante utilizada pela população e pelos colaboradores municipais, agora tem o status de base de dados oficial, possuindo mais de cem mil acessos mensais únicos.

Este é um passo importante para a correta institucionalização do sistema, permitindo uma sinergia entre os diversos interessados nos dados existentes e publicados através da mesma.

Entre os artigos do decreto, um me chama bastante atenção, oficializando o GeoSampa como plataforma integradora:

Art. 6º Os sistemas de dados e informações municipais de qualquer natureza deverão ser estruturados pelos órgãos responsáveis de forma a permitir sua interoperabilidade e integração com os demais sistemas, facilitando seu escalonamento, reuso e manutenção, e deverão:

I – garantir a simplificação do acesso, de forma a possibilitar à Administração Municipal o uso eficiente de suas informações no atendimento às demandas internas e externas;

II – dar transparência às ações de governo, de forma a permitir o acesso público a todas as informações que não sejam de uso restrito, em conformidade com a legislação pertinente, em especial o Decreto nº 53.623, de 12 de dezembro de 2012;

III – garantir que não haja a sobreposição de ações, evitando o dispêndio desnecessário de recursos e a duplicidade de dados da Administração Municipal.

Parágrafo único. O mecanismo de integração deverá garantir ao usuário acesso à informação atualizada por meio do sincronismo entre os sistemas e as bases externas com periodicidade definida e da atualização da base geoespacial.

O artigo 6° é uma comprovação de nossa filosofia de trabalho: o geoprocessamento pode e deve ser usado de forma inteligente, de maneira aumentar a eficiência do planejamento e redução de custos para a administração pública.

A SIGMA Geosistemas ajuda e ajudou na construção desta plataforma, utilizando apenas tecnologias livres. Dentre os serviços executados, desenvolvemos todas as ferramentas de análise, disponíveis por enquanto na intranet – como filtros, pesquisas geoespaciais, geração de gráficos e agrupamentos.

Em tempo, gostaria de parabenizar a toda equipe envolvida no GeoSampa e ao prefeito, por uma decisão acertada.

Ainda teremos muitas novidades sobre esta plataforma. Fique ligado!

Olá pessoal!

Aqui na SIGMA sempre estamos desenvolvendo ferramentas úteis para nós e que talvez também sejam úteis para outras pessoas.

Nossa ideia principal, é contribuir um pouco com esse enorme ecossistema Python/Django existente. Como já disseram, estamos sobre os ombros de gigantes.

Bem, desenvolvemos o Django Topology com o objetivo de simplificar a validação de dados geométricos/geográficos que encontramos em nosso dia a dia.

É muito comum, por exemplo, ter de validar a entrada de um polígono e precisamos garantir que ele esteja dentro de outro polígono. Ou garantir que este polígono específico não esteja sobrepondo outro polígono de uma mesma classe.

Para isso desenvolvemos o Django Topology. Através dele você consegue configurar suas validações dentro do banco de dados e executá-las de forma simples.

O fluxo é simples e o pacote já conta com três validações:

• must be contained – garante que o modelo A deve estar contido no modelo B;
• must not overlap – garante que o modelo A não pode sobrepor nenhum outro registro em A;
• must not overlap with – garante que o modelo A não pode sobrepor o modelo B;

O pacote é facilmente extensível e você desenvolver suas próprias validações topológicas.

Um exemplo simples:

        rule = Rule(
            name='regra de validação 1',
            description='A deve estar contido em B',
            message='deve estar contido',
            method='topology.rules.must_be_contained'
        )
        rule.save()
        topology_rule = TopologyRule(
            content_type_a=ContentType.objects.get(app_label='seuapp', model='item'),
            content_type_b=ContentType.objects.get(app_label='seuapp', model='container'),
            geom_field_b='geom',
            rule=rule
        )
        topology_rule.save()

Até aqui, definimos nossa regra topológica, de que A (qualquer instância do modelo Item) deve estar contida em B (Container).

Veja como realizar a validação:

        item_a = Item(geom=unit_polygon(Point(x=0.0, y=0.0, srid=4326)))
        item_a.save()
        container = Container(geom=unit_polygon(Point(x=0.0, y=0.0, srid=4326), size=3))
        container.save()

        errors = topology_rule.validate(item_a)
        len(errors)
>>> 3

No exemplo acima, calculamos os erros diretamente pela regra topológica (TopologyRule) e não foi encontrado nenhum erro.

Os erros gerados pelo TopologyRule não são persistidos no banco de dados, ficando a cargo do desenvolvedor a determinar o melhor momento para tal. As vezes nem será necessário, como por exemplo, em uma validação de formulário Django.

Também desenvolvemos um análogo ao TopologyChecker do QGIS e ele tem o mesmo nome. Sua função é executar todas as validações associadas a um determinado modelo, de uma vez, e persisti-las (ou não).

Veja como usá-lo:

        # definindo as regras
        rule1 = Rule(
            name='A não deve sobrepor A',
            description='A não deve sobrepor A',
            message='sobrepõe',
            method='topology.rules.must_not_overlap'
        )
        rule1.save()
        rule2 = Rule(
            name='A não deve sobrepor B',
            description='A não deve sobrepor B',
            message='sobrepõe',
            method='topology.rules.must_not_overlap_with'
        )
        rule2.save()
        topology_rule1 = TopologyRule(
            content_type_a=ContentType.objects.get(app_label='seuapp', model='item'),
            rule=rule1
        )
        topology_rule1.save()
        topology_rule2 = TopologyRule(
            content_type_a=ContentType.objects.get(app_label='seuapp', model='item'),
            content_type_b=ContentType.objects.get(app_label='seuapp', model='container'),
            geom_field_b='geom',
            rule=rule2
        )
        topology_rule2.save()

        item1 = Item(geom=unit_polygon(Point(x=0.0, y=0.0, srid=4326)))
        item1.save()
        item2 = Item(geom=unit_polygon(Point(x=0.0, y=0.0, srid=4326)))
        item2.save()
        container = Container(geom=unit_polygon(Point(x=0.0, y=0.0, srid=4326), size=2))
        container.save()

        # até aqui, criamos nossas regras e os registros de item e container

        topo_checker = TopologyChecker()

        errors = topo_checker.validate_all(Item)

O TopologyChecker retorna um dicionário, usando como chave o nome da validação executada e uma lista associada, com N erros detectados. No caso acima, o topologychecker encontrou 4 erros:

• item 1 sobrepõe item 2;
• item 2 sobrepõe item 1;
• item 1 sobrepõe Container 1;
• item 2 sobrepõe COntainer 1;

Estamos usando o Django Topology em produção no Geoadmin um produto que trabalha intensivamente com dados geográficos.

Você pode extender o mesmo com suas próprias validações. Basta criar um método com a seguinte assinatura:

def minha_validacao(rule, feature, **kwargs):
    # sua validacao aqui
    # deve retornar uma lista de TopologyError (sem salvar no banco)
    if feature.geom.intersects(outra_geometria):
        return [TopologyError()]

    return []

Com este método pronto, você só precisa criar uma Rule, apontando o atributo method para o caminmho qualificado da sua função:

rule = Rule(
    name='name'
    method='foo.bar.minha_validacao
)

Quer ajudar? Estamos aí, confere o repositório e bora lá.

Hoje vamos falar sobre uma ferramenta importante do QGIS, usada para conexão com banco de dados PostgreSQL/PostGIS.

Com esta ferramenta você poderá gerenciar seus bancos de dados, e as principais formas de interação são:

• Importar Shapefile para o banco de dados;
• Exportar uma tabela do banco de dados para diversos formatos;
• Executar queries complexas e carregá-las como camada diretamente no QGIS;

Para criar a conexão devemos acessar o menu Camada > Adicionar Camada > PostGIS.

Será aberta a tela a seguir:

Ao clicar em Novo será aberta a tela de configuração de conexão onde deverão ser incluídos os dados de conexão. O QGIS suporta a conexão tanto com servidores locais, quanto na rede interna, até mesmo na internet.

Veja abaixo a tela de conexão com o banco de dados.

Após inserir os dados você poderá clicar em Testar conexão para verificar se os dados inseridos estão corretos e clicar em OK para salvar sua conexão.

Se tudo estiver correto ao clicar no botão Conectar serão listadas todas as tabelas que possuem colunas geométricas.

A partir daí você poderá adicionar as camadas aos seus projetos, porém esta funcionalidade ainda não permite o gerenciamento de Banco de Dados, ela é o primeiro passo para gerenciá-lo.

Para acessar a ferramenta de gerenciamento de Banco de dados você deverá acessar o menu Banco de Dados > Gerenciador BD > Gerenciador BD.

Ao clicar você verá a tela abaixo, note que se expandir o menu do PostGIS irá ver a conexão criada.

Você poderá navegar entre as tabelas de seu banco de dados, note que no nome de cada tabela existe um ícone mostrando qual é o tipo geométrico da tabela. Caso ela não possa geometria, o QGIS utiliza um outro ícone para renderizá-la.

Nas abas Info, Tabela e Pré-visualizar você poderá ter acesso rápido aos dados do banco sem a necessidade de carregar a camada em seu projeto.

Existem três ferramentas que são muito úteis para a manipulação dos dados no PostGIS.

São elas:

• Janela SQL

Através da Janela SQL você poderá utilizar qualquer query para consultar seu banco de dados, inclusive utilizando funções do Postgis.

SELECT
id,
ST_AsText(geometria) as geometria.
ST_IsValidReason(geometria) as tipo_erro
FROM uso_solo
WHERE ST_IsValid(geometria_ = FALSE)

No exemplo o objetivo é listar os polígonos com geometria invalida para que possam ser corrigidos.

Foram utilizadas as funções:

ST_GeomFromText para retornar as coordenadas em texto;

ST_IsValidReason para mostrar qual o erro que gerou a geometria invalida e

ST_IsValid para listar somente as geometrias inválidas.

Além de listar estes polígonos é possível carregar o resultado como uma camada, basta marcar a opção Carregar como uma nova camada, para isto é necessário que exista no resultado de sua query uma coluna com um valor único e uma coluna com o valor geométrico, selecione os campos e clique no botão Carregar agora!, e uma nova camada será carregada em seu projeto.

Abaixo figura da camada carregada com o erro encontrado:

• Importar Camada/arquivo

Esta ferramenta importa um arquivo do tipo shapefile do QGIS diretamente para o PostGIS. Não é necessário criar a tabela previamente, será criada juntamente com as colunas e os tipos definidos no arquivo shapefile.

• Exportar Camada/arquivo

Esta ferramenta faz o oposto da importação, com ela é possível exportar uma tabela do banco de dados para um arquivo shapefile ou em algum dos formatos suportados.

Quem trabalha com com geoprocessamento ou dados geográficos e quer conhecer um pouco mais do PostgreSQL/PostGIS esta é uma ferramenta incrível para começar, pois irá lhe poupar algumas horas de trabalho visualizando os resultados das queries direto no mapa.

Vocês conhecem o projeto do github, o Hubot?

O hubot é um bot, capaz de te ajudar em diversas tarefas dentro da sua organização. Ele funciona recebendo comandos de uma sala, existente no seu sofware de mensagens instantâneas. Existem vários adaptadores, para programas, como Skype, slack e o mattermost, que é o software que usamos aqui.

Basicamente, você precisa de uma instância dele rodando em algum lugar e conectá-lo ao seu software de mensagens instatâneas.

Não vou entrar em detalhes aqui, pois o processo é diferente para cada software, mas é bastante fácil. Temos uma instância rodando no Heroku.

Deem uma conferida na documentação de como subir o bot, aqui.

Mas como vamos gerenciar nossos projetos?

Aqui na Sigma usamos o Gitlab como nosso gerenciador de repositórios. Não só repositórios, mas tudo mais que o Gitlab traz, de graça para você, como:

• Usuários
• Projetos
• Issues
• Milestones
• Merge Requests (similar o Pull Request do Github)
• Entre outras coisas bacanas!

O que fizemos foi criar um plugin para o Hubot, que escuta alguns comandos específicos, vai no Gitlab, faz as contas referentes ao andamento do projeto e responde no canal do Mattermost.

Bem bacana! Usamos isto para reportar para nosso clientes o andamento dos projetos e gerar gráficos como este aqui em baixo:

O hubot, no entanto, pode escutar os seguintes comandos:

>

hubot gitlab search [termo]

hubot gitlab list projects (lista os projetos existentes no Gitlab)

hubot gitlab list milestones [project_id] (lista milestones do projeto)

hubot gitlab list issues [project_id] (list issues do projeto);

hubot gitlab progress [project_id] (gera a medida de progresso do projeto)

São poucos comandos no momento, mas estamos planejando expandir esse camarada. O bacana do hubot é que ele funciona muito bem com qualquer tipo de mensageiro instantaneo que possua um adaptador para ele, ou seja, isso pode ser aplicado mesmo se vocẽ não usa o slack ou o mattermost.

Um exemplo em funcionamento:

É bem simples e dá estatísticas atualizadas!

Como sempre, publicamos nosso pacote no npm e ele é aberto em nosso Gitlab. O mesmo já foi puxado ~300 vezes, desde sexta-feira. É uma métrica e tanto para um projeto tão pequeno, mas acredito que deve ser útil para outras pessoas.

No nosso roadmap, ainda iremos implementar o cadastro de sprints, sua abertura e fechamento, bem como a geração inteira do gráfico através do hubot. Hoje só geramos as estatísticas, mas não é difícil gerar o gráfico completo.

E aí pessoal, curtiram? Fiquem a vontade para forkar, testar e adicionar novos comandos caso tenham interesse.

A biblioteca e o projeto spatialite são bastante especiais. Ela permite que você use um banco de dados SQLite como repositório de dados espaciais, com várias tabelas e relações.

Ela é bastante poderosa neste sentido, pois facilita que usuários GIS armazenem e compartilhem seus dados de forma mais simples, ao invés de enviar um monte de shapefiles para cima e para baixo.

No nosso caso, o problemas são com o Django, não com a biblioteca em si. Devido a algumas mudanças, o Django não consegue rodar, usando ela.

Bem, de acordo com a nova versão do Django e da SpatiaLite, algumas coisas mudaram de lugar e nem sempre o Django consegue encontrar a biblioteca.

Se vocẽ ver um erro do tipo:

Unable to load the SpatiaLite library extension “libspatialite.so.7” because: /usr/lib/x86_64-linux-gnu/libspatialite.so.7: undefined symbol:
sqlite3_spatialite_init

você encontrou o mesmo problema que nós.

Isto foi experimentado na versão do Ubuntu 16.04 e provavelmente afeta a todos os derivados (no nosso caso, afetou o Mint).

A resolução é simples. Instale algumas coisas e defina uma variável de ambiente:

Instale:

sudo apt-get install libspatialite3-mod-spatialite

Configure sua variável de ambiente:

echo SPATIALITE_LIBRARY_PATH="mod_spatialite" >> ~/.bashrc

Reinicie seu shell para que ele possa ler a configuração (ou dê um source no mesmo, tanto faz :D).

No Django, configure:

SPATIALITE_LIBRARY_PATH = 'mod_spatialite'

E aí, tiveram problemas com essa atualização?

Abraços