def geocodificar(fecha, carretera, pk): if fecha == None or carretera == None or pk == None: return (None, None, "Fecha%s, carretera%s o pk%s nulo" % ( iif(fecha==None, "*",""), iif(carretera==None, "*",""), iif(pk==None, "*","") ) ) strechesStore = getStretchFeatureStore() query = getVigentStretchesQuery(strechesStore, fecha) builder = ExpressionUtils.createExpressionBuilder() expression = builder.eq(builder.variable("matricula"), builder.constant(carretera)).toString() #expression = "matricula = '%s'" % carretera try: query.addFilter(expression) query.retrievesAllAttributes() streches = strechesStore.getFeatureSet(query).iterable() if streches.isEmpty(): return (None, None, "Carretera '%s' no encontrada" % carretera) pk = pk * 1000 for strech in streches: location = getLRSManager().getMPointFromGeometry(strech.getDefaultGeometry(), pk) if location != None: # LRS devuelve un Point2DM y falla al guardarse en la BBDD (H2 por lo menos) location = GeometryUtils.createPoint(location.getX(), location.getY()) return (location, strech, None) return (None, None, "kilometro %s no encontrado en '%s'." % (pk,carretera)) finally: DisposeUtils.disposeQuietly(streches)
def geocodificar(fecha, carretera, pk): if fecha == None or carretera == None or pk == None: return (None, "Fecha, carretera o pk nulo") strechesStore = getStretchFeatureStore() query = getVigentStretchesQuery(strechesStore, fecha) expression = "matricula = '%s'" % carretera try: query.addFilter(expression) query.retrievesAllAttributes() streches = strechesStore.getFeatureSet(query) if len(streches) < 1: return (None, "Carretera '%s' no encontrada" % carretera) for strech in streches: location = getLRSManager().getMPointFromGeometry( strech.getDefaultGeometry(), pk) if location != None: # LRS devuelve un Point2DM y falla al guardarse en la BBDD (H2 por lo menos) location = GeometryUtils.createPoint(location.getX(), location.getY()) return (location, None) return (None, "kilometro %s no encontrado en '%s'." % (pk, carretera)) finally: DisposeUtils.disposeQuietly(streches)
def calcularArea(currentView, currentLayer): area = 0 if currentView != None: if currentLayer != None: features = currentLayer.features() # Entidades message = "" if features != None: try: polygonsLayer = currentLayer polygonFeatures = polygonsLayer.features() for polygonFeature in polygonFeatures: area += polygonFeature.geometry().area() area = area * 10000 # area *10000 para obtener el area en kilometros cuadrados except: ex = sys.exc_info()[1] # Captura de excepciones message = ex.__class__.__name__ + " - " + str(ex) finally: DisposeUtils.disposeQuietly( features) # Liberacion de recursos if message != "": title = "Error" messageType = commonsdialog.FORBIDEN root = None commonsdialog.msgbox(message, title, messageType, root) else: message = "En la vista actual no hay seleccionada ninguna capa, debe seleccionar una capa." title = "Error: se debe seleccionar una capa" messageType = commonsdialog.FORBIDEN root = None commonsdialog.msgbox(message, title, messageType, root) else: message = "No se encuentra ninguna vista para comenzar a trabajar" title = "Error: sin vista" messageType = commonsdialog.FORBIDEN root = None commonsdialog.msgbox(message, title, messageType, root) return area
def calcularArea(currentView, currentLayer): # Ejemplo de inputbox message = "Ingrese el valor del " + unichr( 225) + "rea de referencia en km2" title = "Ingreso de datos" messageType = commonsdialog.QUESTION root = None currentProject = gvsig.currentProject() # Proyecto actual # Vista actual print "Vista actual:", currentView # Capas print "Capas de la vista actual:" if currentView != None: currentViewLayers = currentView.getLayers() for currentViewLayer in currentViewLayers: print " ", currentViewLayer # Capa actual print "Sumatory of all of the areas in the polygon layer: ", currentLayer valorReferencia = float( commonsdialog.inputbox(message, title, messageType, root)) print "valor Referencia: ", valorReferencia area = 0 if currentView != None: if currentLayer != None: polygonsLayer = currentLayer # Creamos esquema con el tipo de geometria correspondiente schema = polygonsLayer.getSchema() newSchema = createSchema(schema) # Creamos la capa nueva con el nuevo esquema newPolygonsLayer = createShape(newSchema) newPolygonsLayer.edit() features = currentLayer.features() # Entidades message = "" if features != None: try: polygonFeatures = polygonsLayer.features() contador = 0 for polygonFeature in polygonFeatures: area += polygonFeature.geometry().area() #print("area: ",area) polygon = dict() for field in schema: #print "prueba: "+str(field.getDataTypeName()) if str(field.getDataTypeName()) != "Double": polygon[field.getName()] = polygonFeature.get( field.getName()) else: polygon[field.getName()] = long( polygonFeature.get(field.getName())) tempArea = polygonFeature.geometry().area() * 1000 if tempArea > valorReferencia: newPolygonsLayer.append(polygon) contador = contador + 1 #newfeature = self.createNewFeature(output_store, polygonFeature) #newfeature["GEOMETRY"] = polygon #output_store.insert(newfeature) area = area * 10000 # area *10000 para obtener el area en kilometros cuadrados #self.addOutputText("OutputText", "Area: ") #self.addOutputNumericalValue("OutputNumerical", "area") newPolygonsLayer.commit() newPolygonsLayer.setName("Capa de poligonos mayores") currentView.addLayer(newPolygonsLayer) except: ex = sys.exc_info()[1] # Captura de excepciones message = ex.__class__.__name__ + " - " + str(ex) finally: DisposeUtils.disposeQuietly( features) # Liberacion de recursos if message != "": title = "Error" messageType = commonsdialog.FORBIDEN root = None commonsdialog.msgbox(message, title, messageType, root) else: mensajeCartel( "En la vista actual no hay seleccionada ninguna capa, debe seleccionar una capa.", "Error: se debe seleccionar una capa", commonsdialog.FORBIDEN) else: mensajeCartel("No se encuentra ninguna vista para comenzar a trabajar", "Error: sin vista", commonsdialog.FORBIDEN) return area
def run(self): try: self.__count = 0 count_files = 0 title = self.status.getTitle() repo = self.workspace.getStoresRepository() accidentesStore = repo.getStore("ARENA2_ACCIDENTES") if self.expressionFilter != None and not self.expressionFilter.isEmpty(): fsetAccidentes = accidentesStore.getFeatureStore().getFeatureSet(self.expressionFilter) else: fsetAccidentes = accidentesStore.getFeatureStore().getFeatureSet() ### SET FILTER count = fsetAccidentes.getSize() n = 0 self.status.message("Comprobando accidentes (%s)..." % "Accidentes") self.status.setRangeOfValues(0,count) self.status.setCurValue(0) for feature in fsetAccidentes: n+=1 self.status.setTitle("%s (%d/%d)" % (title, n, count)) rules = self.rules # Regla para Accidentes for rule in rules: if rule != None: #print "Feature: ", feature.get("ID_ACCIDENTE"), "Rule:", rule.getName(), "\n" rule.execute(self.report, feature) self.__count += 1 self.status.incrementCurrentValue() # Regla por las tablas principales mainTables = {"ARENA2_CONDUCTORES", "ARENA2_PASAJEROS", "ARENA2_PEATONES", "ARENA2_VEHICULOS"} idAccidente = feature.get("ID_ACCIDENTE") for mainTable in mainTables: storeToValidate = repo.getStore(mainTable) #print "storeToValidate:", storeToValidate fset = storeToValidate.getFeatureSet("ID_ACCIDENTE='%s'" % idAccidente) #print "check child table: ", fset.getSize(), " over ", idAccidente if fset!=None and fset.getSize()>0: for feature in fset: for rule in rules: if rule != None: rule.execute(self.report, feature) DisposeUtils.disposeQuietly(fset) DisposeUtils.dispose(storeToValidate) storeToValidate = None self.status.message("Comprobacion completada") DisposeUtils.disposeQuietly(fsetAccidentes) self.status.terminate() for action in self.__actions: action(self) except java.lang.Throwable, ex: logger("Error validando accidentes.", LOGGER_WARN, ex) self.status.message("Error validando accidentes (%s)" % "Accidentes") self.status.abort() raise ex
def processExportImage(featureSet, field, formatName, outparams, taskStatus=None): if not formatName in ["PNG", "JPEG", "GIF"]: logger("Not valid format for export images", LOGGER_ERROR) return sm = ToolsSwingLocator.getToolsSwingManager() si = sm.createSimpleImage() if taskStatus != None: taskStatus.setRangeOfValues(0, featureSet.getSize()) if isinstance(field, FeatureAttributeDescriptor): field = field.getName() try: ooption = outparams["option"] oparams = outparams["params"] n = 0 if ooption == 1: for f in featureSet: if taskStatus != None: n += 1 taskStatus.setCurValue(n) if taskStatus.isCancellationRequested(): return value = f.get(field) if value == None or value == "": continue si.set(value) im = si.getBufferedImage() if im == None: logger( "Not able to get Bufferded Image from field " + str(field) + " value:" + str(value), LOGGER_ERROR) continue # Save image ofield = oparams["field"] if isinstance(ofield, FeatureAttributeDescriptor): ofield = ofield.getName() output = f.get(ofield) ImageIO.write(im, formatName, output) elif ooption == 2: for f in featureSet: if taskStatus != None: n += 1 taskStatus.setCurValue(n) if taskStatus.isCancellationRequested(): return value = f.get(field) if value == None or value == "": continue si.set(value) im = si.getBufferedImage() if im == None: logger( "Not able to get Bufferded Image from field " + str(field) + " value:" + str(value), LOGGER_ERROR) continue ofield = oparams["field"] if isinstance(ofield, FeatureAttributeDescriptor): ofield = ofield.getName() oname = f.get(ofield) if oname == None or oname == "": continue outputPath = oparams["path"].getAbsolutePath() output = getUniqueValueFileByField(oname, outputPath, formatName) ImageIO.write(im, formatName, output) elif ooption == 3: s = ExpressionEvaluatorLocator.getManager().createSymbolTable() fst = DALLocator.getDataManager().createFeatureSymbolTable() s.addSymbolTable(fst) exp = oparams["expression"] if exp.isEmpty(): logger("Expression is empty", LOGGER_ERROR) return for f in featureSet: if taskStatus != None: n += 1 taskStatus.setCurValue(n) if taskStatus.isCancellationRequested(): return value = f.get(field) if value == None or value == "": continue si.set(value) im = si.getBufferedImage() fst.setFeature(f) output = exp.execute(s) outputex = output + "." + formatName.lower() if os.path.exists(outputex): logger("Already exists: " + outputex, LOGGER_ERROR) continue ImageIO.write(im, formatName, File(outputex)) except: ex = str(sys.exc_info()[1]) logger( "Not able to export: " + ex + " caused on: " + ex.__class__.__name__, LOGGER_ERROR) try: DisposeUtils.disposeQuietly(featureSet) except: logger("Not able dispose export images feature set", LOGGER_ERROR)
def processImportFields(tableTarget, fieldTarget, tableSource, fieldSource, data, translator, taskStatus=None): ### Init processimportfields" # Update ft #translator = NamesTranslator.createTrimTranslator(11) storeTarget = tableTarget.getFeatureStore() storeSource = tableSource.getFeatureStore() ftTarget = storeTarget.getDefaultFeatureType() ftSource = storeSource.getDefaultFeatureType() #Names translator init #for attr in ftTarget: # translator.addSource(attr.getName()) # if storeTarget == storeSource: logger("Can't use same store for import tables", LOGGER_ERROR) return # Checks ## Ningun del nombre de los campos nuevos usados existe ya en la tabla previa for d in data: used = ftTarget.getAttributeDescriptor(d['idname']) if used != None: logger("Field " + d['idname'] + " already created in table", LOGGER_ERROR) return # Process newftTarget = gvsig.createFeatureType(ftTarget) newftSource = gvsig.createFeatureType(ftSource) for d in data: name = d["idfield"] descriptor = newftSource.getEditableAttributeDescriptor(name) newname = d["idname"] descriptor.setName(newname) newftTarget.addLike(descriptor) try: storeTarget.edit() storeTarget.update(newftTarget) storeTarget.commit() except: logger("Not able to update feature type", LOGGER_ERROR) return # Update values storeTarget.edit() fsetSource = tableSource.getFeatureStore().getFeatureSet() if taskStatus != None: taskStatus.setRangeOfValues(0, fsetSource.getSize()) taskStatus.setCurValue(0) taskStatus.add() for fSource in fsetSource: if taskStatus != None and taskStatus.isCancellationRequested(): break if taskStatus != None: taskStatus.incrementCurrentValue() # QUERY builder = storeTarget.createExpressionBuilder() ## Eq expression expFilter = builder.eq(builder.column(fieldTarget), builder.constant( fSource.get(fieldSource))).toString() exp = ExpressionEvaluatorLocator.getManager().createExpression() exp.setPhrase(expFilter) evaluator = DALLocator.getDataManager().createExpresion(exp) #filterValue = str(field2)+"="+str(fTarget.get(fieldTarget)) fqTarget = storeTarget.createFeatureQuery() fqTarget.setFilter(evaluator) #for d in data: #need al attributos to get editable valid # if not ftSource.getAttributeDescriptor(d["idfield"]).isReadOnly(): # fq1.addAttributeName(d["idname"]) #defaultGeometry = ftTarget.getDefaultGeometryAttributeName() #fqTarget.addAttributeName(defaultGeometry) fqTarget.retrievesAllAttributes() # UPDATE VALUES fsetTarget = storeTarget.getFeatureSet(fqTarget) for ftTarget in fsetTarget: efTarget = ftTarget.getEditable() for d in data: if newftTarget.getAttributeDescriptor( d["idname"]).isReadOnly(): #logger("Field is read only", LOGGER_WARN) continue value = fSource.get(d["idfield"]) efTarget.set(d["idname"], value) fsetTarget.update(efTarget) if storeTarget.canCommitChanges( ) and storeTarget.getPendingChangesCount() > 100000: storeTarget.commitChanges() storeTarget.commit() try: pass except: ex = sys.exc_info()[1] logger("Not able to update features value: " + str(ex), LOGGER_ERROR) try: DisposeUtils.disposeQuietly(fsetTarget) DisposeUtils.disposeQuietly(fsetSource) store1.cancelEditing() except: logger("Not able to cancel editing", LOGGER_ERROR) finally: DisposeUtils.disposeQuietly(fsetTarget) DisposeUtils.disposeQuietly(fsetSource)
def updateRealField(self, columnSelectedDescriptor, store, exp, expFilter, useFilterType, dialog, prefs): i18nManager = ToolsLocator.getI18nManager() try: ftype = store.getDefaultFeatureType() s = ExpressionEvaluatorLocator.getManager().createSymbolTable() fst = DALLocator.getDataManager().createFeatureSymbolTable() s.addSymbolTable(fst) store.edit() #store.beginComplexNotification() #beginEditingGroup("field-calculator-update") # Create fset if useFilterType == 0: fset = store.getSelection() if store.getSelection().getSize() == 0: logger("Selection is empty", LOGGER_WARN) self.taskStatus.message( i18nManager.getTranslation("_Selection_is_empty")) return elif useFilterType == 1: if expFilter != None and not expFilter.isPhraseEmpty( ) and not expFilter.isEmpty(): fq = store.createFeatureQuery() fq.addFilter(expFilter) fq.retrievesAllAttributes() fset = store.getFeatureSet(fq) else: fset = store.getFeatureSet() else: fset = store.getFeatureSet() # set taskstatus self.taskStatus.setRangeOfValues(0, fset.getSize()) self.taskStatus.setCurValue(0) self.taskStatus.add() # Limit of changes before commit limit = prefs["limit_rows_in_memory"] # Update features for f in fset: if self.taskStatus.isCancellationRequested(): break fst.setFeature(f) v = exp.execute(s) # value de la expression c = f.getEditable() c.set(columnSelectedDescriptor.getName(), v) fset.update(c) #if commitingMode: if limit != -1 and self.store.getPendingChangesCount() > limit: fset.commitChanges() #self.taskStatus.setCurValue(count) self.taskStatus.incrementCurrentValue() except: ex = sys.exc_info()[1] #ex.__class__.__name__, str(ex) logger("Exception updated features: " + str(ex), LOGGER_ERROR) finally: #store.endEditingGroup() try: DisposeUtils.disposeQuietly(fset) except: logger("Not able to dispone fset", LOGGER_ERROR) if self.modeExitTool: try: store.finishEditing() except: logger("Not able to save store changes", LOGGER_ERROR) try: store.cancelEditing() except: logger("Not able to cancel editing", LOGGER_ERROR) if self.editingMode: try: store.edit() except: logger("Not able to put store into editing mode", LOGGER_ERROR) else: logger("Field Calculator Tool expression applied", LOGGER_INFO) if self.editingMode == False: try: store.finishEditing() except: logger("Not able to puto layer into editing again", LOGGER_ERROR)
def run(self): fname = "???" try: self.__count = 0 count_files = 0 title = self.status.getTitle() for fname in self.files: self.status.setTitle("%s (%d/%d)" % (title, count_files, len(self.files))) count_files += 1 fname_tail = os.path.sep.join(fname.split(os.path.sep)[-3:]) self.input_store = self.openStore(fname) # TODO #Si el featureType tiene tags de errores de valores no encontrados # tags = self.input_store.getDefaultFeatureType().getTags() if tags.get("notSupportedKeys") != None: print "Tags new found: ", tags # if self.input_store == None: self.status.abort() return count = self.input_store.getFeatureCount() self.status.setRangeOfValues(0, count) self.status.setCurValue(0) rules = self.rules self.status.message("Comprobando accidentes (%s)..." % fname_tail) input_features = self.input_store.iterator() for feature in input_features: for rule in rules: if rule != None: rule.execute(self.report, feature) self.__count += 1 self.status.incrementCurrentValue() DisposeUtils.disposeQuietly(input_features) children = self.input_store.getChildren() count = 0 for name in children.keySet(): childStore = children.get(name) if childStore == None: continue fset = childStore.iterator() for feature in fset: for rule in rules: if rule != None: rule.execute(self.report, feature) DisposeUtils.disposeQuietly(fset) DisposeUtils.dispose(childStore) self.input_store.dispose() self.input_store = None self.status.message("Comprobacion completada") self.status.terminate() for action in self.__actions: action(self) except java.lang.Throwable, ex: logger("Error validando accidentes.", LOGGER_WARN, ex) self.status.message("Error validando accidentes (%s)" % fname) self.status.abort() raise ex