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

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.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]

    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 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	# Copyright (c) 2001, 2002 by Intevation GmbH
2	# 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	import shapelib
11
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	fill = None, stroke = _black, stroke_width = 1, visible = 1):
106	"""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	self.stroke_width = stroke_width
125	self.shapefile = None
126	self.open_shapefile()
127	# shapetable is the table associated with the shapefile, while
128	# table is the default table used to look up attributes for
129	# display
130	self.shapetable = Table(filename)
131	self.table = self.shapetable
132
133	def open_shapefile(self):
134	if self.shapefile is None:
135	self.shapefile = shapelib.ShapeFile(self.filename)
136	numshapes, shapetype, mins, maxs = self.shapefile.info()
137	self.numshapes = numshapes
138	self.shapetype = shapelib_shapetypes[shapetype]
139	self.bbox = mins[:2] + maxs[:2]
140
141	def BoundingBox(self):
142	"""Return the bounding box of the layer's shapes in their default
143	coordinate system"""
144	self.open_shapefile()
145	return self.bbox
146
147	def LatLongBoundingBox(self):
148	"""Return the layer's bounding box in lat/long coordinates"""
149	llx, lly, urx, ury = self.BoundingBox()
150	if self.projection is not None:
151	llx, lly = self.projection.Inverse(llx, lly)
152	urx, ury = self.projection.Inverse(urx, ury)
153	return llx, lly, urx, ury
154
155	def NumShapes(self):
156	"""Return the number of shapes in the layer"""
157	self.open_shapefile()
158	return self.numshapes
159
160	def ShapeType(self):
161	"""Return the type of the shapes in the layer.
162	This is either SHAPETYPE_POINT, SHAPETYPE_ARC or SHAPETYPE_POLYGON.
163	"""
164	self.open_shapefile()
165	return self.shapetype
166
167	def Shape(self, index):
168	"""Return the shape with index index"""
169	self.open_shapefile()
170	shape = self.shapefile.read_object(index)
171	if self.shapetype == SHAPETYPE_POINT:
172	points = shape.vertices()
173	else:
174	#for poly in shape.vertices():
175	poly = shape.vertices()[0]
176	points = []
177	for x, y in poly:
178	points.append((x, y))
179	return Shape(points)
180
181	def SetProjection(self, projection):
182	"""Set the layer's projection"""
183	self.projection = projection
184	self.changed(LAYER_PROJECTION_CHANGED, self)
185
186	def SetFill(self, fill):
187	"""Set the layer's fill color. None means the shapes are not filled"""
188	self.fill = fill
189	self.changed(LAYER_LEGEND_CHANGED, self)
190
191	def SetStroke(self, stroke):
192	"""Set the layer's stroke color. None means the shapes are not
193	stroked."""
194	self.stroke = stroke
195	self.changed(LAYER_LEGEND_CHANGED, self)
196
197	def SetStrokeWidth(self, width):
198	"""Set the layer's stroke width."""
199	self.stroke_width = width
200	self.changed(LAYER_LEGEND_CHANGED, self)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision