|
1 |
# -*- coding: utf-8 -*-
|
|
2 |
#
|
|
3 |
# File: gvpy.py
|
|
4 |
# Version: v0.4
|
|
5 |
#
|
|
6 |
|
|
7 |
__author__ = """Oscar Martinez Olmos <masquesig@gmail.com>"""
|
|
8 |
|
|
9 |
import gvsig
|
|
10 |
import geom
|
|
11 |
import gvsig_raster
|
|
12 |
from org.gvsig.app import ApplicationLocator
|
|
13 |
from org.gvsig.fmap.dal import DALLocator
|
|
14 |
import os.path
|
|
15 |
from org.gvsig.andami import PluginsLocator
|
|
16 |
from org.gvsig.fmap.mapcontext import MapContextLocator
|
|
17 |
import java.awt
|
|
18 |
import java.awt.event
|
|
19 |
import java.awt.geom
|
|
20 |
from java.io import File
|
|
21 |
|
|
22 |
def addDependencyWithPlugin(pluginCode):
|
|
23 |
pluginsManager = PluginsLocator.getManager()
|
|
24 |
scriptingPlugin = pluginsManager.getPlugin("org.gvsig.scripting.app.extension")
|
|
25 |
scriptingPlugin.addDependencyWithPlugin(pluginsManager.getPlugin(pluginCode))
|
|
26 |
|
|
27 |
addDependencyWithPlugin("org.gvsig.geoprocess.app.mainplugin")
|
|
28 |
|
|
29 |
from es.unex.sextante.core import Sextante, OutputFactory, AnalysisExtent
|
|
30 |
from es.unex.sextante.outputs import FileOutputChannel
|
|
31 |
from es.unex.sextante.gui.core import SextanteGUI
|
|
32 |
from es.unex.sextante.dataObjects import IRasterLayer
|
|
33 |
|
|
34 |
from org.gvsig.geoprocess.lib.sextante.dataObjects import FlyrVectIVectorLayer, FLyrRasterIRasterLayer, TableDocumentITable
|
|
35 |
from org.gvsig.fmap.mapcontext.layers import FLayer
|
|
36 |
from java.awt.geom import RectangularShape, Rectangle2D
|
|
37 |
from org.gvsig.fmap.mapcontext.layers.vectorial import FLyrVect
|
|
38 |
from org.gvsig.raster.fmap.layers import DefaultFLyrRaster
|
|
39 |
|
|
40 |
#Constant
|
|
41 |
TYPE_POLYGON = 0
|
|
42 |
TYPE_LINE = 1
|
|
43 |
TYPE_POINT = 2
|
|
44 |
|
|
45 |
#With True will appear a lot of extra info about all steps through the process
|
|
46 |
DEV_INFO = False
|
|
47 |
|
|
48 |
class Geoprocess:
|
|
49 |
def __init__(self):
|
|
50 |
Sextante.initialize()
|
|
51 |
SextanteGUI.initialize()
|
|
52 |
self.__FlyrVectIVectorLayer = None
|
|
53 |
self.__outputFactory = SextanteGUI.getOutputFactory()
|
|
54 |
self.__algorithms = dict()
|
|
55 |
self.__defaultAE = None #default AExtension
|
|
56 |
|
|
57 |
keySetIterator = Sextante.getAlgorithms().keySet().iterator()
|
|
58 |
while(keySetIterator.hasNext()):
|
|
59 |
key = keySetIterator.next()
|
|
60 |
algorithms = Sextante.getAlgorithms().get(str(key))
|
|
61 |
for name in algorithms.keySet():
|
|
62 |
self.__algorithms[str(name)] = algorithms.get(name)
|
|
63 |
|
|
64 |
def __createSextanteLayer(self, layer):
|
|
65 |
""" gvsig layer -> SEXTANTE """
|
|
66 |
slayer = FlyrVectIVectorLayer()
|
|
67 |
slayer.create(layer)
|
|
68 |
return slayer
|
|
69 |
|
|
70 |
def __createSextanteRaster(self, layer):
|
|
71 |
""" gvsig raster -> SEXTANTE """
|
|
72 |
rlayer = FLyrRasterIRasterLayer()
|
|
73 |
rlayer.create(layer)
|
|
74 |
return rlayer
|
|
75 |
|
|
76 |
def __createSextanteTable(self, layer):
|
|
77 |
""" gvsig table -> SEXTANTE """
|
|
78 |
table = TableDocumentITable()
|
|
79 |
table.create(layer)
|
|
80 |
return table
|
|
81 |
|
|
82 |
def getAlgorithms(self):
|
|
83 |
return self.__algorithms
|
|
84 |
|
|
85 |
def __defineParameters_str2value(self, i, param, kwparams):
|
|
86 |
if param.getParameterName() in kwparams:
|
|
87 |
paramValue = kwparams[param.getParameterName()]
|
|
88 |
else:
|
|
89 |
paramValue = kwparams[i]
|
|
90 |
|
|
91 |
#Input params: Tranform STRING to NUMERIC
|
|
92 |
cond1 = (str(param) == "Numerical Value")
|
|
93 |
cond2 = (str(param) == "Selection")
|
|
94 |
isstr = isinstance(paramValue, str)
|
|
95 |
cond4 = (str(param) == "Boolean")
|
|
96 |
cond5 = (str(param) == "Table Field")
|
|
97 |
if "Multi" in (str(param)):
|
|
98 |
cond6 = True
|
|
99 |
else:
|
|
100 |
cond6 = False
|
|
101 |
cond7 = (str(param) == "Point")
|
|
102 |
|
|
103 |
if isstr:
|
|
104 |
if cond1:
|
|
105 |
paramValue = float(paramValue)
|
|
106 |
elif cond2:
|
|
107 |
paramValue = int(paramValue)
|
|
108 |
elif cond4:
|
|
109 |
paramValue = eval(paramValue.capitalize())
|
|
110 |
elif cond5:
|
|
111 |
paramValue = int(paramValue)
|
|
112 |
elif cond6:
|
|
113 |
# <type 'java.util.ArrayList'>
|
|
114 |
paramValue = list(paramValue)
|
|
115 |
elif cond7: #Point
|
|
116 |
paramValue = paramValue.split(',')
|
|
117 |
x = float(paramValue[0])
|
|
118 |
y = float(paramValue[1])
|
|
119 |
paramValue = java.awt.geom.Point2D.Double(x, y)
|
|
120 |
else: #is str
|
|
121 |
pass
|
|
122 |
else:
|
|
123 |
if cond7: #punto de gvsig. agregar condicion punto
|
|
124 |
x = paramValue.getX()
|
|
125 |
y = paramValue.getY()
|
|
126 |
paramValue = java.awt.geom.Point2D.Double(x, y)
|
|
127 |
if DEV_INFO:
|
|
128 |
print "Param Name: ", param.getParameterName()
|
|
129 |
print "Param: ", param
|
|
130 |
print "Resulta: ", paramValue, type(paramValue)
|
|
131 |
return paramValue
|
|
132 |
|
|
133 |
def __defineParameters_vector2sextante(self, param, paramValue):
|
|
134 |
if isinstance(paramValue, str):
|
|
135 |
layer = gvsig.currentView().getLayer(paramValue)
|
|
136 |
paramValue = self.__createSextanteLayer(layer())
|
|
137 |
else:
|
|
138 |
paramValue = self.__createSextanteLayer(paramValue())
|
|
139 |
|
|
140 |
if DEV_INFO: print "extent add+"
|
|
141 |
if self.__defaultAE == None:
|
|
142 |
self.__defaultAE = AnalysisExtent(paramValue)
|
|
143 |
else:
|
|
144 |
self.__defaultAE.addExtent(AnalysisExtent(paramValue))
|
|
145 |
if DEV_INFO: print "PARAM VALUE 1: ", paramValue
|
|
146 |
return paramValue
|
|
147 |
|
|
148 |
def __defineParameters_multi2sextante(self, param, paramValue):
|
|
149 |
if DEV_INFO: print "PARAM VALUE PRE", paramValue
|
|
150 |
paramValue2 = []
|
|
151 |
for i in paramValue:
|
|
152 |
if isinstance(i, str):
|
|
153 |
layer = gvsig.currentView().getLayer(i)
|
|
154 |
i = self.__createSextanteLayer(layer())
|
|
155 |
ii = self.__createSextanteLayer(layer())
|
|
156 |
|
|
157 |
else:
|
|
158 |
if DEV_INFO: print type(i)
|
|
159 |
if isinstance(i, tuple): #si dentro de la lista viene una tupla identificamos que es un raster y su banda
|
|
160 |
from es.unex.sextante.parameters import RasterLayerAndBand
|
|
161 |
rlb = RasterLayerAndBand(self.__createSextanteRaster(i[0]),i[1]) #puesta numero de banda
|
|
162 |
|
|
163 |
ii = self.__createSextanteRaster(i[0])
|
|
164 |
i = rlb
|
|
165 |
if DEV_INFO: print "*************************** RASTERLAYERBAND", rlb
|
|
166 |
|
|
167 |
else:
|
|
168 |
if str(type(i)) == "<type 'org.gvsig.raster.fmap.layers.DefaultFLyrRaster'>":
|
|
169 |
ii = self.__createSextanteRaster(i)
|
|
170 |
i = self.__createSextanteRaster(i)
|
|
171 |
else:
|
|
172 |
ii = self.__createSextanteLayer(i())
|
|
173 |
i = self.__createSextanteLayer(i())
|
|
174 |
|
|
175 |
if DEV_INFO: print "createStextenatnte Layer i :", i
|
|
176 |
paramValue2.append(i)
|
|
177 |
|
|
178 |
if self.__defaultAE == None:
|
|
179 |
try:
|
|
180 |
self.__defaultAE = AnalysisExtent(AnalysisExtent(ii))
|
|
181 |
self.__defaultAE.setCellSize(0.49) ### test
|
|
182 |
self.__defaultAE.setCellSizeZ(0.49) ### test
|
|
183 |
#self.__defaultAE.addExtent( )
|
|
184 |
if DEV_INFO: print "----------- ini defaultAE"
|
|
185 |
except:
|
|
186 |
try:
|
|
187 |
self.__defaultAE = AnalysisExtent(ii())
|
|
188 |
except:
|
|
189 |
self.__defaultAE = AnalysisExtent(ii)
|
|
190 |
elif self.__defaultAE != None:
|
|
191 |
try:
|
|
192 |
ae = self.__defaultAE
|
|
193 |
#ae.addExtent(AnalysisExtent(ii))
|
|
194 |
if DEV_INFO: print "------------ diferente defaultAE"
|
|
195 |
except:
|
|
196 |
|
|
197 |
self.__defaultAE.addExtent(AnalysisExtent(ii()))
|
|
198 |
|
|
199 |
"""
|
|
200 |
if self.__defaultAE == None:
|
|
201 |
try:
|
|
202 |
self.__defaultAE = AnalysisExtent(i)
|
|
203 |
except:
|
|
204 |
print "excepttttttttttttttt", i
|
|
205 |
ae = i.getRasterLayer()
|
|
206 |
self.__defaultAE = AnalysisExtent(ae)
|
|
207 |
else:
|
|
208 |
try:
|
|
209 |
|
|
210 |
self.__defaultAE.addExtent(AnalysisExtent(i))
|
|
211 |
except:
|
|
212 |
print 'exceptttttttttttttt 222222222"', i
|
|
213 |
ae = i.getRasterLayer()
|
|
214 |
print 'ae',ae
|
|
215 |
self.__defaultAE.addExtent(AnalysisExtent(ae))
|
|
216 |
#print self.__defaultAE
|
|
217 |
"""
|
|
218 |
|
|
219 |
paramValue = paramValue2
|
|
220 |
from java.util import ArrayList
|
|
221 |
if DEV_INFO:
|
|
222 |
print "PARAM VALUE 2: ", paramValue
|
|
223 |
print "****************** CONDI6: ", paramValue
|
|
224 |
print "****************** CONDI6: ", ArrayList(paramValue)
|
|
225 |
newParamValue = ArrayList()
|
|
226 |
for i in paramValue:
|
|
227 |
newParamValue.add(i)
|
|
228 |
paramValue = newParamValue
|
|
229 |
#print "***************** CONDI6: ", paramValue
|
|
230 |
#from es.unex.sextante.parameters import ParameterMultipleInput
|
|
231 |
#pmi = ParameterMultipleInput()
|
|
232 |
#pmi.setParameterValue(paramValue)
|
|
233 |
#paramValue = pmi
|
|
234 |
if DEV_INFO: print "#####################################################################"
|
|
235 |
return paramValue
|
|
236 |
|
|
237 |
def __defineParameters_raster2sextante(self, param, paramValue):
|
|
238 |
if isinstance(paramValue, str):
|
|
239 |
layer = gvsig.currentView().getLayer(paramValue)
|
|
240 |
paramValue = self.__createSextanteRaster(layer)
|
|
241 |
else:
|
|
242 |
paramValue = self.__createSextanteRaster(paramValue)
|
|
243 |
|
|
244 |
if DEV_INFO: print "** extent add+"
|
|
245 |
if self.__defaultAE == None:
|
|
246 |
self.__defaultAE = AnalysisExtent(paramValue)
|
|
247 |
else:
|
|
248 |
self.__defaultAE.addExtent(AnalysisExtent(paramValue))
|
|
249 |
return paramValue
|
|
250 |
|
|
251 |
def __defineParameters_table2sextante(self, param, paramValue):
|
|
252 |
if isinstance(paramValue, str):
|
|
253 |
layer = gvsig.currentProject().getTable(paramValue)
|
|
254 |
paramValue = self.__createSextanteTable(layer())
|
|
255 |
else:
|
|
256 |
paramValue = self.__createSextanteTable(paramValue())
|
|
257 |
return paramValue
|
|
258 |
|
|
259 |
def __defineParameters(self, algorithm, kwparams):
|
|
260 |
""" Define input parameters """
|
|
261 |
params = algorithm.getParameters()
|
|
262 |
if DEV_INFO: print self.__defaultAE
|
|
263 |
|
|
264 |
for i in xrange(0,params.getNumberOfParameters()):
|
|
265 |
param = params.getParameter(i)
|
|
266 |
if DEV_INFO: print "****************************************** PARAMETER *******************************************"
|
|
267 |
#print "********************* ", dir(param)
|
|
268 |
#print "********************* ", type(param)
|
|
269 |
#print "********************* ", param.getParameterName()
|
|
270 |
#print "********************* ", param.getParameterDescription()
|
|
271 |
#print "********************* ", param.getParameterTypeName()
|
|
272 |
#print "********************* ", param.getParameterTooltip()
|
|
273 |
#print "********************* ", param.getParameterClass()
|
|
274 |
#print "********************* ", param.getClass()
|
|
275 |
#print "********************* ", param.parameterName
|
|
276 |
#print "********************* ", param.parameterTypeName
|
|
277 |
paramValue = self.__defineParameters_str2value( i, param, kwparams)
|
|
278 |
#print type(paramValue)
|
|
279 |
|
|
280 |
#Vector to SEXTANTE
|
|
281 |
if DEV_INFO: print "PARAMETER TYPE: ",param.getParameterTypeName()
|
|
282 |
if param.getParameterTypeName() == "Vector Layer":
|
|
283 |
paramValue = self.__defineParameters_vector2sextante(param, paramValue)
|
|
284 |
|
|
285 |
# Multiple input: Vector and Raster
|
|
286 |
elif param.getParameterTypeName() == "Multiple Input": #para vectores y raster
|
|
287 |
paramValue = self.__defineParameters_multi2sextante(param, paramValue)
|
|
288 |
#Raster to SEXTANTE
|
|
289 |
elif param.getParameterTypeName() == "Raster Layer":
|
|
290 |
paramValue = self.__defineParameters_raster2sextante(param, paramValue)
|
|
291 |
#Table to SEXTANTE
|
|
292 |
elif param.getParameterTypeName() == "Table":
|
|
293 |
paramValue = self.__defineParameters_table2sextante(param, paramValue)
|
|
294 |
#Set parameter value
|
|
295 |
#print "@@@@@@@@@@@@@@@@@@@@@@@@ cluster error: ", paramValue, type(paramValue)
|
|
296 |
#print "@@@@@@@@@@@@@@@@@@@@@@@@ ", type(param)
|
|
297 |
|
|
298 |
param.setParameterValue(paramValue)
|
|
299 |
#print "@@@@@@@@@@@@@@", dir(param)
|
|
300 |
|
|
301 |
#print "@@@@@@@@@@@@@@", param.isParameterValueCorrect()
|
|
302 |
#print "@@@@@@@@@@@@@@ param:", param
|
|
303 |
#print "@@@@@@@@@@@@@@ ", param.getParameterValueAsArrayList()
|
|
304 |
|
|
305 |
|
|
306 |
def __defineExtent(self, algorithm, kwparams):
|
|
307 |
""" Define Analysis Extent """
|
|
308 |
if self.__defaultAE == None:
|
|
309 |
if DEV_INFO: print "-------- cambiar extent"
|
|
310 |
change=True
|
|
311 |
else:
|
|
312 |
if DEV_INFO: print "-------- no cambiar extent"
|
|
313 |
change = False
|
|
314 |
AExtent = self.__defaultAE
|
|
315 |
changeCell = False
|
|
316 |
if 'EXTENT' in kwparams.keys() and algorithm.getUserCanDefineAnalysisExtent() :
|
|
317 |
changeCell = True
|
|
318 |
frame = kwparams['EXTENT']
|
|
319 |
if isinstance(frame, str): frame = gvsig.currentView().getLayer(frame)
|
|
320 |
#print ("|"+str(frame)+"||"+str(type(frame)))
|
|
321 |
if isinstance(frame, str) or isinstance(frame, gvsig.View):
|
|
322 |
AExtent = AnalysisExtent()
|
|
323 |
if DEV_INFO: print "| EXTENT from VIEW"
|
|
324 |
if isinstance(frame, gvsig.View): view = frame
|
|
325 |
else: view = gvsig.currentProject().getView(frame)
|
|
326 |
envelope = view.getMap().getFullEnvelope()
|
|
327 |
xlow = envelope.getLowerCorner().getX()
|
|
328 |
ylow = envelope.getLowerCorner().getY()
|
|
329 |
xup = envelope.getUpperCorner().getX()
|
|
330 |
yup = envelope.getUpperCorner().getY()
|
|
331 |
AExtent.setXRange(xlow, xup, False)
|
|
332 |
AExtent.setYRange(ylow, yup, False)
|
|
333 |
AExtent.setZRange(0, 0, False)
|
|
334 |
elif isinstance(frame, DefaultFLyrRaster):
|
|
335 |
if DEV_INFO: print "| EXTENT from RASTER"
|
|
336 |
layer = self.__createSextanteRaster(frame)
|
|
337 |
AExtent = AnalysisExtent(layer)
|
|
338 |
changeCell = False
|
|
339 |
#AExtent.setZRange(0, 1, True)
|
|
340 |
if DEV_INFO: print AExtent
|
|
341 |
elif isinstance(frame, list):
|
|
342 |
if DEV_INFO: print "| EXTENT from LIST"
|
|
343 |
AExtent = AnalysisExtent()
|
|
344 |
AExtent.setCellSize(0.49)
|
|
345 |
AExtent.setCellSizeZ(0.49)
|
|
346 |
xlow, ylow, zlow, xup, yup, zup = frame[0], frame[1], frame[2], frame[3], frame[4], frame[5]
|
|
347 |
AExtent.setXRange(xlow, xup, True)
|
|
348 |
AExtent.setYRange(ylow, yup, True)
|
|
349 |
AExtent.setZRange(zlow, zup, True)
|
|
350 |
elif isinstance(frame, gvsig.Layer):
|
|
351 |
if DEV_INFO: print "| EXTENT from Layer"
|
|
352 |
layer = self.__createSextanteLayer(frame())
|
|
353 |
AExtent = AnalysisExtent(layer)
|
|
354 |
else:
|
|
355 |
raise Exception("Not Extent Define")
|
|
356 |
algorithm.setAnalysisExtent(AExtent)
|
|
357 |
|
|
358 |
elif change == True:
|
|
359 |
if DEV_INFO: print ("| Not Extent: No input data")
|
|
360 |
AExtent = AnalysisExtent()
|
|
361 |
changeCell = True
|
|
362 |
if self.__defaultAE != None:
|
|
363 |
if DEV_INFO: print "| Extent from Algorithm Layers"
|
|
364 |
AExtent = self.__defaultAE
|
|
365 |
else:
|
|
366 |
try:
|
|
367 |
if DEV_INFO: print "| Extent from View"
|
|
368 |
envelope = gvsig.currentView().getMap().getFullEnvelope()
|
|
369 |
except:
|
|
370 |
raise Exception("None open View")
|
|
371 |
|
|
372 |
if DEV_INFO: print "| Setting AExtent: ",
|
|
373 |
try: #from view
|
|
374 |
xlow = envelope.getLowerCorner().getX()
|
|
375 |
ylow = envelope.getLowerCorner().getY()
|
|
376 |
zlow = 0
|
|
377 |
xup = envelope.getUpperCorner().getX()
|
|
378 |
yup = envelope.getUpperCorner().getY()
|
|
379 |
zup = 0
|
|
380 |
if DEV_INFO: print "| View: ",
|
|
381 |
if DEV_INFO: print xlow, ylow, xup,yup
|
|
382 |
except: # default
|
|
383 |
xlow, ylow, zlow, xup, yup, zup = 0,0,0,100,100,0
|
|
384 |
if DEV_INFO: print "| Default:", xlow, ylow, xup, yup
|
|
385 |
|
|
386 |
frame = Rectangle2D.Double(xlow, ylow, xup, yup)
|
|
387 |
AExtent.setXRange(xlow, xup, False)
|
|
388 |
AExtent.setYRange(ylow, yup, False)
|
|
389 |
AExtent.setZRange(zlow, zup, False)
|
|
390 |
algorithm.setAnalysisExtent(AExtent)
|
|
391 |
|
|
392 |
#Set: cellsize
|
|
393 |
|
|
394 |
if 'CELLSIZE' in kwparams.keys():
|
|
395 |
AExtent.setCellSize(kwparams['CELLSIZE'])
|
|
396 |
if DEV_INFO: print "| New Cellsize: ", kwparams['CELLSIZE'], AExtent.getCellSize()
|
|
397 |
elif changeCell == True:
|
|
398 |
AExtent.setCellSize(AExtent.getCellSize())
|
|
399 |
if DEV_INFO: print "| Cellsize: ", AExtent.getCellSize()
|
|
400 |
|
|
401 |
if 'CELLSIZEZ' in kwparams.keys():
|
|
402 |
AExtent.setCellSizeZ(kwparams['CELLSIZEZ'])
|
|
403 |
if DEV_INFO: print "| New Cellsize Z: ", kwparams['CELLSIZEZ'], AExtent.getCellSizeZ()
|
|
404 |
elif changeCell == True:
|
|
405 |
AExtent.setCellSize(AExtent.getCellSizeZ())
|
|
406 |
if DEV_INFO: print "| CellsizeZ: ", AExtent.getCellSizeZ()
|
|
407 |
|
|
408 |
if DEV_INFO: print "Å‚Å‚ end extent: ", AExtent
|
|
409 |
#AExtent.setZRange(0.0, 0.0, True)
|
|
410 |
algorithm.setAnalysisExtent(AExtent)
|
|
411 |
if DEV_INFO: print ("| Set Extent")
|
|
412 |
|
|
413 |
def __defineOutput(self, algorithm, kwparams):
|
|
414 |
if 'PATH' in kwparams.keys():
|
|
415 |
path = kwparams['PATH']
|
|
416 |
checkFilesExist(path)
|
|
417 |
outputSet = algorithm.getOutputObjects()
|
|
418 |
if outputSet.getOutputDataObjectsCount() == 1:
|
|
419 |
out1 = outputSet.getOutput(0)
|
|
420 |
out1.setOutputChannel(FileOutputChannel("New_name"))
|
|
421 |
out1channel = out1.getOutputChannel()
|
|
422 |
if isinstance(path, str):
|
|
423 |
out1channel.setFilename(path)
|
|
424 |
elif isinstance(path, list):
|
|
425 |
out1channel.setFilename(path[0])
|
|
426 |
else:
|
|
427 |
raise Exception("No valid path")
|
|
428 |
if DEV_INFO: print "| PATH: Good path"
|
|
429 |
elif outputSet.getOutputDataObjectsCount() > 1 and isinstance(path, list):
|
|
430 |
for n in xrange(0, outputSet.getOutputDataObjectsCount()):
|
|
431 |
out1 = outputSet.getOutput(n)
|
|
432 |
out1.setOutputChannel(FileOutputChannel("New_name"))
|
|
433 |
out1channel = out1.getOutputChannel()
|
|
434 |
out1channel.setFilename(path[n])
|
|
435 |
if DEV_INFO: print "| PATH: Good path"
|
|
436 |
else:
|
|
437 |
raise Exception("Bad path")
|
|
438 |
|
|
439 |
elif algorithm.getOutputObjects().getOutput(0).getOutputChannel():
|
|
440 |
output0 = algorithm.getOutputObjects().getOutput(0)
|
|
441 |
out0 = output0.getOutputChannel()
|
|
442 |
out0.setFilename(None)
|
|
443 |
if DEV_INFO: print "| PATH: Without path"
|
|
444 |
|
|
445 |
def __executeAlgorithm(self, algorithm):
|
|
446 |
"""Execute Algorithm"""
|
|
447 |
#Check algorithm
|
|
448 |
correctValues = algorithm.hasCorrectParameterValues()
|
|
449 |
if DEV_INFO: print "| Parameter values:", correctValues
|
|
450 |
if not correctValues: raise Exception("Not correct values")
|
|
451 |
try:
|
|
452 |
if DEV_INFO: print "| Pre-algorithm:", list(algorithm.algorithmAsCommandLineSentences)
|
|
453 |
except:
|
|
454 |
if DEV_INFO: print "| Not - algorithm"
|
|
455 |
|
|
456 |
algorithm.execute( None, self.__outputFactory)
|
|
457 |
print "| Algorithm:", list(algorithm.algorithmAsCommandLineSentences)
|
|
458 |
|
|
459 |
def __getOutputObjects(self, algorithm):
|
|
460 |
"""Take outputObjets of the algorithm"""
|
|
461 |
oos = algorithm.getOutputObjects()
|
|
462 |
ret = dict()
|
|
463 |
for i in xrange(0,oos.getOutputObjectsCount()):
|
|
464 |
oo = oos.getOutput(i)
|
|
465 |
value = oo.getOutputObject()
|
|
466 |
if isinstance(value, FlyrVectIVectorLayer):
|
|
467 |
if DEV_INFO: print "| Vector"
|
|
468 |
store = value.getFeatureStore()
|
|
469 |
layer = MapContextLocator.getMapContextManager().createLayer(value.getName(),store)
|
|
470 |
store.dispose()
|
|
471 |
ret[value.getName()] = layer
|
|
472 |
layer.dispose()
|
|
473 |
elif isinstance(value, IRasterLayer):
|
|
474 |
if DEV_INFO: print "| Raster layer"
|
|
475 |
dalManager = gvsig.DALLocator.getDataManager()
|
|
476 |
mapContextManager = gvsig.MapContextLocator.getMapContextManager()
|
|
477 |
params = dalManager.createStoreParameters("Gdal Store")
|
|
478 |
params.setFile(File(value.getFilename()))
|
|
479 |
dataStore = dalManager.createStore(params)
|
|
480 |
layer = mapContextManager.createLayer(value.getName(), dataStore)
|
|
481 |
ret[value.getName()] = layer
|
|
482 |
else:
|
|
483 |
try:
|
|
484 |
ret[value.getName()] = value
|
|
485 |
except:
|
|
486 |
if not value == None:
|
|
487 |
x = 0
|
|
488 |
while True:
|
|
489 |
field = "value_" + str(x)
|
|
490 |
if any(field in s for s in ret.keys()):
|
|
491 |
x += 1
|
|
492 |
ret[str(x)] = value
|
|
493 |
break
|
|
494 |
if DEV_INFO: print "@@@@@@@@ ret:", ret
|
|
495 |
return ret
|
|
496 |
|
|
497 |
def __returnOutputObjects(self, r, kwparams):
|
|
498 |
if r == None: return
|
|
499 |
outList = []
|
|
500 |
print "| Output layers: "
|
|
501 |
for value in r.values():
|
|
502 |
if isinstance(value, unicode):
|
|
503 |
outList.append(value.encode("UTF-8"))
|
|
504 |
elif isinstance(value, FLyrVect):
|
|
505 |
print "|\t Value:", value.getName().encode("UTF-8")
|
|
506 |
path = value.getDataStore().getFullName()
|
|
507 |
print "|\t\tPath: ", path
|
|
508 |
if "OUTVIEW" in kwparams: # other view
|
|
509 |
viewName = (kwparams["OUTVIEW"]).decode("UTF-8")
|
|
510 |
if "TOCNAME" in kwparams:
|
|
511 |
value = loadShapeFileNew(str(path), view=viewName, tocName=kwparams["TOCNAME"])
|
|
512 |
else:
|
|
513 |
value = loadShapeFileNew(str(path), view=viewName)
|
|
514 |
else: #current view
|
|
515 |
if "TOCNAME" in kwparams:
|
|
516 |
value = loadShapeFileNew(str(path), tocName=kwparams["TOCNAME"])
|
|
517 |
else:
|
|
518 |
value = loadShapeFileNew(str(path))
|
|
519 |
|
|
520 |
|
|
521 |
outList.append(value)
|
|
522 |
elif isinstance(value,FLayer):
|
|
523 |
print "|\t Value:", value.getName()
|
|
524 |
print "|\t\t", value.getFileName()[0]
|
|
525 |
#Not yet: Waiting for new loadRasterLayer that can set OUTVIEW
|
|
526 |
if "TOCNAME" in kwparams:
|
|
527 |
value = loadRasterLayerNew(value.getFileName()[0], tocName=kwparams["TOCNAME"])
|
|
528 |
else:
|
|
529 |
value = loadRasterLayerNew(value.getFileName()[0])
|
|
530 |
|
|
531 |
outList.append(value)
|
|
532 |
else:
|
|
533 |
print "|\t Non-type"
|
|
534 |
print "\tValue: ", value
|
|
535 |
print "\n"
|
|
536 |
|
|
537 |
#Return object or list
|
|
538 |
if len(r.values()) > 1: return outList
|
|
539 |
elif len(r.values()) == 1: return value
|
|
540 |
else: return None
|
|
541 |
|
|
542 |
|
|
543 |
def execute(self, algorithmId, kwparams):
|
|
544 |
print "| Algoritmo: ", algorithmId
|
|
545 |
algorithm = self.getAlgorithms()[algorithmId]
|
|
546 |
#print algorithm.getAlgorithmAsCommandLineSentences()
|
|
547 |
|
|
548 |
#Input params
|
|
549 |
self.__defineParameters(algorithm, kwparams)
|
|
550 |
|
|
551 |
#Analisys Extension
|
|
552 |
self.__defineExtent(algorithm, kwparams)
|
|
553 |
|
|
554 |
#Output files
|
|
555 |
self.__defineOutput(algorithm, kwparams)
|
|
556 |
|
|
557 |
|
|
558 |
#***Cambiar nombre NO el de las capas
|
|
559 |
"""
|
|
560 |
print "** Define name"
|
|
561 |
if 'PATH' in kwparams.keys():
|
|
562 |
print "| Nombre: Capa_resultados"
|
|
563 |
out0 = java.util.HashMap()
|
|
564 |
out0["RESULT"] = "Capa_resultados"
|
|
565 |
"""
|
|
566 |
|
|
567 |
#Exec algorithm
|
|
568 |
self.__executeAlgorithm(algorithm)
|
|
569 |
|
|
570 |
#Output objects
|
|
571 |
ret = self.__getOutputObjects(algorithm)
|
|
572 |
r = self.__returnOutputObjects(ret, kwparams)
|
|
573 |
|
|
574 |
return r
|
|
575 |
|
|
576 |
def unionParameters(params, kwparams):
|
|
577 |
for i in range(0,len(params)):
|
|
578 |
kwparams[i]=params[i]
|
|
579 |
return kwparams
|
|
580 |
|
|
581 |
def runalg(algorithmId,*params, **kwparams):
|
|
582 |
kwparams = unionParameters(params, kwparams)
|
|
583 |
geoprocess = Geoprocess()
|
|
584 |
r = geoprocess.execute(algorithmId, kwparams)
|
|
585 |
del(geoprocess)
|
|
586 |
return r
|
|
587 |
|
|
588 |
|
|
589 |
def loadShapeFileNew(shpFile, CRS='CRS:84', tocName=False, active=False, view=gvsig.currentView()):
|
|
590 |
try:
|
|
591 |
CRS = gvsig.currentView().getProjectionCode()
|
|
592 |
except:
|
|
593 |
pass
|
|
594 |
layer = loadLayerNew('Shape', shpFile=shpFile, CRS=CRS, tocName=tocName, )
|
|
595 |
if isinstance(view,str):
|
|
596 |
view = gvsig.currentProject().getView(view)
|
|
597 |
else:
|
|
598 |
view= gvsig.currentView()
|
|
599 |
view.addLayer(layer)
|
|
600 |
layer.setActive(active)
|
|
601 |
return gvsig.Layer(layer)
|
|
602 |
|
|
603 |
def loadLayerNew(layerType, tocName=False, **parameters): #
|
|
604 |
try:
|
|
605 |
application = ApplicationLocator.getManager()
|
|
606 |
datamanager = application.getDataManager()
|
|
607 |
mapcontextmanager = application.getMapContextManager()
|
|
608 |
store_parameters = datamanager.createStoreParameters(layerType)
|
|
609 |
gvsig.copyToDynObject(parameters, store_parameters)
|
|
610 |
store = datamanager.openStore(layerType, store_parameters)
|
|
611 |
if tocName!=False:
|
|
612 |
nameStore = tocName
|
|
613 |
else:
|
|
614 |
nameStore = store.getName()
|
|
615 |
layer = mapcontextmanager.createLayer(nameStore, store)
|
|
616 |
except Throwable, ex:
|
|
617 |
raise RuntimeException("Can't load layer, "+ str(ex))
|
|
618 |
|
|
619 |
return layer
|
|
620 |
|
|
621 |
def loadRasterLayerNew(rasterfile, mode = "r", tocName=False ):
|
|
622 |
## Load a Raster file in a Layer
|
|
623 |
gvsig_raster.sourceFileName[0]=rasterfile
|
|
624 |
if not isinstance (rasterfile,File):
|
|
625 |
rasterfile = File(rasterfile)
|
|
626 |
|
|
627 |
name, ext = gvsig_raster.splitext(rasterfile.getName())
|
|
628 |
|
|
629 |
if tocName!=False:
|
|
630 |
name = tocName
|
|
631 |
else:
|
|
632 |
name = name
|
|
633 |
|
|
634 |
|
|
635 |
view = gvsig.currentView()
|
|
636 |
|
|
637 |
# Get the manager to use
|
|
638 |
dalManager = DALLocator.getDataManager()
|
|
639 |
mapContextManager = MapContextLocator.getMapContextManager()
|
|
640 |
|
|
641 |
if ext.lower() == ".ecw" or ext.lower() == ".jp2" :
|
|
642 |
# FIXME
|
|
643 |
pass
|
|
644 |
elif ext.lower() == ".mrsid":
|
|
645 |
# FIXME
|
|
646 |
pass
|
|
647 |
else:
|
|
648 |
# Create the parameters to open the raster store based in GDAL
|
|
649 |
params = dalManager.createStoreParameters("Gdal Store")
|
|
650 |
params.setFile(rasterfile)
|
|
651 |
|
|
652 |
# Create the raster store
|
|
653 |
dataStore = dalManager.createStore(params)
|
|
654 |
|
|
655 |
# Create a raster layer based in this raster store
|
|
656 |
layer = mapContextManager.createLayer(name, dataStore);
|
|
657 |
|
|
658 |
view.addLayer(layer)
|
|
659 |
return layer
|
|
660 |
|
|
661 |
def algHelp(geoalgorithmId):
|
|
662 |
geoprocess = Geoprocess()
|
|
663 |
for algorithmId, algorithm in geoprocess.getAlgorithms().items():
|
|
664 |
if algorithmId.encode('UTF-8') == geoalgorithmId.encode('UTF-8') or geoalgorithmId == "All":
|
|
665 |
pass
|
|
666 |
else:
|
|
667 |
continue
|
|
668 |
print "* Algorithm help: ", algorithm.getName().encode('UTF-8')
|
|
669 |
print "*", algorithm.commandLineHelp.encode('UTF-8')
|
|
670 |
del(geoprocess)
|
|
671 |
|
|
672 |
def algSearch(strSearch):
|
|
673 |
print "\nInicio de busqueda.."
|
|
674 |
geoprocess = Geoprocess()
|
|
675 |
search = strSearch.lower().encode('ASCII','ignore')
|
|
676 |
for algorithmId, algorithm in geoprocess.getAlgorithms().items():
|
|
677 |
name = (algorithm.getName()).lower().encode('ASCII','ignore')
|
|
678 |
group = (algorithm.getGroup()).lower().encode('ASCII','ignore')
|
|
679 |
con1 = str(name).find(search) >= 0
|
|
680 |
con2 = str(group).find(search) >= 0
|
|
681 |
con3 = algorithmId.encode('ASCII').find(search) >= 0
|
|
682 |
if con1 or con2 or con3:
|
|
683 |
if con1 or con2:
|
|
684 |
print "ID: ", algorithmId, " || GROUP: ", algorithm.getGroup().encode('UTF-8'), " || NAME: ", algorithm.getName().encode('UTF-8')
|
|
685 |
else:
|
|
686 |
print "*", algorithm.commandLineHelp.encode('UTF-8')
|
|
687 |
print "..Busqueda finalizada\n"
|
|
688 |
del(geoprocess)
|
|
689 |
|
|
690 |
def currentRaster():
|
|
691 |
"""Return first raster active layer on the View"""
|
|
692 |
layers = gvsig.currentView().getLayers()
|
|
693 |
lyrlist = [ layers[i] for i in range(0,layers.__len__())]
|
|
694 |
for i in lyrlist:
|
|
695 |
if i.isActive() and isinstance(i, DefaultFLyrRaster): return i
|
|
696 |
return None
|
|
697 |
|
|
698 |
def firstRaster():
|
|
699 |
"""Return first raster active layer on the View"""
|
|
700 |
layers = gvsig.currentView().getLayers()
|
|
701 |
lyrlist = [ layers[i] for i in range(0,layers.__len__())]
|
|
702 |
for i in lyrlist:
|
|
703 |
if isinstance(i, DefaultFLyrRaster): return i
|
|
704 |
return None
|
|
705 |
|
|
706 |
def sRaster(n):
|
|
707 |
"""Return first raster active layer on the View"""
|
|
708 |
layers = gvsig.currentView().getLayers()
|
|
709 |
lyrlist = [ layers[i] for i in range(0,layers.__len__())]
|
|
710 |
count = 0
|
|
711 |
for i in lyrlist:
|
|
712 |
if isinstance(i, DefaultFLyrRaster):
|
|
713 |
if count == n:
|
|
714 |
return i
|
|
715 |
else:
|
|
716 |
count+=1
|
|
717 |
return None
|
|
718 |
def currentActive():
|
|
719 |
"""Return first active layer on the View"""
|
|
720 |
layers = gvsig.currentView().getLayers()
|
|
721 |
lyrlist = [ layers[i] for i in range(0, layers.__len__())]
|
|
722 |
for i in lyrlist:
|
|
723 |
if i.isActive(): return i
|
|
724 |
return None
|
|
725 |
|
|
726 |
def getProjectLayer(view,layer):
|
|
727 |
"""Get vector layer or raster"""
|
|
728 |
|
|
729 |
try:
|
|
730 |
if isinstance(view, str): view = gvsig.currentProject().getView(view)
|
|
731 |
if isinstance(layer, str):
|
|
732 |
return view.getLayer(layer)
|
|
733 |
else:
|
|
734 |
return layer
|
|
735 |
except: #Bug: Raster problem with getLayer
|
|
736 |
for i in gvsig.currentProject().getView(view).getLayers():
|
|
737 |
if i.name == layer: return i
|
|
738 |
|
|
739 |
def getProjectTable(table):
|
|
740 |
"""Get table"""
|
|
741 |
return gvsig.currentProject().getTable(table)
|
|
742 |
|
|
743 |
def checkFilesExist(files):
|
|
744 |
"""Path or Paths of files"""
|
|
745 |
#raise a exception
|
|
746 |
|
|
747 |
if isinstance(files, str):
|
|
748 |
if os.path.isfile(files): raise Exception("File already exist" + files)
|
|
749 |
elif isinstance(files, list):
|
|
750 |
for fname in files:
|
|
751 |
if os.path.isfile(fname): raise Exception("File already exist" + fname)
|
|
752 |
|
|
753 |
def main(*args):
|
|
754 |
#checkFilesExist(["C:/gvsig/ran10.shp"])
|
|
755 |
|
|
756 |
#geoprocessSearch(" ")
|
|
757 |
#geoprocessHelp("closegapsnn")
|
|
758 |
#geoprocessHelp("perturbatepointslayer")
|
|
759 |
#r = runalg("perturbatepointslayer", LAYER = gvsig.currentLayer(),MEAN = 10, STDDEV = 10 )
|
|
760 |
#r = runalg("perturbatepointslayer", EXTENT = "VIEW", LAYER = currentLayer(),MEAN = 10, STDDEV = 10 )
|
|
761 |
#r = runalg("perturbatepointslayer", EXTENT = [0,0,500,500], LAYER = currentLayer(), MEAN = 10, STDDEV = 10 )
|
|
762 |
#r = runalg("perturbatepointslayer", PATH = "C://gvsig//perturbatepoints028.shp", LAYER = gvsig.currentLayer(),MEAN = 5, STDDEV = 5 )
|
|
763 |
#layer = gvsig.currentView().getLayer("data_test_lines.shp")
|
|
764 |
#r = runalg("linestoequispacedpoints", LINES=layer,DISTANCE=2)
|
|
765 |
|
|
766 |
#for i in range(10):
|
|
767 |
#r = runalg("perturbatepointslayer", LAYER = r[0],PATH = "C://gvsig//perturbatepoints028_" + str(i) + ".shp",MEAN =0.5, STDDEV = 0.5 )
|
|
768 |
#r = runalg("fixeddistancebuffer", LAYER = r[0], DISTANCE=1, TYPES="", RINGS=3, NOTROUNDED=False)
|
|
769 |
#r = runalg("randomvector", COUNT=20, TYPE=1, EXTENT=gvsig.currentView())
|
|
770 |
#RASTER
|
|
771 |
#r1 = runalg("generaterandomnormal", EXTENT = [0,0,500,500], PATH = "C://gvsig//perturbatepoints030.tif", MEAN =0.5, STDDEV = 0.5)
|
|
772 |
#layer = gvsig.currentView().getLayer("perturbatepoints030")
|
|
773 |
|
|
774 |
#raster = currentRaster()
|
|
775 |
#print raster
|
|
776 |
|
|
777 |
#layer = gvsig_raster.loadRasterLayer('c:/gvsig/test_low.tif')
|
|
778 |
#r1 = runalg("gradientlines",INPUT = layer, MIN=1, MAX=10, SKIP=1)
|
|
779 |
#r = runalg("gridorientation",INPUT=layer,METHOD=0)
|
|
780 |
#r = runalg("gridorientation",INPUT=layer,METHOD=0, PATH = "C://gvsig//perturbatepoints010.tif")
|
|
781 |
#r = runalg("gridorientation", INPUT=raster, METHOD=0, PATH = "C://gvsig//perturbatepoints011.tif")
|
|
782 |
#r = runalg("gradientlines", INPUT = layer, MIN=1, MAX=10, SKIP=1, PATH = "C://gvsig//perturbatepoints012.tif")
|
|
783 |
#r = runalg("generaterandomnormal", EXTENT = [0,0,500,500], PATH = "C://gvsig//perturbatepoints013.tif", MEAN =0.5, STDDEV = 0.5)
|
|
784 |
#geoprocessHelp("randomvector")
|
|
785 |
#r = runalg("randomvector", COUNT=20, TYPE=2, EXTENT=gvsig.currentLayer())
|
|
786 |
#r = runalg("randomvector", 200, TYPE_POINT, EXTENT=gvsig.currentLayer(), PATH="C://gvsig//test_puntos_sm01.shp")
|
|
787 |
#r = runalg("randomvector", COUNT=20, TYPE=1, EXTENT=gvsig.currentView())
|
|
788 |
#r = runalg("randomvector", COUNT=20, TYPE=1, EXTENT="VIEW")
|
|
789 |
#r = runalg("randomvector", COUNT=20, TYPE=1, EXTENT=currentRaster())
|
|
790 |
#r = runalg("gvSIG-convexhull", LAYER="Puntos_de_interes_01.shp", CHECK=True, PATH = "C://gvsig//gvsigconvexhull_001.shp")
|
|
791 |
#r = runalg("generaterandomnormal", PATH = "C://gvsig//per.tif", EXTENT=gvsig.currentLayer(), CELLSIZE = 100, PATH = "C://gvsig//perturbatepoints014.tif", MEAN =5, STDDEV = 5)
|
|
792 |
#geoprocessHelp("tablebasicstats")
|
|
793 |
#r =runalg("tablebasicstats",TABLE=gvsig.currentTable(), FIELD=0)
|
|
794 |
|
|
795 |
#Without parameters label
|
|
796 |
|
|
797 |
#layers = gvsig.currentView().getLayers()
|
|
798 |
##r = runalg("gridorientation", layer, 0, PATH = "C://gvsig//perturbatepoints012.tif")
|
|
799 |
|
|
800 |
#r = runalg("gridorientation", layer, 0)
|
|
801 |
#r = runalg("gradientlines", layers[0], 1, 10, 1, PATH = "C://gvsig//perturbatepoints012.shp")
|
|
802 |
#r = runalg("cva", "test_low", "test_low", "test_low", "test_low")
|
|
803 |
#r = runalg("cva", currentRaster(), currentRaster(), currentRaster(), currentRaster(),PATH=["C:/gvsig/1.tif","C:/gvsig/2.tif"])
|
|
804 |
|
|
805 |
#layerRaster = gvsig_raster.loadRasterLayer('c:/gvsig/test_low.tif')
|
|
806 |
#r = runalg("gridorientation",layerRaster,0, PATH = "C://gvsig//Grid_orientation.tif",EXTENT=layerRaster, CELLSIZE=1, CELLSIZEZ=10)
|
|
807 |
#r2 = runalg("cva", r, r, r, r, PATH=["C:/gvsig/1.tif","C:/gvsig/2.tif"])
|
|
808 |
#print r2[0], r2[1]
|
|
809 |
#print layerRaster
|
|
810 |
#print getProjectLayer("Vista1", "test_low")
|
|
811 |
|
|
812 |
|
|
813 |
#layer = getProjectLayer("Vista1", "as.shp")
|
|
814 |
#extent = getProjectLayer("Vista1", "analisis_extent")
|
|
815 |
#runalg("difference", "as.shp", "vista2_testeo.shp", PATH="C:/gvsig/recorte_extent.shp", EXTENT=[100, 100, 0, 540, 500, 0])
|
|
816 |
#runalg("difference", "vista2_testeo.shp", layer, PATH="C:/gvsig/recorte_extent_2.shp", EXTENT=layer, OUTVIEW="Nueva")
|
|
817 |
#r = runalg("tablebasicstats", "species", 0)
|
|
818 |
#print r.encode("UTF-8")
|
|
819 |
|
|
820 |
#algHelp("generaterandomnormal")
|
|
821 |
"""
|
|
822 |
r = runalg("generaterandomnormal", 100,100, CELLSIZE=100, EXTENT=[250,250,0,500,500,0])
|
|
823 |
r = runalg("generaterandomnormal", 10, 10, CELLSIZE=50, EXTENT=[500,500,0, 1000,1000,0])
|
|
824 |
r = runalg("generaterandombernoulli", 50.0, CELLSIZE=25, EXTENT=[1000,1000,0, 1250,1250,0])
|
|
825 |
r = runalg("gradientlines", r, 1, 100, 1)
|
|
826 |
|
|
827 |
v1 = runalg("randomvector",10, TYPE_POLYGON, EXTENT=[0,0,0,500,500,0])
|
|
828 |
v2 = runalg("randomvector", 5, TYPE_POLYGON, EXTENT=v1)
|
|
829 |
v3 = runalg("difference", v1, v2, PATH="C:/gvsig/Diferencia.shp")
|
|
830 |
v4 = runalg("randomvector", 5, 0, PATH="C:/gvsig/randomvector.shp", EXTENT=v3)
|
|
831 |
v5 = runalg("randomvector", 100, 2, PATH="C:/gvsig/randompoints.shp", EXTENT="randomvector", OUTVIEW="Nueva")
|
|
832 |
v6 = runalg("gvSIG-xyshift", "randompoints", "false", "-250.0", "-250.0", PATH=["C:/gvsig/ran1010.shp","C:/gvsig/ran2020.shp","C:/gvsig/ran3030.shp"])
|
|
833 |
algHelp("tablebasicstats")
|
|
834 |
v7 = runalg("gvSIG-buffer", "randompoints", False, 50.0, 0, False, True, 0, 0, PATH="C:/gvsig/buffer_gvsig0138.shp")
|
|
835 |
v5 = runalg("randomvector", 100, 2, EXTENT=[0,0,0,500,500,0])
|
|
836 |
|
|
837 |
#Test for model sextante
|
|
838 |
v5 = runalg("randomvector", 10, 2, EXTENT=[0,0,0,500,500,0], OUTVIEW="Nueva")
|
|
839 |
v5 = runalg("randomvector", "5", 2, EXTENT=[0,0,0,500,500,0], OUTVIEW="Nueva")
|
|
840 |
|
|
841 |
r = runalg("generaterandomnormal", 100,100, CELLSIZE=1)
|
|
842 |
|
|
843 |
vista= (gvsig.currentView().name).encode('UTF-8')
|
|
844 |
"""
|
|
845 |
|
|
846 |
|
|
847 |
"""
|
|
848 |
vista= "Sin tÃtulo"
|
|
849 |
#vista = vista.encode("UTF-8")
|
|
850 |
|
|
851 |
print gvsig.currentProject().getView(vista)
|
|
852 |
|
|
853 |
|
|
854 |
endid = "_104.shp"
|
|
855 |
v = runalg("randomvector", 20, 0)
|
|
856 |
v2 = runalg("randomvector", 20, 0,PATH=["C://gvsig//i"+endid])
|
|
857 |
#fitpoints = runalg("fitnpointsinpolygon",v, "2", "74", 1, 0)
|
|
858 |
intersection = runalg("gvSIG-intersection", v, getProjectLayer(gvsig.currentView(),"i_102"), True, True,PATH=["C://gvsig//inter_pol"+endid,"C://gvsig//inter_line"+endid,"C://gvsig//inter_point"+endid])
|
|
859 |
"""
|
|
860 |
#algSearch("nodelines")
|
|
861 |
#ID: extractendpointsoflines || GROUP: Topolog????a || NAME: Obtener extremos de l??neas
|
|
862 |
|
|
863 |
#v7 = runalg("gvSIG-buffer", v, "False", 50.0, 0, "false", "true", 0, 0)
|
|
864 |
#print "**Addfield: ", gvpy.addField(v, "ID5")
|
|
865 |
#import gvpy
|
|
866 |
#gvpy.addField(v, "ID89")
|
|
867 |
#runalg("vectoraddfield", v, "Campo1", 0, 1, 0, 1, PATH="C:\\Users\\Oscar\\Desktop\\testi.shp")
|
|
868 |
#layer = runalg("randomvector", 20, TYPE_LINE, EXTENT=[0,0,0,500,500,0], OUTVIEW="Po1")
|
|
869 |
|
|
870 |
#2015-1-2
|
|
871 |
|
|
872 |
|
|
873 |
#runalg("graticulebuilder", "10.0", "10.0", 1, PATH="/home/oscm/temp/reticula10.shp")
|
|
874 |
#layer1 = gvsig.currentView().getLayer("1")
|
|
875 |
#layer2 = gvsig.currentView().getLayer("2")
|
|
876 |
#print layer1, layer2
|
|
877 |
#
|
|
878 |
#algHelp("cluster")
|
|
879 |
#runalg("merge", layer1, [layer2])
|
|
880 |
|
|
881 |
#layer1 = sRaster(0)
|
|
882 |
#layer2 = sRaster(1)
|
|
883 |
#print "Layer1: ", layer1.name, layer1, layer1.getCellSize()
|
|
884 |
#print "Layer2: ", layer2.name, layer2, layer2.getCellSize()
|
|
885 |
|
|
886 |
|
|
887 |
#runalg("cluster" , INPUT=[(layer1, 0),(layer2,0)] , NUMCLASS=3)#, CELLSIZE=layer1.getCellSize(), CELLSIZEZ=1)#,EXTENT=layer1)
|
|
888 |
#runalg("mergegrids", [layer1, layer2], "0")
|
|
889 |
v1 = runalg("randomvector",10, TYPE_POLYGON, EXTENT=[0,0,0,500,500,0], TOCNAME="Random vector")
|
|
890 |
r = runalg("generaterandomnormal", EXTENT = [0,0,0,500,500,0], MEAN =0.5, STDDEV = 0.5, TOCNAME="Raster Generate Random normal")
|
|
891 |
print "end"
|
|
892 |
|
|
893 |
def mainLibrary():
|
|
894 |
#showFields(gvsig.currentLayer())
|
|
895 |
#removeField(layer, "campo3")
|
|
896 |
#removeField(layer, "campo5")
|
|
897 |
#addField(layer,"campo1")
|
|
898 |
#addField(layer,"campo2")
|
|
899 |
#renameField(layer, "campo5", "campo50")
|
|
900 |
|
|
901 |
#print list2geompoly([[1,2],[3,10],[5,30]])
|
|
902 |
#addFeature(layer, "test01", "test2", [15,200])
|
|
903 |
#addFeature(layer, "test11", "test3", geom.createPoint(300, 301))
|
|
904 |
#addFeature(layer, campo1 = "kwparam", campo2 = "kwparam2", GEOMETRY = geom.createPoint(300,300))
|
|
905 |
#addFeature(layer, "linea", "01", [[1,2],[3,10],[5,30]])
|
|
906 |
#addFeature(layer, "pol", "02", [[50,80],[150,50],[100,10],[0,10],[50,80]])
|
|
907 |
|
|
908 |
"""
|
|
909 |
layer = newLayer()
|
|
910 |
addFeature(layer, "pol", "01", [[50,80],[150,50],[100,10],[0,10],[50,80]])
|
|
911 |
addFeature(layer, "pol", "02", [[0,0],[10,5],[10,10],[0,10],[5,5]])
|
|
912 |
addFeature(layer, "pol", "03", [[-50, -34],[0,0], [-14,30]])
|
|
913 |
addField(layer,"campo3")
|
|
914 |
modifyFeatures(layer, "campo3", "nuevo poligono")
|
|
915 |
"""
|
|
916 |
"""
|
|
917 |
#Create shapes
|
|
918 |
layer1 = newLayer(layer,"C:/gvsig/point_shape.shp", 1)
|
|
919 |
layer2 = newLayer(layer,"C:/gvsig/line_shape.shp", 2)
|
|
920 |
layer3 = newLayer(layer,"C:/gvsig/polygon_shape", 3)
|
|
921 |
|
|
922 |
#Add features
|
|
923 |
addFeature(layer1, "point", "01", [50,80])
|
|
924 |
addFeature(layer1, "point", "02",[150,50])
|
|
925 |
addFeature(layer1, "point", "03",[100,10])
|
|
926 |
addFeature(layer1, "point", "04",[0,10])
|
|
927 |
|
|
928 |
addFeature(layer3, "polygon", "01", [[50,80],[150,50],[100,10],[0,10],[50,80]])
|
|
929 |
|
|
930 |
addFeature(layer2, "line", "01", [[50,80],[150,50],[100,10],[0,10],[50,80]])
|
|
931 |
|
|
932 |
#Modify all values in one column
|
|
933 |
modifyFeatures(layer1, "campo1", "Points_gsoc")
|
|
934 |
modifyFeatures(layer2, "campo1", "Lines_gsoc")
|
|
935 |
|
|
936 |
#Modify schema
|
|
937 |
addField(layer1,"Name")
|
|
938 |
removeField(layer1,"Surname")
|
|
939 |
|
|
940 |
##Execute SEXTANTE
|
|
941 |
#r = geoprocess("perturbatepointslayer", LAYER = currentLayer(),MEAN = 5, STDDEV = 5 )
|
|
942 |
"""
|
|
943 |
#layer = gvsig.currentView().getLayer("line_04.shp")
|
|
944 |
#newLayer(layer, "C:/gvsig/gvpy_test006.shp")
|
|
945 |
#layer2 = copyLayer(layer, "C:/gvsig/gvpy_copylayer_012.shp")
|
|
946 |
#v = copyLayer(layer, "C:/gvpy_copylayer_new_06.shp")
|
|
947 |
#layer = gvsig.currentView().getLayer("gvpy_copylayer_new_06")
|
|
948 |
#addFeature(v, "Camino", [[50,00],[50,50],[10,10],[0,1],[50,18]])
|
|
949 |
|
|
950 |
#Basics field
|
|
951 |
"""
|
|
952 |
addField(v, "Direccion")
|
|
953 |
modifyFeatures(v, "Direccion", "Av")
|
|
954 |
removeField(v, "Direccion")
|
|
955 |
"""
|
|
956 |
|
|
957 |
"""
|
|
958 |
#EJEMPLO 1
|
|
959 |
#New shapes
|
|
960 |
layer = gvpy.runalg("randomvector", 20, gvpy.TYPE_LINE, EXTENT=[0,0,0,500,500,0], OUTVIEW="Po1")
|
|
961 |
#layer = gvsig.currentLayer()
|
|
962 |
#Advanced field
|
|
963 |
removeField(layer, "ID")
|
|
964 |
removeField(layer, "Distance")
|
|
965 |
addField(layer, "ID") #Add fields
|
|
966 |
addField(layer, "Distance", "STRING")
|
|
967 |
addField(layer, "Long", "LONG")
|
|
968 |
removeField(layer, "Long") #Remove field
|
|
969 |
modifyFeatures(layer, "ID", "90") #Modify all features
|
|
970 |
modifyField(layer, "ID", "LONG") #Modify type of field
|
|
971 |
modifyField(layer, "Distance", "FLOAT")
|
|
972 |
addFeature(layer, 1, 0, [[50,0],[1000,0]]) #Add new feature with geometry line
|
|
973 |
for feature in layer.features():
|
|
974 |
perimeter = feature.geometry().perimeter()
|
|
975 |
modifyFeature(layer, feature, "Distance", perimeter) #Modify each feature
|
|
976 |
|
|
977 |
pass
|
|
978 |
#FIN EJEMPLO 1
|
|
979 |
"""
|
|
980 |
|
|
981 |
#modifyFeatures(gvsig.currentLayer(), "ID", 100, "Distance == 90")
|
|
982 |
layer = gvsig.currentLayer()
|
|
983 |
for feature in gvsig.currentLayer().features():
|
|
984 |
value = feature.Distance
|
|
985 |
#modifyFeature(layer, feature, "ID", distance)
|
|
986 |
feature.edit()
|
|
987 |
feature.set("ID", value)
|
|
988 |
layer.update(feature)
|
|
989 |
#model2script("C://gsoc//test02.model", "C://gsoc//nuevoScript.py")
|
|
990 |
print "END TEST"
|
|
991 |
|
|
992 |
def copyLayerFeatures2Layer(layer1, layer2):
|
|
993 |
for i in layer1.features():
|
|
994 |
layer2.append(i.getValues())
|
|
995 |
layer2.commit()
|
|
996 |
|
|
997 |
def copyLayer(layer, path):
|
|
998 |
output = newLayer(layer, path)
|
|
999 |
copyLayerFeatures2Layer(layer, output)
|
|
1000 |
#addLayerView(output)
|
|
1001 |
return output
|
|
1002 |
|
|
1003 |
def newLayer(layer, path, geometryType=None):
|
|
1004 |
CRS = layer.getProjectionCode()
|
|
1005 |
schema = gvsig.createSchema(layer.getSchema())
|
|
1006 |
if geometryType==None: geometryType = layer.getTypeVectorLayer().getType()
|
|
1007 |
output = gvsig.createShape( schema, path, CRS=CRS, geometryType=geometryType )
|
|
1008 |
gvsig.currentView().addLayer(output)
|
|
1009 |
return output
|
|
1010 |
|
|
1011 |
def addLayerView(layer):
|
|
1012 |
gvsig.currentView().addLayer(layer)
|
|
1013 |
|
|
1014 |
def addFeature(layer, *params, **kwparams):
|
|
1015 |
#IN: layer, feature params + geometry
|
|
1016 |
typeLayer = layer.getTypeVectorLayer().name
|
|
1017 |
#if kwparams != {}:
|
|
1018 |
# layer.append(kwparams)
|
|
1019 |
# layer.commit()
|
|
1020 |
# return
|
|
1021 |
|
|
1022 |
if "COMMIT" in kwparams:
|
|
1023 |
pass
|
|
1024 |
else:
|
|
1025 |
COMMIT=1
|
|
1026 |
if params != ():
|
|
1027 |
schValues = layer.getSchema().getAttrNames()
|
|
1028 |
values = {}
|
|
1029 |
itera = iter((list(params)))
|
|
1030 |
value = itera.next()
|
|
1031 |
for sch in schValues:
|
|
1032 |
#Si el campo a modificar es una geometria
|
|
1033 |
#print "Comprobación:", sch, isinstance(value, list)
|
|
1034 |
#re comprobacion si es campo geometry
|
|
1035 |
#bug: Comprobar si es lista o objeto geom en primer if
|
|
1036 |
#... sch == "Geometry" and ES UNA LISTA
|
|
1037 |
#... sino copia el valor directamente: caso de pasar geometrias
|
|
1038 |
if sch == "GEOMETRY":
|
|
1039 |
print typeLayer
|
|
1040 |
if typeLayer == "Point2D":
|
|
1041 |
if isinstance(value, list):
|
|
1042 |
values[sch] = geom.createPoint(value[0],value[1])
|
|
1043 |
elif typeLayer == "MultiCurve2D":
|
|
1044 |
if isinstance(value, list):
|
|
1045 |
values[sch] = list2geomcurve(value)
|
|
1046 |
elif typeLayer == "MultiSurface2D":
|
|
1047 |
if isinstance(value, list):
|
|
1048 |
values[sch] = list2geompoly(value)
|
|
1049 |
else: #Si son geometrias
|
|
1050 |
values[sch] = value
|
|
1051 |
else:
|
|
1052 |
values[sch] = value
|
|
1053 |
try:
|
|
1054 |
value = itera.next()
|
|
1055 |
except:
|
|
1056 |
break
|
|
1057 |
layer.append(values)
|
|
1058 |
if COMMIT==1: layer.commit()
|
|
1059 |
print "Add feature ", params, " to ", layer
|
|
1060 |
|
|
1061 |
def list2geompoly(listPoints):
|
|
1062 |
#IN: list[[x,y],...]
|
|
1063 |
#OUT: geometry polygon
|
|
1064 |
geometry = geom.createGeometry(3)
|
|
1065 |
for point in listPoints:
|
|
1066 |
geometry.addVertex(geom.createPoint(point[0],point[1]))
|
|
1067 |
if listPoints[0] != listPoints[len(listPoints)-1]:
|
|
1068 |
geometry.addVertex(geom.createPoint(listPoints[0][0], listPoints[0][1]))
|
|
1069 |
return geometry
|
|
1070 |
|
|
1071 |
def list2geomcurve(listPoints):
|
|
1072 |
#IN: list [[x,y],...]
|
|
1073 |
#OUT: geometry line
|
|
1074 |
geometry = geom.createGeometry(2)
|
|
1075 |
for point in listPoints:
|
|
1076 |
geometry.addVertex(geom.createPoint(point[0],point[1]))
|
|
1077 |
return geometry
|
|
1078 |
|
|
1079 |
def modifyFeatures(layer, field, value, COMMIT=1,FILTER=None):
|
|
1080 |
#IN: layer, field, new value
|
|
1081 |
if FILTER == None:
|
|
1082 |
features = layer.features()
|
|
1083 |
else:
|
|
1084 |
features = layer.features(FILTER)
|
|
1085 |
|
|
1086 |
for feature in features:
|
|
1087 |
feature.edit()
|
|
1088 |
feature.set(field, value)
|
|
1089 |
layer.update(feature)
|
|
1090 |
if COMMIT==1: layer.commit()
|
|
1091 |
print "Modify feature ", layer.name, field, value
|
|
1092 |
|
|
1093 |
def showFields(layer):
|
|
1094 |
#IN: layer
|
|
1095 |
#OUT: str(atributos)
|
|
1096 |
print layer.getSchema().getAttrNames()
|
|
1097 |
|
|
1098 |
def addField(layer,field, sType = "STRING",iSize=20):
|
|
1099 |
#IN: layer, field, *sType, *iSize)
|
|
1100 |
#OUT: layer
|
|
1101 |
#addField(layer, "nombre")
|
|
1102 |
schema = gvsig.createSchema(layer.getSchema())
|
|
1103 |
schema.modify()
|
|
1104 |
if isinstance(field,str): schema.append(field,sType,iSize)
|
|
1105 |
layer.edit()
|
|
1106 |
layer.updateSchema(schema)
|
|
1107 |
layer.commit()
|
|
1108 |
print "Add field ", field, " to ", layer.name
|
|
1109 |
return layer
|
|
1110 |
|
|
1111 |
def modifyField(layer, field, iType="STRING", iSize=20):
|
|
1112 |
temp = []
|
|
1113 |
for i in layer.features():
|
|
1114 |
temp.append(i.get(field))
|
|
1115 |
removeField(layer, field)
|
|
1116 |
addField(layer, field, iType, iSize)
|
|
1117 |
n = 0
|
|
1118 |
for i in layer.features():
|
|
1119 |
modifyFeature(layer, i, field, temp[n],COMMIT=0)
|
|
1120 |
n += 1
|
|
1121 |
layer.commit()
|
|
1122 |
print "Modify field type to: ", field, " in ", layer.name
|
|
1123 |
|
|
1124 |
def modifyFeature(layer, feature, field, value, COMMIT=1):
|
|
1125 |
feature.edit()
|
|
1126 |
feature.set(field, value)
|
|
1127 |
layer.update(feature)
|
|
1128 |
print "Modify Feature field: ", field , " to ", value
|
|
1129 |
if COMMIT==1: layer.commit()
|
|
1130 |
|
|
1131 |
def removeField(layer, field):
|
|
1132 |
#IN: layer, field
|
|
1133 |
#OUT: layer
|
|
1134 |
#removeField(layer, "apellido")
|
|
1135 |
print "Campo %s eliminado" % (str(field))
|
|
1136 |
schema = layer.getSchema()
|
|
1137 |
schema.modify()
|
|
1138 |
if isinstance(field,str): schema.remove(field)
|
|
1139 |
else: return
|
|
1140 |
layer.edit()
|
|
1141 |
layer.updateSchema(schema)
|
|
1142 |
layer.commit()
|
|
1143 |
return layer
|
|
1144 |
|
|
1145 |
|
|
1146 |
def model2script(pathXML, pathFile):
|
|
1147 |
#eliminar la ultima linea
|
|
1148 |
#pathXML = commonsdialog.openFileDialog("Selecciona archivo", 'C:/gsoc/')
|
|
1149 |
#pathXML = str(pathXML[0])
|
|
1150 |
#pathXML = 'C:/gsoc/test02.model'
|
|
1151 |
#pathFILE = 'C:/gsoc/script0002.py'
|
|
1152 |
import os.path
|
|
1153 |
if os.path.isfile(pathXML)==True:
|
|
1154 |
pass
|
|
1155 |
else:
|
|
1156 |
print "No valid model file path"
|
|
1157 |
return
|
|
1158 |
fileFile = open(pathXML, 'r')
|
|
1159 |
document = fileFile.read()
|
|
1160 |
import xml.dom.minidom
|
|
1161 |
root = xml.dom.minidom.parseString(document)
|
|
1162 |
#root
|
|
1163 |
inputObject = {}
|
|
1164 |
inputObjectParams = {}
|
|
1165 |
dataObject = {}
|
|
1166 |
algorithms = {}
|
|
1167 |
tab = " "
|
|
1168 |
gvpyFile = open(pathFile, "w")
|
|
1169 |
#Cargamos los parametros
|
|
1170 |
print "\nData object"
|
|
1171 |
for child in root.getElementsByTagName("data_object"):
|
|
1172 |
#data_object - Parametros
|
|
1173 |
if "INNER" in child.getAttribute("key"):
|
|
1174 |
inputObjectParams[child.getAttribute("key")] = child.getAttribute("value")
|
|
1175 |
#data_object - result of algorithms
|
|
1176 |
else:
|
|
1177 |
inputObject[child.getAttribute("key")]=[child.getAttribute("value"), child.getAttribute("description").encode("UTF-8")]
|
|
1178 |
|
|
1179 |
print "\n Attribute"
|
|
1180 |
for child in root.getElementsByTagName("input"):
|
|
1181 |
for i in child.getElementsByTagName("attribute"):
|
|
1182 |
if i.getAttribute("name")=="default": dataObject[child.getAttribute("name")] = i.getAttribute("value")
|
|
1183 |
|
|
1184 |
print "\n Algorithm"
|
|
1185 |
order = 1
|
|
1186 |
for child in reversed(root.getElementsByTagName("algorithm")):
|
|
1187 |
print "Algoritmo: ", child
|
|
1188 |
keyAlgorithm = child.getAttribute("key")
|
|
1189 |
algorithmParams = {}
|
|
1190 |
algorithmParams["alg_cmd_line_name"]=child.getAttribute("alg_cmd_line_name")
|
|
1191 |
for i in child.getElementsByTagName("assignment"):
|
|
1192 |
algorithmParams[i.getAttribute("key")] = i.getAttribute("assigned_to")
|
|
1193 |
algorithmParams["result_of_algorithm"] = keyAlgorithm
|
|
1194 |
algorithms[order] = algorithmParams
|
|
1195 |
order +=1
|
|
1196 |
|
|
1197 |
print "\n\n******* RESULTADO *******"
|
|
1198 |
print "inputObject: ", inputObject
|
|
1199 |
print "inputObjectParams: ", inputObjectParams
|
|
1200 |
print "algorithms: ", algorithms
|
|
1201 |
print "data object: ", dataObject
|
|
1202 |
|
|
1203 |
#Writing script .py
|
|
1204 |
print "\nTransform to gvpy"
|
|
1205 |
for i in root.getElementsByTagName("model"):
|
|
1206 |
modelName = i.getAttribute("name")
|
|
1207 |
gvpyFile.write("# Modelo de SEXTANTE: " + modelName)
|
|
1208 |
gvpyFile.write(
|
|
1209 |
"""
|
|
1210 |
import gvpy
|
|
1211 |
import gvsig
|
|
1212 |
import geom
|
|
1213 |
import gvsig_raster
|
|
1214 |
|
|
1215 |
def main(*args):
|
|
1216 |
""")
|
|
1217 |
|
|
1218 |
print "gvpy - data_object"
|
|
1219 |
listInputObject = []
|
|
1220 |
for n in reversed(inputObject.keys()):
|
|
1221 |
listInputObject.append([n,inputObject[n][1]])
|
|
1222 |
|
|
1223 |
print "gvpy - inputObjectParams"
|
|
1224 |
for n in (inputObjectParams.keys()):
|
|
1225 |
gvpyFile.write( tab + n + ' = "' + inputObjectParams[n] + '"\n' )
|
|
1226 |
|
|
1227 |
print "gvpy - vars"
|
|
1228 |
for n in (dataObject.keys()):
|
|
1229 |
gvpyFile.write( tab + n +' = "' + dataObject[n] + '"\n\n' )
|
|
1230 |
|
|
1231 |
|
|
1232 |
print "gvpy - algorithms"
|
|
1233 |
#inputObject list of result algorithms names
|
|
1234 |
for n in reversed(sorted(algorithms.keys())): #reversed(algorithms.keys()):
|
|
1235 |
gvpy= ""
|
|
1236 |
alg = algorithms[n]
|
|
1237 |
#prefijo: buscar en los data_object el nombre que debe de llevar la capa resultado
|
|
1238 |
for i in listInputObject:
|
|
1239 |
if alg["result_of_algorithm"] in i[0]:
|
|
1240 |
prefix = i[0]
|
|
1241 |
description = i[1]
|
|
1242 |
#Escribimos el codigo del algoritmo
|
|
1243 |
gvpyFile.write( tab + '# '+ description + '\n')
|
|
1244 |
gvpy += prefix + '= gvpy.runalg("'+alg["alg_cmd_line_name"]+'"'
|
|
1245 |
for i in alg:
|
|
1246 |
if i == "alg_cmd_line_name" or i == "result_of_algorithm": continue
|
|
1247 |
gvpy += ', '+i+'='+ alg[i] + ''
|
|
1248 |
gvpy += ')'
|
|
1249 |
gvpyFile.write( tab + gvpy + "\n\n" )
|
|
1250 |
|
|
1251 |
gvpyFile.close()
|