def updateFormat(): dataManager = DALLocator.getDataManager() ws = dataManager.getDatabaseWorkspace("ARENA2_DB") server = ws.getServerExplorer() accidentesParameters = server.get("ARENA2_ACCIDENTES") dataManager = DALLocator.getDataManager() store = dataManager.openStore(accidentesParameters.getProviderName(), accidentesParameters) ft = store.getDefaultFeatureType() eft = None #store.getDefaultFeatureType().getEditable() if not store.isEditing(): store.edit() if eft == None: eft = store.getDefaultFeatureType().getEditable() e = eft.getEditableAttributeDescriptor("HORA_ACCIDENTE") e.setDefaultFormat("%tR") e = eft.getEditableAttributeDescriptor("KM") e.setDefaultFormat("%.3f") if eft != None: store.update(eft) print eft.getAttributeDescriptor("HORA_ACCIDENTE").getDefaultFormat() print eft.getAttributeDescriptor("KM").getDefaultFormat() print "store editing:", store.isEditing() if store.isEditing(): store.finishEditing() print "finish" DisposeUtils.dispose(store) return
def updateft(): dataManager = DALLocator.getDataManager() ws = dataManager.getDatabaseWorkspace("ARENA2_DB") server = ws.getServerExplorer() accidentesParameters = server.get("ARENA2_ACCIDENTES") dataManager = DALLocator.getDataManager() store = dataManager.openStore(accidentesParameters.getProviderName(), accidentesParameters) ft = store.getDefaultFeatureType() eft = None #store.getDefaultFeatureType().getEditable() if ft.get("OPERACION") == None: if not store.isEditing(): store.edit() if eft == None: eft = store.getDefaultFeatureType().getEditable() add_attribute_OPERACION(eft) if ft.get("ESTADO_ACCIDENTE") == None: if not store.isEditing(): store.edit() if eft == None: eft = store.getDefaultFeatureType().getEditable() add_attribute_ESTADO_ACCIDENTE(eft) if eft != None: store.update(eft) if store.isEditing(): store.finishEditing() DisposeUtils.dispose(store) return
def updatePriority(): dataManager = DALLocator.getDataManager() ws = dataManager.getDatabaseWorkspace("ARENA2_DB") server = ws.getServerExplorer() accidentesParameters = server.get("ARENA2_ACCIDENTES") dataManager = DALLocator.getDataManager() store = dataManager.openStore(accidentesParameters.getProviderName(), accidentesParameters) ft = store.getDefaultFeatureType() eft = None #store.getDefaultFeatureType().getEditable() if not store.isEditing(): store.edit() if eft == None: eft = store.getDefaultFeatureType().getEditable() #tags = attr.getTags() #tags.set(u'report.attr.label', u"FOREING_VALUE('ESTADO_ACCIDENTE.DESCRIPCION')") e = eft.getEditableAttributeDescriptor("HORA_ACCIDENTE") tags = e.getTags() tags.set(u'dal.search.attribute.priority', 1) if eft != None: store.update(eft) print eft.getAttributeDescriptor("HORA_ACCIDENTE").getDefaultFormat() print eft.getAttributeDescriptor("KM").getDefaultFormat() print "store editing:", store.isEditing() if store.isEditing(): store.finishEditing() print "finish" DisposeUtils.dispose(store) return
def main(*args): # Test pq con original phrase no funciona store = gvsig.currentLayer().getFeatureStore() dm = DALLocator.getDataManager() filterExpression = ExpressionEvaluatorLocator.getManager().createExpression() filterExpression.setPhrase("") spatialGeometry = geom.createGeometryFromWKT("POLYGON ((-74.26662451007567 40.497289998, -74.26662451007567 40.517289997999995, -74.24930400199999 40.527289998, -74.2319834939243 40.517289997999995, -74.2319834939243 40.497289998, -74.24930400199999 40.487289997999994, -74.26662451007567 40.497289998))") spatialGeometry.setProjection(gvsig.currentLayer().getProjection()) ## store, exp, spatialGeometry print "Spatial" builder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder() """ expr1 = builder.and( builder.custom(exp.getPhrase()), builder.ST_Intersects( builder.geometry(spatialGeometry), builder.column("GEOMETRY") ) ).toString() """ expr1 = builder.ST_Intersects( builder.geometry(spatialGeometry), builder.column("GEOMETRY") ).toString() ## Creating new expression eva = ExpressionEvaluatorLocator.getManager().createExpression() eva.setPhrase(expr1) evaluator = DALLocator.getDataManager().createExpresion(eva) # Query fq = store.createFeatureQuery() fq.addFilter(evaluator) fq.retrievesAllAttributes() fset = store.getFeatureSet(fq) print "SIZE: ",fset.getSize() ### Reusing expression cloneExpression = filterExpression.clone() print "not cloning" cloneExpression.setPhrase(expr1) evaluator = DALLocator.getDataManager().createExpresion(cloneExpression) ## Query fq = store.createFeatureQuery() fq.addFilter(evaluator) fq.retrievesAllAttributes() fset = store.getFeatureSet(fq) print "SIZE: ",fset.getSize()
def initComponents(self): i18n = ToolsLocator.getI18nManager() toolsSwingManager = ToolsSwingLocator.getToolsSwingManager() dataManager = DALLocator.getDataManager() dataSwingManager = DALSwingLocator.getSwingManager() taskManager = ToolsSwingLocator.getTaskStatusSwingManager() expSwingManager = ExpressionEvaluatorSwingLocator.getManager() self.btnVerAccidente.setText("") self.btnExportIssues.setText("") self.filter = expSwingManager.createExpressionPickerController( self.txtFilter, self.btnFilter, self.btnFilterHistory, self.btnFilterBookmarks) self.taskStatusController = taskManager.createTaskStatusController( self.lblTaskTitle, self.lblTaskMessage, self.pgbTaskProgress) self.setVisibleTaskStatus(False) self.tblIssues.setModel(self.report.getTableModel()) self.report.setCellEditors(self.tblIssues) dataSwingManager.setStoreAction(self.btnVerAccidente, "ShowForm", True, ShowFormFromIssueActionContext(self)) dataSwingManager.setStoreAction(self.btnExportIssues, "Export", True, ExportFromIssueActionContext(self)) self.lblIssuesMessage.setText("") self.tblIssues.getSelectionModel().addListSelectionListener( self.issuesSelectionChanged) self.tblIssues.setAutoCreateRowSorter(True) self.btnModifyIssues.setEnabled(False) self.btnVerAccidente.setEnabled(False) self.btnExportIssues.setEnabled(False) self.setPreferredSize(800, 500)
def loadRasterLayer (rasterfile, mode = "r" ): ## Load a Raster file in a Layer sourceFileName[0]=rasterfile if not isinstance (rasterfile,File): rasterfile = File(rasterfile) name, ext = splitext(rasterfile.getName()) view = currentView() # Get the manager to use dalManager = DALLocator.getDataManager() mapContextManager = MapContextLocator.getMapContextManager() if ext.lower() == ".ecw" or ext.lower() == ".jp2" : # FIXME pass elif ext.lower() == ".mrsid": # FIXME pass else: # Create the parameters to open the raster store based in GDAL params = dalManager.createStoreParameters("Gdal Store") params.setFile(rasterfile) # Create the raster store dataStore = dalManager.createStore(params) # Create a raster layer based in this raster store layer = mapContextManager.createLayer(name, dataStore); view.addLayer(layer) return layer
def selectDuplicates(store, attrName): mvstore = None tempFile = None status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus( "SelectDuplicates") status.add() status.setAutoremove(True) try: dataManager = DALLocator.getDataManager() dup = dataManager.createLargeMap() dup.clear() selection = store.createFeatureSelection() status.setRangeOfValues(0, store.getFeatureCount()) n = 0 for f in store: status.setCurValue(n) value = f.get(attrName) if dup.has_key(value): selection.select(f) else: dup[value] = True n += 1 store.setSelection(selection) finally: status.terminate()
def importData(issues_pathname, slot, slotsize, workspaceName): status = LoggerTaskStatus("ImportArena2Files") issues_pathname = issues_pathname % slot fnames, slots = calculateSlots(folderData, slotsize, slot, status) status.logger("import slot %d/%d" % (slot, slots)) if not connectToWorkspace(workspaceName, status): return importManager = getArena2ImportManager() report = Report(importManager) report.setEnabledEvents(False) dataManager = DALLocator.getDataManager() workspace = dataManager.getDatabaseWorkspace("ARENA2_DB") if workspace==None: status.logger("Can't access to workspace ARENA2_DB", gvsig.LOGGER_WARN) return issues = dataManager.openStore("CSV","File", issues_pathname) report.addIssues(issues.getFeatureSet()) if len(report) != issues.getFeatureCount(): status.logger("Can't load issues in report", gvsig.LOGGER_WARN) return p = ImportProcess(importManager, fnames, workspace, report, status) p.run()
def _updateAllUI(self): # Input params dependant of layer swm = DALSwingLocator.getSwingManager() ## Field with image data ft1 = self.store.getDefaultFeatureType() self.pickerFieldsImageData.setFeatureType(ft1) # Output params ## Use absolute path from ield self.pickerFieldsPath.setFeatureType(ft1) ## Export to folder using name self.pickerFieldsName.setFeatureType(ft1) ## Expression for absolute path self.pickerExpStore.setFeatureStore(self.store) ### Preview expression ## Sample feature sampleFeature = None try: sampleFeature = store.getFeatureSelection().first() if sampleFeature == None: sampleFeature = store.first() except: logger("Not able to create Sample Feature for FieldCalculatorTool", LOGGER_WARN) if sampleFeature!=None: dataManager = DALLocator.getDataManager() featureSymbolTable = dataManager.createFeatureSymbolTable() featureSymbolTable.setFeature(sampleFeature) self.pickerExp.setPreviewSymbolTable(featureSymbolTable.createParent())
def createTableAndFill(workspace, tableName): # Create table #self.status.message("Creando "+tableName) #self.status.incrementCurrentValue() server = workspace.getServerExplorer() fname = getResource(__file__, "data", tableName + ".csv") if fname == None: return parameters = getOpenStoreParametersOfDictionaryByPath(fname) addparams = server.getAddParameters(tableName) ft = addparams.getDefaultFeatureType() dataManager = DALLocator.getDataManager() store = dataManager.openStore(parameters.getProviderName(), parameters) ft.copyFrom(store.getDefaultFeatureType()) store.dispose() server.add(tableName, addparams, False) # Fill table #self.status.message("Importando "+tableName) #self.status.incrementCurrentValue() params_src = getOpenStoreParametersOfDictionaryByPath(fname) params_dst = server.get(tableName) store_src = dataManager.openStore(params_src.getProviderName(), params_src) store_dst = dataManager.openStore(params_dst.getProviderName(), params_dst) store_src.copyTo(store_dst) store_src.dispose() store_dst.dispose()
def validateData(folderData, issues_pathname, slot, slotsize, workspaceName): status = LoggerTaskStatus("ValidateArena2Files") issues_pathname = issues_pathname % slot fnames, slots = calculateSlots(folderData, slotsize, slot, status) status.logger("validate slot %d/%d" % (slot, slots)) if not connectToWorkspace(workspaceName, status): return importManager = getArena2ImportManager() report = MyReport(importManager) report.setEnabledEvents(False) dataManager = DALLocator.getDataManager() workspace = dataManager.getDatabaseWorkspace("ARENA2_DB") if workspace == None: status.logger("Can't access to workspace ARENA2_DB", gvsig.LOGGER_WARN) p = ValidatorProcess(importManager, fnames, report, workspace, status) p.run() if os.path.exists(issues_pathname): status.logger("removing file %r" % issues_pathname) os.unlink(issues_pathname) explorer = dataManager.openServerExplorer("FilesystemExplorer") store = report.getStore() status.logger("export issues to %r" % issues_pathname) store.export(explorer, "CSV", explorer.getAddParameters(File(issues_pathname)))
def test3(): from org.gvsig.fmap.dal import DALLocator dataManager = DALLocator.getDataManager() factory = Arena2ReaderFactory() folder = '/home/jjdelcerro/arena2/quincenas' fnames = list() for root, dirs, files in os.walk(folder, followlinks=True): for name in files: pathname = os.path.join(root, name) if pathname.lower().endswith(".xml"): if factory.accept(File(pathname)): gvsig.logger("found file: %r" % pathname) fnames.append(pathname) else: gvsig.logger("skip file: %r" % pathname, gvsig.LOGGER_WARN) fnames.sort() #fnames = ( '/home/jjdelcerro/arena2/quincenas/Valencia/TV_46_2018_01_Q1/victimas.xml', ) maxfiles = len(fnames) maxfiles = min(10,len(fnames)) for n in range(0,maxfiles): fname = fnames[n] gvsig.logger("Process: %d/%d %r" % (n, maxfiles, fname)) if not factory.accept(File(fname)): gvsig.logger("File not supported ", gvsig.LOGGER_WARN) continue store = dataManager.openStore("ARENA2", "file", fname, "CRS", "EPSG:25830") for feature in store: pass store.close() store = None
def createReader(self, params): f = params.getFile() dataManager = DALLocator.getDataManager() repo = BaseStoresRepository("ARENA2_"+f.getName()) for name in getDictionaryNames(): parameters = getOpenStoreParametersOfDictionary(name) repo.add(name,parameters) reader = Arena2Reader(self, params, repo) return reader
def main(*args): manager = DALLocator.getDataManager() 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) print storeH2, dir(storeH2)
def crearTabla_estaciones(connection): tableName = "AFOROS_ESTACIONES" dataManager = DALLocator.getDataManager() server = dataManager.openServerExplorer(connection.getProviderName(), connection) params = server.getAddParameters(tableName) ft = params.getDefaultFeatureType() configurar_featuretype_estaciones(ft) server.add(tableName, params, False)
def crearTabla_ARENA2_PASAJEROS(connection): tableName = "ARENA2_PASAJEROS" dataManager = DALLocator.getDataManager() server = dataManager.openServerExplorer(connection.getProviderName(), connection) params = server.getAddParameters(tableName) ft = params.getDefaultFeatureType() configurar_featuretype_ARENA2_PASAJEROS(ft) server.add(tableName, params, False)
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 updateDGT(): dataManager = DALLocator.getDataManager() ws = dataManager.getDatabaseWorkspace("ARENA2_DB") server = ws.getServerExplorer() accidentesParameters = server.get("ARENA2_ACCIDENTES") dataManager = DALLocator.getDataManager() store = dataManager.openStore(accidentesParameters.getProviderName(), accidentesParameters) ft = store.getDefaultFeatureType() eft = None #store.getDefaultFeatureType().getEditable() myfuncs = [[add_attribute_TOTAL_VICTIMAS_DGT, "TOTAL_VICTIMAS_DGT"], [add_attribute_TOTAL_MUERTOS_DGT, "TOTAL_MUERTOS_DGT"], [add_attribute_TOTAL_GRAVES_DGT, "TOTAL_GRAVES_DGT"], [add_attribute_TOTAL_LEVES_DGT, "TOTAL_LEVES_DGT"], [add_attribute_TOTAL_ILESOS_DGT, "TOTAL_ILESOS_DGT"], [add_attribute_TOTAL_VEHICULOS_DGT, "TOTAL_VEHICULOS_DGT"], [add_attribute_TOTAL_CONDUCTORES_DGT, "TOTAL_CONDUCTORES_DGT"], [add_attribute_TOTAL_PASAJEROS_DGT, "TOTAL_PASAJEROS_DGT"], [add_attribute_TOTAL_PEATONES_DGT, "TOTAL_PEATONES_DGT"], [add_attribute_NUM_TURISMOS_DGT, "NUM_TURISMOS_DGT"], [add_attribute_NUM_FURGONETAS_DGT, "NUM_FURGONETAS_DGT"], [add_attribute_NUM_CAMIONES_DGT, "NUM_CAMIONES_DGT"], [add_attribute_NUM_AUTOBUSES_DGT, "NUM_AUTOBUSES_DGT"], [add_attribute_NUM_CICLOMOTORES_DGT, "NUM_CICLOMOTORES_DGT"], [add_attribute_NUM_MOTOCICLETAS_DGT, "NUM_MOTOCICLETAS_DGT"], [add_attribute_NUM_BICICLETAS_DGT, "NUM_BICICLETAS_DGT"], [add_attribute_NUM_OTROS_VEHI_DGT, "NUM_OTROS_VEHI_DGT"]] for addattr in myfuncs: if ft.get(addattr[1]) == None: if not store.isEditing(): store.edit() if eft == None: eft = store.getDefaultFeatureType().getEditable() addattr[0](eft) if eft != None: store.update(eft) if store.isEditing(): store.finishEditing() DisposeUtils.dispose(store) return
def testFormat(): dataManager = DALLocator.getDataManager() ws = dataManager.getDatabaseWorkspace("ARENA2_DB") server = ws.getServerExplorer() accidentesParameters = server.get("ARENA2_ACCIDENTES") dataManager = DALLocator.getDataManager() store = dataManager.openStore(accidentesParameters.getProviderName(), accidentesParameters) ft = store.getDefaultFeatureType() ehora = ft.getAttributeDescriptor("HORA_ACCIDENTE") ekm = ft.getAttributeDescriptor("KM") from java.sql import Timestamp from java.util import Date ts = Timestamp(Date().getTime()) print ehora.format(ts) print ekm.format(10.282999895) from java.lang import String print String.format("%.3f", 10.39283) print String.format("%tR", Timestamp(Date().getTime()))
def updateCalculatedField(self, columnSelectedDescriptor, store, exp): i18nManager = ToolsLocator.getI18nManager() try: self.taskStatus.setRangeOfValues(0, 1) self.taskStatus.setCurValue(0) self.taskStatus.add() #Process newComputed = DALLocator.getDataManager( ).createFeatureAttributeEmulatorExpression( store.getDefaultFeatureType(), exp) #Check if required field is himself for req in newComputed.getRequiredFieldNames(): if req == columnSelectedDescriptor.getName(): mss = i18nManager.getTranslation( "_A_computed_field_can_not_have_itself_as_required_field_in_the_expression" ) self.taskStatus.message(mss) logger(mss, LOGGER_WARN) raise Throwable(mss) newFeatureType = gvsig.createFeatureType( store.getDefaultFeatureType()) #DefaultEditableFeatureAttributeDescriptor efd = newFeatureType.getEditableAttributeDescriptor( columnSelectedDescriptor.getName()) efd.setFeatureAttributeEmulator(newComputed) try: store.edit() store.update(newFeatureType) store.commit() self.taskStatus.incrementCurrentValue() self.taskStatus.message( i18nManager.getTranslation("_Computed_field_updated")) except: #store.cancelEditing() self.taskStatus.message( i18nManager.getTranslation( "_Computed_field_calculation_has_some_errors")) logger( "Not able change Emulatore Expression Attribute in Feature Type", LOGGER_ERROR) except: pass finally: if self.editingMode: try: store.edit() except: logger("Not able to put store into editing mode", LOGGER_ERROR)
def addAccidentsLayer(self): dataManager = DALLocator.getDataManager() workspace = dataManager.getDatabaseWorkspace("ARENA2_DB") if workspace == None: msgbox("Debera conectarse al espacio de trabajo de ARENA2_DB") return repo = workspace.getStoresRepository() store = repo.getStore("ARENA2_ACCIDENTES") layer = MapContextLocator.getMapContextManager().createLayer( "Accidentes", store) gvsig.currentView().getMainWindow().getMapControl().addLayer(layer)
def reload(self): #store = getCarreterasManager().getStretchFeatureStore() dataManager = DALLocator.getDataManager() pool = dataManager.getDataServerExplorerPool() explorerParams = pool.get("carreteras_gva").getExplorerParameters() explorerParams.setSchema("layers") explorer = dataManager.openServerExplorer( explorerParams.getProviderName(), explorerParams) params = explorer.get("tramos_carreteras") store = dataManager.openStore(params.getProviderName(), params) self.setValue(store)
def create_DAL_ARENA2_AC_VE_CO_PA_PE_CR(): from tablas.ARENA2_AC_VE_CO_PA_PE_CR import configurar_featuretype_ARENA2_AC_VE_CO_PA_PE_CR tableName = "ARENA2_AC_VE_CO_PA_PE_CR" dataManager = DALLocator.getDataManager() ft = dataManager.createFeatureType() configurar_featuretype_ARENA2_AC_VE_CO_PA_PE_CR(ft) dalfile = DALFile.getDALFile() dalfile.setFeatureType(ft) pathname = getResource(__file__, "../Arena2Reader/datos/recursos/", tableName + ".dal") dalfile.write(File(pathname))
def getProvinciasFeatureSet(): manager = DALLocator.getDataManager() storeParameters = manager.createStoreParameters("H2Spatial") database_file = gvsig.getResource(__file__,"data","catastroInfo.mv.db") storeParameters.setDynValue("database_file",database_file) storeParameters.setDynValue("Table","Provincias") store = manager.openStore("H2Spatial",storeParameters) print "*** GETTING FEATURE SET""" featureSet = store.getFeatureSet() print "*** YE FEATURE SET" return featureSet, store
def openStore(self, fname): dataManager = DALLocator.getDataManager() try: fname_tail = os.path.sep.join(fname.split(os.path.sep)[-3:]) self.status.message("Cargando accidentes...(%s)" % fname_tail) store = dataManager.openStore("ARENA2", "file", fname, "CRS", "EPSG:25830") return store except java.lang.Throwable, ex: logger("Error cargando accidentes.", LOGGER_WARN, ex) self.status.message("Error Cargando accidentes (%s)" % fname) return None
def getOpenStoreParametersOfDictionaryByPath(fname): dataManager = DALLocator.getDataManager() #fname = getResource(__file__,"datos", "tablas",name+".csv") parameters = dataManager.createStoreParameters("CSV") parameters.setDynValue("profile", "STANDARD_PREFERENCE") parameters.setDynValue("quotePolicy", "AlwaysQuoteMode") parameters.setDynValue("delimiter", ";") parameters.setDynValue("commentStartMarker", "#") parameters.setDynValue("automaticTypesDetection", False) parameters.setDynValue("firstLineHeader", True) parameters.setFile(File(fname)) return parameters
def showAccidentsSearch(self): dataSwingManager = DALSwingLocator.getSwingManager() dataManager = DALLocator.getDataManager() winManager = ToolsSwingLocator.getWindowManager() workspace = dataManager.getDatabaseWorkspace("ARENA2_DB") if workspace == None: msgbox("Debera conectarse al espacio de trabajo de ARENA2_DB") return repo = workspace.getStoresRepository() store = repo.getStore("ARENA2_ACCIDENTES") panel = dataSwingManager.createFeatureStoreSearchPanel(store) winManager.showWindow(panel.asJComponent(), "Busqueda de accidentes", WindowManager.MODE.WINDOW)
def addArena2Workspace(): dataManager = DALLocator.getDataManager() pool = dataManager.getDataServerExplorerPool() for entry in pool: if isinstance(entry.getExplorerParameters(), JDBCServerExplorerParameters): if entry.getName() == "ARENA2_DB": workspace = dataManager.createDatabaseWorkspaceManager( entry.getExplorerParameters()) if workspace.isValidStoresRepository(): dataManager.addDatabaseWorkspace(workspace) break
def saveBuffer(self,filename): manager = DALLocator.getDataManager () eparams = manager.createServerExplorerParameters(FilesystemServerExplorer.NAME) eparams.setDynValue("initialpath",os.path.dirname(sourceFileName[0])) serverExplorer = manager.openServerExplorer(eparams.getExplorerName(),eparams) sparams = serverExplorer.getAddParameters("Gdal Store") sparams.setDestination(os.path.dirname(sourceFileName[0]),filename) sparams.setBuffer(self.buffer) #at = AffineTransform(1, 0, 0, -1, 0, 0) #sparams.setAffineTransform(at); serverExplorer.add("Gdal Store", sparams, True)
def getMunicipiosFeatureSet(provincia): manager = DALLocator.getDataManager() storeParameters = manager.createStoreParameters("H2Spatial") database_file = gvsig.getResource(__file__,"data","catastroInfo.mv.db") storeParameters.setDynValue("database_file",database_file) storeParameters.setDynValue("Table","Municipios") store = manager.openStore("H2Spatial",storeParameters) #try: # query = u"""CODPROV='{0}'""".format(provincia) # featureSet = store.getFeatureSet(query) #except: featureSet = store.getFeatureSet() return featureSet, store
def __init__(self, importManager): self.__dataManager = DALLocator.getDataManager() self.__importManager = importManager self.__ftype = None self.__columnNames = list() self.__issues_list = None #self.__issues = self.createMemoryStore() self.__issues = self.createH2Store() for attr in self.__ftype: if not attr.isHidden(): self.__columnNames.append(attr.getName()) self.__timer = None self.__delayed_events = 0 self.__eventsEnableds = True
def main2(*args): store = gvsig.currentLayer().getFeatureStore() dm = DALLocator.getDataManager() i="True" evaluator = dm.createExpresion(i) fq = store.createFeatureQuery() fq.addFilter(evaluator) fq.retrievesAllAttributes() fset = store.getFeatureSet(fq) count = 0 for f in fset: count+=1 print count ### print "Spatial" spatialGeometry = geom.createGeometryFromWKT("POLYGON ((-74.26662451007567 40.497289998, -74.26662451007567 40.517289997999995, -74.24930400199999 40.527289998, -74.2319834939243 40.517289997999995, -74.2319834939243 40.497289998, -74.24930400199999 40.487289997999994, -74.26662451007567 40.497289998))") spatialGeometry.setProjection(gvsig.currentLayer().getProjection()) builder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder() expr1 = builder.and( builder.custom(i), builder.ST_Intersects( builder.geometry(spatialGeometry), builder.column("GEOMETRY") ) ).toString() eva = ExpressionEvaluatorLocator.getManager().createExpression() eva.setPhrase(expr1) evaluator = DALLocator.getDataManager().createExpresion(eva) fq = store.createFeatureQuery() fq.addFilter(evaluator) fq.retrievesAllAttributes() fset = store.getFeatureSet(fq) count = 0 for f in fset: count+=1 print count
def loadStore (self,rasterfile, mode = "r" ): if not isinstance(rasterfile,File): rasterfile = File(rasterfile) name, ext = splitext(rasterfile.getName()) dalManager = DALLocator.getDataManager() if ext.lower() == ".ecw" or ext.lower() == ".jp2" : # FIXME pass elif ext.lower() == ".mrsid": # FIXME pass else: # Create the parameters to open the raster store based in GDAL params = dalManager.createStoreParameters("Gdal Store") params.setFile(rasterfile) # Create the raster store dataStore = dalManager.createStore(params) return dataStore