Thuban/Model/layer.py

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

__version__ = "$Revision$"

import os
import warnings

from Thuban import _

from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
     LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED

import classification

from color import Transparent, Black
from base import TitledObject, Modifiable
from data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT

import resource

from color import Color

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, projection = None):
        """Initialize the layer.

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

    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)

    def HasClassification(self):
        """Determine if this layer supports classifications."""
        return False

    def HasShapes(self):
        """Determine if this layer supports shapes."""
        return False

    def GetProjection(self):
        """Return the layer's projection."""
        return self.projection

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

    def Type(self):
        return "Unknown"

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 Transparent, 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 = Transparent, 
                 stroke = 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 Transparent if the shapes are 
                not filled
        stroke -- the stroke color or 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,
                                 projection = projection)

        self.__classification = None
        self.store = None

        self.SetShapeStore(data)

        self.classification_column = None
        self.SetClassificationColumn(None)
        self.SetClassification(None)

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

        self.UnsetModified()

    def SetShapeStore(self, store):
        # Set the classification to None if there is a classification
        # and the new shapestore doesn't have a table with a suitable
        # column, i.e one with the same name and type as before
        # FIXME: Maybe we should keep it the same if the type is
        # compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
        if self.__classification is not None:
            columnname = self.classification_column
            columntype = self.GetFieldType(columnname)
            table = store.Table()
            if (columnname is not None
                and (not table.HasColumn(columnname)
                     or table.Column(columnname).type != columntype)):
                self.SetClassification(None)

        self.store = store

        self.changed(LAYER_SHAPESTORE_REPLACED, self)

    def ShapeStore(self):
        return self.store

    def Destroy(self):
        BaseLayer.Destroy(self)
        if self.__classification is not None:
            self.__classification.Unsubscribe(CLASS_CHANGED,
                                              self._classification_changed)

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

        If the layer has no shapes, return None.
        """
        return self.store.BoundingBox()

    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 and self.projection is not None:
            bbox = self.projection.InverseBBox(bbox)
        return bbox

    def Type(self):
        return self.ShapeType();

    def ShapesBoundingBox(self, shapes):
        """Return a bounding box in lat/long coordinates for the given
        list of shape ids.

        If shapes is None or empty, return None.
        """

        if shapes is None or len(shapes) == 0: return None

        xs = []
        ys = []

        for id in shapes:
            bbox = self.Shape(id).compute_bbox()
            if self.projection is not None:
                bbox = self.projection.InverseBBox(bbox)
            left, bottom, right, top = bbox
            xs.append(left); xs.append(right)
            ys.append(bottom); ys.append(top)

        return (min(xs), min(ys), max(xs), max(ys))


    def GetFieldType(self, fieldName):
        if self.store:
            table = self.store.Table()
            if table.HasColumn(fieldName):
                return table.Column(fieldName).type
        return None

    def HasShapes(self):
        return True

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

    def ShapeType(self):
        """Return the type of the shapes in the layer.

        The return value is one of the SHAPETYPE_* constants defined in
        Thuban.Model.data.
        """
        return self.store.ShapeType()

    def Shape(self, index):
        """Return the shape with index index"""
        return self.store.Shape(index)

    def ShapesInRegion(self, bbox):
        """Return an iterable over the shapes that overlap the bounding box.

        The bbox parameter should be the bounding box as a tuple in the
        form (minx, miny, maxx, maxy) in unprojected coordinates.
        """
        if self.projection is not None:
            # Ensure that region lies within the layer's bounding box
            # Otherwise projection of the region would lead to incorrect
            # values.
            clipbbox = self.__mangle_bounding_box(bbox)
            bbox = self.projection.ForwardBBox(clipbbox)
        return self.store.ShapesInRegion(bbox)

    def GetClassificationColumn(self):
        return self.classification_column

    def SetClassificationColumn(self, column):
        """Set the column to classifiy on, or None. If column is not None
        and the column does not exist in the table, raise a ValueError.
        """
        if column:
            columnType = self.GetFieldType(column)
            if columnType is None:
                raise ValueError()
        changed = self.classification_column != column
        self.classification_column = column
        if changed:
            self.changed(LAYER_CHANGED, self)

    def HasClassification(self):
        return True

    def GetClassification(self):
        return self.__classification

    def SetClassification(self, clazz):
        """Set the classification used by this layer to 'clazz'

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

        This issues a LAYER_CHANGED event.
        """

        if self.__classification is not None:
            self.__classification.Unsubscribe(CLASS_CHANGED,
                                              self._classification_changed)

        if clazz is None:
            clazz = classification.Classification()

        self.__classification = clazz
        self.__classification.Subscribe(CLASS_CHANGED,
                                        self._classification_changed)

        self._classification_changed()

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

        items.append(_("Filename: %s") % self.ShapeStore().FileName())

        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)") % tuple(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)

    def __mangle_bounding_box(self, bbox):
        # FIXME: This method doesn't make much sense.
        # See RT #2845 which effectively says:
        #
        # If this method, which was originally called ClipBoundingBox,
        # is supposed to do clipping it shouldn't return the parameter
        # unchanged when it lies completely outside of the bounding box.
        # It would be better to return None and return an empty list in
        # ShapesInRegion (the only caller) in that case.
        #
        # This method was introduced to fix a bug that IIRC had
        # something todo with projections and bounding boxes containing
        # NaN or INF when the parameter to ShapesInRegion covered the
        # entire earth or something similarly large).
        bminx, bminy, bmaxx, bmaxy = bbox
        lminx, lminy, lmaxx, lmaxy = self.LatLongBoundingBox()
        if bminx > lmaxx or bmaxx < lminx:
            left, right = bminx, bmaxx
        else:
            left = max(lminx, bminx)
            right = min(lmaxx, bmaxx)
        if bminy > lmaxy or bmaxy < lminy:
            bottom, top = bminy, bmaxy
        else:
            bottom = max(lminy, bminy)
            top = min(lmaxy, bmaxy)

        return (left, bottom, right, top)


if resource.has_gdal_support():
    import gdal
    from gdalconst import GA_ReadOnly

class RasterLayer(BaseLayer):

    MASK_NONE  = 0
    MASK_BIT   = 1
    MASK_ALPHA = 2

    def __init__(self, title, filename, projection = None, 
                 visible = True, opacity = 1, masktype = MASK_BIT):
        """Initialize the Raster Layer.

        title -- title for the layer.

        filename -- file name of the source image.

        projection -- Projection object describing the projection which
                      the source image is in.

        visible -- True is the layer should initially be visible.

        Throws IOError if the filename is invalid or points to a file that
        is not in a format GDAL can use.
        """

        BaseLayer.__init__(self, title, visible = visible)

        self.projection = projection
        self.filename = os.path.abspath(filename)

        self.bbox = -1

        self.mask_type = masktype
        self.opacity = opacity

        self.image_info = None

        if resource.has_gdal_support():
            #
            # temporarily open the file so that GDAL can test if it's valid.
            #
            dataset = gdal.Open(self.filename, GA_ReadOnly)

            if dataset is None:
                raise IOError()

            #
            # while we have the file, extract some basic information 
            # that we can display later
            #
            self.image_info = {}

            self.image_info["nBands"] = dataset.RasterCount
            self.image_info["Size"] = (dataset.RasterXSize, dataset.RasterYSize)
            self.image_info["Driver"] = dataset.GetDriver().ShortName

            # store some information about the individual bands
            # [min_value, max_value]
            a = self.image_info["BandData"] = []

            for i in range(1, dataset.RasterCount+1):
                band = dataset.GetRasterBand(i)
                a.append(band.ComputeRasterMinMax())

        self.UnsetModified()

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

        If the there is no support for images, or the file cannot
        be read, or there is no geographics information available, return None.
        """
        if not resource.has_gdal_support():
            return None

        if self.bbox == -1:
            dataset = gdal.Open(self.filename, GA_ReadOnly)
            if dataset is None:
                self.bbox = None
            else:
                geotransform = dataset.GetGeoTransform()
                if geotransform is None:
                    return None

                x = 0
                y = dataset.RasterYSize
                left = geotransform[0] +        \
                       geotransform[1] * x +    \
                       geotransform[2] * y

                bottom = geotransform[3] +      \
                         geotransform[4] * x +  \
                         geotransform[5] * y

                x = dataset.RasterXSize
                y = 0
                right = geotransform[0] +       \
                        geotransform[1] * x +   \
                        geotransform[2] * y

                top = geotransform[3] +         \
                      geotransform[4] * x +     \
                      geotransform[5] * y

                self.bbox = (left, bottom, right, top)

        return self.bbox

    def LatLongBoundingBox(self):
        bbox = self.BoundingBox()
        if bbox is None:
            return None

        if self.projection is not None:
            bbox = self.projection.InverseBBox(bbox)

        return bbox

    def Type(self):
        return "Image"

    def GetImageFilename(self):
        return self.filename

    def MaskType(self):
        """Return True if the mask should be used when rendering the layer."""
        return self.mask_type

    def SetMaskType(self, type):
        """Set the type of mask to use.

        type can be one of MASK_NONE, MASK_BIT, MASK_ALPHA

        If the state changes, a LAYER_CHANGED message is sent.
        """
        if type not in (self.MASK_NONE, self.MASK_BIT, self.MASK_ALPHA):
            raise ValueError("type is invalid")

        if type != self.mask_type: 
            self.mask_type = type
            self.changed(LAYER_CHANGED, self)

    def Opacity(self):
        """Return the level of opacity used in alpha blending.
        """
        return self.opacity

    def SetOpacity(self, op):
        """Set the level of alpha opacity. 

        0 <= op <= 1.

        The layer is fully opaque when op = 1.
        """
        if not (0 <= op <= 1):
            raise ValueError("op out of range")

        if op != self.opacity: 
            self.opacity = op
            self.changed(LAYER_CHANGED, self)

    def ImageInfo(self):
        return self.image_info

    def TreeInfo(self):
        items = []

        items.append(_("Filename: %s") % self.GetImageFilename())

        if self.Visible():
            items.append(_("Shown"))
        else:
            items.append(_("Hidden"))

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

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

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

