def loadFileIntoH2(self, oml, outputPathFull):
path=gvsig.getTempFile(oml.getCodMun(),'')#os.path.join(self.getDownloadPath(),oml.get)
print "PATH FOR GML:", path
os.mkdir(path)
zip_ref = zipfile.ZipFile(outputPathFull, 'r')
zip_ref.extractall(path)
zip_ref.close()
gmlFile = 'A.ES.SDGC.CP.{0}.cadastralparcel.gml'.format(oml.getCodMun())
gmlFilePath = os.path.join(path, gmlFile)
if not os.path.exists(gmlFilePath):
print "fail"
return
manager = DALLocator.getDataManager()
storeParameters = manager.createStoreParameters("GMLDataStoreProvider")
#storeParameters.setDynValue("connectionString",None)
storeParameters.setDynValue("CRS",self.view.getProjection())
#storeParameters.setDynValue("defaultGeometryField",None)
storeParameters.setDynValue("file",gmlFilePath)
#storeParameters.setDynValue("gfsSchema",None)
#storeParameters.setDynValue("ignoreSpatialFilter",True)
storeParameters.setDynValue("layerName",oml.getCodMun())
#storeParameters.setDynValue("ProviderName",None)
#storeParameters.setDynValue("xsdSchema",None)
storeGML = manager.openStore("GMLDataStoreProvider",storeParameters)
#application = ApplicationLocator.getManager()
#mapcontextmanager = application.getMapContextManager()
#layer = mapcontextmanager.createLayer(oml.getId(),store)
#self.view.addLayer(layer)
# Open Store
storeParameters = manager.createStoreParameters("H2Spatial")
database_file=gvsig.getResource(__file__, "data", "municipalities.mv.db")
storeParameters.setDynValue("database_file",database_file)
storeParameters.setDynValue("Table","Muni")
storeH2 = manager.openStore("H2Spatial",storeParameters)
storeH2.edit()
fsetGML = storeGML.getFeatureSet()
for f in fsetGML:
value = {
'CODPROV': oml.getCodProv(),
'PROV': oml.getProv(),
'CODMUN': oml.getCodMun(),
'MUN': oml.getMun(),
'ID': oml.getId(),
'gml_id': f.get('gml_id'),
'GEOMETRY': f.getDefaultGeometry()
}
storeH2.append(value)
storeH2.commit()
storeGML.dispose()
storeH2.dispose()
def processAlgorithm(self):
params = self.getParameters()
studyAreaNameVector = params.getParameterValueAsVectorLayer(
"studyAreaNameVector").getFeatureStore()
outputFilePath = params.getParameterValueAsString("outputFilePath")
if outputFilePath == "":
outputFilePath = gvsig.getTempFile("result_geometries", ".shp")
elif not outputFilePath.endswith('.shp'):
outputFilePath = outputFilePath + ".shp"
process(self, studyAreaNameVector, outputFilePath)
return True
def process(selfStatus,store,raster,outputFilePath=None):
# SELECT METHOD TO TRANSFORM POINTS
method = "setZFromRaster" #None
geomManager = GeometryLocator.getGeometryManager()
if store.getFeatureSelection().getSize()>0:
fset = store.getFeatureSelection()
else:
fset = store.getFeatureSet()
nsch = gvsig.createFeatureType(store.getDefaultFeatureType())
if method == "setZFromRaster":
transformMethod = setZFromRaster
subtype = geom.D3M
nsch.get("GEOMETRY").setGeometryType(nsch.get("GEOMETRY").getGeometryType(), subtype)
if outputFilePath is None:
outputFilePath = gvsig.getTempFile("result_geometries",".shp")
ns = gvsig.createShape(nsch,outputFilePath)
ns.edit()
store = ns.getFeatureStore()
selfStatus.setRangeOfValues(0,fset.getSize())
for f in fset:
selfStatus.next()
fg = f.getDefaultGeometry()
#print "Default geometry: ", fg,
if subtype == None:
subtype = fg.getGeometryType().getSubType()
nm = geomManager.create(fg.getGeometryType().getType(), subtype)
if isinstance(fg,MultiPrimitive): # for multiprimitive
for i in range(0,fg.getPrimitivesNumber()):
iPol = fg.getPrimitiveAt(i)
np = geomManager.create(iPol.getGeometryType().getType(), subtype)
insertVertexFromGeometryInGeometry(iPol, np, raster, transformMethod) ## INSERT
nm.addPrimitive(np)
else: # for primitive
insertVertexFromGeometryInGeometry(fg, nm, raster, transformMethod) ## INSERT
nf = store.createNewFeature(f)
nf.set("GEOMETRY", nm)
store.insert(nf)
if selfStatus.isCanceled() == True:
ns.finishEditing()
return True
ns.finishEditing()
gvsig.currentView().addLayer(ns)
def downloadXMLQuery(url):
#try:
outputPath = gvsig.getTempFile("municipioXML", ".xml")
f = download(url)
#total_size = int(f.headers["Content-Length"])
#MB_size = round(total_size/1048576, 2)
block_size = 1024 * 1024
with open(outputPath, "wb") as file:
while True:
block = f.read(block_size)
dSize = round(int(os.stat(outputPath).st_size) / 1048576, 2)
#print "(" + str(dSize) + "/" + str(MB_size) + " MB) " + url + "Downloading"
if not block:
break
file.write(block)
return outputPath
def process(selfStatus, store, cutDistance, outputFilePath=None):
geomManager = GeometryLocator.getGeometryManager()
fset = store.getFeatureSet()
nsch = gvsig.createFeatureType(store.getDefaultFeatureType())
if outputFilePath is None:
outputFilePath = gvsig.getTempFile("result_geometries", ".shp")
ns = gvsig.createShape(nsch, outputFilePath)
ns.edit()
store = ns.getFeatureStore()
#selfStatus.setRangeOfValues(0,fset.getSize())
for f in fset:
#selfStatus.next()
fg = f.getDefaultGeometry()
if isinstance(fg, MultiPrimitive):
linesToProcess = []
for i in range(0, fg.getPrimitivesNumber()):
iLine = fg.getPrimitiveAt(i)
linesToProcess.append(iLine)
else:
linesToProcess = [fg]
for iLine in linesToProcess:
setLines = processLine3D(iLine, cutDistance)
for singleLine in setLines:
#if singleLine.getNumVertices()<=1:
# continue
nf = store.createNewFeature(f)
nf.set("GEOMETRY", singleLine)
store.insert(nf)
#if selfStatus.isCanceled() == True:
# ns.finishEditing()
# return True
ns.finishEditing()
gvsig.currentView().addLayer(ns)
return ns
def createNewEmptyMunicipalities():
database_file = gvsig.getTempFile("/home/osc/temp/h2/municipalities",".mv.db")
print "** DATABASE FILE_: ", database_file
# Create store
manager = DALLocator.getDataManager()
serverParameters = manager.createServerExplorerParameters("H2Spatial")
serverParameters.setDynValue("database_file",database_file)
serverExplorer = manager.openServerExplorer("H2Spatial",serverParameters)
p = serverExplorer.getAddParameters()
p.setDynValue("Table","Muni")
ft = manager.createFeatureType()
# "CODPROV","PROV","CODMUN","MUN","ID"
ft.add("CODPROV", DataTypes.STRING)
ft.add("PROV", DataTypes.STRING)
ft.add("CODMUN", DataTypes.STRING)
ft.add("MUN", DataTypes.STRING)
ft.add("ID", DataTypes.STRING)
ft.add("gml_id", DataTypes.STRING)
ft.add("GEOMETRY", DataTypes.GEOMETRY) #Geometry.TYPES.CURVE)
ft.get("GEOMETRY").setGeometryType(geom.POLYGON, geom.D2)
ft.get("GEOMETRY").setSRS(gvsig.currentView().getProjection())
p.setDefaultFeatureType(ft)
serverExplorer.add("H2Spatial", p, True)
def createNewDataBaseBasicPronviciasMunicipios():
database_file = gvsig.getTempFile("/home/osc/temp/h2/catas",".mv.db")
print "** DATABASE FILE_: ", database_file
# Create store
manager = DALLocator.getDataManager()
serverParameters = manager.createServerExplorerParameters("H2Spatial")
serverParameters.setDynValue("database_file",database_file)
serverExplorer = manager.openServerExplorer("H2Spatial",serverParameters)
p = serverExplorer.getAddParameters()
p.setDynValue("Table","Provincias")
ft = manager.createFeatureType()
ft.add("CODIGO", DataTypes.STRING)
ft.add("PROVINCIA", DataTypes.STRING)
p.setDefaultFeatureType(ft)
serverExplorer.add("H2Spatial", p, True)
p = serverExplorer.getAddParameters()
p.setDynValue("Table","Municipios")
ft = manager.createFeatureType()
ft.add("CODPROV", DataTypes.STRING)
ft.add("PROV", DataTypes.STRING)
ft.add("CODMUN", DataTypes.STRING)
ft.add("MUN", DataTypes.STRING)
ft.add("ID", DataTypes.STRING)
p.setDefaultFeatureType(ft)
serverExplorer.add("H2Spatial", p, True)
# Open Store
storeParameters = manager.createStoreParameters("H2Spatial")
storeParameters.setDynValue("database_file",database_file)
storeParameters.setDynValue("Table","Provincias")
store = manager.openStore("H2Spatial",storeParameters)
store.edit()
for p in data.getProvincias():
value = p[1] #.encode('utf-8')
store.append({ "CODIGO":p[0], "PROVINCIA":value})
store.commit()
#for i in store.getFeatureSet():
# print i.get('PROVINCIA=')#.encode("utf-8")
storeParameters = manager.createStoreParameters("H2Spatial")
storeParameters.setDynValue("Table","Municipios")
storeParameters.setDynValue("database_file",database_file)
store = manager.openStore("H2Spatial",storeParameters)
store.edit()
csvFilePath = gvsig.getResource(__file__,"data","dataMunicipalities.csv")
if not os.path.exists(csvFilePath):
print "not found"
return None
with open(csvFilePath, 'rb') as csvfile:
spamreader = csv.reader(csvfile, delimiter=',') #, quotechar='|')
for row in spamreader:
d = {}
d["CODPROV"]=row[0].decode('utf-8')
d["PROV"]=row[1].decode('utf-8')
d["CODMUN"]=row[2].decode('utf-8')
d["MUN"]=row[3].decode('utf-8')
d["ID"]=row[4].decode('utf-8')
store.append(d)
store.commit()
for n,f in enumerate(store):
print f
if n==100:
break
#Create layer
return
application = ApplicationLocator.getManager()
mapcontextmanager = application.getMapContextManager()
layer = mapcontextmanager.createLayer("Layer H2",store)
def processAlgorithm(self):
i18nManager = ToolsLocator.getI18nManager()
params = self.getParameters()
table = params.getParameterValueAsTable(
"inputTable") #gvsig.currentTable()
field = params.getParameterValueAsInt(
"tableField") #str(commonsdialog.inputbox("Name of the field"))
limitNumberOfKeys = 10
store = None
try:
#import pdb
#pdb.set_trace()
features = table.getBaseDataObject().getFeatureStore(
).getFeatureSet()
except:
commonsdialog.msgbox("Table not opened")
return False
count = dict()
size = features.getSize()
self.setRangeOfValues(0, size)
#self.getStatus().setTitle("Processing..")
self.setProgressText(i18nManager.getTranslation("_Counting_features"))
n = 0
numberOfKeys = 0
changedToDB = False
for f in features:
n += 1
ff = str(f.get(field))
if ff in count.keys():
count[ff] += 1
else:
count[ff] = 1
numberOfKeys += 1
# Check if is necessary change to a disk db for keys
if changedToDB is False and numberOfKeys > limitNumberOfKeys:
changedToDB = True
store, temp = createDiskDataBase()
for k in count.keys():
temp[k] = count[k]
count = temp
store.commit()
# Save db each 50000 values
if n % 50000 == 0 and changedToDB is True:
store.commit()
# Each 100000 values make a commit if db is being used
if self.isCanceled() is True:
return False
else:
self.next()
if changedToDB is True and store != None:
store.commit()
sch = gvsig.createFeatureType()
sch.append('ID', 'STRING', 15)
sch.append('COUNT', 'INTEGER', 20)
dbf = gvsig.createDBF(sch, gvsig.getTempFile("count", ".dbf"))
dbf.edit()
for k, v in count.iteritems():
f = dbf.createNewFeature()
f.set('ID', k)
f.set('COUNT', v)
dbf.insert(f)
dbf.commit()
if changedToDB is True and store != None:
store.close()
d = gvsig.loadDBF(dbf.getFullName())
d.setName(i18nManager.getTranslation("_Count_Duplicates_Table"))
return True
def createDiskDataBase():
dbFile = gvsig.getTempFile("db", ".maps")
store = MVStore.Builder().fileName(dbFile).open()
d = store.openMap("db1")
return store, d