/[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 1262 by jonathan, Fri Jun 20 14:15:30 2003 UTC revision 2229 by bh, Thu Jun 3 15:18:07 2004 UTC
# Line 1  Line 1 
1  # Copyright (c) 2002, 2003 by Intevation GmbH  # Copyright (c) 2002, 2003, 2004 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 BaseLayer, Layer, RasterLayer, \  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer
28       SHAPETYPE_POLYGON, SHAPETYPE_ARC, 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_SHAPESTORE_REPLACED, LAYER_CHANGED       LAYER_VISIBILITY_CHANGED, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED
 from Thuban.Model.color import Color  
31  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
32  from Thuban.Model.proj import Projection  from Thuban.Model.proj import Projection
33  from Thuban.Model.data import DerivedShapeStore  from Thuban.Model.data import DerivedShapeStore
34  from Thuban.Model.classification import Classification, ClassGroupSingleton  from Thuban.Model.classification import Classification, ClassGroupSingleton, \
35         ClassGroupRange
36    
37  import Thuban.Model.resource  import Thuban.Model.resource
38    
# Line 40  class TestLayer(unittest.TestCase, suppo Line 41  class TestLayer(unittest.TestCase, suppo
41    
42      """Test cases for different layer (shape) types"""      """Test cases for different layer (shape) types"""
43    
     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])  
   
44      def setUp(self):      def setUp(self):
45          """Create a session self.session and initialize self.layer to None"""          """Create a session self.session and initialize self.layer to None"""
46          self.session = Session("Test session for %s" % self.__class__)          self.session = Session("Test session for %s" % self.__class__)
# Line 52  class TestLayer(unittest.TestCase, suppo Line 48  class TestLayer(unittest.TestCase, suppo
48    
49      def tearDown(self):      def tearDown(self):
50          """Call the layer's Destroy method and set session and layer to None"""          """Call the layer's Destroy method and set session and layer to None"""
51            self.session.Destroy()
52          self.session = None          self.session = None
53          if self.layer is not None:          if self.layer is not None:
54              self.layer.Destroy()              self.layer.Destroy()
# Line 77  class TestLayer(unittest.TestCase, suppo Line 74  class TestLayer(unittest.TestCase, suppo
74          self.failUnless(layer.Visible())          self.failUnless(layer.Visible())
75    
76          self.failIf(layer.HasClassification())          self.failIf(layer.HasClassification())
77            self.failIf(layer.HasShapes())
78    
79          self.assertEquals(layer.GetProjection(), None)          self.assertEquals(layer.GetProjection(), None)
80    
81          # set/get projection          # set/get projection
82          proj = Projection(["proj=utm", "zone=26"])          proj = Projection(["proj=utm", "zone=26", "ellps=clrk66"])
83    
84          layer.SetProjection(proj)          layer.SetProjection(proj)
85          self.failUnless(layer.GetProjection() is proj)          self.failUnless(layer.GetProjection() is proj)
# Line 94  class TestLayer(unittest.TestCase, suppo Line 93  class TestLayer(unittest.TestCase, suppo
93          """Test Layer with arc shapes"""          """Test Layer with arc shapes"""
94          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
95                                     self.open_shapefile("roads-line.shp"))                                     self.open_shapefile("roads-line.shp"))
96            self.failUnless(layer.HasClassification())
97            self.failUnless(layer.HasShapes())
98          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
99          self.assertEquals(layer.NumShapes(), 839)          self.assertEquals(layer.NumShapes(), 839)
100          shape = layer.Shape(32)          shape = layer.Shape(32)
101          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
102                                      [(-15.082174301147461, 66.27738189697265),                                     [[(-15.082174301147461, 66.27738189697265),
103                                       (-15.026350021362305, 66.27339172363281)])                                       (-15.026350021362305, 66.27339172363281)]])
104          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
105                                   [-24.450359344482422, 63.426830291748047,                                   [-24.450359344482422, 63.426830291748047,
106                                    -13.55668830871582, 66.520111083984375])                                    -13.55668830871582, 66.520111083984375])
107          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
108            self.assertEquals([s.ShapeID() for s in shapes],
109                            [613, 726, 838])                            [613, 726, 838])
110    
111          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
# Line 111  class TestLayer(unittest.TestCase, suppo Line 113  class TestLayer(unittest.TestCase, suppo
113                             -15.026350021362305, 66.27738189697265])                             -15.026350021362305, 66.27738189697265])
114    
115          shape = layer.Shape(33)          shape = layer.Shape(33)
116          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
117                                      [(-22.248506546020508, 66.30645751953125),                                     [[(-22.24850654602050, 66.30645751953125),
118                                       (-22.232730865478516, 66.294075012207031),                                       (-22.23273086547851, 66.29407501220703),
119                                       (-22.23158073425293,  66.287689208984375),                                       (-22.23158073425293,  66.2876892089843),
120                                       (-22.246318817138672, 66.270065307617188)])                                       (-22.24631881713867, 66.27006530761718)]])
121    
122          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),
123                                   [-22.248506546020508, 66.270065307617188,                                   [-22.248506546020508, 66.270065307617188,
# Line 128  class TestLayer(unittest.TestCase, suppo Line 130  class TestLayer(unittest.TestCase, suppo
130          """Test Layer with polygon shapes"""          """Test Layer with polygon shapes"""
131          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
132                                     self.open_shapefile("political.shp"))                                     self.open_shapefile("political.shp"))
133            self.failUnless(layer.HasClassification())
134            self.failUnless(layer.HasShapes())
135          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
136          self.assertEquals(layer.NumShapes(), 156)          self.assertEquals(layer.NumShapes(), 156)
137          shape = layer.Shape(4)          shape = layer.Shape(4)
138          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
139                                      [(-22.406391143798828, 64.714111328125),                                     [[(-22.40639114379882, 64.714111328125),
140                                       (-22.41621208190918, 64.71600341796875),                                       (-22.41621208190918, 64.7160034179687),
141                                       (-22.406051635742188, 64.719200134277344),                                       (-22.40605163574218, 64.719200134277),
142                                       (-22.406391143798828, 64.714111328125)])                                       (-22.40639114379882, 64.714111328125)]])
143          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
144                                   [-24.546524047851562, 63.286754608154297,                                   [-24.546524047851562, 63.286754608154297,
145                                    -13.495815277099609, 66.563774108886719])                                    -13.495815277099609, 66.563774108886719])
146          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1))
147            self.assertEquals([s.ShapeID() for s in shapes],
148                            [91, 92, 144, 146, 148, 150, 152, 153])                            [91, 92, 144, 146, 148, 150, 152, 153])
149    
150      def test_point_layer(self):      def test_point_layer(self):
151          """Test Layer with point shapes"""          """Test Layer with point shapes"""
152          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
153                             self.open_shapefile("cultural_landmark-point.shp"))                             self.open_shapefile("cultural_landmark-point.shp"))
154            self.failUnless(layer.HasClassification())
155            self.failUnless(layer.HasShapes())
156          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
157          self.assertEquals(layer.NumShapes(), 34)          self.assertEquals(layer.NumShapes(), 34)
158          shape = layer.Shape(0)          shape = layer.Shape(0)
159          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
160                                      [(-22.711074829101562, 66.36572265625)])                                     [[(-22.711074829101562, 66.36572265625)]])
161          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
162                                   [-23.806047439575195, 63.405960083007812,                                   [-23.806047439575195, 63.405960083007812,
163                                    -15.12291431427002, 66.36572265625])                                    -15.12291431427002, 66.36572265625])
164          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1))
165            self.assertEquals([s.ShapeID() for s in shapes],
166                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])
167    
168        def test_arc_layer_with_projection(self):
169            """Test Layer with point shapes and a projection"""
170            # We use mock data here so that we have precise control over the
171            # values
172            table = MemoryTable([("FOO", FIELDTYPE_STRING)], [("bla",)])
173            store = mockgeo.SimpleShapeStore(SHAPETYPE_ARC,
174                                  [[[(9884828.7209840547, 5607720.9774499247),
175                                     (11298336.04640449, 9287823.2044059951)]]],
176                                             table)
177            layer = self.layer = Layer("Test Layer", store)
178    
179            proj = Projection(["proj=lcc", "lon_0=0", "lat_1=20n", "lat_2=60n",
180                               "ellps=clrk66"])
181            layer.SetProjection(proj)
182    
183            self.assertFloatSeqEqual(layer.BoundingBox(),
184                                     (9884828.7209840547, 5607720.9774499247,
185                                      11298336.04640449, 9287823.2044059951))
186            self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
187                                     (90.0, -8.90043373, 120, 11.1616263))
188            shapes = layer.ShapesInRegion((100, -10, 150, +10))
189            self.assertEquals([s.ShapeID() for s in shapes], [0])
190            self.assertFloatSeqEqual(layer.ShapesBoundingBox([0]),
191                                     (90.0, -8.90043373, 120, 11.1616263))
192    
193      def test_empty_layer(self):      def test_empty_layer(self):
194          """Test Layer with empty shape file"""          """Test Layer with empty shape file"""
195          # create an empty shape file          # create an empty shape file
# Line 168  class TestLayer(unittest.TestCase, suppo Line 201  class TestLayer(unittest.TestCase, suppo
201          dbffilename = self.temp_file_name("layer_empty.dbf")          dbffilename = self.temp_file_name("layer_empty.dbf")
202          dbf = dbflib.create(dbffilename)          dbf = dbflib.create(dbffilename)
203          dbf.add_field("NAME", dbflib.FTString, 20, 0)          dbf.add_field("NAME", dbflib.FTString, 20, 0)
204            dbf.close()
205    
206          # Now try to open it.          # Now try to open it.
207          layer = self.layer = Layer("Empty Layer",          layer = self.layer = Layer("Empty Layer",
# Line 185  class TestLayer(unittest.TestCase, suppo Line 219  class TestLayer(unittest.TestCase, suppo
219    
220      def test_raster_layer(self):      def test_raster_layer(self):
221          if not Thuban.Model.resource.has_gdal_support():          if not Thuban.Model.resource.has_gdal_support():
222              return              raise support.SkipTest("No gdal support")
223    
224          filename = self.build_path("island.tif")          filename = self.build_path("island.tif")
225          layer = RasterLayer("Test RasterLayer", filename)          layer = RasterLayer("Test RasterLayer", filename)
226          self.assertEquals(layer.GetImageFilename(), filename)          self.failIf(layer.HasClassification())
227            self.failIf(layer.HasShapes())
228            self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
229          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
230                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
231                                    -13.4916670, 66.5666670])                                    -13.4916670, 66.5666670])
# Line 207  class TestLayer(unittest.TestCase, suppo Line 243  class TestLayer(unittest.TestCase, suppo
243              layer.SetShapeStore(derived)              layer.SetShapeStore(derived)
244              self.assert_(layer.ShapeStore() is derived)              self.assert_(layer.ShapeStore() is derived)
245    
246              # check that an exception is raised when the number              self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
247              # of shapes differ from the number of rows in a table.              self.assertEquals(layer.NumShapes(), 839)
248              layer2 = Layer("Test Layer",              shape = layer.Shape(32)
249                             self.open_shapefile("political.shp"))              self.assertPointListEquals(shape.Points(),
250              store2 = layer2.ShapeStore()                                         [[(-15.082174301147, 66.277381896972),
251              self.assertRaises(ValueError,                                           (-15.026350021362, 66.273391723632)]])
252                                DerivedShapeStore, store2, store.Table())              self.assertFloatSeqEqual(layer.BoundingBox(),
253                                         [-24.450359344482422, 63.426830291748047,
254                                          -13.55668830871582, 66.520111083984375])
255                shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
256                self.assertEquals([s.ShapeID() for s in shapes],
257                                  [613, 726, 838])
258    
259                self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
260                                         [-15.082174301147461, 66.27339172363281,
261                                          -15.026350021362305, 66.27738189697265])
262    
263          finally:          finally:
264              store = derived = None              store = derived = None
             layer2.Destroy()  
             store2 = None  
265    
266    
267  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
# Line 231  class SetShapeStoreTests(unittest.TestCa Line 274  class SetShapeStoreTests(unittest.TestCa
274                                            "cultural_landmark-point.dbf")                                            "cultural_landmark-point.dbf")
275          self.store = self.session.OpenShapefile(self.shapefilename)          self.store = self.session.OpenShapefile(self.shapefilename)
276          self.layer = Layer("test layer", self.store)          self.layer = Layer("test layer", self.store)
277          self.classification = Classification(field = "CLPTLABEL")          self.classification = Classification()
278          self.classification.AppendGroup(ClassGroupSingleton("FARM"))          self.classification.AppendGroup(ClassGroupSingleton("FARM"))
279            self.layer.SetClassificationColumn("CLPTLABEL")
280          self.layer.SetClassification(self.classification)          self.layer.SetClassification(self.classification)
281          self.layer.UnsetModified()          self.layer.UnsetModified()
282          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
# Line 254  class SetShapeStoreTests(unittest.TestCa Line 298  class SetShapeStoreTests(unittest.TestCa
298          """          """
299          cls = self.layer.GetClassification()          cls = self.layer.GetClassification()
300          self.assert_(cls is self.classification)          self.assert_(cls is self.classification)
301          self.assertEquals(cls.GetField(), "CLPTLABEL")          field = self.layer.GetClassificationColumn()
302          self.assertEquals(cls.GetFieldType(), FIELDTYPE_STRING)          self.assertEquals(field, "CLPTLABEL")
303            self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
304          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
305          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
306    
# Line 298  class SetShapeStoreTests(unittest.TestCa Line 343  class SetShapeStoreTests(unittest.TestCa
343                               (self.layer, LAYER_SHAPESTORE_REPLACED)])                               (self.layer, LAYER_SHAPESTORE_REPLACED)])
344    
345    
346  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
347    
348      """Test cases for Layer method that modify the layer.      """Test cases for Layer method that modify the layer.
349      """      """
# Line 310  class TestLayerLegend(unittest.TestCase, Line 355  class TestLayerLegend(unittest.TestCase,
355          """          """
356          self.clear_messages()          self.clear_messages()
357          self.session = Session("Test session for %s" % self.__class__)          self.session = Session("Test session for %s" % self.__class__)
358          filename = os.path.join("..", "Data", "iceland", "political.shp")          self.filename = os.path.join("..", "Data", "iceland", "political.shp")
359          self.layer = Layer("Test Layer",          self.layer = Layer("Test Layer",
360                             self.session.OpenShapefile(filename))                             self.session.OpenShapefile(self.filename))
361          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
362                               LAYER_LEGEND_CHANGED)                               LAYER_LEGEND_CHANGED)
363          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
364                               self.subscribe_with_params,                               self.subscribe_with_params,
365                               LAYER_VISIBILITY_CHANGED)                               LAYER_VISIBILITY_CHANGED)
366            self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
367                                 LAYER_CHANGED)
368    
369      def tearDown(self):      def tearDown(self):
370          """Clear the list of received messages and explictly destroy self.layer          """Clear the list of received messages and explictly destroy self.layer
# Line 328  class TestLayerLegend(unittest.TestCase, Line 375  class TestLayerLegend(unittest.TestCase,
375          self.session = None          self.session = None
376          self.clear_messages()          self.clear_messages()
377    
378      def test_initial_settings(self):      def test_sanity(self):
379          """Test Layer's initial legend attributes"""          """TestLayerModification Sanity Checks"""
380          # test default settings          # test default settings
381          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)  
382          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
383          # no messages should have been produced          # no messages should have been produced
384          self.check_messages([])          self.check_messages([])
# Line 349  class TestLayerLegend(unittest.TestCase, Line 393  class TestLayerLegend(unittest.TestCase,
393          # the layer.          # the layer.
394          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
395    
396            def test_set_classification(self):
397  #          """Test Layer.SetClassification"""
398  # the tree info now contains Color objects which are difficult to test          classification = Classification()
399  #          classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
400  #   def test_tree_info(self):  
401  #       """Test Layer.TreeInfo"""          self.layer.SetClassification(classification)
402  #       self.assertEquals(self.layer.TreeInfo(),          self.layer.SetClassificationColumn("AREA")
403  #                         ("Layer 'Test Layer'",  
404  #                          ['Shown',          self.check_messages([(self.layer, LAYER_CHANGED),
405  #                           'Shapes: 156',                               (self.layer, LAYER_CHANGED)])
406  #                           ('Extent (lat-lon):'          self.failUnless(self.layer.WasModified())
407  #                            ' (-24.5465, 63.2868, -13.4958, 66.5638)'),  
408  #                           'Shapetype: Polygon',          self.clear_messages()
409  #                           'Fill: None',          self.layer.UnsetModified()
410  #                           'Outline: (0.000, 0.000, 0.000)']))  
411            # change only the classification column. This should issue a
412            # LAYER_CHANGED message as well.
413            self.layer.SetClassificationColumn("PERIMETER")
414    
415            self.check_messages([(self.layer, LAYER_CHANGED)])
416            self.failUnless(self.layer.WasModified())
417    
418    
419        def test_tree_info(self):
420            """Test Layer.TreeInfo"""
421            self.assertEquals(self.layer.TreeInfo(),
422                              ("Layer 'Test Layer'",
423                               ['Filename: %s' % os.path.abspath(self.filename),
424                                'Shown',
425                                'Shapes: 156',
426                       'Extent (lat-lon): (-24.5465, 63.2868, -13.4958, 66.5638)',
427                                'Shapetype: Polygon',
428                                self.layer.GetClassification()]))
429    
430    
431  if __name__ == "__main__":  if __name__ == "__main__":
Legend:
Removed from v.1262  
changed lines
  Added in v.2229
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26