1	bh	2644	# Copyright (c) 2001, 2002, 2003, 2004, 2005 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4	jonathan	412	# Jonathan Coles <[email protected]>
5	silke	2339	# Silke Reimer <[email protected]>
6	bh	6	#
7			# This program is free software under the GPL (>=v2)
8			# Read the file COPYING coming with Thuban for details.
9
10			__version__ = "$Revision$"
11
12	bh	1599	import os
13	bh	1219	import warnings
14	bh	171
15	jan	374	from Thuban import _
16	bh	6
17	bh	701	from messages import LAYER_PROJECTION_CHANGED, LAYER_VISIBILITY_CHANGED, \
18	jonathan	1427	LAYER_CHANGED, LAYER_SHAPESTORE_REPLACED, CLASS_CHANGED
19	bh	6
20	jonathan	437	import classification
21	bh	6
22	jonathan	1338	from color import Transparent, Black
23	bh	6	from base import TitledObject, Modifiable
24	bh	1558	from data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
25	bh	6
26	jonathan	1158	import resource
27	bh	723
28	jonathan	2551	from color import Color
29	jonathan	1158
30	bh	6	shapetype_names = {SHAPETYPE_POINT: "Point",
31			SHAPETYPE_ARC: "Arc",
32			SHAPETYPE_POLYGON: "Polygon"}
33
34			class BaseLayer(TitledObject, Modifiable):
35
36			"""Base class for the layers."""
37
38	jonathan	929	def __init__(self, title, visible = True, projection = None):
39	bh	6	"""Initialize the layer.
40
41			title -- the title
42			visible -- boolean. If true the layer is visible.
43			"""
44			TitledObject.__init__(self, title)
45			Modifiable.__init__(self)
46			self.visible = visible
47	jonathan	929	self.projection = projection
48	bh	6
49			def Visible(self):
50			"""Return true if layer is visible"""
51			return self.visible
52
53			def SetVisible(self, visible):
54			"""Set the layer's visibility."""
55			self.visible = visible
56			self.issue(LAYER_VISIBILITY_CHANGED, self)
57	bh	276
58	jonathan	929	def HasClassification(self):
59	bernhard	2343	"""Determine if this layer supports classifications."""
60	jonathan	929	return False
61	bh	276
62	jonathan	1273	def HasShapes(self):
63			"""Determine if this layer supports shapes."""
64			return False
65
66	jonathan	929	def GetProjection(self):
67			"""Return the layer's projection."""
68			return self.projection
69
70			def SetProjection(self, projection):
71	bernhard	2343	"""Set the layer's projection."""
72	jonathan	929	self.projection = projection
73			self.changed(LAYER_PROJECTION_CHANGED, self)
74
75	jonathan	2551	def Type(self):
76			return "Unknown"
77
78	bh	6	class Layer(BaseLayer):
79
80			"""Represent the information of one geodata file (currently a shapefile)
81
82			All children of the layer have the same type.
83
84			A layer has fill and stroke colors. Colors should be instances of
85	jonathan	1338	Color. They can also be Transparent, indicating no fill or no stroke.
86	bh	6
87			The layer objects send the following events, all of which have the
88			layer object as parameter:
89
90			TITLE_CHANGED -- The title has changed.
91			LAYER_PROJECTION_CHANGED -- the projection has changed.
92			"""
93
94	bh	723	def __init__(self, title, data, projection = None,
95	jonathan	1338	fill = Transparent,
96			stroke = Black,
97	jonathan	464	lineWidth = 1,
98	jonathan	771	visible = True):
99	bh	6	"""Initialize the layer.
100
101			title -- the title
102	bh	723	data -- datastore object for the shape data shown by the layer
103	bh	6	projection -- the projection object. Its Inverse method is
104			assumed to map the layer's coordinates to lat/long
105			coordinates
106	jonathan	1338	fill -- the fill color or Transparent if the shapes are
107	jonathan	610	not filled
108	jonathan	1338	stroke -- the stroke color or Transparent if the shapes
109	jonathan	610	are not stroked
110	bh	6	visible -- boolean. If true the layer is visible.
111
112			colors are expected to be instances of Color class
113			"""
114	jonathan	929	BaseLayer.__init__(self, title,
115			visible = visible,
116			projection = projection)
117	bh	276
118	bh	723	self.__classification = None
119	jonathan	1427	self.store = None
120	jonathan	481
121	bh	723	self.SetShapeStore(data)
122	jonathan	492
123	bh	1452	self.classification_column = None
124			self.SetClassificationColumn(None)
125	jonathan	492	self.SetClassification(None)
126
127	jonathan	464	self.__classification.SetDefaultLineColor(stroke)
128			self.__classification.SetDefaultLineWidth(lineWidth)
129	jonathan	412	self.__classification.SetDefaultFill(fill)
130	jonathan	364
131	jonathan	389	self.UnsetModified()
132
133	bh	723	def SetShapeStore(self, store):
134	jonathan	1427	# Set the classification to None if there is a classification
135			# and the new shapestore doesn't have a table with a suitable
136			# column, i.e one with the same name and type as before
137			# FIXME: Maybe we should keep it the same if the type is
138			# compatible enough such as FIELDTYPE_DOUBLE and FIELDTYPE_INT
139			if self.__classification is not None:
140	bh	1452	columnname = self.classification_column
141			columntype = self.GetFieldType(columnname)
142	jonathan	1427	table = store.Table()
143	bh	1452	if (columnname is not None
144			and (not table.HasColumn(columnname)
145			or table.Column(columnname).type != columntype)):
146	jonathan	1427	self.SetClassification(None)
147
148	bh	723	self.store = store
149	bh	179
150	bh	1142	self.changed(LAYER_SHAPESTORE_REPLACED, self)
151	bh	723
152			def ShapeStore(self):
153			return self.store
154
155	bh	258	def Destroy(self):
156	bh	260	BaseLayer.Destroy(self)
157	jonathan	1427	if self.__classification is not None:
158	bh	1452	self.__classification.Unsubscribe(CLASS_CHANGED,
159			self._classification_changed)
160	bh	258
161	bh	6	def BoundingBox(self):
162	bh	179	"""Return the layer's bounding box in the intrinsic coordinate system.
163
164			If the layer has no shapes, return None.
165			"""
166	bh	1535	return self.store.BoundingBox()
167	bh	6
168			def LatLongBoundingBox(self):
169	bh	179	"""Return the layer's bounding box in lat/long coordinates.
170	bh	6
171	bh	179	Return None, if the layer doesn't contain any shapes.
172			"""
173			bbox = self.BoundingBox()
174	bh	1983	if bbox is not None and self.projection is not None:
175			bbox = self.projection.InverseBBox(bbox)
176			return bbox
177	bh	179
178	jonathan	2551	def Type(self):
179			return self.ShapeType();
180
181	jonathan	828	def ShapesBoundingBox(self, shapes):
182			"""Return a bounding box in lat/long coordinates for the given
183			list of shape ids.
184
185			If shapes is None or empty, return None.
186			"""
187
188			if shapes is None or len(shapes) == 0: return None
189
190	bh	1983	xs = []
191			ys = []
192	jonathan	828
193			for id in shapes:
194	bh	1983	bbox = self.Shape(id).compute_bbox()
195			if self.projection is not None:
196			bbox = self.projection.InverseBBox(bbox)
197			left, bottom, right, top = bbox
198			xs.append(left); xs.append(right)
199			ys.append(bottom); ys.append(top)
200	jonathan	828
201	bh	1983	return (min(xs), min(ys), max(xs), max(ys))
202	jonathan	828
203
204	jonathan	464	def GetFieldType(self, fieldName):
205	jonathan	1427	if self.store:
206			table = self.store.Table()
207			if table.HasColumn(fieldName):
208			return table.Column(fieldName).type
209	bh	839	return None
210	jonathan	464
211	jonathan	1273	def HasShapes(self):
212			return True
213
214	bh	6	def NumShapes(self):
215			"""Return the number of shapes in the layer"""
216	bh	1535	return self.store.NumShapes()
217	bh	6
218			def ShapeType(self):
219			"""Return the type of the shapes in the layer.
220	bh	1535
221			The return value is one of the SHAPETYPE_* constants defined in
222			Thuban.Model.data.
223	bh	6	"""
224	bh	1535	return self.store.ShapeType()
225	bh	6
226			def Shape(self, index):
227			"""Return the shape with index index"""
228	bh	1535	return self.store.Shape(index)
229	jonathan	364
230	bh	1587	def ShapesInRegion(self, bbox):
231	bh	1593	"""Return an iterable over the shapes that overlap the bounding box.
232	bh	143
233	bh	1593	The bbox parameter should be the bounding box as a tuple in the
234			form (minx, miny, maxx, maxy) in unprojected coordinates.
235	bh	143	"""
236	jonathan	794	if self.projection is not None:
237	silke	2339	# Ensure that region lies within the layer's bounding box
238			# Otherwise projection of the region would lead to incorrect
239			# values.
240	bh	2644	clipbbox = self.__mangle_bounding_box(bbox)
241	silke	2339	bbox = self.projection.ForwardBBox(clipbbox)
242	bh	1587	return self.store.ShapesInRegion(bbox)
243	bh	143
244	bh	1452	def GetClassificationColumn(self):
245			return self.classification_column
246	jonathan	1427
247	bh	1452	def SetClassificationColumn(self, column):
248			"""Set the column to classifiy on, or None. If column is not None
249			and the column does not exist in the table, raise a ValueError.
250	jonathan	1427	"""
251	bh	1452	if column:
252			columnType = self.GetFieldType(column)
253			if columnType is None:
254	jonathan	1427	raise ValueError()
255	bh	1452	changed = self.classification_column != column
256			self.classification_column = column
257			if changed:
258			self.changed(LAYER_CHANGED, self)
259	jonathan	1427
260	jonathan	929	def HasClassification(self):
261			return True
262	jonathan	725
263	jonathan	412	def GetClassification(self):
264			return self.__classification
265
266			def SetClassification(self, clazz):
267	jonathan	1338	"""Set the classification used by this layer to 'clazz'
268	jonathan	481
269	jonathan	1338	If 'clazz' is None a default classification is created.
270
271	jonathan	1427	This issues a LAYER_CHANGED event.
272	jonathan	492	"""
273	jonathan	481
274	jonathan	1427	if self.__classification is not None:
275	bh	1452	self.__classification.Unsubscribe(CLASS_CHANGED,
276			self._classification_changed)
277	jonathan	529
278	jonathan	1338	if clazz is None:
279			clazz = classification.Classification()
280	jonathan	529
281	jonathan	1427	self.__classification = clazz
282	bh	1452	self.__classification.Subscribe(CLASS_CHANGED,
283			self._classification_changed)
284	jonathan	1338
285	bh	1452	self._classification_changed()
286	jonathan	492
287	bh	1452	def _classification_changed(self):
288	jonathan	492	"""Called from the classification object when it has changed."""
289	jonathan	558	self.changed(LAYER_CHANGED, self)
290	jonathan	492
291	bh	217	def TreeInfo(self):
292			items = []
293
294	jonathan	1338	items.append(_("Filename: %s") % self.ShapeStore().FileName())
295	jan	1012
296	bh	217	if self.Visible():
297	jan	374	items.append(_("Shown"))
298	bh	217	else:
299	jan	374	items.append(_("Hidden"))
300			items.append(_("Shapes: %d") % self.NumShapes())
301	bh	217
302			bbox = self.LatLongBoundingBox()
303			if bbox is not None:
304	bh	2228	items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % tuple(bbox))
305	bh	217	else:
306	jan	374	items.append(_("Extent (lat-lon):"))
307			items.append(_("Shapetype: %s") % shapetype_names[self.ShapeType()])
308	bh	217
309	jonathan	736	if self.projection and len(self.projection.params) > 0:
310			items.append((_("Projection"),
311			[str(param) for param in self.projection.params]))
312
313	jonathan	412	items.append(self.__classification)
314	bh	217
315	jan	374	return (_("Layer '%s'") % self.Title(), items)
316	jonathan	382
317	bh	2644	def __mangle_bounding_box(self, bbox):
318			# FIXME: This method doesn't make much sense.
319			# See RT #2845 which effectively says:
320			#
321			# If this method, which was originally called ClipBoundingBox,
322			# is supposed to do clipping it shouldn't return the parameter
323			# unchanged when it lies completely outside of the bounding box.
324			# It would be better to return None and return an empty list in
325			# ShapesInRegion (the only caller) in that case.
326			#
327			# This method was introduced to fix a bug that IIRC had
328			# something todo with projections and bounding boxes containing
329			# NaN or INF when the parameter to ShapesInRegion covered the
330			# entire earth or something similarly large).
331	silke	2339	bminx, bminy, bmaxx, bmaxy = bbox
332			lminx, lminy, lmaxx, lmaxy = self.LatLongBoundingBox()
333			if bminx > lmaxx or bmaxx < lminx:
334			left, right = bminx, bmaxx
335			else:
336			left = max(lminx, bminx)
337			right = min(lmaxx, bmaxx)
338			if bminy > lmaxy or bmaxy < lminy:
339			bottom, top = bminy, bmaxy
340			else:
341			bottom = max(lminy, bminy)
342			top = min(lmaxy, bmaxy)
343	bh	2644
344	silke	2339	return (left, bottom, right, top)
345
346
347	jonathan	1158	if resource.has_gdal_support():
348			import gdal
349			from gdalconst import GA_ReadOnly
350
351	jonathan	929	class RasterLayer(BaseLayer):
352
353	jonathan	2562	MASK_NONE = 0
354			MASK_BIT = 1
355			MASK_ALPHA = 2
356
357	jonathan	2614	def __init__(self, title, filename, projection = None,
358			visible = True, opacity = 1, masktype = MASK_BIT):
359	jonathan	929	"""Initialize the Raster Layer.
360
361			title -- title for the layer.
362
363			filename -- file name of the source image.
364
365			projection -- Projection object describing the projection which
366			the source image is in.
367
368			visible -- True is the layer should initially be visible.
369	jonathan	961
370			Throws IOError if the filename is invalid or points to a file that
371			is not in a format GDAL can use.
372	jonathan	929	"""
373
374			BaseLayer.__init__(self, title, visible = visible)
375
376			self.projection = projection
377	bh	1599	self.filename = os.path.abspath(filename)
378	jonathan	929
379			self.bbox = -1
380
381	jonathan	2614	self.mask_type = masktype
382			self.opacity = opacity
383	jonathan	2551
384			self.image_info = None
385
386	jonathan	1158	if resource.has_gdal_support():
387			#
388			# temporarily open the file so that GDAL can test if it's valid.
389			#
390			dataset = gdal.Open(self.filename, GA_ReadOnly)
391	jonathan	961
392	jonathan	1158	if dataset is None:
393			raise IOError()
394	jonathan	961
395	jonathan	2551	#
396			# while we have the file, extract some basic information
397			# that we can display later
398			#
399			self.image_info = {}
400
401			self.image_info["nBands"] = dataset.RasterCount
402			self.image_info["Size"] = (dataset.RasterXSize, dataset.RasterYSize)
403			self.image_info["Driver"] = dataset.GetDriver().ShortName
404
405			# store some information about the individual bands
406			# [min_value, max_value]
407			a = self.image_info["BandData"] = []
408
409			for i in range(1, dataset.RasterCount+1):
410			band = dataset.GetRasterBand(i)
411			a.append(band.ComputeRasterMinMax())
412
413	jonathan	929	self.UnsetModified()
414
415			def BoundingBox(self):
416			"""Return the layer's bounding box in the intrinsic coordinate system.
417
418	jonathan	1338	If the there is no support for images, or the file cannot
419			be read, or there is no geographics information available, return None.
420	jonathan	929	"""
421	jonathan	1158	if not resource.has_gdal_support():
422			return None
423
424	jonathan	929	if self.bbox == -1:
425			dataset = gdal.Open(self.filename, GA_ReadOnly)
426			if dataset is None:
427			self.bbox = None
428			else:
429	jonathan	961	geotransform = dataset.GetGeoTransform()
430			if geotransform is None:
431			return None
432
433			x = 0
434			y = dataset.RasterYSize
435			left = geotransform[0] + \
436			geotransform[1] * x + \
437			geotransform[2] * y
438
439			bottom = geotransform[3] + \
440			geotransform[4] * x + \
441			geotransform[5] * y
442
443			x = dataset.RasterXSize
444			y = 0
445			right = geotransform[0] + \
446			geotransform[1] * x + \
447			geotransform[2] * y
448
449			top = geotransform[3] + \
450			geotransform[4] * x + \
451			geotransform[5] * y
452
453	jonathan	929	self.bbox = (left, bottom, right, top)
454
455			return self.bbox
456
457			def LatLongBoundingBox(self):
458			bbox = self.BoundingBox()
459	jonathan	961	if bbox is None:
460	jonathan	929	return None
461
462	jonathan	961	if self.projection is not None:
463	bh	1983	bbox = self.projection.InverseBBox(bbox)
464	jonathan	961
465	bh	1983	return bbox
466	jonathan	961
467	jonathan	2551	def Type(self):
468			return "Image"
469
470	jonathan	929	def GetImageFilename(self):
471			return self.filename
472
473	jonathan	2562	def MaskType(self):
474	jonathan	2551	"""Return True if the mask should be used when rendering the layer."""
475	jonathan	2562	return self.mask_type
476	jonathan	2551
477	jonathan	2562	def SetMaskType(self, type):
478			"""Set the type of mask to use.
479	jonathan	2551
480	jonathan	2562	type can be one of MASK_NONE, MASK_BIT, MASK_ALPHA
481
482	jonathan	2551	If the state changes, a LAYER_CHANGED message is sent.
483			"""
484	jonathan	2562	if type not in (self.MASK_NONE, self.MASK_BIT, self.MASK_ALPHA):
485			raise ValueError("type is invalid")
486
487			if type != self.mask_type:
488			self.mask_type = type
489	jonathan	2551	self.changed(LAYER_CHANGED, self)
490
491	jonathan	2587	def Opacity(self):
492			"""Return the level of opacity used in alpha blending.
493	jonathan	2562	"""
494	jonathan	2587	return self.opacity
495	jonathan	2562
496	jonathan	2587	def SetOpacity(self, op):
497	jonathan	2562	"""Set the level of alpha opacity.
498
499			0 <= op <= 1.
500
501			The layer is fully opaque when op = 1.
502			"""
503			if not (0 <= op <= 1):
504			raise ValueError("op out of range")
505
506	jonathan	2587	if op != self.opacity:
507			self.opacity = op
508			self.changed(LAYER_CHANGED, self)
509	jonathan	2562
510	jonathan	2551	def ImageInfo(self):
511			return self.image_info
512
513	jonathan	929	def TreeInfo(self):
514			items = []
515
516	jonathan	1338	items.append(_("Filename: %s") % self.GetImageFilename())
517
518	jonathan	929	if self.Visible():
519			items.append(_("Shown"))
520			else:
521			items.append(_("Hidden"))
522
523			bbox = self.LatLongBoundingBox()
524			if bbox is not None:
525			items.append(_("Extent (lat-lon): (%g, %g, %g, %g)") % bbox)
526			else:
527			items.append(_("Extent (lat-lon):"))
528
529			if self.projection and len(self.projection.params) > 0:
530			items.append((_("Projection"),
531			[str(param) for param in self.projection.params]))
532
533			return (_("Layer '%s'") % self.Title(), items)
534
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision