gvsig-scripting / org.gvsig.scripting.app / trunk / org.gvsig.scripting.app / org.gvsig.scripting.app.extension / src / main / resources / scripting / lib / gvsig.py @ 388
History | View | Annotate | Download (25.4 KB)
1 |
# -*- coding: utf-8 -*-
|
---|---|
2 |
#
|
3 |
# File: gvsig.py
|
4 |
#
|
5 |
# Copyright (c) 2011 by Model Driven Development sl and Antonio Carrasco Valero
|
6 |
#
|
7 |
# GNU General Public License (GPL)
|
8 |
#
|
9 |
# This program is free software; you can redistribute it and/or
|
10 |
# modify it under the terms of the GNU General Public License
|
11 |
# as published by the Free Software Foundation; either version 2
|
12 |
# of the License, or (at your option) any later version.
|
13 |
#
|
14 |
# This program is distributed in the hope that it will be useful,
|
15 |
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
16 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
17 |
# GNU General Public License for more details.
|
18 |
#
|
19 |
# You should have received a copy of the GNU General Public License
|
20 |
# along with this program; if not, write to the Free Software
|
21 |
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
22 |
# 02110-1301, USA.
|
23 |
#
|
24 |
#
|
25 |
|
26 |
__author__ = """Antonio Carrasco Valero
|
27 |
Model Driven Development sl and Antonio Carrasco Valero
|
28 |
<carrasco@modeldd.org>
|
29 |
Victor Acevedo Royer <vacevedor@gvsig.com>, <vacevedor@gmail.com>
|
30 |
"""
|
31 |
|
32 |
__docformat__ = 'plaintext'
|
33 |
|
34 |
from java.awt import Color |
35 |
|
36 |
from java.lang import RuntimeException |
37 |
from java.lang import Throwable |
38 |
|
39 |
from java.util.prefs import Preferences |
40 |
|
41 |
from org.gvsig.app import ApplicationLocator |
42 |
from org.gvsig.app.project.documents.view import ViewDocument |
43 |
|
44 |
from org.gvsig.fmap.mapcontext import MapContextLocator |
45 |
from org.gvsig.fmap.mapcontext.layers import FLayers |
46 |
from org.gvsig.fmap.dal import DALLocator, DataTypes |
47 |
from org.gvsig.fmap.dal.feature import EditableFeature, EditableFeatureType, FeatureQueryOrder |
48 |
from org.gvsig.fmap.dal.feature.impl import DefaultEditableFeature |
49 |
|
50 |
from org.gvsig.tools import ToolsLocator |
51 |
|
52 |
from geom import POINT, POLIGON, LINE, MULTIPOINT, MULTILINE, MULTIPOLIGON |
53 |
|
54 |
import thread |
55 |
import random |
56 |
|
57 |
|
58 |
|
59 |
"""
|
60 |
ARRAY, BOOLEAN, BYTE, BYTEARRAY, CHAR, CONTAINER, DATE, DOUBLE, DYNOBJECT, FILE,
|
61 |
FLOAT, FOLDER, INT, INVALID, LIST, LONG, MAP, MAX_TYPE_VALUE, OBJECT, SET,
|
62 |
STRING, SUBTYPE_DATE, SUBTYPE_FILE, SUBTYPE_FOLDER, TIME, TIMESTAMP, UNKNOWN,
|
63 |
URI, URL
|
64 |
"""
|
65 |
|
66 |
def runTask(name, function, *args): |
67 |
manager = ToolsLocator.getTaskStatusManager() |
68 |
status = manager.createDefaultSimpleTaskStatus(name) |
69 |
status.add() |
70 |
args = list(args)
|
71 |
args.append(status) |
72 |
try:
|
73 |
thread.start_new_thread(function, tuple(args))
|
74 |
status.terminate() |
75 |
except Exception,e: |
76 |
status.abort() |
77 |
raise e
|
78 |
|
79 |
|
80 |
class WrapperToJava(object): |
81 |
"""
|
82 |
Create a wrapper that allows python object access to the Java object
|
83 |
properties and methods
|
84 |
"""
|
85 |
def __init__(self, javaobj): |
86 |
if javaobj == None: |
87 |
raise RuntimeException("Can't create "+ self.__class__.__name__) |
88 |
self._javaobj = javaobj
|
89 |
|
90 |
def __call__(self): |
91 |
return self._javaobj |
92 |
|
93 |
def __getattr__(self,name): |
94 |
return getattr(self._javaobj,name) |
95 |
|
96 |
class Project(WrapperToJava): |
97 |
"""
|
98 |
Represents a gvSIG project
|
99 |
"""
|
100 |
def __init__(self, project): |
101 |
WrapperToJava.__init__(self, project)
|
102 |
|
103 |
def getView(self, name=None): |
104 |
"""
|
105 |
Return active view, or view called 'name' or None
|
106 |
|
107 |
:param name: view name
|
108 |
:type name: string
|
109 |
"""
|
110 |
v = None
|
111 |
|
112 |
if name == None: |
113 |
try:
|
114 |
activeDocument = self.getActiveDocument()
|
115 |
if activeDocument.getTypeName() == "project.document.view2d": |
116 |
v = View(activeDocument) |
117 |
except Exception, ex: |
118 |
raise Exception("%s"%repr(ex)) |
119 |
|
120 |
else:
|
121 |
views = self.getViews()
|
122 |
if len(views) >0: |
123 |
for view in views: |
124 |
if name == view.getName():
|
125 |
v = View(view) |
126 |
|
127 |
return v
|
128 |
|
129 |
def getTable(self, name=None): |
130 |
"""
|
131 |
Return active Table Document, or Table Document called 'name' or None
|
132 |
|
133 |
:param name: Table Document name
|
134 |
:type name: string
|
135 |
"""
|
136 |
t = None
|
137 |
if name == None: |
138 |
try:
|
139 |
activeDocument = self.getActiveDocument()
|
140 |
if activeDocument.getTypeName() == "project.document.table": |
141 |
t = Table(activeDocument) |
142 |
except Exception, ex: |
143 |
raise Exception("%s"%repr(ex)) |
144 |
else:
|
145 |
tables = self.getDocuments("project.document.table") |
146 |
if len(tables) >0: |
147 |
for table in tables: |
148 |
if name == table.getName():
|
149 |
t = Table(table) |
150 |
|
151 |
return t
|
152 |
|
153 |
def getProjectionCode(self): |
154 |
return self.getProjection().getFullCode() |
155 |
|
156 |
class View(WrapperToJava): |
157 |
"""
|
158 |
Represents gvSIG view document.
|
159 |
"""
|
160 |
def __init__(self,view): |
161 |
WrapperToJava.__init__(self,view)
|
162 |
|
163 |
def getLayer(self, name=None): |
164 |
"""
|
165 |
Return one of the view layers documents. If name is None return view active
|
166 |
layer if the view has one, if name is not None return view called name else
|
167 |
return None.
|
168 |
|
169 |
:param name: view name in Table Of Contents
|
170 |
:type name: string
|
171 |
:return: View
|
172 |
:return: None
|
173 |
|
174 |
"""
|
175 |
map = self.getMapContext();
|
176 |
if name == None: |
177 |
activeLayers = map.getLayers().getActives()
|
178 |
if len(activeLayers) != 1 : |
179 |
raise RuntimeException("The view has not an active layer") |
180 |
for layer in activeLayers: |
181 |
if not isinstance(layer, FLayers): |
182 |
return Layer(layer)
|
183 |
raise RuntimeException("The view has not an active layer") |
184 |
|
185 |
ls = self.getLayers()
|
186 |
for i in xrange(ls.getLayersCount()): |
187 |
l = ls.getLayer(i) |
188 |
if l.name == name:
|
189 |
return Layer(l)
|
190 |
|
191 |
return None |
192 |
|
193 |
def getMap(self): |
194 |
"""
|
195 |
Return view mapContext
|
196 |
"""
|
197 |
return self.getMapContext(); |
198 |
|
199 |
def addLayer(self, layer): |
200 |
if isinstance(layer, Layer): |
201 |
layer =layer() |
202 |
self.getMapContext().getLayers().addLayer(layer)
|
203 |
|
204 |
def getLayers(self): |
205 |
"""
|
206 |
Return iterable view layers set
|
207 |
"""
|
208 |
map = self.getMapContext();
|
209 |
return Layers(map.getLayers()) |
210 |
|
211 |
def getGraphicsLayer(self): |
212 |
"""
|
213 |
Return view graphics layer
|
214 |
"""
|
215 |
return self.getMapContext().getGraphicsLayer() |
216 |
|
217 |
def getProjectionCode(self): |
218 |
return self.getProjection().getFullCode() |
219 |
|
220 |
class Layers(WrapperToJava): |
221 |
"""
|
222 |
Iterable layers set
|
223 |
"""
|
224 |
def __init__(self,layers): |
225 |
WrapperToJava.__init__(self, layers)
|
226 |
|
227 |
def __len__(self): |
228 |
return self.getLayersCount() |
229 |
|
230 |
def __getitem__(self, index): |
231 |
return self.getLayer(index) |
232 |
|
233 |
def __iter__(self): |
234 |
return LayersIterator(self) |
235 |
|
236 |
class LayersIterator(object): |
237 |
|
238 |
def __init__(self,layers): |
239 |
self.__layers = layers
|
240 |
self.__index = -1 |
241 |
|
242 |
def next(self): |
243 |
self.__index+=1 |
244 |
if self.__index >= self.__layers.getLayersCount() : |
245 |
raise StopIteration() |
246 |
return Layer(self.__layers.getLayer(self.__index)) |
247 |
|
248 |
class Store(WrapperToJava): |
249 |
"""
|
250 |
Represents gvsig store
|
251 |
"""
|
252 |
def __init__(self,store): |
253 |
WrapperToJava.__init__(self, store)
|
254 |
#self.data = None
|
255 |
self.fset = None |
256 |
|
257 |
def features(self, expresion = None, sortBy="", asc=True): |
258 |
"""
|
259 |
Return layer features set (FeatureSet)
|
260 |
|
261 |
:param expresion: filter to apply to the feature set to select
|
262 |
determinates features that match with expression
|
263 |
:type expresion: string
|
264 |
:param sortBy: name of attribute to sort
|
265 |
:type sortby: string
|
266 |
:param: asc: order
|
267 |
:type asc: boolean
|
268 |
:return: FeatureSet
|
269 |
"""
|
270 |
|
271 |
if expresion == None and sortBy =="": |
272 |
self.fset = self.getFeatureSet() |
273 |
else:
|
274 |
application = ApplicationLocator.getManager() |
275 |
datamanager = application.getDataManager() |
276 |
query = self.createFeatureQuery()
|
277 |
if sortBy != "": |
278 |
order = FeatureQueryOrder() |
279 |
order.add(sortBy, asc) |
280 |
query.setOrder(order) |
281 |
if expresion != None: |
282 |
query.setFilter(datamanager.createExpresion(expresion)) |
283 |
#self.fset = data.getFeatureSet(query)
|
284 |
self.fset = self.getFeatureSet(query) |
285 |
|
286 |
return FeatureSet(self.fset) |
287 |
|
288 |
def edit(self): |
289 |
"""
|
290 |
Set layer data store in edition mode
|
291 |
"""
|
292 |
|
293 |
if not self.isEditing(): |
294 |
self().edit()
|
295 |
|
296 |
def append(self, *valuesList, **values): |
297 |
"""
|
298 |
Create a new feature from given values and insert it in the feature set
|
299 |
|
300 |
:param values: dictionary with name property value or list named params
|
301 |
:type values: dict
|
302 |
|
303 |
"""
|
304 |
try:
|
305 |
if len(valuesList) ==1: |
306 |
values.update(valuesList[0])
|
307 |
|
308 |
if not self.isEditing(): |
309 |
self.edit()
|
310 |
f = self.createNewFeature()
|
311 |
|
312 |
if f == None: |
313 |
raise RuntimeError("Failed to create a new Feature") |
314 |
for k,v in values.iteritems(): |
315 |
f.set(k,v) |
316 |
self.insert(f)
|
317 |
except Throwable, ex:
|
318 |
raise RuntimeException("Can't append values %s to layer %s (%s)" % ( |
319 |
repr(values),
|
320 |
self.getName(),
|
321 |
str(ex)
|
322 |
) |
323 |
) |
324 |
|
325 |
def updateSchema(self, schema): |
326 |
try:
|
327 |
self().update(schema._javaobj)
|
328 |
except Throwable, ex:
|
329 |
raise RuntimeException(repr(ex)) |
330 |
|
331 |
def update(self, feature): |
332 |
"""
|
333 |
Update exist feature in the layer featureSet
|
334 |
|
335 |
:param editableFeature: editableFeature
|
336 |
:type editableFeature: Java editableFeature
|
337 |
"""
|
338 |
if not isinstance(feature, EditableFeature): |
339 |
feature = feature._javaobj |
340 |
self.fset.update(feature)
|
341 |
|
342 |
def getSchema(self): |
343 |
"""
|
344 |
Return layer schema definition
|
345 |
"""
|
346 |
return Schema(self.getDefaultFeatureType()) |
347 |
|
348 |
def commit(self): |
349 |
"""
|
350 |
Finish layer edition
|
351 |
"""
|
352 |
try:
|
353 |
self.finishEditing()
|
354 |
except Throwable, ex:
|
355 |
self.abort()
|
356 |
raise Throwable("Can't finish layer edition, cancelling changes. %s" % repr(ex)) |
357 |
|
358 |
def abort(self): |
359 |
"""
|
360 |
Cancel layer edition
|
361 |
"""
|
362 |
self.cancelEditing()
|
363 |
self.dispose()
|
364 |
|
365 |
def getSelection(self): |
366 |
"""
|
367 |
Return layer feature selected set
|
368 |
"""
|
369 |
return FeatureSet(self().getSelection()) |
370 |
|
371 |
class __DefaultTable__(WrapperToJava): |
372 |
def __init__(self,document, data): |
373 |
self.data = Store(data)
|
374 |
WrapperToJava.__init__(self,document)
|
375 |
self.selection = None |
376 |
|
377 |
def features(self, expresion = None, sortBy="", asc=True): |
378 |
"""
|
379 |
Return data features set
|
380 |
|
381 |
:param expresion: filter to apply to the feature set to select
|
382 |
determinates features that match with expression
|
383 |
:type expresion: string
|
384 |
:return: FeatureSet
|
385 |
"""
|
386 |
|
387 |
return self.data.features(expresion, sortBy, asc) |
388 |
|
389 |
def edit(self): |
390 |
"""
|
391 |
Set data in edition mode
|
392 |
"""
|
393 |
|
394 |
self.data.edit()
|
395 |
|
396 |
def append(self, *valuesList, **values): |
397 |
"""
|
398 |
Create a new feature from given values and insert it in the feature set
|
399 |
|
400 |
:param values: dictionary with name property value or list named params
|
401 |
:type values: dict
|
402 |
|
403 |
"""
|
404 |
self.data.append(*valuesList, **values)
|
405 |
|
406 |
def updateSchema(self, schema): |
407 |
"""
|
408 |
Update data schema definition with the given schema
|
409 |
"""
|
410 |
self.data.updateSchema(schema)
|
411 |
|
412 |
def update(self, feature): |
413 |
"""
|
414 |
Update exist feature in the featureSet
|
415 |
|
416 |
:param editableFeature: editableFeature
|
417 |
:type editableFeature: Java editableFeature
|
418 |
"""
|
419 |
self.data.update(feature)
|
420 |
|
421 |
def getSchema(self): |
422 |
"""
|
423 |
Return schema definition
|
424 |
"""
|
425 |
return self.data.getSchema() |
426 |
|
427 |
def commit(self): |
428 |
"""
|
429 |
Finish edition
|
430 |
"""
|
431 |
self.data.commit()
|
432 |
|
433 |
def abort(self): |
434 |
"""
|
435 |
Cancel edition
|
436 |
"""
|
437 |
self.data.abort()
|
438 |
|
439 |
def getSelection(self): |
440 |
"""
|
441 |
Return features selected set
|
442 |
"""
|
443 |
if self.selection == None: |
444 |
self.selection = self.data.getSelection() |
445 |
|
446 |
return self.selection |
447 |
|
448 |
def select(self, selection): |
449 |
"""
|
450 |
Insert features in the features selection set
|
451 |
"""
|
452 |
if isinstance(selection,Feature) or isinstance(selection, FeatureSet): |
453 |
self.data.getSelection().select(selection._javaobj)
|
454 |
else:
|
455 |
self.data.getSelection().select(selection)
|
456 |
|
457 |
def deselect(self, selection): |
458 |
"""
|
459 |
Remove features in the features selection set
|
460 |
"""
|
461 |
if isinstance(selection,Feature) or isinstance(selection, FeatureSet): |
462 |
self.data.getSelection().deselect(selection._javaobj)
|
463 |
else:
|
464 |
self.data.getSelection().deselect(selection)
|
465 |
|
466 |
def isSelected(feature): |
467 |
"""
|
468 |
Returns if feature is selected
|
469 |
"""
|
470 |
if isinstance(feature, Feature): |
471 |
self.data.getSelection().deselect(feature._javaobj)
|
472 |
else:
|
473 |
self.data.getSelection().deselect(feature)
|
474 |
|
475 |
def getProjectionCode(self): |
476 |
"""
|
477 |
Return layer projection code
|
478 |
"""
|
479 |
return self.getProjection().getFullCode() |
480 |
|
481 |
|
482 |
class Table(__DefaultTable__): |
483 |
"""
|
484 |
Represents gvsig layer document
|
485 |
"""
|
486 |
def __init__(self,table): |
487 |
__DefaultTable__.__init__(self, table, table.getStore())
|
488 |
|
489 |
class Layer(__DefaultTable__): |
490 |
"""
|
491 |
Represents gvsig layer document
|
492 |
"""
|
493 |
def __init__(self,layer): |
494 |
__DefaultTable__.__init__(self, layer, layer.getFeatureStore())
|
495 |
#WrapperToJava.__init__(self,layer)
|
496 |
|
497 |
def getTypeVectorLayer(self): |
498 |
return self().getTypeVectorLayer() |
499 |
|
500 |
class FeatureSet(WrapperToJava): |
501 |
def __init__(self,featureSet): |
502 |
WrapperToJava.__init__(self,featureSet)
|
503 |
|
504 |
def getCount(self): |
505 |
return self.getSize() |
506 |
|
507 |
def update(self, feature): |
508 |
"""
|
509 |
Update exist feature in the featureSet
|
510 |
|
511 |
:param editableFeature: editableFeature
|
512 |
:type editableFeature: Java editableFeature
|
513 |
"""
|
514 |
#FIXME
|
515 |
if not isinstance(feature, EditableFeature) and not isinstance(feature, DefaultEditableFeature): |
516 |
feature = feature._javaobj |
517 |
self().update(feature)
|
518 |
|
519 |
def __iter__(self): |
520 |
return Iterator(self.fastIterator()) |
521 |
|
522 |
class Iterator(WrapperToJava): |
523 |
|
524 |
def __init__(self,iterator): |
525 |
WrapperToJava.__init__(self,iterator)
|
526 |
|
527 |
def next(self): |
528 |
if not self.hasNext(): |
529 |
raise StopIteration() |
530 |
return Feature(self().next()) |
531 |
|
532 |
class Feature(WrapperToJava): |
533 |
"""
|
534 |
Represents layer feature data
|
535 |
"""
|
536 |
def __init__(self,feature): |
537 |
WrapperToJava.__init__(self,feature)
|
538 |
self.featureNoEditable = None |
539 |
|
540 |
def geometry(self): |
541 |
"""
|
542 |
Return feature default geometry
|
543 |
"""
|
544 |
return self.getDefaultGeometry() |
545 |
|
546 |
def getValues(self): |
547 |
"""
|
548 |
Return dictionary with name value attributes
|
549 |
"""
|
550 |
descriptor = self.getType()
|
551 |
items = dict()
|
552 |
for attr in descriptor.getAttributeDescriptors(): |
553 |
name = attr.getName() |
554 |
value = self.get(attr.getName())
|
555 |
items[name] = value |
556 |
return items
|
557 |
|
558 |
def edit(self): |
559 |
"""
|
560 |
Return editable feature
|
561 |
"""
|
562 |
if not isinstance(self._javaobj, EditableFeature): |
563 |
self.featureNoEditable = self._javaobj |
564 |
self._javaobj = self._javaobj.getEditable() |
565 |
|
566 |
def __getitem__(self,key): |
567 |
return self.get(key) |
568 |
|
569 |
def __getattr__(self,name): |
570 |
try:
|
571 |
v = getattr(self._javaobj,name, None) |
572 |
if v == None: |
573 |
v = self().get(name)
|
574 |
return v
|
575 |
except Throwable, ex:
|
576 |
raise RuntimeException("Can't access to attribute %s of feature (%s)" % (name, str(ex))) |
577 |
|
578 |
class Schema(WrapperToJava): |
579 |
"""
|
580 |
Layer feature definition
|
581 |
"""
|
582 |
|
583 |
def __init__(self, featureType): |
584 |
WrapperToJava.__init__(self,featureType)
|
585 |
self.featureTypeNoEditable = None |
586 |
|
587 |
def append(self, name, type, size=None, default=None, precision=4): |
588 |
"""
|
589 |
Adds property to feature properties definition.
|
590 |
|
591 |
:param name: Feature property name
|
592 |
:type name: String
|
593 |
:param type: Feature property type
|
594 |
:type name: String
|
595 |
:param size: Feature property size
|
596 |
:type size: int
|
597 |
:param default: Feature property default value
|
598 |
:return: new atribute
|
599 |
|
600 |
"""
|
601 |
if not isinstance(self._javaobj, EditableFeatureType): |
602 |
self.modify()
|
603 |
#self.featureTypeNoEditable = self._javaobj
|
604 |
#self._javaobj = self._javaobj.getEditable()
|
605 |
|
606 |
if isinstance(type, str): |
607 |
try:
|
608 |
application = ApplicationLocator.getManager() |
609 |
datamanager = application.getDataManager() |
610 |
dataTypes = application.getDataTypesManager() |
611 |
type = dataTypes.getType(type) #dataType constant value from string |
612 |
except:
|
613 |
raise RuntimeError( |
614 |
"Feature Property Data type (%s) is not valid. name=%s, type=%s, size=%s, default=%s)" % (
|
615 |
type,
|
616 |
name, |
617 |
type,
|
618 |
size, |
619 |
default |
620 |
) |
621 |
) |
622 |
if isinstance(type, int): |
623 |
try:
|
624 |
type = dataTypes.get(type)
|
625 |
except:
|
626 |
raise RuntimeError( |
627 |
"Data type (%s) is not valid. name=%s, type=%s, size=%s, default=%s)" % (
|
628 |
type,
|
629 |
name, |
630 |
type,
|
631 |
size, |
632 |
default |
633 |
) |
634 |
) |
635 |
|
636 |
attribute = self.add(name, type.getType()) |
637 |
|
638 |
if size != None: |
639 |
attribute.setSize(size) |
640 |
|
641 |
if default != None: |
642 |
attribute.setDefaultValue(default) |
643 |
|
644 |
if precision != None and type.getType() in (DataTypes.DOUBLE, DataTypes.FLOAT): |
645 |
attribute.setPrecision(precision) |
646 |
|
647 |
if type.getType() == DataTypes.GEOMETRY and self.getDefaultGeometryAttributeName()==None: |
648 |
self.setDefaultGeometryAttributeName(name)
|
649 |
|
650 |
return attribute
|
651 |
|
652 |
def __getitem__(self, name): |
653 |
return self.getAttributeDescriptor(name) |
654 |
|
655 |
def get(self, name, default=None): |
656 |
"""
|
657 |
Return a feature attribute descriptor that contains information about
|
658 |
one of the attributes in a feature, such as its name, data type or
|
659 |
precision.
|
660 |
:param name: Attribute name
|
661 |
:type name: string
|
662 |
:param default: Value to return if no attribute name found.
|
663 |
:return: AttributeDescriptor
|
664 |
"""
|
665 |
x = self.getAttributeDescriptor(name)
|
666 |
if x == None: |
667 |
return default
|
668 |
return x
|
669 |
|
670 |
def getAttrNames(self): |
671 |
"""
|
672 |
Return list with definition schema atribute names
|
673 |
"""
|
674 |
names = list(attr.getName() for attr in self.getAttributeDescriptors()) |
675 |
return names
|
676 |
"""
|
677 |
l = list()
|
678 |
for attr in self.getAttributeDescriptors():
|
679 |
l.append(attr.getName())
|
680 |
|
681 |
return l
|
682 |
"""
|
683 |
|
684 |
def getCopy(self): |
685 |
return Schema(self().getCopy()) |
686 |
|
687 |
def modify(self): |
688 |
if not isinstance(self._javaobj, EditableFeatureType): |
689 |
self.featureTypeNoEditable = self._javaobj |
690 |
self._javaobj = self._javaobj.getEditable() |
691 |
|
692 |
|
693 |
#=====================#
|
694 |
# Vectorial Functions #
|
695 |
#=====================#
|
696 |
|
697 |
def createSchema(schema = None): |
698 |
"""
|
699 |
Return empty layer definition
|
700 |
"""
|
701 |
if schema != None: |
702 |
s = schema.getCopy() |
703 |
s.modify() |
704 |
return s
|
705 |
|
706 |
application = ApplicationLocator.getManager() |
707 |
datamanager = application.getDataManager() |
708 |
return Schema(datamanager.createFeatureType())
|
709 |
|
710 |
def createLayer(schema, servertype, layertype=None, **parameters): |
711 |
"""
|
712 |
Create a new layer and return it
|
713 |
|
714 |
:param schema: layer data definition
|
715 |
:type schema: Schema
|
716 |
:param servertype:
|
717 |
:type servertype: string
|
718 |
:return: new layer
|
719 |
:rtype: Layer
|
720 |
:raise: RuntimeException
|
721 |
|
722 |
"""
|
723 |
if layertype == None: |
724 |
layertype = servertype |
725 |
servertype = "FilesystemExplorer"
|
726 |
|
727 |
if layertype == "Shape" : |
728 |
if schema.get("GEOMETRY",None) == None: |
729 |
raise RuntimeException("Shape need a field named GEOMETRY in the schema") |
730 |
|
731 |
#parameters["geometryType"] = getGeometryType(parameters["geometryType"])
|
732 |
|
733 |
if parameters["geometryType"] == None: |
734 |
raise RuntimeException("Invalid geometry type for new layer") |
735 |
|
736 |
try:
|
737 |
application = ApplicationLocator.getManager() |
738 |
datamanager = application.getDataManager() |
739 |
|
740 |
mapcontextmanager = application.getMapContextManager() |
741 |
|
742 |
server_parameters = datamanager.createServerExplorerParameters(servertype) |
743 |
copyToDynObject(parameters, server_parameters) |
744 |
|
745 |
server = datamanager.openServerExplorer(servertype, server_parameters) |
746 |
|
747 |
store_parameters = server.getAddParameters(layertype) |
748 |
copyToDynObject(parameters, store_parameters) |
749 |
store_parameters.setDefaultFeatureType(schema()) |
750 |
|
751 |
server.add(layertype, store_parameters, True)
|
752 |
|
753 |
store = datamanager.openStore(layertype, store_parameters) |
754 |
|
755 |
layer = mapcontextmanager.createLayer(store.getName(), store) |
756 |
|
757 |
return Layer(layer)
|
758 |
except Throwable, ex:
|
759 |
raise RuntimeException("Can't create layer, "+ str(ex)) |
760 |
|
761 |
def createShape(definition, filename, geometryType, CRS="wsg86"): |
762 |
"""
|
763 |
Create a new shape layer
|
764 |
|
765 |
:param definition: layer data definition
|
766 |
:type definition: Schema
|
767 |
:param filename: absolute path for shape files.
|
768 |
:type filename: string
|
769 |
:param geometryType: geometry type for shape
|
770 |
:type geometryType: string
|
771 |
:return: new shape layer
|
772 |
:rtype: Layer
|
773 |
"""
|
774 |
return createLayer(
|
775 |
definition, |
776 |
"FilesystemExplorer",
|
777 |
"Shape",
|
778 |
shpFile=filename, |
779 |
CRS=CRS, |
780 |
geometryType = geometryType |
781 |
) |
782 |
|
783 |
def createTable(schema, servertype, tableType=None, **parameters): |
784 |
if tableType == None: |
785 |
tableType = servertype |
786 |
servertype = "FilesystemExplorer"
|
787 |
|
788 |
try:
|
789 |
application = ApplicationLocator.getManager() |
790 |
datamanager = application.getDataManager() |
791 |
|
792 |
server_parameters = datamanager.createServerExplorerParameters(servertype) |
793 |
copyToDynObject(parameters, server_parameters) |
794 |
|
795 |
server = datamanager.openServerExplorer(servertype, server_parameters) |
796 |
|
797 |
store_parameters = server.getAddParameters(tableType) |
798 |
copyToDynObject(parameters, store_parameters) |
799 |
store_parameters.setDefaultFeatureType(schema()) |
800 |
|
801 |
server.add(tableType, store_parameters, True)
|
802 |
|
803 |
store = datamanager.openStore(tableType, store_parameters) |
804 |
|
805 |
return Table(store)
|
806 |
|
807 |
except Throwable, ex:
|
808 |
raise RuntimeException("Can't create table, "+ str(ex)) |
809 |
|
810 |
def createDBF(definition, DbfFile, CRS="wsg86"): |
811 |
"""
|
812 |
Create a new dbf document
|
813 |
|
814 |
:param definition: layer data definition
|
815 |
:type definition: Schema
|
816 |
:param DbfFile: absolute path for shape files.
|
817 |
:type DbfFile: string
|
818 |
:return: new dbf
|
819 |
:rtype: Table
|
820 |
"""
|
821 |
return createTable(
|
822 |
definition, |
823 |
"FilesystemExplorer",
|
824 |
"DBF",
|
825 |
DbfFile=DbfFile, |
826 |
CRS=CRS, |
827 |
) |
828 |
|
829 |
#=====================#
|
830 |
# Documents Functions #
|
831 |
#=====================#
|
832 |
|
833 |
def currentProject(): |
834 |
"""
|
835 |
Return the current gvSIG proyect
|
836 |
:return: Proyect
|
837 |
"""
|
838 |
|
839 |
application = ApplicationLocator.getManager() |
840 |
project = application.getCurrentProject() |
841 |
return Project(project)
|
842 |
|
843 |
def currentDocument(): |
844 |
"""
|
845 |
Return the current active document if it's a DocumentTable or DocumentView2D
|
846 |
|
847 |
:return: Active document, None
|
848 |
"""
|
849 |
|
850 |
application = ApplicationLocator.getManager() |
851 |
doc = application.getActiveDocument() |
852 |
|
853 |
if doc.getTypeName() == "project.document.table": |
854 |
return Table(doc)
|
855 |
|
856 |
if doc.getTypeName() == "project.document.view2d": |
857 |
return View(doc)
|
858 |
|
859 |
return None |
860 |
|
861 |
def currentTable(): |
862 |
"""
|
863 |
Return the current active table document or None
|
864 |
|
865 |
:return: Table or None
|
866 |
"""
|
867 |
return Table(currentProject().getTable())
|
868 |
|
869 |
def currentView(): |
870 |
"""
|
871 |
Return the current active view document or None
|
872 |
|
873 |
:return: View or None
|
874 |
"""
|
875 |
|
876 |
return View(currentProject().getView())
|
877 |
|
878 |
def currentLayer(): |
879 |
"""
|
880 |
Return current view active layer
|
881 |
|
882 |
:return: gvSIG active layer
|
883 |
"""
|
884 |
|
885 |
return currentView().getLayer()
|
886 |
|
887 |
#=====================#
|
888 |
# Simbology Functions #
|
889 |
#=====================#
|
890 |
|
891 |
def simplePointSymbol(color=None): |
892 |
"""
|
893 |
Return simple point symbol using parameter color
|
894 |
|
895 |
:param color: Java awt Color
|
896 |
:return: gvSIG point symbol
|
897 |
"""
|
898 |
if not isinstance(color, Color): |
899 |
color = getColor() |
900 |
|
901 |
return MapContextLocator.getSymbolManager().createSymbol(POINT, color)
|
902 |
|
903 |
def simpleLineSymbol(color=None): |
904 |
"""
|
905 |
Return simple line symbol using parameter color
|
906 |
|
907 |
:param color: Java awt Color
|
908 |
:return: gvSIG line symbol
|
909 |
"""
|
910 |
if not isinstance(color, Color): |
911 |
color = getColor() |
912 |
|
913 |
return MapContextLocator.getSymbolManager().createSymbol(CURVE, color)
|
914 |
|
915 |
def simplePoligonSymbol(color = None): |
916 |
"""
|
917 |
Return simple poligon symbol using parameter color
|
918 |
|
919 |
:param color: Java awt Color
|
920 |
:return: gvSIG poligon symbol
|
921 |
"""
|
922 |
if not isinstance(color, Color): |
923 |
color = getColor() |
924 |
|
925 |
return MapContextLocator.getSymbolManager().createSymbol(SURFACE, color)
|
926 |
|
927 |
|
928 |
#=========================================#
|
929 |
# gvSIG Application Preferences Functions #
|
930 |
#=========================================#
|
931 |
|
932 |
def getDataFolder(): |
933 |
"""
|
934 |
Return gvSIG data folder. This folder is defined in application preferences
|
935 |
If not defined return None
|
936 |
"""
|
937 |
|
938 |
return Preferences.userRoot().node("gvsig.foldering").get('DataFolder', None) |
939 |
|
940 |
def getProjectsFolder(): |
941 |
"""
|
942 |
Return gvSIG projects folder. This folder is defined in application preferences.
|
943 |
If not defined return None
|
944 |
"""
|
945 |
|
946 |
return Preferences.userRoot().node("gvsig.foldering").get('ProjectsFolder', None) |
947 |
|
948 |
|
949 |
def getColor(): |
950 |
if MapContextLocator.getSymbolManager().isDefaultSymbolFillColorAleatory():
|
951 |
color = Color(random.randint(0-255), |
952 |
random.randint(0-255), |
953 |
random.randint(0-255) |
954 |
) |
955 |
else:
|
956 |
color = MapContextLocator.getSymbolManager().getSymbolPreferences().getDefaultSymbolFillColor() |
957 |
return color
|
958 |
|
959 |
#================#
|
960 |
# OTHER #
|
961 |
#================#
|
962 |
def copyToDynObject(values, target): |
963 |
definition = target.getDynClass(); |
964 |
fields = definition.getDynFields(); |
965 |
for field in fields: |
966 |
name = field.getName() |
967 |
keys = values.keys() |
968 |
for k in keys: |
969 |
if k.lower() == name.lower():
|
970 |
target.setDynValue(name, values[name]) |
971 |
break
|
972 |
# ====================================
|
973 |
#
|
974 |
|
975 |
def main(): |
976 |
layer = currentLayer() |
977 |
schema = createSchema() |
978 |
schema.append("ID", "String", 50) |
979 |
schema.append("GEOMETRY", "Geometry") |
980 |
|
981 |
output = createLayer( |
982 |
schema, |
983 |
"FilesystemExplorer",
|
984 |
"Shape",
|
985 |
shpFile="/tmp/pp.shp",
|
986 |
CRS="EPSG:23030",
|
987 |
geometryType=POINT |
988 |
) |
989 |
|
990 |
for feature in layer.features(): |
991 |
point = feature.geometry().centroid() |
992 |
output.append(ID=feature.ID, GEOMETRY=point) |
993 |
|
994 |
output.commit() |
995 |
|
996 |
currentView().addLayer(output()) |