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