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$"

import os
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 table import Table

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 = 1):
        """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, filename, projection = None,
                 fill = Color.Transparent, 
                 stroke = Color.Black, 
                 lineWidth = 1, 
                 visible = 1):
        """Initialize the layer.

        title -- the title
        filename -- the name of the shapefile
        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)

        # Make the filename absolute. The filename will be
        # interpreted relative to that anyway, but when saving a
        # session we need to compare absolute paths and it's usually
        # safer to always work with absolute paths.
        self.filename = os.path.abspath(filename)

        self.projection = projection
        self.shapefile = None
        self.shapetree = None
        self.open_shapefile()
        # shapetable is the table associated with the shapefile, while
        # table is the default table used to look up attributes for
        # display
        self.shapetable = Table(filename)
        self.table = self.shapetable

        #
        # 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.SetClassification(None)

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

        self.UnsetModified()

    def open_shapefile(self):
        if self.shapefile is None:
            self.shapefile = shapelib.ShapeFile(self.filename)
            numshapes, shapetype, mins, maxs = self.shapefile.info()
            self.numshapes = numshapes
            self.shapetype = shapelib_shapetypes[shapetype]

            # if there are shapes, set the bbox accordinly. 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)

    def Destroy(self):
        BaseLayer.Destroy(self)
        if self.shapefile is not None:
            self.shapefile.close()
            self.shapefile = None
            self.shapetree = None
        self.SetClassification(None)
        self.table.Destroy()

    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 the coordinate
        system used by the layer's shapefile.
        """
        left, bottom, right, top = box
        return self.shapetree.find_shapes((left, bottom), (right, top))

    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()])

        items.append(self.__classification)

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

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