Instrutores
Pessoal,
Buenas noches de Porto Velho.
Tenho trabalhado muito e a consequência disso é um blog um cado "largado". Me desculpem por isso!
Hoje venho oferecer uma oportunidade: estou precisando de três instrutores em áreas diferentes.
Preciso de um instrutor em:
- Python
- PostGIS
- MapServer
Estamos implantando uma solução corporativa para um órgão público e preciso destes três instrutores. Caso alguém conheça alguém, ou se vocês mesmos tiverem disponibilidade, me avisem! Mais detalhes, por email.
Abraços,
George
Introdução ao GeoDjango
Boa noite pessoal,
Me desculpem pela demora em postar coisas novas no blog. Não esqueço deste espaço não, mas o tempo, continua difícil.
Hoje quero falar um pouco sobre o GeoDjango, um framework MVC (Model, View, Controller) - na verdade, MTV (Model, Template, View) para programarmos aplicações web com grande agilidade.
O lema do framework é The Web Framework for Perfectionist, ou seja: o framework web para perfeccionistas. Parece bom né?
Quais são as vantagens de se ter um framework deste tipo (MVC/MTV)?
- Código de qualidade;
- Aplicações prontas altamente configuráveis;
- Aplicação do princípio DRY - Don't Repeat Yourself - coisa que na web, é bastante comum;
- Total separação de responsabilidades: os modelos conversam com os bancos de dados, os templates desenham nossas páginas e as views representam a camada de negócios - ou seja: código (re)usável;
- Entre outras;
O MTV/MVC é apenas uma forma de se trabalhar/arquitetar uma solução. Este tipo de desenho de solução se encaixa muito bem para desenvolvimento web, pelos motivos acima. É muito menos trabalho, com alto reuso de código - ou seja, um ganho de produtividade tremendo para quem desenvolve e aumento da qualidade para os usuários.
Existem diversos frameworks deste tipo por aí, muitos deles são bons e na verdade conheço dois: Django/GeoDjango e ASP.MVC. Não quero comparar os dois, pois são classes de softwares diferentes, ambos muito bons e cada um com suas particularidades. O GeoDjango é muito atrativo pelo fato de trabalhar nativamente com vários bancos de dados, inclusive com PostGIS e outros bancos de dados espaciais menos conhecidos (MySql Spatial, Spatial Lite - por exemplo) e de conter pacotes específicos para o desenvolvimento de aplicações SIG.
O que precisamos para brincar com o tal do GeoDjango/Django?
Bem, o Django, projeto pai, que contém o código do GeoDjango é feito todo em Python. Novamente, uma linguagem fácil, tranquila de se aprender e muito flexível. Web e flexibilidade combinam. É tudo Python. Até os templates contém código Python, da mesma maneira que código .asp pode conter código C#.
Pré-requisitos (sempre existem, não?):
Para os que desejam utilizar o banco de dados PostgreSQL/PostGIS (altamente recomendado!):
Pode parecer muita coisa, mas não é. Você precisa das bilbiotecas e os python bindings para fazer toda essa máquina de guerra funcionar. Uma dica: quem usa/usará PostgreSQL já tem o GeOS instalado (que é o mais complicado de obter/compilar). As outras são facéis de se arrumar e configurar.
Chega de papo. O que o Django/GeoDjango pode fazer por mim? Vamos à uma demonstração de código dos models espaciais:
from django.contrib.gis.db import models
# note que aqui herdamos em nossa classe
# a classe Models. Ela contém toda a funcionalidade que precisamos.
class Setor(models.Model):
nome_setor = models.CharField(max_length=100,unique=True)
poligono_setor = models.PolygonField(srid=29192)
objects = models.GeoManager()
class Bairro(models.Model):
nome_bairro = models.CharField(max_length=100,unique=True)
setor = models.ForeignKey(Setor)
poligono_bairro = models.PolygonField(srid=29192)
# vamos dizer ao admin do python que usaremos mapas
# para editar o poligono_bairro
objects = models.GeoManager()
Só isso? Só isso. O Django já sabe o que fazer com nossos modelos. Note que não definimos de forma explícita uma chave primária, mas podemos caso precisarmos. O Django dá suporte para diversos tipos de dados, incluindo imagens, arquivos, datas, entre outros e suporta herança entre modelos. Isso significa que podemos economizar muito código utilizando os simples conceitos da programação orientada à objetos.
Todos os modelos devem ter tabelas no banco de dados que correspondam à ele, com exceção do caso de modelos abstratos, os quais não possuem tabela nos bancos de dados. Eles servem basicamente para usarmos as funcionalidades da OOP.
from django.contrib.gis.db import models
class TipoLogradouro(models.Model)
descricao_tipo_logradouro = models.CharField(max_length=30)
class ResultadoGeocodificacao(models.Model):
tipo_logradouro = models.ForeignKey(TipoLogradouro)
nome_logradouro = models.CharField(max_length=100)
numero = models.Integer()
# se não especificarmos o srid, o default é WGS84
ponto_geocodificado = models.PointField()
objects = models.GeoManager()
class Meta:
abstract = True
class AcidenteGeocodificado(models.Model,ResultadoGeocodificacao):
numero_feridos = models.IntegerField()
numero_veiculos = models.IntegerField()
A única diferença entre o primeiro e o segundo exemplo é a adição da classe interna Meta, em ResultadoGeocodificacao, com o atributo abstract = True. Esta única linha diz ao Django que ele não deve criar uma tabela correspondente para ResultadoGeocodificacao, mas, AcidenteGeocodificado irá herdar toda informação de ResultadoGeocodificado e terá sua própria tabela no banco de dados, com todos os campos especificados em ResultadoGeocodificado e AcidenteGeocodificado. Divertido não?
Lembram dos nossos posts sobre a administração pública e modelos de dados? Quero continuar a série, terminar a modelagem de dados (que é bastante simples) e iniciar no desenvolvimento desta aplicação em GeoDjango.
Django, o poderoso framework!
O que acharam do GeoDjango/Django?
Um abraço,
George R. C. Silva
Usando Python e o geoprocessing framework #2
Boa tarde pessoal!
Continuando naquele nosso projetinho, hoje vamos falar sobre a classe em Python que atualiza nossos dados em um determinado banco de dados. Temos algumas particularidades quando trabalhamos com ArcSDE, (registro de camadas como versionadas/não versionadas), portanto mostrarei como trabalhar com um Geodatabase local. A alteração para ArcSDE não é tão grande, e com um cadinho de pesquisa vocês conseguem fazer.
Lembre-se das outras classes que precisamos, mostradas no post anterior.
Construiremos duas classes, uma chamada GeoprocessorWrapper, um "embrulho" do objeto geoprocessor da ESRI. Isto não necessário, mas facilita, já que facilitamos algumas operações através deste "embrulho". A outra será uma tarefa, que juntará todos os dados e resultados das classes anteriores para atualizar nosso banco de dados.
Vamos começar com a mais simples, geoprocessorWrapper:
import arcgisscripting, logHandler
__toolboxAliases = [
"analysis",
"management",
"3d",
"cartography",
"arc",
"interop",
"geocoding",
"ga",
"lr",
"md",
"na",
"samples",
"sa",
"stats"]
class geoprocessorWrapperClass():
def __init__(self,workspace,toolboxList,overwriteOutput=False):
self.logs = logHandler.logHandlerClass()
# Startup logging object
self.gp = arcgisscripting.create(9.3)
# Startup ESRI geoprocessing object
self.gp.Workspace = workspace
self.gp.OverwriteOutput = overwriteOutput
# Define overwrite output. Default is to FALSE.
#lista de toolboxes disponiveis
self.toolboxList = []
self.toolboxList += toolboxList
self.buildGeoprocessorOptions(toolboxList)
def buildGeoprocessorOptions(self):
for x in self.toolboxList:
try:
if x in __toolboxAliases:
self.gp.AddToolbox(x)
except:
self.logs.newLogMessage(self, "Error in adding " + x + " toolbox to geoprocessor object. Are you sure this toolbox exists?" + self.gp.GetMessages(), "Geoprocessing Error")
# adds all toolboxes to current geoprocessing object.
def changeWorkspace(self,workspace):
self.gp.Workspace = workspace;
# changes the current workspace in geoprocessing object
def removeToolboxes(self,toolboxList):
for x in self.toolboxList:
try:
self.gp.RemoveToolbox(x)
self.toolboxList.remove(x)
self.logs.newLogMessage(self,"Removed " + x + "toolbox from geoprocessing object.","Information")
except:
self.logs.newLogMessage(self,self.gp.GetMessages(),"Geoprocessing Error")
# removes unneeded toolboxes from current geoprocessing object
Vamos começar com alguns detalhes desta classe:
Em primeiro lugar, temos os tradicionais import x. Eles são responsáveis por disponibilizar outras bibliotecas ao nosso código. Note que importamos o módulo arcgisscripting.
Logo depois, temos uma lista dos aliases que cada toolbox possui no Python. É necessário adicionar uma toolbox ao objeto geoprocessing para que se tenha acesso às ferramentas da mesma - o que pode ser feito de dois jeitos, pelo caminho da toolbox (C:\Program Files\...\ArcGis\Toolbox.tbx) ou pelo seu apelido. A primeira maneira é útil para adicionar toolboxes customizadas, que não tem apelido. A segunda maneira é mais prática para adicionar as toolboxes tradicionais.
O construtor da classe toma dois parâmetros obrigatórios e um opcional para inicializar a classe. O workspace é a pasta onde iremos trabalhar - ele poderia ser também um geodatabase, mas neste caso, uma pasta. toolboxList é uma lista com os apelidos das toolboxes que queremos adicionar ao nosso objeto de geoprocessing. O parâmetro adicional é se você deseja que os resultados do objeto geoprocessing sejam escritos por cima dos anteriores (caso tenham o mesmo nome) e é por default, falso.
O construtor é bastante simples. Ele cria um objeto geoprocessing, utilizando a versão 9.3 como opção (ajuste para sua versão caso necessário - mas não garanto que funcione na 9.2 - já que vários métodos como ListDatasets, têm uma resposta diferente do que
na versão 9.3), define qual é o workspace inicial e adiciona as toolboxes relevantes.
A forma de uso é a seguinte:
g = geoprocessorWrapper.geoprocessorWrapperClass(r"C:\",["analysis","management","lr"])
#ou
g = geoprocessorWrapper.geoprocessorWrapperClass(r"C:\",["analysis","management","lr"],true)
# para acessar o geoprocessor do nosso wrapper, use:
listaDeFeatureClasses = g.gp.ListFeatureClasses()
for x in listaDeFeatureClasses:
print x.FeatureType
Bem simples né? Temos um método também para mudar de workspace, sem necessitar de criarmos uma nova ferramenta. O outro método disponível é para remover toolboxes que não precisamos. Um método aqui poderia ser facilmente criado para adicionar novas toolboxes ao objeto. Alguém se arrisca?
Com esta classe podemos fazer quaisquer operações, mas utilizaremos uma outra classe para realizar todo o trabalho sujo. Lembra-se do código do post passado? Temos disponível em nossa máquina um arquivo .zip extraído em uma pasta qualquer, correto?
Vamos à classe geodatabaseUpdateTask.
import os, sys
class geodatabaseOperationClass():
def __init__(self,geoprocessor,inputShapefile,outputGeodatabase,outputFeatureDataset,outputFeatureClass):
self.geoprocessorWrapperClass = geoprocessor
self.inputShapefile = inputShapefile
self.outputGeodatabase = outputGeodatabase
self.outputFeatureDataset = outputFeatureDataset
self.outputFeatureClass = outputFeatureClass
self.processStage = 0
self.stages = ["Testes de conformidade",
"Deleçãoo de Feature Class",
"Cópia de Shapefile",
"Atualização Completa"]
def getProcessStage(self):
return self.stages[self.processStage]
def testGeodatabase(self):
#workspace definido pelo geoprocessor
return self.outputGeodatabase in self.geoprocessorWrapperClass.gp.ListWorkspaces(self.outputGeodatabase,"ALL")
def testFeatureDataset(self):
#adaptando workspace
self.geoprocessorWrapperClass.gp.Workspace += "\\" + self.outputGeodatabase
return self.outputFeatureDataset in self.geoprocessorWrapperClass.gp.ListDatasets(self.outputFeatureDataset,"ALL")
def testFeatureClass(self):
#adaptando workpace
self.geoprocessorWrapperClass.gp.Workspace += "\\" + self.outputFeatureDataset
return self.outputFeatureClass.gp.Workspace in self.geoprocessorWrapperClass.gp.ListFeatureClasses(self.outputFeatureClass,"ALL")
def testAllObjetcs(self):
if self.testGeodatabase() and self.testFeatureDataset() and self.testFeatureClass():
self.processStage = 1
return True
else:
self.processStage = 0
return False
def deleteFeatureClass(self,featureClass):
try:
self.geoprocessorWrapperClass.gp.Delete_management(featureClass)
except:
print self.geoprocessorWrapperClass.gp.getmessages()
def copyFeatures(self,inputShapefile,outputFeatureClass):
try:
self.geoprocessorWrapperClass.gp.CopyFeatures_management(inputShapefile,outputFeatureClass)
except:
print self.geoprocessorWrapperClass.gp.getmessages()
def updateFeatureClass(self):
try:
if self.testAllObjects:
self.processStage += 1
print self.getProcessStage()
self.deleteFeatureClass(self.outputFeatureClass)
self.processStage += 1
print self.getProcessStage()
self.copyFeatures(self.inputShapefile,self.outputFeatureClass)
self.processStage += 1
print self.getProcessStage()
except:
print self.geoprocessorWrapperClass.gp.getmessages()
Temos os tradicionais import no cabeçalho de nosso arquivo e logo depois o construtor da classe.
Nosso construtor tem os seguintes parâmetros: geoprocessor (um objeto do tipo geoprocessorWrapper), o caminho para o shapefile à ser carregado no banco de dados, o geodatabase de destino, o featureDataset de destino e a FeatureClass de destino.
Você pode ver que construí uma lista de estágios que temos de passar antes de atualizar a FeatureClass. O estágio testes de conformidade vão garantir que os objetos existam no geodatabase e não ocorram erros. Esta etapa pode ser customizada, caso a FeatureClass não exista, crie a mesma, somente importando os dados - também deixo isto para o usuário interessado! Lembre-se que temos de passar um objeto geoprocessorWrapper com um workspace, uma pasta. Neste caso em específico, deve-se passar apenas pastas, pois definimos o geodatabase em outras áreas.
Os testes cuidam da mudança de workspace e asseguram que a featureClass exista. Perceba que todo o trabalho é realizado dentro desta classe, nas funções:
- deleteFeatureClass()
- copyFeatureClass()
Uma função resume todo o processo: updateFeatureClass(). Veja que ela não tem parâmetros, pois usa os parâmetros setados no construtor. À medida que a mesma progride, atualiza o status do processo e informa ao usuário.
Forma de uso:
gp = geoprocessorWrapper.geoprocessorWrapperClass(r"C:\",['management']) geoOperation = geodatabaseOperation.geodatabaseOperationClass(gp,r"C:\shapefile.shp","teste.mdb","dnpm","dnpm_brasil") geoOperation.updateFeatureClass()
Lembrem-se que o restante do código (buscar o arquivo na net, dezipar, etc) está no post anterior. Como prometi, aqui vai a classe LogHandler.
E ae pessoal? Dúvidas?
Podem ver que o Python dá muito poder ao framework de geoprocessing do ArcGIS e é muito simples.
Um abraço
George
Usando Python e o Geoprocessing Framework #1
Boa noite pessoal,
Hoje quero falar um pouquinho do framework de geoprocessamento do ArcGIS, disponível em Python. Python, como sabem, é uma linguagem de alto nível, orientada à objetos e muito - mas muito fácil de se aprender.
Existem tarefas extremamente repetitivas que podem ser facilmente automatizadas com um pouquinho de Python e o tal Geoprocessing. O ArcGIS, basicamente faz uso do Python em toda a command-line e em algumas ferramentas da toolbox. Tudo que é feito no ModelBuilder é convertido em código Python.
Bem, vamos à proposta: imagine que você tenha necessidade de atualizar dados disponibilizados como shapefiles, por um órgão do governo, de forma periódica e em um banco de dados (ArcSDE, Personal GDB, File GDB, etc.). Será possível?
Bem, isto é possível pois o Python conta com milhares de bibliotecas para acesso à páginas da web, compressão/descompressão de arquivos .zip, entre outras. Este foi um requerimento real de um trabalho antigo.
Bem, imaginemos o site do DNPM, que disponibiliza shapefiles dos direitos minerários, de tempos em tempos (o DNPM também publica um serviço web, mas nem sempre é um bom caminho). No site SIGMINE você pode puxar separado por estados o shape atualizado e alimentar um banco. Mas é muito trampo para ser feito toda semana. Ainda mais se tua base não for centralizada. Todo mundo tem atualizar milhares de mxds, mapas, etc.
Quais são nossos passos?
- Fazer o download do shapefile em .zip
- Descompactar nosso arquivo em disco
- Atualizar o banco de dados
Podemos realizar o passo número 3 de várias formas, deletando a Feature Class antiga ou então atualizando registro por registro. Para nosso exercício, vamos deletar todos os registros e inseri-los novamente. Em ambientes mais controlados, com outras necessidades, talvez isto não seja o ideal.
Para contemplar nosso objetivo, iremos criar algumas classes:
- leecherHandler - responsável pelo download de arquivos da web;
- folderHandler - responsável pela criação/deleção de pastas;
- zipHandler - responsável pela compressão/descompressão de arquivos .zip;
- logger - responsável por guardar mensagens importantes para controle do que está acontecendo;
- geoprocessor - responsável por realizar as operações e interfaces com o ArcGIS;
Vamos começar pela classe leecherHandler, que é o coração de nosso pequeno sistema:
import sys, urllib2, logHandler
class leecherHandlerClass():
def __init__(self,webAddress,tempFolder):
self.logs = logHandler.logHandlerClass()
# Startup the log object.
self.webAddress = webAddress
self.tempFolder = tempFolder
self.localFile = self.buildLocalFile(self.downloadWebFile())
def buildFileName(self,webAddress):
fileName = "\\" + webAddress.split(r"/")[-1]
return fileName
def downloadWebFile(self):
try:
self.logs.newLogMessage(self,"Starting download...","Information")
# @eventoLogged: Start download.
webFile = urllib2.urlopen(self.webAddress)
# Opening the URL chosen.
self.logs.newLogMessage(self,"Finished download.","Information")
# @eventLogged: Download finished. Return a file object type.
return webFile
except:
self.logs.newLogMessage(self,"It was not possible to download file.\n" + str( sys.exc_info()[0]),"Error")
# @eventLogged: Error downloading file from URL
def buildLocalFile(self,webFile):
try:
self.logs.newLogMessage(self,"Writing file to disk...","Information")
# @eventLogged: Start writing to a local file.
fileName = self.buildFileName(self.webAddress)
localFile = open(self.tempFolder + fileName,"wb")
# Get the filename and open a localfile.
localFile.write(webFile.read())
# Write to brand new file.
# @todo: find a better way to write the file to disk
webFile.close()
localFile.close()
# Close both files. Clean-up action.
Esta classe é bastante simples. Ela usa o módulo urllib2 para fazer os downloads, além de construir um novo arquivo em disco, na pasta especificada. Vejam que o código da função downloadWebFile é muito simples. Apenas precisamos apontar qual é o arquivo que queremos puxar e ela já o constrói em disco, com um nome alterado com data - para não nos perdemos.
Você não precisa fazer mais nada, pois no construtor da classe, ela já dispara todas as ações de download e construção de arquivo em disco. Pode levar um tempo para puxar os arquivos, mas em geral é bastante rápido. Caso seja necessário, você terá de montar e inicializar um proxy - que também será mostrado.
A forma de uso é bastante simples:
shapeLeecher = leecherHandler.leecherHandlerClass('endereco do arquivo web','pasta temporaria de destino')
# para acessarmos o arquivo local em disco, utilzamos a seguinte sintaxe:
# shapeLeecher.localFile
Teremos agora um arquivo .zip em disco. Precisamos descompactá-lo. Crie uma nova classe, com a seguinte definição:
import sys, zipfile, logHandler
class zipHandlerClass():
def __init__(self,tempFolder,zipFilePathname,watchFileFormat="shp"):
self.logs = logHandler.logHandlerClass()
# Startup the log object
self.tempFolder = tempFolder
self.zipFilePathname = zipFilePathname
self.watchFileFormat = watchFileFormat
# Basic properties
self.containedFiles = []
# Generated file list inside zip archive
self.outputWatchFile = watchFileFormat
# outputInformation
def testZipFile(self):
if self.zipFilePathname == None or zipfile.is_zipfile == False:
self.logs.newLogMessage(self,"File pointed is not a valid zipfile" + str(sys.exc_info()[0]),"Error")
return False
else:
return True
def readContainedFiles(self,zipFile):
return zipFile.namelist()
def extractFiles(self):
try:
if self.testZipFile()== True:
extractingFile = zipfile.ZipFile(self.zipFilePathname,"r")
self.containedFiles = self.readContainedFiles(extractingFile)
# Defines a zipFile object using pathname for further manipulation. Read the files inside archive.
for zippedFile in self.containedFiles:
unpackedFile = open(self.tempFolder + "\\" + zippedFile, "wb")
unpackedFile.write(extractingFile.read(zippedFile))
unpackedFile.close()
# Unpack and write file to disk
self.logs.newLogMessage(self,"File " + zippedFile + " unpacked and written to disk.","Information")
# @eventLogged: Zip file unpacked and written in disk with success.
if zippedFile[-3:] == self.watchFileFormat:
self.outputWatchFile = zippedFile
else:
self.outputWatchFile = self.tempFolder
# Test to see if any of these files is of type watched.
# @todo: make this classe output a list of watched files.
extractingFile.close()
# close extracted file. CleanUp.
return True
else:
return False
# Test to see if it is a valid zipfile. If not, return false.
except zipfile.BadZipfile:
self.logs.newLogMessage(self,"Corrupted zipfile. Please download it again.","Error")
return False
Esta classe é um pouco mais complicada. Temos de monitorar um arquivo mestre (em nosso caso, um shapefile) para que possamos iniciar os próximos passos. Olhem a definição da classe - ela pede uma pasta temporária (a mesma que você usou com o leecher), uma localização do arquivo .zip e um formato. Este formato, tem como default a extensão .shp, mas você pode especificar outro.
# a idéia é que se use os resultados armazenados na classe leecher para alimentar
# o construtor da classe zipHandler, criando um processo encadeado
zipH = zipHandler.zipHandlerClass('pasta temporaria','arquivo.zip');
zipH.extractFiles()
No frigir dos ovos, esta classe testa o arquivo zip, confere se o mesmo é válido, extrai os arquivos para a pasta selecionada, e guarda uma referência ao arquivo com a extensão escolhida.
Vamos mostrar agora a clase folderHandler. Ela irá criar nossas pastas para nós:
import sys, os,datetime, shutil, logHandler
class folderHandlerClass():
def __init__(self,tempFolder):
self.logs = logHandler.logHandlerClass()
self.tempFolder = tempFolder
def generateTempFolderName(self):
dataHora = datetime.date.today()
folderName = self.tempZipFile[:-4] + "_" + str(dataHora)
return folderName
def createTempFolder(self):
try:
if os.path.exists(self.tempFolder):
if os.path.isdir(self.tempFolder):
return True
else:
self.logs.newLogMessage(self,"The specified folder is not a valid folder.","Error")
# @eventLogged: Folder is not valid.
return False
else:
os.mkdir(self.tempFolder,222)
self.logs.newLogMessage(self,"Folder " + self.tempFolder + " created with success.","Information")
# @eventLogged: Folder create with success.
return True
except:
self.logs.newLogMessage(self,"An unexpected error occurred while creating the specified folder.\n" + str(sys.exc_info()[0]),"Error")
# @eventLogged: Error while creating folder. More info on sys.exc_info()
def deleteTempFolder(self):
try:
shutil.rmtree(self.tempFolder)
except:
self.logs.newLogMessage(self,"An unexpected error occurred while deleting the specified folder.\n" + str(sys.exc_info()[0]),"Error")
# @eventLogged: Error while deleting folder. More info on sys.exc_info()
Esta classe tem dois métodos principais: um para criar pastas e outro para deletá-las. A classe executa uma verificação básica para saber se a pasta existe ou é uma pasta. Em caso de positivo a pasta não é criada, apenas usada como destino dos arquivos. Caso ela não exista, a classe tenta criá-la. Isto é feito para economizarmos uma operação e evitar de criar uma pasta com um nome já existente, o que nos daria um erro.
O método que deleta a pasta é radical. Ele remove tudo que existe dentro da pasta. Sub-pastas, arquivos, não importa. Ele irá deletar tudo. Cuidado ao usá-lo com outros arquivos. O ideal para se trabalhar com este script é uma pasta separada só para ele. Para usar esta classe, faça assim:
# como usar:
folderH = folderHandler.folderHandlerClass('pasta temporaria')
folderH.createTempFolder()
# ele irá tentar criar a pasta
folderH.deleteTempFolder()
# ele irá tentar deletar a pasta e seu conteúdo
Bem, com estas classes conseguimos construir um pequeno framework para atualizarmos os dados em um banco do ArcGIS. São coisas simples, mas que ajudam bastante. No próximo post, teremos a classe que cuida das operações de geoprocessamento, interfaceando com o ArcGIS - e uma classe "mestra" que faz todas estas classes conversarem.
Como utilizar as três classes juntas?
import sys,folderHandler,zipHandler,leecherHandler
# primeiro tentamos acessar/criar a pasta que queremos
# lembrem-se que um r antes de uma string, significa raw
# não sendo necessário escapar os caracteres \
folderH = folderHandler.folderHandlerClass(r"C:\temporario")
folderH.createTempFolder()
# é só inicializar o leecher Handler. seu construtor cuida do restante para nós
shpLeecher = leecherHandler.leecherHandlerClass("ftp://sigmine.dnpm.gov.br/Brasil.zip",folderH.tempFolder)
# podemos inicializar o zipHandler de duas maneiras
# com uma chamada explícita
zipH = zipHandler.zipHandlerClass(folderH.tempFolder,shpLeecher.localFile,"shp")
# ou implicita, caso a extensao seja shapefile - pois é um parametro com uma entrada
# default. se nada for especificado, .shp irá cair em seu lugar
# zipH = zipHandler.zipHandlerClass(folderH.tempFolder,shpLeecher.localFile)
zipH.extractFiles()
Com o código acima e as três classes descritas, já conseguimos puxar um arquivo da web e descompactá-lo para uma pasta qualquer.
Vocês podem notar que existem outras classes envolvidas aqui, especialmente o tal de LogHandler. Irei disponibilizar todo o projeto no próximo post 
Quaisquer dúvidas, estou à disposição!
Abraços
George
Python QuantumGIS Cookbook
Boa tarde pessoal,
A comunidade internacional lançou à poucos dias um livro de receitas de como programar/extender o QuantumGIS. Vale a pena dar uma olhada. Para os interessados é uma mão na roda para ajudar a começar. Check it out.
Tem uma excelente introdução, passando por tópicos sobre como mexer em camadas vetoriais, raster, construção de geometrias, projeções e por fim como construir um plugin.
Abraços
George R. C. Silva
OOP com python – Uma breve introdução.
Olá pessoal, tudo bem?
Tem muita novidade vindo, mas não é hora, nem lugar, nem o tema para falar sobre. Mas como o show tem que continuar, trago para vocês uma breve introdução sobre Orientação a Objetos com Python. Confesso que já venho estudando Python a algum tempo, mas nunca com tanta intensidade quanto agora, isso por que surgiram projetos para trabalhar com geodjango (uma framework web em python) e a descobri pyqgis.
Deixando de enrolação...
Bem, Python é uma liguagem Orientada a Objetos, mas que permite que você desenvolva aplicativos programando estrutural, é uma liguagem interpretada, que não exige que você indique o tipo da variável (dinamicamente tipada), possui fácil controle de bloco, o que te prende só ao código, sem ter que perder tempo analisando símbolos em casos de erro de sintaxe, e o melhor de tudo, é livre!
Para melhor compreensão, precisamos entender alguns conceitos, como classe, objeto, atributo e método. Para ser diferente (ou não!), começo falando de objetos. Objetos são todas as coisas as quais você deseja abstrair. Bem, você é um objeto! Como assim eu tou louco? É verdade, você é um objeto. Melhor, você alem de ser um objeto, você faz parte de uma classe... Não, esquece a geografia por equanto, que mané classe social... eu estou afirmando que você faz parte de uma classe, a dos Humanos. Legal né? Continuando, seus atributos, de fato são seus atributos (ou características, como queiram.), e os métodos, bem, esses se referem as ações tomadas por você hoje. Acho que você acordou, comeu, andou... Isso são os métodos, as ações tomadas pelos objetos!
E como desenvolver usando OOP com Python?
Para o desenvolvimento em Python usando OOP, é preciso conhecer algumas palavras reservadas, como class, que se refere a uma classe de objetos abstraídos, self que é um parametro que possibilita você fazer referencia a um argumento, substitui o this do Java, dentre outras que veremos conforme a necessidade.
Para exemplificar vou criar aqui um programa bastante simples que pede para você inserir uma mensagem, e esta mensagem é retornada para você. Vejamos:
class Mensagem:
def __init__ (self,pessoa,texto):
self.nome = pessoa
self.opniao = texto
def __str__(self):
saida = self.nome+ ' escreveu: \n' +self.opniao
return saida
nome_saida = raw_input ('Digite seu nome: ')
opniao_saida = raw_input ('O que você achou? \n')
print Mensagem(nome_saida,opniao_saida)
Explicando o código:
No método __init__ da classe Mensagem, foram jogados dois parametros: pessoa e texto. O self, primeiro parametro apresentado é padrao da linguagem, entao é conveniente utilizá-lo.
O trecho self.nome e self.opniao, sao referencias (instanciação)dos objetos antes apresentados: pessoa e texto.
O método __str__(), é mais um método mágico do Python, que determina o que será retornado do objeto.[1]
Perceba que este código sempre que invocado, ira inserir valores setados pelo usuário nos mesmo objetos, o que pra mim, é o segredo da OOP.
Finalizando
Bem, acho que deu para ter noção de como usar OOP em Python. Para maiores referencias sobre o assunto, aconselho visitar a Página da comunidade brasileira
Em breve, outras ferramentas Python... mas isto fica para um próximo post.
P.S.: Agradeço as correções sugeridas pelo amigo George, feitas no código, e ainda os ensinamentos sobre OOP.
Abraço a todos.
Vicente Martins
#Python – pt4
Como disse anteriormente o Python é a linguagem "preferida" pela ESRI para se construir ferramentas e modelos de geoprocessamento.
Na última vez, usei um exemplo pequeno, mas até útil.
Hoje vou mostrar como se pode fazer múltiplas operações, com uma só Feature Class.
O Python é ótimo em executar tarefas tediosas e repetitivas, daquelas que gastaríamos anos para terminar se feito na mão.
Imagine que você precise converter uma série de SRTMs para pontos, juntá-los, e depois interpolar tudo isso (espero que seu computador seja bom 
)
Vamos ao exemplo:
#lembrem-se que o python faz questão de código identado, se ele não tiver identado, não funcionará.
#aqui ao invez de espaços usaremos -
#vamos importar nossas coisas
import sys, os, arcgisscripting, string
gp = arcgisscripting.create(9.3)
diretorio = raw_input("Digite o diretório que contém os rasters. Não se esqueça de duplicar as barras \\, senão não conseguirei achar o caminho...")
#aqui você pode indicar qualquer coisa, um diretório, um banco de dados SDE e até um banco de dados file/personal.
if diretorio:
----pass
else:
----print "Workspace/Espaço de trabalho inválido. Reinicie o script e tente denovo."
----exit()
gp.Workspace = diretorio
ListaRasters = gp.ListDatasets("*","Raster")
#se tivessemos escolhido "SRTM*" ao invés de "*" o Python listaria todos os rasters que começam com as letras SRTM
gp.AddToolbox("conversion") #adiciona a toolbox conversion
gp.AddToolbox("sa") #adiciona a toolbox do spatial analyst - só funciona para quem TEM a licença eim pessoal.
gp.AddToolbox("management") #adiciona management
#já temos nossas ferramentas, mãos à obra.
for Raster in ListaRasters:
----OutFeature = diretorio + "\\" + "ponto_convertido_" + Raster
----gp.RasterToPoint_conversion(Raster,OutFeature)
----print Raster + " convertido para ponto."
#vamos listar nossas feature classes de ponto. lembra do "*"?
ListaFeatureClasses = gp.ListFeatureClasses("ponto_convertido_*","POINT")
#assim garantimos que só vamos mosaicar as featureclasses convertidas e não outras perdidas no mesmo workspace, e claro só do tipo ponto 
#a ferramenta merge exige uma lista das featureclasses a serem juntadas separadas por ponto e virgula, entao vamos dar a ela o que ela quer!
OutputMerge = gp.Workspace+"\\" + "MergeFinal"
gp.Merge_management(string.join(ListaFeatureClasses,";"),OutputMerge)
#a funcao join concatena uma lista utilizando um caractere (ou caracteres separadores) ou seja: ['shape1','shape2',shape3'] viram shape1;shape2;shape3
print "Já está tudo junto, vamos interpolar?"
print "interpolando. deve demorar, vá tomar um café..."
gp.Idw_sa(OutputMerge,"VALUE",gp.workspace+"\\"+"raster_interpolado",30,1)
print "interpolado. parabens!"
Bem pessoal, não testei o código, mas deve funcionar de acordo. O python é muito poderoso e suas funções internas se encaixam muito bem com a API da ESRI. Vejam na parte do Merge. Em outras linguagens teriamos de escrever loops e loops para concatenar as palavras daquela maneira, mas em python tudo é feito rapidinho!
Espero que gostem e que comecem a utilizar Python no seu dia a dia. É de fato um negócio muito útil. 1 hora para escrever um script, mas te salva 80mil horas de trabalho chato, cansativo e passível de erro humano.
Ahn! Não se esqueçam de consultar a documentação das funções utilizadas (join do Python, Merge_management, RasterToPoint_conversion e IDW_sa). Todas as versões do Help do ArcGIS possuem essa documentação. É só apertar F1 e correr para o help de cada ferramentinha, na última parte delas, Scripting. Se acharem algum erro no código postados, favor dar um toque que eu corrijo.
Python Rocks!
#Python – pt3
Vou mostrar a segunda maneira. Os scripts criados pelo ArcGIS são bastante simples, mas é preciso um pouco mais de base teórica, então fica pra depois.
Bem, para isso precisamos utilizar umas manhazinhas. Esta solução vai em duas partes, e poderia ser muito mais complexa, mas o Python vai nos ajudar.
Primeiramente, como perguntar qualquer coisa ao usuário? O Python tem uma pequena função chamada raw_input.
A função raw_input tem como único argumento opcional uma mensagem à ser passada ao seu usuário, mostrando a ele o que ele tem de digitar:
pasta = raw_input("Digite a pasta onde se encontram os shapefiles. ")
#funciona
pasta2 = raw_input()
#funciona também, mas sem mensagem
Bem, antes do script rodar e começar a tentar processar as pastas, é bom testar se o valor que o usuário digitou é válido. Existem diversas validações que poderiam ser executadas, mas vamos usar uma em especial.
#lembre-se que cada - equivale à um espaço e um conjunto com ---- equivale à uma tabulacao.
import sys, os, arcgisscripting
pasta = raw_input("Digite a pasta que deseja projetar. Lembre-se de duplicar as barras \\ senão não acho o caminho. ")
if os.path.isdir(pasta) == true:
----#é uma pasta válida e existe.
----#processe
else:
----#não é uma pasta válida.
----#imprima uma mensagem de erro e saia do script.
----print "Erro, a pasta indicada não é válida."
----exit
Bem pessoal, esse é o começo de tudo. Não repetirei os processamentos com o arcgisscripting, e isso é pra vocês estudarem e tentarem por aí.
Não se esqueçam, o F1 do Python traz a ajuda da versão utilizada, que contém as assinaturas de funções (quais são os paramêtros de entrada e qual é a saída), notas importantes e exemplos de como usá-las.
Agora, como permitir o usuário escolher o datum? Essa é um pouco mais difícil. Teremos de usar um outro tipo de dados do Python, chamado dicionário, que é tão poderoso quanto as listas, mas existem algumas diferenças sobre ele. O dicionário não suporta aquela maravilha de "for x in lista:", pois ele é um...dicionário, e não uma lista.
Os dicionários tem alguns métodos que nos ajudam a achar o que queremos:
a = {'SAD6922SUL':'\\Coordinate Systems\\Projected Coordinate Systems\\Utm\\Other GCS\\South American 1969 UTM Zone 22S.prj'}
Este é um dicionário com somente uma entrada. Enquanto as listas utilizam a posição de cada item (de 0 à n), os dicionários utlizam as keys. No caso supracitado, a key para este endereço monstro é SAD6922SUL, ou seja, ela armazena um valor, que é o diretório para este datum.
Métodos:
len(dicionario) retorna o tamanho do dicionario.
k in dicionario. Verdadeiro se a chave k está presente no dicionario dicionario.
k not in dicionario. Verdadeiro se a chave k NÃO está presente em dicionario.
dicionario.has_key(k). Mesmo que k in dicionario. Versão nova da função.
dicionario.keys(). Copia as keys para uma lista.
dicionario.values(). Copia os valores para uma lista.
dicionario[k] = v. Adiciona uma chave k com o valor de v no dicionario.
Existem outros métodos, mas estes são os mais básicos e necessários para começar.
Imagine o seguinte dicionario:
dicionarioDatums = {'sad69utm22s':\\Coordinate Systems\\Projected Coordinate Systems\\Utm\\Other GCS\\South American 1969 UTM Zone 22S.prj',
'sad69utm23s':'\\Coordinate Systems\\Projected Coordinate Systems\\Utm\\Other GCS\\South American 1969 UTM Zone 23S.prj',
'sad69utm24s':'\\Coordinate Systems\\Projected Coordinate Systems\\Utm\\Other GCS\\South American 1969 UTM Zone 24S.prj'}
e o código a seguir:
chaveDatums = dicionarioDatums.keys()
for chave in chaveDatums:
----print chave
datumEscolhido = raw_input("Digite o datum de sua escolha. ")
if datumDicionario.has_key(datumEscolhido):
----#processo
else:
----print "Você não escolheu um datum válido. Reinicie e tente novamente."
Bem, veja que hoje apenas estruturei a solução. Quero ver algum código aí nos comentários. Alguém tem uma outra idéia para fazer isso?
É bom notar que existem melhoras a serem feitas neste script, por exemplo, forçar o usuário a digitar algo correto no último raw_input, e software não sair daí enquanto ele não o fizer. Existe também a possibilidade de se mapear a pasta Coordinate System automaticamente, sem a necessidade de sempre que precisarmos de um datum novo, que não está na lista, reescrever o código. Deem suas sugestões e espero ter ajudado.
Abraço
George
#Python – pt2
Buenas pessoal,
Bem, Python, como expliquei no post passado é uma linguagem de alto nível e muito recomendada pela ESRI para se construir modelos de geoprocessamento (semelhantes aos construídos no ModelBuilder) e scripts para processamento de informações.
Primeiro, para quem deseja aprender Python:
Aqui encontramos algumas coisas fundamentais, como documentação e links para trocar idéias com a comunidade que desenvolve em Python.
Segundo: irc.freenode.net nos canais #python e #python-br . Nestes locais é possível conversar com desenvolvedores brasileiros e internacionais e resolver possíveis dúvidas.
Terceiro: este aplicado a quem quer integrar esta poderosa ferramenta aos seus métodos de trabalho - WebHelp ESRI e WebHelp Esri 2.
Não tenha medo de errar e não tenha medo de buscar ajuda.
Então vamos lá.
Para qualquer coisa que você queira fazer em python, é necessário importar o módulo que cuida dos objetos geográficos da ESRI, o arcgisscripting.
#importando o módulo arcgisscripting
import arcgisscripting
Quando um script .py contém esta instrução (ela deve ser feita no ínicio do seu script), o python deixa a sua disposição os objetos da ESRI. No webhelp você pode encontrar uma descrição ampla de TODOS eles, bem como exemplos.
Certo, mas depois que este módulo está disponível, o que fazemos para começar a mexer com o ArcGIS?
É necessário criar um objeto do tipo geoprocessing, fornecido pelo módulo arcgisscripting. Olhem o exemplo
gp = arcgisscripting.create()
#este método, sem parâmetros serve tanto para 9.2 quanto para 9.3
#para 9.3, é melhor especificar o paramêtro 9.3 e.g.: gp = arcgisscripting.create(9.3)
O que podemos fazer com o Python? Bem, em teoria, tudo o que estiver disponível dentro de uma Toolbox do ArctoolBox também está disponível para o Python. O Python na verdade, consegue fazer qualquer coisa que esteja em uma toolbox e ainda mais!
Lembre-se que o Python contém muitos módulos, como acesso à sítios remotos, módulos para gerenciar emails, matemáticos, FTP, conversores para PDF, acesso à banco de dados (MSSQL, PostgreSQL, SQLite, entre outros), manipuladores XML...ou seja, é muito flexível e extensível.
Para realizarmos operações dentro do ArcGIS, temos que utilizar o módulo sys e geralmente o módulo os, ambos nativos no Python. Hoje não falarei de como construir scripts que rodam à partir do ArcGIS, apenas scripts que rodam diretamente da shell python (alguém conhece alguma utilidade pra isso? acessar objetos geográficos sem abrir o ArcGIS?)
Bem, imaginemos que queremos Projetar ou Definir projeção de diversos itens, ao mesmo tempo:
#projetar diversos shapefiles para uma única projeção
import sys, os, arcgisscripting
Caminho = "C:\\Pasta\\Shapefiles\\"
#no Python, temos de duplicar as barras, pois uma barra \ é interpretada como alguns
#caracteres especiais, como nova linha, tabulação, entre outros
gp = arcgisscripting.create(9.3)
#vamos projetar shapefiles/featureclasses. temos de utilizar
#as toolboxes correspondentes, entao vamos adicioná-las
gp.AddToolbox("C:\\CaminhoAtéAToolbox\\Nome da Toolbox.tbx")
#podemos adicionar tantas toolboxes quanto precisarmos
#só devemos lembrar que mesmo através de scripts Python, as licensas de extensões
#SÃO CHECADAS. se você não tiver o spatial analyst, o Python irá dar um chilique
gp.Workspace = Caminho
#vamos definir o workspace. No ArcGIS + Python, muita coisa depende do workspace.
#ele é basicamente um apontamento para o diretório correto.
ListaShapefiles = gp.ListDatasets("*","ALL")
#vamos criar um objeto do tipo lista, e inserir nela todos os objetos do arcgis.
#os parametros "*" e "ALL" está dizendo para o ArcGIS inserir na lista todos
#os objetos, sem especificação de tipo (que podem ser Feature, TIN, Raster e CAD)
print ListaShapefiles
#me mostre o que será projetado
projecao = "C:\\CaminhoAteAProjecao\\Projecao.prj"
for Shapefile in ListaShapefiles:
----gp.Project_management(Shapefile,Shapefile+"_projetado",projecao)
----print "Projetei " + Shapefile
#considere os quatro - como uma identação, um toque na tecla tab (o blog está engolindo os espaços)
#fim
Este script é bem simples, deve ser salvo como .py, e ser rodado através da shell python ou com dois cliques no mesmo (desde que o Python esteja devidamente e corretamente instalado).
Algumas notas no entanto: note a forma que duplicamos as barras. Se você utilizar somente uma barra o Python não conseguirá achar os caminhos corretamente.
Os nomes de saída da função project são Shapefile_projetado.
A identação no trecho "gp.Project_management..." é PROPOSITAL E DEVE ESTAR LÁ. SEM ELA O SCRIPT NÃO FUNCIONARÁ. O Python usa a identação obrigatória como forma de controle de código.
Não se esqueça, tudo o que vem depois de # é considerado pelo Python um comentário, não influenciando no programa.
Note que para projetar uma pasta/set de shapefiles diferentes, temos que alterar a variável Caminho, lá em cima. O que podemos fazer para dinamizar esta questão? Como podemos perguntar ao usuário qual é a pasta que precisamos projetar? E a projeção, como definir ela dinamicamente? Essa fica de dever de casa
E agora senhores, o que podemos fazer com Python? Podemos utilizar todas as Toolboxes do ArcGIS para realizar milhares de operações com diversos shapes/featureclasses, e até mesmo cosntruir modelos complexos, do tipo que vemos em ModelBuilder, simulando eventos.
Vamos aprender Python?
#Python – o que é?
Olá pessoal,
Primeiro gostaria de falar sobre a Geo Rede. GeoRede é um projeto do site Geo.NET, um agregador de feeds de diversos blogs sobre Geoprocessamento/Sensoriamento Remoto em geral.
Estou lá também! Depois passem lá e deêm uma olhada. Se você não conhece o Geo.NET é mais uma coisa bacana. Fórum, seção de downloads e muito mais.
Bem, hoje falo para os usuários de ArcGIS. Vocês já devem ter notado, que durante a instalação do ArcGIS ele te pergunta/pede para instalar uma linguagem de programação chamada Python. Bem, se algum de vocês já abriram a aba dela no menu Iniciar do windows devem ter se deparado com algo bastante simples, a IDLE. A IDLE é um shell que intepreta comandos em Python. Algo como o DOS.
Bem, não dá pra fazer muita coisa pela IDLE, já que estamos limitados a "programas" de uma linha. Mas o porque estou falando de Python? O ArcGIS, felizmente, tem um ambiente customizável e permite ao usuário mais avançado a desenvolver suas próprias ferramentinhas, para executar uma infinidade de ações. Desde tarefas de "geoprocessamento" (geoprocessing) à customizar suas layers e representações.
Existem duas maneiras de se estender o ArcGIS. Uma delas é através de uma linguagem compilada .NET (ou VBA) e através do Python.
De acordo com a própria ESRI, a linguagem recomendada para se trabalhar com geoprocessing é Python. O .NET é mais fácil caso você precise estender a GUI (Graphic User Interface) e montar coisinhas mais complexas. O Python é recomendado para geoprocessing e a criação de ferramentas mais simples justamente pelo Python ser simples. A linguagem Python, criada em 1991, é considerada VHLL (Very High Level Language) e traz enormes facilidades para desenvolvedores iniciantes.
Primeiramente, ela é dinamicamente tipada (what the hell?!). Bem isso significa que não é necessário declarar com QUE tipos de variáveis queremos trabalhar antecipadamente. Você coloca alguma coisa na variável e o Python identifica o que ela é pra você. Ou seja, não existe muita confusão no momento de falar que A = 3 ou A = "spam". (neste exemplo, A = 3, representa automaticamente que A é uma variável do tipo inteiro e que em segundo momento, ela é do tipo string)
Segundamente, Python não é uma linguagem compilada. Não é necessário desenvolver um arquivo executável ou algo do tipo, ela é interpretada conforme o Python lê o código digitado. Isso traz uma perda de velocidade (nada muito importante) mas o ganho em agilidade no desenvolvimento compensa.
Python tem tipos muito flexíveis, como listas e dicionários. Não entrarei em detalhes, mas você pode com uma única expressão, criar uma lista com valores que você esteja trabalhando e de forma mais fácil ainda, ler os mesmos.
Um exemplo de lista, que sempre estão entre COLCHETES:
ListaTeste = ['spam','geoprocessamento',2,['arcgis','envi','arcsde']]
Temos na lista acima os items 'spam', 'geoprocessamento',2 e uma outra lista! aninhada, com os objetos 'arcgis','envi' e 'arcsde'. Listas são o carro-chefe do Python e devem ser aprendidas o quanto antes. Através delas podemos fazer o capeta com muito pouco código.
Agora, como integro ArcGIS com Python? A ESRI disponibiliza uma "API" própria para manipulação (de seus) objetos geográficos, como Feature Classes, Layers, Datasets, Geodatabases entres outros.
tudo o que tiver após # são considerados comentários, e não são interpretados pelo Python.
Um exemplinho simples de um script em Python (embora não muito útil) manipulando dados do ArcGIS seria:
import os, sys, arcgisscripting
gp = arcgisscripting.create(9.3) #vamos criar um objeto do tipo geoprocessing, versão 9.3
ListaCamadas = gp.ListDatasets(r"C:\teste python\geodatabase.gdb")
#pega uma lista dos featuredatasets no geodatabase.gdb
for camada in ListaCamadas: #para cada camada em ListaCamadas
print camada #imprima camada
#a resposta do Python vai ser algo assim.
>>>>['Hidrografia','Altimetria','Geologia','Transportes']
Bem, vejam como é fácil andar pelas listas e realizar operações em série. Os loops em Python são descomplicadíssimos.
Sugiro que agora, corram ao site da ESRI, e deem uma olhada nos geoprocessing Objects. Eles podem facilitar muito a vida de um utilizador de SIG.
Um abraço
