Thuban/Model/layer.py

# Copyright (c) 2001, 2002 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_LEGEND_CHANGED, \
     LAYER_VISIBILITY_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.
        LAYER_LEGEND_CHANGED -- the fill or stroke attributes have changed

    """

    def __init__(self, title, filename, projection = None,
                 fill = Color.None, 
                 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.None if the shapes are not filled
        stroke -- the stroke color or Color.None 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

        self.__classification = classification.Classification(self)
        self.__classification.SetDefaultLineColor(stroke)
        self.__classification.SetDefaultLineWidth(lineWidth)
        self.__classification.SetDefaultFill(fill)

        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.table.Destroy()

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

        If the layer has no shapes, return None.
        """
        # The bbox will be set by open_shapefile just as we need it
        # here.
        self.open_shapefile()
        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):
        self.open_shapefile()
        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"""
        self.open_shapefile()
        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.
        """
        self.open_shapefile()
        return self.shapetype

    def Shape(self, index):
        """Return the shape with index index"""
        self.open_shapefile()
        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):
        self.__classification = clazz
        self.changed(LAYER_LEGEND_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	73	# Copyright (c) 2001, 2002 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			from messages import LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
19			LAYER_VISIBILITY_CHANGED
20
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			LAYER_LEGEND_CHANGED -- the fill or stroke attributes have changed
106
107			"""
108
109			def __init__(self, title, filename, projection = None,
110	jonathan	412	fill = Color.None,
111			stroke = Color.Black,
112	jonathan	464	lineWidth = 1,
113	jonathan	412	visible = 1):
114	bh	6	"""Initialize the layer.
115
116			title -- the title
117			filename -- the name of the shapefile
118			projection -- the projection object. Its Inverse method is
119			assumed to map the layer's coordinates to lat/long
120			coordinates
121	jonathan	464	fill -- the fill color or Color.None if the shapes are not filled
122			stroke -- the stroke color or Color.None if the shapes 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	437	self.__classification = classification.Classification(self)
146	jonathan	464	self.__classification.SetDefaultLineColor(stroke)
147			self.__classification.SetDefaultLineWidth(lineWidth)
148	jonathan	412	self.__classification.SetDefaultFill(fill)
149	jonathan	364
150	jonathan	389	self.UnsetModified()
151
152	bh	6	def open_shapefile(self):
153			if self.shapefile is None:
154			self.shapefile = shapelib.ShapeFile(self.filename)
155			numshapes, shapetype, mins, maxs = self.shapefile.info()
156			self.numshapes = numshapes
157			self.shapetype = shapelib_shapetypes[shapetype]
158
159	bh	179	# if there are shapes, set the bbox accordinly. 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	bh	171	# 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
178	bh	258	def Destroy(self):
179	bh	260	BaseLayer.Destroy(self)
180	bh	258	if self.shapefile is not None:
181			self.shapefile.close()
182			self.shapefile = None
183			self.shapetree = None
184			self.table.Destroy()
185
186	bh	6	def BoundingBox(self):
187	bh	179	"""Return the layer's bounding box in the intrinsic coordinate system.
188
189			If the layer has no shapes, return None.
190			"""
191			# The bbox will be set by open_shapefile just as we need it
192			# here.
193	bh	6	self.open_shapefile()
194			return self.bbox
195
196			def LatLongBoundingBox(self):
197	bh	179	"""Return the layer's bounding box in lat/long coordinates.
198	bh	6
199	bh	179	Return None, if the layer doesn't contain any shapes.
200			"""
201			bbox = self.BoundingBox()
202			if bbox is not None:
203			llx, lly, urx, ury = bbox
204			if self.projection is not None:
205			llx, lly = self.projection.Inverse(llx, lly)
206			urx, ury = self.projection.Inverse(urx, ury)
207			return llx, lly, urx, ury
208			else:
209			return None
210
211	jonathan	464	def GetFieldType(self, fieldName):
212			self.open_shapefile()
213			info = self.table.field_info_by_name(fieldName)
214			if info is not None:
215			return info[0]
216			else:
217			return None
218
219	bh	6	def NumShapes(self):
220			"""Return the number of shapes in the layer"""
221			self.open_shapefile()
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			self.open_shapefile()
229			return self.shapetype
230
231			def Shape(self, index):
232			"""Return the shape with index index"""
233			self.open_shapefile()
234			shape = self.shapefile.read_object(index)
235	jonathan	364
236	bh	6	if self.shapetype == SHAPETYPE_POINT:
237			points = shape.vertices()
238			else:
239			#for poly in shape.vertices():
240			poly = shape.vertices()[0]
241			points = []
242			for x, y in poly:
243	bh	82	points.append((x, y))
244	jonathan	364
245	bh	6	return Shape(points)
246
247	bh	143	def ShapesInRegion(self, box):
248			"""Return the ids of the shapes that overlap the box.
249
250			Box is a tuple (left, bottom, right, top) in the coordinate
251			system used by the layer's shapefile.
252			"""
253			left, bottom, right, top = box
254	bh	147	return self.shapetree.find_shapes((left, bottom), (right, top))
255	bh	143
256	bh	6	def SetProjection(self, projection):
257			"""Set the layer's projection"""
258			self.projection = projection
259			self.changed(LAYER_PROJECTION_CHANGED, self)
260
261	jonathan	412	def GetClassification(self):
262			return self.__classification
263
264			def SetClassification(self, clazz):
265			self.__classification = clazz
266			self.changed(LAYER_LEGEND_CHANGED, self)
267
268	bh	217	def TreeInfo(self):
269			items = []
270
271			if self.Visible():
272	jan	374	items.append(_("Shown"))
273	bh	217	else:
274	jan	374	items.append(_("Hidden"))
275			items.append(_("Shapes: %d") % self.NumShapes())
276	bh	217
277			bbox = self.LatLongBoundingBox()
278			if bbox is not None:
279	jan	374	items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)
280	bh	217	else:
281	jan	374	items.append(_("Extent (lat-lon):"))
282			items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])
283	bh	217
284	jonathan	412	items.append(self.__classification)
285	bh	217
286	jan	374	return (_("Layer '%s'") % self.Title(), items)
287	jonathan	382
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision