Thuban/Model/layer.py

# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

__version__ = "$Revision$"

from math import log, ceil

from Thuban import _

import shapelib, shptree

from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
     LAYER_CHANGED

from color import Color

import classification

from base import TitledObject, Modifiable


class Shape:

    """Represent one shape"""

    def __init__(self, points):
        self.points = points
        #self.compute_bbox()

    def compute_bbox(self):
        xs = []
        ys = []
        for x, y in self.points:
            xs.append(x)
            ys.append(y)
        self.llx = min(xs)
        self.lly = min(ys)
        self.urx = max(xs)
        self.ury = max(ys)

    def Points(self):
        return self.points


# Shape type constants
SHAPETYPE_POLYGON = "polygon"
SHAPETYPE_ARC = "arc"
SHAPETYPE_POINT = "point"

# mapping from shapelib shapetype constants to our constants
shapelib_shapetypes = {shapelib.SHPT_POLYGON: SHAPETYPE_POLYGON,
                       shapelib.SHPT_ARC: SHAPETYPE_ARC,
                       shapelib.SHPT_POINT: SHAPETYPE_POINT}

shapetype_names = {SHAPETYPE_POINT: "Point",
                   SHAPETYPE_ARC: "Arc",
                   SHAPETYPE_POLYGON: "Polygon"}

class BaseLayer(TitledObject, Modifiable):

    """Base class for the layers."""

    def __init__(self, title, visible = True):
        """Initialize the layer.

        title -- the title
        visible -- boolean. If true the layer is visible.
        """
        TitledObject.__init__(self, title)
        Modifiable.__init__(self)
        self.visible = visible

    def Visible(self):
        """Return true if layer is visible"""
        return self.visible

    def SetVisible(self, visible):
        """Set the layer's visibility."""
        self.visible = visible
        self.issue(LAYER_VISIBILITY_CHANGED, self)


class Layer(BaseLayer):

    """Represent the information of one geodata file (currently a shapefile)

    All children of the layer have the same type.

    A layer has fill and stroke colors. Colors should be instances of
    Color. They can also be None, indicating no fill or no stroke.

    The layer objects send the following events, all of which have the
    layer object as parameter:

        TITLE_CHANGED -- The title has changed.
        LAYER_PROJECTION_CHANGED -- the projection has changed.
    """

    def __init__(self, title, data, projection = None,
                 fill = Color.Transparent, 
                 stroke = Color.Black, 
                 lineWidth = 1, 
                 visible = True):
        """Initialize the layer.

        title -- the title
        data -- datastore object for the shape data shown by the layer
        projection -- the projection object. Its Inverse method is
               assumed to map the layer's coordinates to lat/long
               coordinates
        fill -- the fill color or Color.Transparent if the shapes are 
                not filled
        stroke -- the stroke color or Color.Transparent if the shapes 
                are not stroked
        visible -- boolean. If true the layer is visible.

        colors are expected to be instances of Color class
        """
        BaseLayer.__init__(self, title, visible = visible)

        self.projection = projection

        #
        # this is really important so that when the classification class
        # tries to set its parent layer the variable will exist
        #
        self.__classification = None
        self.__setClassLock = False

        self.SetShapeStore(data)

        self.SetClassification(None)

        self.__classification.SetDefaultLineColor(stroke)
        self.__classification.SetDefaultLineWidth(lineWidth)
        self.__classification.SetDefaultFill(fill)
        self.__classification.SetLayer(self)

        self.UnsetModified()


    def SetShapeStore(self, store):
        self.store = store
        self.shapefile = self.store.Shapefile()
        self.shapetable = self.store.Table()
        self.filename = self.store.filename
        self.table = self.shapetable

        numshapes, shapetype, mins, maxs = self.shapefile.info()
        self.numshapes = numshapes
        self.shapetype = shapelib_shapetypes[shapetype]

        # if there are shapes, set the bbox accordingly. Otherwise
        # set it to None.
        if self.numshapes:
            self.bbox = mins[:2] + maxs[:2]
        else:
            self.bbox = None

        # estimate a good depth for the quad tree. Each depth
        # multiplies the number of nodes by four, therefore we
        # basically take the base 4 logarithm of the number of
        # shapes.
        if self.numshapes < 4:
            maxdepth = 1
        else:
            maxdepth = int(ceil(log(self.numshapes / 4.0) / log(4)))

        self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2,
                                         maxdepth)
        if self.__classification is not None:
            fieldname = self.__classification.GetField()
            if fieldname is not None and \
               not self.store.Table().field_info_by_name(fieldname):
                self.SetClassification(None)
        self.changed(LAYER_CHANGED, self)

    def ShapeStore(self):
        return self.store

    def Destroy(self):
        BaseLayer.Destroy(self)
        self.SetClassification(None)

    def BoundingBox(self):
        """Return the layer's bounding box in the intrinsic coordinate system.

        If the layer has no shapes, return None.
        """
        return self.bbox

    def LatLongBoundingBox(self):
        """Return the layer's bounding box in lat/long coordinates.

        Return None, if the layer doesn't contain any shapes.
        """
        bbox = self.BoundingBox()
        if bbox is not None:
            llx, lly, urx, ury = bbox
            if self.projection is not None:
                llx, lly = self.projection.Inverse(llx, lly)
                urx, ury = self.projection.Inverse(urx, ury)
            return llx, lly, urx, ury
        else:
            return None

    def GetFieldType(self, fieldName):
        info = self.table.field_info_by_name(fieldName)
        if info is not None:
            return info[0]
        else:
            return None

    def NumShapes(self):
        """Return the number of shapes in the layer"""
        return self.numshapes

    def ShapeType(self):
        """Return the type of the shapes in the layer.
        This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.
        """
        return self.shapetype

    def Shape(self, index):
        """Return the shape with index index"""
        shape = self.shapefile.read_object(index)

        if self.shapetype == SHAPETYPE_POINT:
            points = shape.vertices()
        else:
            #for poly in shape.vertices():
            poly = shape.vertices()[0]
            points = []
            for x, y in poly:
                points.append((x, y))

        return Shape(points)

    def ShapesInRegion(self, box):
        """Return the ids of the shapes that overlap the box.

        Box is a tuple (left, bottom, right, top) in unprojected coordinates.
        """
        left, bottom, right, top = box

        if self.projection is not None:
            left,  bottom = self.projection.Forward(left, bottom)
            right, top    = self.projection.Forward(right, top)

        return self.shapetree.find_shapes((left, bottom), (right, top))

    def GetProjection(self):
        return self.projection

    def SetProjection(self, projection):
        """Set the layer's projection"""
        self.projection = projection
        self.changed(LAYER_PROJECTION_CHANGED, self)

    def GetClassification(self):
        return self.__classification

    def SetClassification(self, clazz):
        """Set the classification to 'clazz'

        If 'clazz' is None a default classification is created
        """

        # prevent infinite recursion when calling SetLayer()
        if self.__setClassLock: return

        self.__setClassLock = True

        if clazz is None:
            if self.__classification is not None:
                self.__classification.SetLayer(None)
            self.__classification = classification.Classification()
        else:
            self.__classification = clazz
            try:
                self.__classification.SetLayer(self)
            except ValueError:
                self.__setClassLock = False
                raise ValueError

        self.changed(LAYER_CHANGED, self)

        self.__setClassLock = False

    def ClassChanged(self):
        """Called from the classification object when it has changed."""
        self.changed(LAYER_CHANGED, self)
 
    def TreeInfo(self):
        items = []

        if self.Visible():
            items.append(_("Shown"))
        else:
            items.append(_("Hidden"))
        items.append(_("Shapes: %d") % self.NumShapes())

        bbox = self.LatLongBoundingBox()
        if bbox is not None:
            items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)
        else:
            items.append(_("Extent (lat-lon):"))
        items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])

        if self.projection and len(self.projection.params) > 0:
            items.append((_("Projection"),
                        [str(param) for param in self.projection.params]))

        items.append(self.__classification)

        return (_("Layer '%s'") % self.Title(), items)


1	# Copyright (c) 2001, 2002, 2003 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	# Jonathan Coles <[email protected]>
5	#
6	# This program is free software under the GPL (>=v2)
7	# Read the file COPYING coming with Thuban for details.
8
9	__version__ = "$Revision$"
10
11	from math import log, ceil
12
13	from Thuban import _
14
15	import shapelib, shptree
16
17	from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
18	LAYER_CHANGED
19
20	from color import Color
21
22	import classification
23
24	from base import TitledObject, Modifiable
25
26
27	class Shape:
28
29	"""Represent one shape"""
30
31	def __init__(self, points):
32	self.points = points
33	#self.compute_bbox()
34
35	def compute_bbox(self):
36	xs = []
37	ys = []
38	for x, y in self.points:
39	xs.append(x)
40	ys.append(y)
41	self.llx = min(xs)
42	self.lly = min(ys)
43	self.urx = max(xs)
44	self.ury = max(ys)
45
46	def Points(self):
47	return self.points
48
49
50
51	# Shape type constants
52	SHAPETYPE_POLYGON = "polygon"
53	SHAPETYPE_ARC = "arc"
54	SHAPETYPE_POINT = "point"
55
56	# mapping from shapelib shapetype constants to our constants
57	shapelib_shapetypes = {shapelib.SHPT_POLYGON: SHAPETYPE_POLYGON,
58	shapelib.SHPT_ARC: SHAPETYPE_ARC,
59	shapelib.SHPT_POINT: SHAPETYPE_POINT}
60
61	shapetype_names = {SHAPETYPE_POINT: "Point",
62	SHAPETYPE_ARC: "Arc",
63	SHAPETYPE_POLYGON: "Polygon"}
64
65	class BaseLayer(TitledObject, Modifiable):
66
67	"""Base class for the layers."""
68
69	def __init__(self, title, visible = True):
70	"""Initialize the layer.
71
72	title -- the title
73	visible -- boolean. If true the layer is visible.
74	"""
75	TitledObject.__init__(self, title)
76	Modifiable.__init__(self)
77	self.visible = visible
78
79	def Visible(self):
80	"""Return true if layer is visible"""
81	return self.visible
82
83	def SetVisible(self, visible):
84	"""Set the layer's visibility."""
85	self.visible = visible
86	self.issue(LAYER_VISIBILITY_CHANGED, self)
87
88
89	class Layer(BaseLayer):
90
91	"""Represent the information of one geodata file (currently a shapefile)
92
93	All children of the layer have the same type.
94
95	A layer has fill and stroke colors. Colors should be instances of
96	Color. They can also be None, indicating no fill or no stroke.
97
98	The layer objects send the following events, all of which have the
99	layer object as parameter:
100
101	TITLE_CHANGED -- The title has changed.
102	LAYER_PROJECTION_CHANGED -- the projection has changed.
103	"""
104
105	def __init__(self, title, data, projection = None,
106	fill = Color.Transparent,
107	stroke = Color.Black,
108	lineWidth = 1,
109	visible = True):
110	"""Initialize the layer.
111
112	title -- the title
113	data -- datastore object for the shape data shown by the layer
114	projection -- the projection object. Its Inverse method is
115	assumed to map the layer's coordinates to lat/long
116	coordinates
117	fill -- the fill color or Color.Transparent if the shapes are
118	not filled
119	stroke -- the stroke color or Color.Transparent if the shapes
120	are not stroked
121	visible -- boolean. If true the layer is visible.
122
123	colors are expected to be instances of Color class
124	"""
125	BaseLayer.__init__(self, title, visible = visible)
126
127	self.projection = projection
128
129	#
130	# this is really important so that when the classification class
131	# tries to set its parent layer the variable will exist
132	#
133	self.__classification = None
134	self.__setClassLock = False
135
136	self.SetShapeStore(data)
137
138	self.SetClassification(None)
139
140	self.__classification.SetDefaultLineColor(stroke)
141	self.__classification.SetDefaultLineWidth(lineWidth)
142	self.__classification.SetDefaultFill(fill)
143	self.__classification.SetLayer(self)
144
145	self.UnsetModified()
146
147
148	def SetShapeStore(self, store):
149	self.store = store
150	self.shapefile = self.store.Shapefile()
151	self.shapetable = self.store.Table()
152	self.filename = self.store.filename
153	self.table = self.shapetable
154
155	numshapes, shapetype, mins, maxs = self.shapefile.info()
156	self.numshapes = numshapes
157	self.shapetype = shapelib_shapetypes[shapetype]
158
159	# if there are shapes, set the bbox accordingly. Otherwise
160	# set it to None.
161	if self.numshapes:
162	self.bbox = mins[:2] + maxs[:2]
163	else:
164	self.bbox = None
165
166	# estimate a good depth for the quad tree. Each depth
167	# multiplies the number of nodes by four, therefore we
168	# basically take the base 4 logarithm of the number of
169	# shapes.
170	if self.numshapes < 4:
171	maxdepth = 1
172	else:
173	maxdepth = int(ceil(log(self.numshapes / 4.0) / log(4)))
174
175	self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2,
176	maxdepth)
177	if self.__classification is not None:
178	fieldname = self.__classification.GetField()
179	if fieldname is not None and \
180	not self.store.Table().field_info_by_name(fieldname):
181	self.SetClassification(None)
182	self.changed(LAYER_CHANGED, self)
183
184	def ShapeStore(self):
185	return self.store
186
187	def Destroy(self):
188	BaseLayer.Destroy(self)
189	self.SetClassification(None)
190
191	def BoundingBox(self):
192	"""Return the layer's bounding box in the intrinsic coordinate system.
193
194	If the layer has no shapes, return None.
195	"""
196	return self.bbox
197
198	def LatLongBoundingBox(self):
199	"""Return the layer's bounding box in lat/long coordinates.
200
201	Return None, if the layer doesn't contain any shapes.
202	"""
203	bbox = self.BoundingBox()
204	if bbox is not None:
205	llx, lly, urx, ury = bbox
206	if self.projection is not None:
207	llx, lly = self.projection.Inverse(llx, lly)
208	urx, ury = self.projection.Inverse(urx, ury)
209	return llx, lly, urx, ury
210	else:
211	return None
212
213	def GetFieldType(self, fieldName):
214	info = self.table.field_info_by_name(fieldName)
215	if info is not None:
216	return info[0]
217	else:
218	return None
219
220	def NumShapes(self):
221	"""Return the number of shapes in the layer"""
222	return self.numshapes
223
224	def ShapeType(self):
225	"""Return the type of the shapes in the layer.
226	This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.
227	"""
228	return self.shapetype
229
230	def Shape(self, index):
231	"""Return the shape with index index"""
232	shape = self.shapefile.read_object(index)
233
234	if self.shapetype == SHAPETYPE_POINT:
235	points = shape.vertices()
236	else:
237	#for poly in shape.vertices():
238	poly = shape.vertices()[0]
239	points = []
240	for x, y in poly:
241	points.append((x, y))
242
243	return Shape(points)
244
245	def ShapesInRegion(self, box):
246	"""Return the ids of the shapes that overlap the box.
247
248	Box is a tuple (left, bottom, right, top) in unprojected coordinates.
249	"""
250	left, bottom, right, top = box
251
252	if self.projection is not None:
253	left, bottom = self.projection.Forward(left, bottom)
254	right, top = self.projection.Forward(right, top)
255
256	return self.shapetree.find_shapes((left, bottom), (right, top))
257
258	def GetProjection(self):
259	return self.projection
260
261	def SetProjection(self, projection):
262	"""Set the layer's projection"""
263	self.projection = projection
264	self.changed(LAYER_PROJECTION_CHANGED, self)
265
266	def GetClassification(self):
267	return self.__classification
268
269	def SetClassification(self, clazz):
270	"""Set the classification to 'clazz'
271
272	If 'clazz' is None a default classification is created
273	"""
274
275	# prevent infinite recursion when calling SetLayer()
276	if self.__setClassLock: return
277
278	self.__setClassLock = True
279
280	if clazz is None:
281	if self.__classification is not None:
282	self.__classification.SetLayer(None)
283	self.__classification = classification.Classification()
284	else:
285	self.__classification = clazz
286	try:
287	self.__classification.SetLayer(self)
288	except ValueError:
289	self.__setClassLock = False
290	raise ValueError
291
292	self.changed(LAYER_CHANGED, self)
293
294	self.__setClassLock = False
295
296	def ClassChanged(self):
297	"""Called from the classification object when it has changed."""
298	self.changed(LAYER_CHANGED, self)
299
300	def TreeInfo(self):
301	items = []
302
303	if self.Visible():
304	items.append(_("Shown"))
305	else:
306	items.append(_("Hidden"))
307	items.append(_("Shapes: %d") % self.NumShapes())
308
309	bbox = self.LatLongBoundingBox()
310	if bbox is not None:
311	items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)
312	else:
313	items.append(_("Extent (lat-lon):"))
314	items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])
315
316	if self.projection and len(self.projection.params) > 0:
317	items.append((_("Projection"),
318	[str(param) for param in self.projection.params]))
319
320	items.append(self.__classification)
321
322	return (_("Layer '%s'") % self.Title(), items)
323
324
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision