/[thuban]/branches/WIP-pyshapelib-bramz/test/test_layer.py
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/test/test_layer.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 723 by bh, Thu Apr 24 15:31:53 2003 UTC revision 2644 by bh, Tue Jul 5 16:30:51 2005 UTC
# Line 1  Line 1 
1  # Copyright (c) 2002, 2003 by Intevation GmbH  # Copyright (c) 2002, 2003, 2004, 2005 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  #  #
# Line 16  __version__ = "$Revision$" Line 16  __version__ = "$Revision$"
16  import os  import os
17  import unittest  import unittest
18    
19    import mockgeo
20  import support  import support
21  support.initthuban()  support.initthuban()
22    
# Line 23  import shapelib Line 24  import shapelib
24  import dbflib  import dbflib
25    
26  from Thuban.Model.session import Session  from Thuban.Model.session import Session
27  from Thuban.Model.layer import Layer, SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer
28       SHAPETYPE_POINT  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
29  from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \  from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \
30       LAYER_VISIBILITY_CHANGED       LAYER_VISIBILITY_CHANGED, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED
31    from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
32    from Thuban.Model.proj import Projection
33    from Thuban.Model.data import DerivedShapeStore
34    from Thuban.Model.classification import Classification, ClassGroupSingleton, \
35         ClassGroupRange
36  from Thuban.Model.color import Color  from Thuban.Model.color import Color
37    
38    import Thuban.Model.resource
39    
40  class TestLayer(unittest.TestCase, support.FileTestMixin,  class TestLayer(unittest.TestCase, support.FileTestMixin,
41                  support.FloatComparisonMixin):                  support.FloatComparisonMixin):
42    
43      """Test cases for different layer (shape) types"""      """Test cases for different layer (shape) types"""
44    
     def assertFloatTuplesEqual(self, test, value):  
         """Assert equality of two lists of tuples of float"""  
         for i in range(len(test)):  
             self.assertFloatSeqEqual(test[i], value[i])  
   
45      def setUp(self):      def setUp(self):
46          """Create a session"""          """Create a session self.session and initialize self.layer to None"""
47          self.session = Session("Test session for %s" % self.__class__)          self.session = Session("Test session for %s" % self.__class__)
48            self.layer = None
49    
50      def tearDown(self):      def tearDown(self):
51            """Call the layer's Destroy method and set session and layer to None"""
52            self.session.Destroy()
53          self.session = None          self.session = None
54            if self.layer is not None:
55                self.layer.Destroy()
56                self.layer = None
57    
58        def build_path(self, filename):
59            return os.path.join("..", "Data", "iceland", filename)
60    
61        def open_shapefile(self, filename):
62            """Open and return a shapestore for filename in the iceland data set"""
63            return self.session.OpenShapefile(self.build_path(filename))
64    
65        def test_base_layer(self):
66            layer = self.layer = BaseLayer("Test BaseLayer")
67            self.assertEquals(layer.Title(), "Test BaseLayer")
68            self.failUnless(layer.Visible())
69    
70            # toggle visibility
71            layer.SetVisible(False)
72            self.failIf(layer.Visible())
73    
74            layer.SetVisible(True)
75            self.failUnless(layer.Visible())
76    
77            self.failIf(layer.HasClassification())
78            self.failIf(layer.HasShapes())
79    
80            self.assertEquals(layer.GetProjection(), None)
81    
82            # set/get projection
83            proj = Projection(["proj=utm", "zone=26", "ellps=clrk66"])
84    
85            layer.SetProjection(proj)
86            self.failUnless(layer.GetProjection() is proj)
87    
88            # __init__ with other arguments
89            layer = BaseLayer("Test BaseLayer", False, proj)
90            self.failIf(layer.Visible())
91            self.failUnless(layer.GetProjection() is proj)
92    
93      def test_arc_layer(self):      def test_arc_layer(self):
94          """Test Layer with arc shapes"""          """Test Layer with arc shapes"""
95          filename = os.path.join("..", "Data", "iceland", "roads-line.shp")          layer = self.layer = Layer("Test Layer",
96          layer = Layer("Test Layer", self.session.OpenShapefile(filename))                                     self.open_shapefile("roads-line.shp"))
97          self.assertEquals(layer.Title(), "Test Layer")          self.failUnless(layer.HasClassification())
98            self.failUnless(layer.HasShapes())
99          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
100          self.assertEquals(layer.NumShapes(), 839)          self.assertEquals(layer.NumShapes(), 839)
101          shape = layer.Shape(32)          shape = layer.Shape(32)
102          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
103                                      [(-15.082174301147461, 66.27738189697265),                                     [[(-15.082174301147461, 66.27738189697265),
104                                       (-15.026350021362305, 66.27339172363281)])                                       (-15.026350021362305, 66.27339172363281)]])
105          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
106                                   [-24.450359344482422, 63.426830291748047,                                   [-24.450359344482422, 63.426830291748047,
107                                    -13.55668830871582, 66.520111083984375])                                    -13.55668830871582, 66.520111083984375])
108          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
109            self.assertEquals([s.ShapeID() for s in shapes],
110                            [613, 726, 838])                            [613, 726, 838])
111          layer.Destroy()  
112            self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
113                              [-15.082174301147461, 66.27339172363281,
114                               -15.026350021362305, 66.27738189697265])
115    
116            shape = layer.Shape(33)
117            self.assertPointListEquals(shape.Points(),
118                                       [[(-22.24850654602050, 66.30645751953125),
119                                         (-22.23273086547851, 66.29407501220703),
120                                         (-22.23158073425293,  66.2876892089843),
121                                         (-22.24631881713867, 66.27006530761718)]])
122    
123            self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),
124                                     [-22.248506546020508, 66.270065307617188,
125                                      -15.026350021362305, 66.30645751953125])
126    
127            self.assertEquals(layer.ShapesBoundingBox([]), None)
128            self.assertEquals(layer.ShapesBoundingBox(None), None)
129    
130      def test_polygon_layer(self):      def test_polygon_layer(self):
131          """Test Layer with polygon shapes"""          """Test Layer with polygon shapes"""
132          filename = os.path.join("..", "Data", "iceland", "political.shp")          layer = self.layer = Layer("Test Layer",
133          layer = Layer("Test Layer", self.session.OpenShapefile(filename))                                     self.open_shapefile("political.shp"))
134          self.assertEquals(layer.Title(), "Test Layer")          self.failUnless(layer.HasClassification())
135            self.failUnless(layer.HasShapes())
136          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
137          self.assertEquals(layer.NumShapes(), 156)          self.assertEquals(layer.NumShapes(), 156)
138          shape = layer.Shape(4)          shape = layer.Shape(4)
139          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
140                                      [(-22.406391143798828, 64.714111328125),                                     [[(-22.40639114379882, 64.714111328125),
141                                       (-22.41621208190918, 64.71600341796875),                                       (-22.41621208190918, 64.7160034179687),
142                                       (-22.406051635742188, 64.719200134277344),                                       (-22.40605163574218, 64.719200134277),
143                                       (-22.406391143798828, 64.714111328125)])                                       (-22.40639114379882, 64.714111328125)]])
144          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
145                                   [-24.546524047851562, 63.286754608154297,                                   [-24.546524047851562, 63.286754608154297,
146                                    -13.495815277099609, 66.563774108886719])                                    -13.495815277099609, 66.563774108886719])
147          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1))
148            self.assertEquals([s.ShapeID() for s in shapes],
149                            [91, 92, 144, 146, 148, 150, 152, 153])                            [91, 92, 144, 146, 148, 150, 152, 153])
         layer.Destroy()  
150    
151      def test_point_layer(self):      def test_point_layer(self):
152          """Test Layer with point shapes"""          """Test Layer with point shapes"""
153          filename = os.path.join("..", "Data", "iceland",          layer = self.layer = Layer("Test Layer",
154                                  "cultural_landmark-point.shp")                             self.open_shapefile("cultural_landmark-point.shp"))
155          layer = Layer("Test Layer", self.session.OpenShapefile(filename))          self.failUnless(layer.HasClassification())
156          self.assertEquals(layer.Title(), "Test Layer")          self.failUnless(layer.HasShapes())
157          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
158          self.assertEquals(layer.NumShapes(), 34)          self.assertEquals(layer.NumShapes(), 34)
159          shape = layer.Shape(0)          shape = layer.Shape(0)
160          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
161                                      [(-22.711074829101562, 66.36572265625)])                                     [[(-22.711074829101562, 66.36572265625)]])
162          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
163                                   [-23.806047439575195, 63.405960083007812,                                   [-23.806047439575195, 63.405960083007812,
164                                    -15.12291431427002, 66.36572265625])                                    -15.12291431427002, 66.36572265625])
165          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1))
166            self.assertEquals([s.ShapeID() for s in shapes],
167                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])
168          layer.Destroy()  
169        def test_arc_layer_with_projection(self):
170            """Test Layer with point shapes and a projection"""
171            # We use mock data here so that we have precise control over the
172            # values
173            table = MemoryTable([("FOO", FIELDTYPE_STRING)], [("bla",)])
174            store = mockgeo.SimpleShapeStore(SHAPETYPE_ARC,
175                                  [[[(9884828.7209840547, 5607720.9774499247),
176                                     (11298336.04640449, 9287823.2044059951)]]],
177                                             table)
178            layer = self.layer = Layer("Test Layer", store)
179    
180            proj = Projection(["proj=lcc", "lon_0=0", "lat_1=20n", "lat_2=60n",
181                               "ellps=clrk66"])
182            layer.SetProjection(proj)
183    
184            self.assertFloatSeqEqual(layer.BoundingBox(),
185                                     (9884828.7209840547, 5607720.9774499247,
186                                      11298336.04640449, 9287823.2044059951))
187            self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
188                                     (90.0, -8.90043373, 120, 11.1616263))
189            shapes = layer.ShapesInRegion((100, -10, 150, +10))
190            self.assertEquals([s.ShapeID() for s in shapes], [0])
191            self.assertFloatSeqEqual(layer.ShapesBoundingBox([0]),
192                                     (90.0, -8.90043373, 120, 11.1616263))
193    
194            # Test a very large bounding box in the query.  Naive inverse
195            # projection will create infs instead of proper coordinate
196            # values and a different result (an empty list instead of [0])
197            shapes = layer.ShapesInRegion((-180, -170, 200, +120))
198            self.assertEquals([s.ShapeID() for s in shapes],[0])
199    
200      def test_empty_layer(self):      def test_empty_layer(self):
201          """Test Layer with empty shape file"""          """Test Layer with empty shape file"""
# Line 113  class TestLayer(unittest.TestCase, suppo Line 208  class TestLayer(unittest.TestCase, suppo
208          dbffilename = self.temp_file_name("layer_empty.dbf")          dbffilename = self.temp_file_name("layer_empty.dbf")
209          dbf = dbflib.create(dbffilename)          dbf = dbflib.create(dbffilename)
210          dbf.add_field("NAME", dbflib.FTString, 20, 0)          dbf.add_field("NAME", dbflib.FTString, 20, 0)
211            dbf.close()
212    
213          # Now try to open it.          # Now try to open it.
214          layer = Layer("Empty Layer",          layer = self.layer = Layer("Empty Layer",
215                        self.session.OpenShapefile(shapefilename))                                     self.session.OpenShapefile(shapefilename))
216          self.assertEquals(layer.BoundingBox(), None)          self.assertEquals(layer.BoundingBox(), None)
217          self.assertEquals(layer.LatLongBoundingBox(), None)          self.assertEquals(layer.LatLongBoundingBox(), None)
218          self.assertEquals(layer.NumShapes(), 0)          self.assertEquals(layer.NumShapes(), 0)
         layer.Destroy()  
219    
220        def test_get_field_type(self):
221            """Test Layer.GetFieldType()"""
222            layer = self.layer = Layer("Test Layer",
223                                       self.open_shapefile("roads-line.shp"))
224            self.assertEquals(layer.GetFieldType("LENGTH"), FIELDTYPE_DOUBLE)
225            self.assertEquals(layer.GetFieldType("non existing"), None)
226    
227        def test_raster_layer(self):
228            if not Thuban.Model.resource.has_gdal_support():
229                raise support.SkipTest("No gdal support")
230    
231            filename = self.build_path("island.tif")
232            layer = RasterLayer("Test RasterLayer", filename)
233            self.failIf(layer.HasClassification())
234            self.failIf(layer.HasShapes())
235            self.assertEquals(layer.MaskType(), layer.MASK_BIT)
236            self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
237            self.assertFloatSeqEqual(layer.BoundingBox(),
238                                     [-24.5500000, 63.2833330,
239                                      -13.4916670, 66.5666670])
240            self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
241                                     [-24.5500000, 63.2833330,
242                                      -13.4916670, 66.5666670])
243    
244            info = layer.ImageInfo()
245            self.failIf(info is None)
246            self.failUnless(info.has_key("nBands"))
247            self.failUnless(info.has_key("Size"))
248            self.failUnless(info.has_key("Driver"))
249            self.failUnless(info.has_key("BandData"))
250    
251            self.assertEquals(info["nBands"], 1)
252            self.assertEquals(info["Size"], (5002, 394))
253            self.assertEquals(info["Driver"], "GTiff")
254            self.assertEquals(info["BandData"], [(0.0, 140.0)])
255    
256        def test_derived_store(self):
257            """Test layer with derived store"""
258            layer = self.layer = Layer("Test Layer",
259                                       self.open_shapefile("roads-line.shp"))
260            try:
261                store = layer.ShapeStore()
262                derived = DerivedShapeStore(store, store.Table())
263                layer.SetShapeStore(derived)
264                self.assert_(layer.ShapeStore() is derived)
265    
266                self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
267                self.assertEquals(layer.NumShapes(), 839)
268                shape = layer.Shape(32)
269                self.assertPointListEquals(shape.Points(),
270                                           [[(-15.082174301147, 66.277381896972),
271                                             (-15.026350021362, 66.273391723632)]])
272                self.assertFloatSeqEqual(layer.BoundingBox(),
273                                         [-24.450359344482422, 63.426830291748047,
274                                          -13.55668830871582, 66.520111083984375])
275                shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
276                self.assertEquals([s.ShapeID() for s in shapes],
277                                  [613, 726, 838])
278    
279                self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
280                                         [-15.082174301147461, 66.27339172363281,
281                                          -15.026350021362305, 66.27738189697265])
282    
283            finally:
284                store = derived = None
285    
286    
287    class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
288    
289        def setUp(self):
290            """Create a layer with a classification as self.layer"""
291            self.clear_messages()
292            self.session = Session("Test session for %s" % self.__class__)
293            self.shapefilename = os.path.join("..", "Data", "iceland",
294                                              "cultural_landmark-point.dbf")
295            self.store = self.session.OpenShapefile(self.shapefilename)
296            self.layer = Layer("test layer", self.store)
297            self.classification = Classification()
298            self.classification.AppendGroup(ClassGroupSingleton("FARM"))
299            self.layer.SetClassificationColumn("CLPTLABEL")
300            self.layer.SetClassification(self.classification)
301            self.layer.UnsetModified()
302            self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
303                                 self.subscribe_with_params,
304                                 LAYER_SHAPESTORE_REPLACED)
305            self.layer.Subscribe(LAYER_CHANGED,
306                                 self.subscribe_with_params, LAYER_CHANGED)
307    
308        def tearDown(self):
309            self.clear_messages()
310            self.layer.Destroy()
311            self.session.Destroy()
312            self.session = self.layer = self.store = self.classification = None
313    
314        def test_sanity(self):
315            """SetShapeStoreTests sanity check
316    
317            Test the initial state of the test case instances after setUp.
318            """
319            cls = self.layer.GetClassification()
320            self.assert_(cls is self.classification)
321            field = self.layer.GetClassificationColumn()
322            self.assertEquals(field, "CLPTLABEL")
323            self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
324            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
325            self.failIf(self.layer.WasModified())
326    
327        def test_set_shape_store_modified_flag(self):
328            """Test whether Layer.SetShapeStore() sets the modified flag"""
329            memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
330                          [("bla",)] * self.layer.ShapeStore().Table().NumRows())
331            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
332    
333            self.assert_(self.layer.WasModified())
334    
335        def test_set_shape_store_different_field_name(self):
336            """Test Layer.SetShapeStore() with different column name"""
337            memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
338                          [("bla",)] * self.layer.ShapeStore().Table().NumRows())
339            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
340            # The classification should contain only the default group now.
341            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
342            self.check_messages([(self.layer, LAYER_CHANGED),
343                                 (self.layer, LAYER_SHAPESTORE_REPLACED)])
344    
345        def test_set_shape_store_same_field(self):
346            """Test Layer.SetShapeStore() with same column name and type"""
347            memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_STRING)],
348                          [("bla",)] * self.layer.ShapeStore().Table().NumRows())
349            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
350            # The classification should be the same as before
351            self.assert_(self.layer.GetClassification() is self.classification)
352            self.check_messages([(self.layer, LAYER_SHAPESTORE_REPLACED)])
353    
354  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):      def test_set_shape_store_same_field_different_type(self):
355            """Test Layer.SetShapeStore() with same column name but different type
356            """
357            memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_DOUBLE)],
358                          [(0.0,)] * self.layer.ShapeStore().Table().NumRows())
359            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
360            # The classification should contain only the default group now.
361            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
362            self.check_messages([(self.layer, LAYER_CHANGED),
363                                 (self.layer, LAYER_SHAPESTORE_REPLACED)])
364    
365    
366    class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
367    
368      """Test cases for Layer method that modify the layer.      """Test cases for Layer method that modify the layer.
369      """      """
# Line 135  class TestLayerLegend(unittest.TestCase, Line 375  class TestLayerLegend(unittest.TestCase,
375          """          """
376          self.clear_messages()          self.clear_messages()
377          self.session = Session("Test session for %s" % self.__class__)          self.session = Session("Test session for %s" % self.__class__)
378          filename = os.path.join("..", "Data", "iceland", "political.shp")          self.filename = os.path.join("..", "Data", "iceland", "political.shp")
379          self.layer = Layer("Test Layer",          self.layer = Layer("Test Layer",
380                             self.session.OpenShapefile(filename))                             self.session.OpenShapefile(self.filename))
381          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
382                               LAYER_LEGEND_CHANGED)                               LAYER_LEGEND_CHANGED)
383          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
384                               self.subscribe_with_params,                               self.subscribe_with_params,
385                               LAYER_VISIBILITY_CHANGED)                               LAYER_VISIBILITY_CHANGED)
386            self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
387                                 LAYER_CHANGED)
388    
389      def tearDown(self):      def tearDown(self):
390          """Clear the list of received messages and explictly destroy self.layer          """Clear the list of received messages and explictly destroy self.layer
# Line 153  class TestLayerLegend(unittest.TestCase, Line 395  class TestLayerLegend(unittest.TestCase,
395          self.session = None          self.session = None
396          self.clear_messages()          self.clear_messages()
397    
398      def test_initial_settings(self):      def build_path(self, filename):
399          """Test Layer's initial legend attributes"""          return os.path.join("..", "Data", "iceland", filename)
400    
401        def test_sanity(self):
402            """TestLayerModification Sanity Checks"""
403          # test default settings          # test default settings
404          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
         #self.assertEquals(self.layer.fill, None)  
         #self.assertEquals(self.layer.stroke.hex(), "#000000")  
         #self.assertEquals(self.layer.stroke_width, 1)  
405          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
406          # no messages should have been produced          # no messages should have been produced
407          self.check_messages([])          self.check_messages([])
# Line 174  class TestLayerLegend(unittest.TestCase, Line 416  class TestLayerLegend(unittest.TestCase,
416          # the layer.          # the layer.
417          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
418    
419            def test_set_classification(self):
420  #          """Test Layer.SetClassification"""
421  # the tree info now contains Color objects which are difficult to test          classification = Classification()
422  #          classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
423  #   def test_tree_info(self):  
424  #       """Test Layer.TreeInfo"""          self.layer.SetClassification(classification)
425  #       self.assertEquals(self.layer.TreeInfo(),          self.layer.SetClassificationColumn("AREA")
426  #                         ("Layer 'Test Layer'",  
427  #                          ['Shown',          self.check_messages([(self.layer, LAYER_CHANGED),
428  #                           'Shapes: 156',                               (self.layer, LAYER_CHANGED)])
429  #                           ('Extent (lat-lon):'          self.failUnless(self.layer.WasModified())
430  #                            ' (-24.5465, 63.2868, -13.4958, 66.5638)'),  
431  #                           'Shapetype: Polygon',          self.clear_messages()
432  #                           'Fill: None',          self.layer.UnsetModified()
433  #                           'Outline: (0.000, 0.000, 0.000)']))  
434            # change only the classification column. This should issue a
435            # LAYER_CHANGED message as well.
436            self.layer.SetClassificationColumn("PERIMETER")
437    
438            self.check_messages([(self.layer, LAYER_CHANGED)])
439            self.failUnless(self.layer.WasModified())
440    
441    
442        def test_tree_info(self):
443            """Test Layer.TreeInfo"""
444            self.assertEquals(self.layer.TreeInfo(),
445                              ("Layer 'Test Layer'",
446                               ['Filename: %s' % os.path.abspath(self.filename),
447                                'Shown',
448                                'Shapes: 156',
449                       'Extent (lat-lon): (-24.5465, 63.2868, -13.4958, 66.5638)',
450                                'Shapetype: Polygon',
451                                self.layer.GetClassification()]))
452    
453        def test_raster_layer(self):
454            if not Thuban.Model.resource.has_gdal_support():
455                raise support.SkipTest("No gdal support")
456    
457    
458            filename = self.build_path("island.tif")
459            layer = RasterLayer("Test RasterLayer", filename)
460    
461            layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
462                            LAYER_CHANGED)
463    
464            self.assertEquals(layer.MaskType(), layer.MASK_BIT)
465    
466            layer.SetMaskType(layer.MASK_NONE)
467            self.failIf(layer.MaskType() != layer.MASK_NONE)
468            self.check_messages([(layer, LAYER_CHANGED)])
469            self.clear_messages()
470    
471            layer.SetMaskType(layer.MASK_NONE)
472            self.failIf(layer.MaskType() != layer.MASK_NONE)
473            self.check_messages([])
474            self.clear_messages()
475    
476            layer.SetMaskType(layer.MASK_BIT)
477            self.failIf(layer.MaskType() != layer.MASK_BIT)
478            self.check_messages([(layer, LAYER_CHANGED)])
479            self.clear_messages()
480    
481            layer.SetMaskType(layer.MASK_BIT)
482            self.failIf(layer.MaskType() != layer.MASK_BIT)
483            self.check_messages([])
484            self.clear_messages()
485    
486            layer.SetMaskType(layer.MASK_ALPHA)
487            self.failIf(layer.MaskType() != layer.MASK_ALPHA)
488    
489            layer.SetOpacity(0)
490            self.assertEquals(layer.Opacity(), 0)
491            layer.SetOpacity(0.5)
492            self.assertEquals(layer.Opacity(), 0.5)
493    
494            self.clear_messages()
495            layer.SetOpacity(1)
496            self.assertEquals(layer.Opacity(), 1)
497            self.check_messages([(layer, LAYER_CHANGED)])
498            self.clear_messages()
499    
500            self.assertRaises(ValueError, layer.SetOpacity, -0.1)
501            self.assertRaises(ValueError, layer.SetOpacity, 1.1)
502    
503            layer.SetMaskType(layer.MASK_NONE)
504            self.clear_messages()
505            self.assertEquals(layer.Opacity(), 1)
506            self.check_messages([])
507            self.clear_messages()
508    
509            self.assertRaises(ValueError, layer.SetMaskType, -1)
510            self.assertRaises(ValueError, layer.SetMaskType, 4)
511    
512    
513  if __name__ == "__main__":  if __name__ == "__main__":
Legend:
Removed from v.723  
changed lines
  Added in v.2644
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26