def intersects(self, line1, theDataSet2): result= [False, []] if theDataSet2.getSpatialIndex() != None: for featureReference in theDataSet2.query(line1): feature2 = featureReference.getFeature() line2 = feature2.getDefaultGeometry() if line1.intersects(line2): result[0] = True result[1].append(feature2) else: if self.expression == None: self.expression = ExpressionEvaluatorLocator.getManager().createExpression() self.expressionBuilder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder() # self.expressionBuilder = GeometryExpressionEvaluatorLocator.getManager().createExpressionBuilder() store2 = theDataSet2.getFeatureStore() self.geomName = store2.getDefaultFeatureType().getDefaultGeometryAttributeName() self.expression.setPhrase( self.expressionBuilder.ifnull( self.expressionBuilder.column(self.geomName), self.expressionBuilder.constant(False), self.expressionBuilder.ST_Intersection( self.expressionBuilder.geometry(line1), self.expressionBuilder.column(self.geomName) ) ).toString() ) features2 = theDataSet2.findAll(self.expression) for feature2 in features2: result[0] = True result[1].append(feature2) return result
def intersects(self, buffer1, theDataSet2): result = [False, []] if theDataSet2.getSpatialIndex() != None: for featureReference in theDataSet2.query(buffer1): feature2 = featureReference.getFeature() line2 = feature2.getDefaultGeometry().toLines() # Boundary if line2.intersects(buffer1): result[0] = True break else: if self.expression == None: self.expression = ExpressionEvaluatorLocator.getManager().createExpression() self.expressionBuilder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder() # self.expressionBuilder = GeometryExpressionEvaluatorLocator.getManager().createExpressionBuilder() store2 = theDataSet2.getFeatureStore() self.geomName = store2.getDefaultFeatureType().getDefaultGeometryAttributeName() self.expression.setPhrase( self.expressionBuilder.ifnull( self.expressionBuilder.column(self.geomName), self.expressionBuilder.constant(False), self.expressionBuilder.ST_Intersects( self.expressionBuilder.ST_ExteriorRing( self.expressionBuilder.geometry(buffer1) ), self.expressionBuilder.column(self.geomName) ) ).toString() ) if theDataSet2.findFirst(self.expression) != None: result[0] = True return result
def setDynmicSymbologyLabeling(self, store): mcm = MapContextLocator.getMapContextManager() vl = mcm.createLegend(DynamicVectorLegend.NAME) expression = ExpressionEvaluatorLocator.getManager().createExpression() expression.setPhrase("COUTLINE") vl.setOutlineColor(expression.clone()) expression.setPhrase("CFILL") vl.setFillColor(expression.clone()) expression.setPhrase("CSIZE") vl.setSize(expression.clone()) expression.setPhrase("CROTATION") vl.setRotation(expression.clone()) self.layer.setLegend(vl) # Set dynamic labeling sm = SymbologyLocator.getSymbologyManager() dynamicLabeling = sm.createLabelingStrategy(DynamicLabelingStrategy.NAME) expression = ExpressionEvaluatorLocator.getManager().createExpression() expression.setPhrase("LROTATION") dynamicLabeling.setRotation(expression.clone()) expression.setPhrase("LTEXT") dynamicLabeling.setText(expression.clone()) expression.setPhrase("LHEIGHT") dynamicLabeling.setHeight(expression.clone()) expression.setPhrase("LCOLOR") dynamicLabeling.setColor(expression.clone()) expression.setPhrase("LFONT") dynamicLabeling.setFont(expression.clone()) expression.setPhrase("LFONTS") dynamicLabeling.setFontStyle(expression.clone()) expression.setPhrase("LUNIT") dynamicLabeling.setUnit(expression.clone()) expression.setPhrase("LREF") dynamicLabeling.setReferenceSystem(expression.clone()) self.layer.setLabelingStrategy(dynamicLabeling) self.layer.setIsLabeled(True)
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 contains(self, polygon1, theDataSet2): result = False if theDataSet2.getSpatialIndex() != None: for featureReference in theDataSet2.query(polygon1): feature2 = featureReference.getFeature() point2 = feature2.getDefaultGeometry() if polygon1.contains(point2): result = True break else: if self.expression == None: manager = ExpressionEvaluatorLocator.getManager() self.expression = manager.createExpression() self.expressionBuilder = manager.createExpressionBuilder() store2 = theDataSet2.getFeatureStore() self.geomName = store2.getDefaultFeatureType( ).getDefaultGeometryAttributeName() self.expression.setPhrase( self.expressionBuilder.ifnull( self.expressionBuilder.column(self.geomName), self.expressionBuilder.constant(False), self.expressionBuilder.ST_Contains( self.expressionBuilder.geometry(polygon1), self.expressionBuilder.column( self.geomName))).toString()) if theDataSet2.findFirst(self.expression) != None: result = True return result
def main1(*args): from org.gvsig.expressionevaluator import ExpressionEvaluatorLocator manager = ExpressionEvaluatorLocator.getManager() symbolTable = manager.createSymbolTable() symbolTable.addVar("A", 2) expression = "[A]" code = manager.compile(expression) out = manager.evaluate(symbolTable, code) print out, type(out)
def __init__(self, plan, factory, tolerance, dataSet1, dataSet2): AbstractTopologyRule.__init__(self, plan, factory, tolerance, dataSet1, dataSet2) self.addAction(DeletePointAction()) self.expression = ExpressionEvaluatorLocator.getManager( ).createExpression() self.expressionBuilder = GeometryExpressionEvaluatorLocator.getManager( ).createExpressionBuilder() self.geomName = None
def main3(*args): from org.gvsig.expressionevaluator import ExpressionEvaluatorLocator manager = ExpressionEvaluatorLocator.getManager() expression = "COS(0)" evaluator = manager.createEvaluator(expression) print evaluator.getSymbolTable() symbolTable = manager.createSymbolTable() symbolTable.addVar("A", 2) symbolTable.addVar("B", 3) evaluator.setSymbolTable(symbolTable) print evaluator.compile()
def main4(*args): from org.gvsig.expressionevaluator import ExpressionEvaluatorLocator manager = ExpressionEvaluatorLocator.getManager() symbols = manager.createSymbolTable() interpreter = manager.createInterpreter() symbols.setSymbolTable(interpreter.getSymbolTable()) interpreter.setSymbolTable(symbols) expression = "n*sin(90)" code = manager.compile(expression) symbols.addVar("n",5) out = interpreter.run(code) print out
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 main(*args): fset = gvsig.currentLayer().getFeatureStore().getFeatureSet() field = "resblob" formatName = "PNG" #https://docs.oracle.com/javase/tutorial/2d/images/saveimage.html ft = gvsig.currentLayer().getFeatureStore().getDefaultFeatureType( ).getAttributeDescriptor("id") outparams = { "option": 2, "params": { "path": File("/home/osc/Working/exportimages/"), "field": ft } } exp = ExpressionEvaluatorLocator.getManager().createExpression() exp.setPhrase("CONCAT('/home/osc/Working/exportimages/', id)") outparams = {"option": 3, "params": {"expression": exp}} processExportImage(fset, field, formatName, outparams)
def put(self, fctParameters): #Put fieldCalculatorToolParameter on his elements expressionEvaluatorManager = ExpressionEvaluatorLocator.getExpressionEvaluatorManager( ) self.pickerField.set(fctParameters.getName()) self.updateEnableApplyButton() #construir expresion a partir de String fctParameters.getExp() newExpression = expressionEvaluatorManager.createExpression() newExpression.setPhrase(fctParameters.getExp()) self.expBuilder.setExpression(newExpression) self.cmbTypeFilter.setSelectedIndex( fctParameters.getComboFilterResults()) newExpFilter = expressionEvaluatorManager.createExpression() newExpFilter.setPhrase(fctParameters.getFilterResults()) self.expFilter.set(newExpFilter) self.expFilterStore = DALSwingLocator.getSwingManager( ).createFeatureStoreElement(self.store) self.expFilter.addElement(self.expFilterStore)
def getFeatureSetForGeoprocess(store, filterExpression, spatialGeometry=None, geomFieldName="GEOMETRY"): if filterExpression==None: #.getPhrase()=="": #org.gvsig.expressionevaluator.Expression if store.getSelection().getSize()==0: builder = GeometryExpressionEvaluatorLocator.getGeometryExpressionEvaluatorManager().createExpressionBuilder() expr1 = builder.ST_Intersects( builder.geometry(spatialGeometry), builder.column(geomFieldName) ).toString() #cloneExpression = filterExpression.clone() cloneExpression = ExpressionEvaluatorLocator.getManager().createExpression() cloneExpression.setPhrase(expr1) evaluator = DALLocator.getDataManager().createFilter(cloneExpression) """ exp = ExpressionEvaluatorLocator.getManager().createExpression() exp.setPhrase(expr1) evaluator = DALLocator.getDataManager().createExpresion(exp) """ fq = store.createFeatureQuery() fq.addFilter(cloneExpression) #fq.retrievesAllAttributes() #fq.addAttributeName("Id") featuresLayer = store.getFeatureSet(fq) return featuresLayer else: featuresLayer = store.getSelection() return featuresLayer else: builder = GeometryExpressionEvaluatorLocator.getGeometryExpressionEvaluatorManager().createExpressionBuilder() expr2 = builder.and( builder.custom(filterExpression.getPhrase()), builder.ST_Intersects( builder.geometry(spatialGeometry), builder.column("GEOMETRY") ) ).toString() cloneExpression = filterExpression.clone() cloneExpression.setPhrase(expr2) fq = store.createFeatureQuery() fq.addFilter(cloneExpression) #fq.retrievesAllAttributes() featuresLayer = store.getFeatureSet(fq) return featuresLayer
def getFilter(self): if (self.checkModify()==False): return None tipoAccidente = self.tipoAccidente.getSelectedItem().getValue() dateDesde = self.pickerFechaDesde.get() dateHasta = self.pickerFechaHasta.get() expManager= ExpressionEvaluatorLocator.getManager() exp = expManager.createExpression() builder = expManager.createExpressionBuilder() if (tipoAccidente!=""): builder.and(builder.eq( builder.variable("TIPO_ACC_COLISION"), builder.constant(tipoAccidente) ) ) if (dateDesde!=None and dateHasta != None): builder.and( builder.and( builder.ge( builder.variable("FECHA_ACCIDENTE"), builder.date(dateDesde) ), builder.le( builder.variable("FECHA_ACCIDENTE"), builder.date(dateHasta) #builder.function(FUNCTION_DATE,dateFormat.format(dateHasta), dateFormat) ) ) ) elif (dateDesde!=None): builder.and(builder.ge( builder.variable("FECHA_ACCIDENTE"), builder.date(dateDesde) )) elif (dateHasta!=None): builder.and(builder.le( builder.variable("FECHA_ACCIDENTE"), builder.date(dateHasta) )) return builder.value()
def main1(*args): from org.gvsig.expressionevaluator import ExpressionEvaluatorLocator manager = ExpressionEvaluatorLocator.getManager() interpreter = manager.createInterpreter() #print interpreter symbolTable = manager.createSymbolTable() symbolTable.addVar("A", 2) symbolTable.addVar("B", 3) expression = "COS(0)" code = manager.compile(expression) symbol = interpreter.getSymbolTable() symbol = MyTable() interpreter.setSymbolTable(symbol) out = interpreter.run(code) print out
def main(*args): proportionX = 1 proportionY = 1 nameFieldHour = "CDATE" nameFieldDay = "CMPLNT_FR_" nameFieldHour = "CMPLNT_FR_" dm = DALLocator.getDataManager() evaluator = dm.createExpresion("") exp = ExpressionEvaluatorLocator.getManager().createExpression() exp.setPhrase('') print evaluator expression = exp xi = 0 yi = 0 store = gvsig.currentLayer().getFeatureStore() aoristicClockGrid(store, proportionX, proportionY, nameFieldHour, nameFieldDay, expression, 0, 0)
def createExpression(self): expManager= ExpressionEvaluatorLocator.getManager() exp = expManager.createExpression() builder = expManager.createExpressionBuilder() # Accidente codAccidente = self.txtCodAccidente.getText() #Codigo if (codAccidente!=""): builder.set( builder.like( builder.variable("ID_ACCIDENTE"), builder.constant(codAccidente) ) ) # Carretera carreteraValue = self.tabControllerCarretera.getFilter() if (carreteraValue!=None): builder.and(carreteraValue) # Fecha y tipo fechaValue = self.tabControllerFecha.getFilter() if (fechaValue!=None): builder.and(fechaValue) # Victimas victimasValue = self.tabControllerVictimas.getFilter() if (victimasValue!=None): builder.and(victimasValue) # Acumulada accumulatedFilter = self.simplifiedPanel.getAccumulatedFilter() if(accumulatedFilter!=None): builder.and(builder.toValue(accumulatedFilter)) try: exp.setPhrase(builder.toString()) except: exp.setPhrase("") return exp
def intersects(self, buffer1, theDataSet2): result = False if theDataSet2.getSpatialIndex() != None: for featureReference in theDataSet2.query(buffer1): feature2 = featureReference.getFeature() line2 = feature2.getDefaultGeometry() numVertices = line2.getNumVertices() if buffer1.intersects(line2.getVertex(0)) or buffer1.intersects(line2.getVertex(numVertices - 1)): result = True break else: if self.expression == None: manager = ExpressionEvaluatorLocator.getManager() self.expression = manager.createExpression() self.expressionBuilder = manager.createExpressionBuilder() store2 = theDataSet2.getFeatureStore() self.geomName = store2.getDefaultFeatureType().getDefaultGeometryAttributeName() self.expression.setPhrase( self.expressionBuilder.ifnull( self.expressionBuilder.column(self.geomName), self.expressionBuilder.constant(False), self.expressionBuilder.or( self.expressionBuilder.ST_Intersects( self.expressionBuilder.function("ST_StartPoint", self.expressionBuilder.column(self.geomName)), self.expressionBuilder.geometry(buffer1, buffer1.getProjection()) ), self.expressionBuilder.ST_Intersects( self.expressionBuilder.function("ST_EndPoint", self.expressionBuilder.column(self.geomName)), self.expressionBuilder.geometry(buffer1, buffer1.getProjection()) ) ) ).toString() ) if theDataSet2.findFirst(self.expression) != None: result = True return result
def getFilter(self): #getFilter if (self.checkModify()==False): return None provincia = self.provincia.getSelectedItem().getValue() titularidad = self.titularidad.getSelectedItem().getValue() carretera = self.carretera.getText() pkInicio = self.pki.getText() pkInicioUmbral = self.pkiu.getText() pkFin = self.pkf.getText() pkFinUmbral = self.pkfu.getText() sentido = self.sentido.getSelectedItem().getValue() expManager= ExpressionEvaluatorLocator.getManager() exp = expManager.createExpression() builder = expManager.createExpressionBuilder() if (provincia!=""): builder.and(builder.eq( builder.variable("COD_PROVINCIA"), builder.constant(provincia) ) ) if (titularidad!=""): builder.and(builder.eq( builder.variable("TITULARIDAD_VIA"), builder.constant(titularidad) ) ) if (carretera!=""): builder.and(builder.eq( builder.variable("CARRETERA"), builder.constant(carretera) ) ) if pkInicio!="": pkInicioTotal = float(pkInicio) if pkInicioUmbral!="": pkInicioTotal += float("0."+pkInicioUmbral) if pkFin!="": pkFinTotal = float(pkFin) if pkFinUmbral!="": pkFinTotal += float("0."+pkFinUmbral) if pkInicio != "" and pkFin != "": builder.and( builder.and( builder.ge( builder.variable("KM"), builder.constant(pkInicioTotal) ), builder.le( builder.variable("KM"), builder.constant(pkFinTotal) ) ) ) elif pkInicio != "": builder.and( builder.ge( builder.variable("KM"), builder.constant(pkInicioTotal) ) ) elif pkFin != "": builder.and( builder.le( builder.variable("KM"), builder.constant(pkFinTotal) ) ) if (sentido!=""): builder.and(builder.eq( builder.variable("SENTIDO"), builder.constant(sentido) ) ) return builder.value()
def process(self, filterType):#btnProcess_click(self, *args): store = self.layer.getFeatureStore() # TODO: if field is empty, return all features filter if filterType=="basicFilter": ft = store.getDefaultFeatureType() builder = store.createExpressionBuilder() field = self.cmbFields.getSelectedItem().getValue() if field==None: return nameField = field.getName() if nameField=="": return if len(self.valuesList.getSelectedValuesList()) == 0: return if len(self.valuesList.getSelectedValuesList()) == 1: value = self.valuesList.getSelectedValuesList()[0] ## Eq expression expFilter = builder.eq( builder.column(nameField), builder.constant(value) ).toString() else: expFilter = "" for value in self.valuesList.getSelectedValuesList(): partialExpFilter = builder.eq( builder.column(nameField), builder.constant(value) ).toString() if expFilter=="": expFilter += partialExpFilter else: expFilter = builder.or( builder.custom(expFilter), builder.custom(partialExpFilter)).toString() #expFilter = expFilter.toString() logger("Filter applied: " + expFilter, LOGGER_INFO) exp = ExpressionEvaluatorLocator.getManager().createExpression() exp.setPhrase(expFilter) evaluator = DALLocator.getDataManager().createExpresion(exp) fq = store.createFeatureQuery() fq.retrievesAllAttributes() fq.setFilter(evaluator) fq.retrievesAllAttributes() # UPDATE VALUES #fset = store.getFeatureSet(fq) fq.addFilter(exp) if isinstance(fq, Evaluator): self.layer.addBaseFilter(fq) else: self.layer.setBaseQuery(fq) elif filterType=="advancedFilter": expression = self.expBuilder.getExpression() fq = store.createFeatureQuery() fq.retrievesAllAttributes() #for field in store.getDefaultFeatureType().getAttrNames(): # fq.addAttributeName(field) fq.setFilter(expression) self.layer.setBaseQuery(fq) else: return #self.view.getWindowOfView() fixMapcontextInvalidate(self.view.getMapContext())
def getFilter(self): if (self.checkModify()==False): return None expManager= ExpressionEvaluatorLocator.getManager() exp = expManager.createExpression() builder = expManager.createExpressionBuilder() categoria = self.categoria.getSelectedItem().getValue() peligrosas = self.peligrosas.isSelected() mortalesOperador = self.mortalesOperador.getSelectedItem().getValue() operator1 = self.operator1.getSelectedItem().getValue() gravesOperador = self.gravesOperador.getSelectedItem().getValue() operator2 = self.operator2.getSelectedItem().getValue() levesOperador = self.levesOperador.getSelectedItem().getValue() mortales = self.mortales.getText() graves = self.graves.getText() leves = self.leves.getText() if (categoria!=""): if (categoria==self.CATEGORIA_CON_VICTIMAS): builder.and(builder.gt( builder.variable("TOTAL_VICTIMAS"), builder.constant(0) ) ) elif (categoria==self.CATEGORIA_CON_DANOS): builder.and(builder.eq( builder.variable("TOTAL_VICTIMAS"), builder.constant(0) ) ) if (peligrosas): dataManager = DALLocator.getDataManager() #EXISTS(SELECT LID_VEHICULO FROM ARENA2_VEHICULOS WHERE ARENA2_ACCIDENTES.ID_ACCIDENTE = ARENA2_VEHICULOS.ID_ACCIDENTE AND MP LIMIT 1) dalbuilder = dataManager.createDALExpressionBuilder() #DALExpressionBuilder peligrosasfilter = dalbuilder.exists(dalbuilder.select() .column("LID_VEHICULO") .from("ARENA2_VEHICULOS") .limit(1) .where( dalbuilder.expression().and( dalbuilder.expression().eq( dalbuilder.expression().getattr("ARENA2_ACCIDENTES","ID_ACCIDENTE"), dalbuilder.expression().getattr("ARENA2_VEHICULOS","ID_ACCIDENTE") ), dalbuilder.expression().column("MP") )).toValue()) builder.and(peligrosasfilter) # TOTAL -> Juntos en allbuilder. como apoyo opbuilder opbuilder = expManager.createExpressionBuilder() allBuilder = expManager.createExpressionBuilder() valueMortales = None if (mortales!=""): valueMortales = opbuilder.binaryOperator( mortalesOperador, opbuilder.variable("TOTAL_MUERTOS"), opbuilder.constant(mortales, DataTypes.INT) ) allBuilder.and(valueMortales) valueGraves = None if (graves!=""): valueGraves = opbuilder.binaryOperator( gravesOperador, opbuilder.variable("TOTAL_GRAVES"), opbuilder.constant(graves, DataTypes.INT) ) if (valueMortales!=""): if (operator1 == ExpressionBuilder.OPERATOR_AND): allBuilder.and(valueGraves) elif (operator1 == ExpressionBuilder.OPERATOR_OR): allBuilder.or(valueGraves) valueLeves = None if (leves!=""): valueLeves = opbuilder.binaryOperator( levesOperador, opbuilder.variable("TOTAL_LEVES"), opbuilder.constant(leves, DataTypes.INT) ) if (valueMortales!="" or valueGraves!=""): if (operator2 == ExpressionBuilder.OPERATOR_AND): allBuilder.and(valueLeves) elif (operator2 == ExpressionBuilder.OPERATOR_OR): allBuilder.or(valueLeves) allValue = allBuilder.value() if (allValue!=None): # Unimos TOTAL_ con builder builder.and(allValue) return builder.value()
def check(self, taskStatus, report, feature1): #SimpleTaskStatus taskStatus, #TopologyReport report, #Feature feature1 try: logger("tak", LOGGER_INFO) if (self.expression == None): manager = ExpressionEvaluatorLocator.getManager() self.expression = manager.createExpression() self.expressionBuilder = manager.createExpressionBuilder() self.geomName = feature1.getType( ).getDefaultGeometryAttributeName() polygon = feature1.getDefaultGeometry() if (polygon == None): return #logger("1", LOGGER_INFO) theDataSet = self.getDataSet1() #logger("2", LOGGER_INFO) if theDataSet.getSpatialIndex() != None: #logger("if", LOGGER_INFO) for reference in theDataSet.query(polygon): #FeatureReference reference # Misma feature #logger("ref"+str(reference), LOGGER_INFO) if (reference.equals(feature1.getReference())): continue feature = reference.getFeature() otherPolygon = feature.getDefaultGeometry() if (otherPolygon != None and polygon.overlaps(otherPolygon)): error = polygon.intersection(otherPolygon) report.addLine(self, theDataSet, None, polygon, error, feature1.getReference(), None, False, "The polygon overlay with others.") break else: logger("else", LOGGER_INFO) self.expression.setPhrase( self.expressionBuilder.ifnull( self.expressionBuilder.column(self.geomName), self.expressionBuilder.constant(False), self.expressionBuilder.ST_Overlaps( self.expressionBuilder.column(self.geomName), self.expressionBuilder.geometry( polygon))).toString()) feature = theDataSet.findFirst(self.expression) if feature != None: otherPolygon = feature.getDefaultGeometry() error = None if otherPolygon != None: error = polygon.difference(otherPolygon) report.addLine(self, theDataSet, None, polygon, error, feature1.getReference(), None, False, "The polygon overlay with others.") logger("end", LOGGER_INFO) except: # Exception as ex: #logger("2 Can't check feature."+str(ex), LOGGER_WARN) ex = sys.exc_info()[1] logger("Can't execute rule. Class Name:" + ex.__class__.__name__ + " Except:" + str(ex)) finally: pass
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 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 checkGaps(self, polygon1, theDataSet2, tolerance1): result = [False, []] if theDataSet2.getSpatialIndex() != None: if not self.hasGaps: self.findGaps(polygon1, theDataSet2, tolerance1) if self.hasGaps: result[0] = True self.hasGaps = False else: if self.expression == None: self.expression = ExpressionEvaluatorLocator.getManager().createExpression() self.expressionBuilder = ExpressionEvaluatorLocator.getManager().createExpressionBuilder() # self.expressionBuilder = GeometryExpressionEvaluatorLocator.getManager().createExpressionBuilder() store2 = theDataSet2.getFeatureStore() self.geomName = store2.getDefaultFeatureType().getDefaultGeometryAttributeName() self.expression.setPhrase( self.expressionBuilder.ifnull( self.expressionBuilder.column(self.geomName), self.expressionBuilder.constant(False), self.expressionBuilder.and( self.expressionBuilder.ST_Intersects( self.expressionBuilder.geometry(polygon1), self.expressionBuilder.ST_Difference( self.expressionBuilder.ST_MakePolygon( self.expressionBuilder.ST_ExteriorRing( self.expressionBuilder.ST_Union( self.expressionBuilder.geometry(polygon1), self.expressionBuilder.column(self.geomName) ) ) ), self.expressionBuilder.ST_Union( self.expressionBuilder.geometry(polygon1), self.expressionBuilder.column(self.geomName) ) ) ), self.expressionBuilder.gt( self.expressionBuilder.ST_Length( self.expressionBuilder.ST_Intersection( self.expressionBuilder.geometry(polygon1), self.expressionBuilder.ST_Difference( self.expressionBuilder.ST_MakePolygon( self.expressionBuilder.ST_ExteriorRing( self.expressionBuilder.ST_Union( self.expressionBuilder.geometry(polygon1), self.expressionBuilder.column(self.geomName) ) ) ), self.expressionBuilder.ST_Union( self.expressionBuilder.geometry(polygon1), self.expressionBuilder.column(self.geomName) ) ) ) ), self.expressionBuilder.constant(0.0) ) ) ).toString() ) if theDataSet2.findFirst(self.expression) != None: result[0] = True return result
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 check(self, taskStatus, report, feature1): #SimpleTaskStatus taskStatus, #TopologyReport report, #Feature feature1 try: print "Starts with: ", feature1.Name logger("si", LOGGER_INFO) if (self.expression == None): manager = ExpressionEvaluatorLocator.getManager() self.expression = manager.createExpression() self.expressionBuilder = manager.createExpressionBuilder() self.geomName = feature1.getType( ).getDefaultGeometryAttributeName() line = feature1.getDefaultGeometry() if line == None: return tolerance = self.getTolerance() numVertexLine = line.getNumVertices() lista = [line.getVertex(0), line.getVertex(numVertexLine - 1)] for vertex in lista: noError = False print "One end of the line ", feature1.get( "Name"), "is: ", vertex if tolerance != 0: vertexTolerance = vertex.buffer(tolerance) else: vertexTolerance = vertex theDataSet = self.getDataSet1() if theDataSet.getSpatialIndex() != None: for reference in theDataSet.query(vertexTolerance): #FeatureReference reference feature = reference.getFeature() otherLine = feature.getDefaultGeometry() print "Analyzing vertex of ", feature1.Name, " with line ", feature.Name if (reference.equals(feature1.getReference())): print "Same entity" print numVertexLine if numVertexLine > 2: endVertex = line.getVertex(0) print type(endVertex) cloneLine = line.cloneGeometry() if lista.index(vertex) == 0: cloneLine.removeVertex(0) if cloneLine.intersects(vertexTolerance): print "Intersects with itself" noError = True else: print "No intersects with itself" else: cloneLine.removeVertex(numVertexLine - 1) if cloneLine.intersects(vertexTolerance): print "Intersects with itself" noError = True else: print "No intersects with itself" if (vertexTolerance.intersects(otherLine) and not line.equals(otherLine)): print "Intersects vertex", feature1.Name, " with line ", feature.Name noError = True break logger("previous report", LOGGER_INFO) if noError == False: error = vertex ver = vertex.convertToWKT() logger("report", LOGGER_INFO) print "The mistake is: ", error report.addLine(self, theDataSet, None, line, error, feature1.getReference(), None, 0, 0, False, "The point is dangling", ver) else: print "Intersects" else: logger("else", LOGGER_INFO) self.expression.setPhrase( self.expressionBuilder.ifnull( self.expressionBuilder.column(self.geomName), self.expressionBuilder.constant(False), self.expressionBuilder.ST_Overlaps( self.expressionBuilder.column(self.geomName), self.expressionBuilder.geometry(line))).toString()) feature = theDataSet.findFirst(self.expression) if feature != None: otherPoint = feature.getDefaultGeometry() error = None if otherPoint != None: error = point.difference(otherPoint) report.addLine(self, theDataSet, None, point, error, feature1.getReference(), None, False, "The point is dangling") logger("end", LOGGER_INFO) except: #logger("2 Can't check feature."+str(ex), LOGGER_WARN) ex = sys.exc_info()[1] logger("Can't execute rule. Class Name:" + ex.__class__.__name__ + " Except:" + str(ex)) finally: pass
def check(self, taskStatus, report, feature1): #SimpleTaskStatus taskStatus, #TopologyReport report, #Feature feature1 try: if (self.expression == None): manager = ExpressionEvaluatorLocator.getManager() self.expression = manager.createExpression() self.expressionBuilder = manager.createExpressionBuilder() self.geomName = feature1.getType().getDefaultGeometryAttributeName() point = feature1.getDefaultGeometry() tolerance = self.getTolerance() pointTolerance = point.buffer(tolerance) if point==None: return if pointTolerance==None: pointTolerance = point theDataSet = self.getDataSet1() if theDataSet.getSpatialIndex() != None: for reference in theDataSet.query(pointTolerance): #FeatureReference reference # Same feature if reference.equals(feature1.getReference()): continue; feature = reference.getFeature() otherPoint = feature.getDefaultGeometry() if otherPoint!=None and not pointTolerance.disjoint(otherPoint): error = point report.addLine(self, theDataSet, None, point, error, feature1.getReference(), None, -1, -1, False, "The point is not disjoint.", "" ) break else: logger("else", LOGGER_INFO) self.expression.setPhrase(self.expressionBuilder.ifnull( self.expressionBuilder.column(self.geomName), self.expressionBuilder.constant(False), self.expressionBuilder.ST_Disjoint( self.expressionBuilder.column(self.geomName), self.expressionBuilder.geometry(pointTolerance) ) ).toString() ) feature = theDataSet.findFirst(self.expression) if feature != None: otherPoint = feature.getDefaultGeometry() error = None if otherPoint != None: error = point report.addLine(self, theDataSet, None, point, error, feature1.getReference(), None, -1, -1, False, "The point is not disjoint." "" ) except: ex = sys.exc_info()[1] logger("Can't execute rule. Class Name:" + ex.__class__.__name__ + " Except:" + str(ex)) finally: pass