Thuban/Model/layer.py

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

__version__ = "$Revision$"

import shapelib, shptree

from messages import LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
     LAYER_VISIBILITY_CHANGED

from color import Color
# Some predefined colors for internal use
_black = Color(0, 0, 0)


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 = None, stroke = _black, stroke_width = 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 None if the shapes are not filled
        stroke -- the stroke color or 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)
        self.filename = filename
        self.projection = projection
        self.fill = fill
        self.stroke = stroke
        self.stroke_width = stroke_width
        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

    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]
            self.bbox = mins[:2] + maxs[:2]
            #print "building tree for", self.filename, "..."
            self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2, 0)
            #print "done"

    def BoundingBox(self):
        """Return the bounding box of the layer's shapes in their default
        coordinate system"""
        self.open_shapefile()
        return self.bbox

    def LatLongBoundingBox(self):
        """Return the layer's bounding box in lat/long coordinates"""
        llx, lly, urx, ury = self.BoundingBox()
        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

    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 SetFill(self, fill):
        """Set the layer's fill color. None means the shapes are not filled"""
        self.fill = fill
        self.changed(LAYER_LEGEND_CHANGED, self)

    def SetStroke(self, stroke):
        """Set the layer's stroke color. None means the shapes are not
        stroked."""
        self.stroke = stroke
        self.changed(LAYER_LEGEND_CHANGED, self)

    def SetStrokeWidth(self, width):
        """Set the layer's stroke width."""
        self.stroke_width = width
        self.changed(LAYER_LEGEND_CHANGED, self)
1	bh	73	# Copyright (c) 2001, 2002 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			__version__ = "$Revision$"
9
10	bh	143	import shapelib, shptree
11	bh	6
12			from messages import LAYER_PROJECTION_CHANGED, LAYER_LEGEND_CHANGED, \
13			LAYER_VISIBILITY_CHANGED
14
15			from color import Color
16			# Some predefined colors for internal use
17			_black = Color(0, 0, 0)
18
19
20			from table import Table
21
22			from base import TitledObject, Modifiable
23
24			class Shape:
25
26			"""Represent one shape"""
27
28			def __init__(self, points):
29			self.points = points
30			#self.compute_bbox()
31
32			def compute_bbox(self):
33			xs = []
34			ys = []
35			for x, y in self.points:
36			xs.append(x)
37			ys.append(y)
38			self.llx = min(xs)
39			self.lly = min(ys)
40			self.urx = max(xs)
41			self.ury = max(ys)
42
43			def Points(self):
44			return self.points
45
46
47
48			# Shape type constants
49			SHAPETYPE_POLYGON = "polygon"
50			SHAPETYPE_ARC = "arc"
51			SHAPETYPE_POINT = "point"
52
53			# mapping from shapelib shapetype constants to our constants
54			shapelib_shapetypes = {shapelib.SHPT_POLYGON: SHAPETYPE_POLYGON,
55			shapelib.SHPT_ARC: SHAPETYPE_ARC,
56			shapelib.SHPT_POINT: SHAPETYPE_POINT}
57
58			shapetype_names = {SHAPETYPE_POINT: "Point",
59			SHAPETYPE_ARC: "Arc",
60			SHAPETYPE_POLYGON: "Polygon"}
61
62			class BaseLayer(TitledObject, Modifiable):
63
64			"""Base class for the layers."""
65
66			def __init__(self, title, visible = 1):
67			"""Initialize the layer.
68
69			title -- the title
70			visible -- boolean. If true the layer is visible.
71			"""
72			TitledObject.__init__(self, title)
73			Modifiable.__init__(self)
74			self.visible = visible
75
76			def Visible(self):
77			"""Return true if layer is visible"""
78			return self.visible
79
80			def SetVisible(self, visible):
81			"""Set the layer's visibility."""
82			self.visible = visible
83			self.issue(LAYER_VISIBILITY_CHANGED, self)
84
85
86			class Layer(BaseLayer):
87
88			"""Represent the information of one geodata file (currently a shapefile)
89
90			All children of the layer have the same type.
91
92			A layer has fill and stroke colors. Colors should be instances of
93			Color. They can also be None, indicating no fill or no stroke.
94
95			The layer objects send the following events, all of which have the
96			layer object as parameter:
97
98			TITLE_CHANGED -- The title has changed.
99			LAYER_PROJECTION_CHANGED -- the projection has changed.
100			LAYER_LEGEND_CHANGED -- the fill or stroke attributes have changed
101
102			"""
103
104			def __init__(self, title, filename, projection = None,
105	bh	73	fill = None, stroke = _black, stroke_width = 1, visible = 1):
106	bh	6	"""Initialize the layer.
107
108			title -- the title
109			filename -- the name of the shapefile
110			projection -- the projection object. Its Inverse method is
111			assumed to map the layer's coordinates to lat/long
112			coordinates
113			fill -- the fill color or None if the shapes are not filled
114			stroke -- the stroke color or None if the shapes are not stroked
115			visible -- boolean. If true the layer is visible.
116
117			colors are expected to be instances of Color class
118			"""
119			BaseLayer.__init__(self, title, visible = visible)
120			self.filename = filename
121			self.projection = projection
122			self.fill = fill
123			self.stroke = stroke
124	bh	73	self.stroke_width = stroke_width
125	bh	6	self.shapefile = None
126	bh	143	self.shapetree = None
127	bh	21	self.open_shapefile()
128	bh	6	# shapetable is the table associated with the shapefile, while
129			# table is the default table used to look up attributes for
130			# display
131			self.shapetable = Table(filename)
132			self.table = self.shapetable
133
134			def open_shapefile(self):
135			if self.shapefile is None:
136			self.shapefile = shapelib.ShapeFile(self.filename)
137			numshapes, shapetype, mins, maxs = self.shapefile.info()
138			self.numshapes = numshapes
139			self.shapetype = shapelib_shapetypes[shapetype]
140			self.bbox = mins[:2] + maxs[:2]
141	bh	143	#print "building tree for", self.filename, "..."
142			self.shapetree = shptree.SHPTree(self.shapefile.cobject(), 2, 0)
143			#print "done"
144	bh	6
145			def BoundingBox(self):
146			"""Return the bounding box of the layer's shapes in their default
147			coordinate system"""
148			self.open_shapefile()
149			return self.bbox
150
151			def LatLongBoundingBox(self):
152			"""Return the layer's bounding box in lat/long coordinates"""
153			llx, lly, urx, ury = self.BoundingBox()
154			if self.projection is not None:
155			llx, lly = self.projection.Inverse(llx, lly)
156			urx, ury = self.projection.Inverse(urx, ury)
157			return llx, lly, urx, ury
158
159			def NumShapes(self):
160			"""Return the number of shapes in the layer"""
161			self.open_shapefile()
162			return self.numshapes
163
164			def ShapeType(self):
165			"""Return the type of the shapes in the layer.
166			This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.
167			"""
168			self.open_shapefile()
169			return self.shapetype
170
171			def Shape(self, index):
172			"""Return the shape with index index"""
173			self.open_shapefile()
174			shape = self.shapefile.read_object(index)
175			if self.shapetype == SHAPETYPE_POINT:
176			points = shape.vertices()
177			else:
178			#for poly in shape.vertices():
179			poly = shape.vertices()[0]
180			points = []
181			for x, y in poly:
182	bh	82	points.append((x, y))
183	bh	6	return Shape(points)
184
185	bh	143	def ShapesInRegion(self, box):
186			"""Return the ids of the shapes that overlap the box.
187
188			Box is a tuple (left, bottom, right, top) in the coordinate
189			system used by the layer's shapefile.
190			"""
191			left, bottom, right, top = box
192	bh	147	return self.shapetree.find_shapes((left, bottom), (right, top))
193	bh	143
194	bh	6	def SetProjection(self, projection):
195			"""Set the layer's projection"""
196			self.projection = projection
197			self.changed(LAYER_PROJECTION_CHANGED, self)
198
199			def SetFill(self, fill):
200			"""Set the layer's fill color. None means the shapes are not filled"""
201			self.fill = fill
202			self.changed(LAYER_LEGEND_CHANGED, self)
203
204			def SetStroke(self, stroke):
205			"""Set the layer's stroke color. None means the shapes are not
206			stroked."""
207			self.stroke = stroke
208			self.changed(LAYER_LEGEND_CHANGED, self)
209	bh	73
210			def SetStrokeWidth(self, width):
211			"""Set the layer's stroke width."""
212			self.stroke_width = width
213			self.changed(LAYER_LEGEND_CHANGED, self)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision