/[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 1593 by bh, Fri Aug 15 14:10:27 2003 UTC
# 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 77  class TestLayer(unittest.TestCase, suppo Line 73  class TestLayer(unittest.TestCase, suppo
73          self.failUnless(layer.Visible())          self.failUnless(layer.Visible())
74    
75          self.failIf(layer.HasClassification())          self.failIf(layer.HasClassification())
76            self.failIf(layer.HasShapes())
77    
78          self.assertEquals(layer.GetProjection(), None)          self.assertEquals(layer.GetProjection(), None)
79    
80          # set/get projection          # set/get projection
# Line 94  class TestLayer(unittest.TestCase, suppo Line 92  class TestLayer(unittest.TestCase, suppo
92          """Test Layer with arc shapes"""          """Test Layer with arc shapes"""
93          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
94                                     self.open_shapefile("roads-line.shp"))                                     self.open_shapefile("roads-line.shp"))
95            self.failUnless(layer.HasClassification())
96            self.failUnless(layer.HasShapes())
97          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
98          self.assertEquals(layer.NumShapes(), 839)          self.assertEquals(layer.NumShapes(), 839)
99          shape = layer.Shape(32)          shape = layer.Shape(32)
100          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
101                                      [(-15.082174301147461, 66.27738189697265),                                     [[(-15.082174301147461, 66.27738189697265),
102                                       (-15.026350021362305, 66.27339172363281)])                                       (-15.026350021362305, 66.27339172363281)]])
103          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
104                                   [-24.450359344482422, 63.426830291748047,                                   [-24.450359344482422, 63.426830291748047,
105                                    -13.55668830871582, 66.520111083984375])                                    -13.55668830871582, 66.520111083984375])
106          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
107            self.assertEquals([s.ShapeID() for s in shapes],
108                            [613, 726, 838])                            [613, 726, 838])
109    
110          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
# Line 111  class TestLayer(unittest.TestCase, suppo Line 112  class TestLayer(unittest.TestCase, suppo
112                             -15.026350021362305, 66.27738189697265])                             -15.026350021362305, 66.27738189697265])
113    
114          shape = layer.Shape(33)          shape = layer.Shape(33)
115          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
116                                      [(-22.248506546020508, 66.30645751953125),                                     [[(-22.24850654602050, 66.30645751953125),
117                                       (-22.232730865478516, 66.294075012207031),                                       (-22.23273086547851, 66.29407501220703),
118                                       (-22.23158073425293,  66.287689208984375),                                       (-22.23158073425293,  66.2876892089843),
119                                       (-22.246318817138672, 66.270065307617188)])                                       (-22.24631881713867, 66.27006530761718)]])
120    
121          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),
122                                   [-22.248506546020508, 66.270065307617188,                                   [-22.248506546020508, 66.270065307617188,
# Line 128  class TestLayer(unittest.TestCase, suppo Line 129  class TestLayer(unittest.TestCase, suppo
129          """Test Layer with polygon shapes"""          """Test Layer with polygon shapes"""
130          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
131                                     self.open_shapefile("political.shp"))                                     self.open_shapefile("political.shp"))
132            self.failUnless(layer.HasClassification())
133            self.failUnless(layer.HasShapes())
134          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
135          self.assertEquals(layer.NumShapes(), 156)          self.assertEquals(layer.NumShapes(), 156)
136          shape = layer.Shape(4)          shape = layer.Shape(4)
137          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
138                                      [(-22.406391143798828, 64.714111328125),                                     [[(-22.40639114379882, 64.714111328125),
139                                       (-22.41621208190918, 64.71600341796875),                                       (-22.41621208190918, 64.7160034179687),
140                                       (-22.406051635742188, 64.719200134277344),                                       (-22.40605163574218, 64.719200134277),
141                                       (-22.406391143798828, 64.714111328125)])                                       (-22.40639114379882, 64.714111328125)]])
142          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
143                                   [-24.546524047851562, 63.286754608154297,                                   [-24.546524047851562, 63.286754608154297,
144                                    -13.495815277099609, 66.563774108886719])                                    -13.495815277099609, 66.563774108886719])
145          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1))
146            self.assertEquals([s.ShapeID() for s in shapes],
147                            [91, 92, 144, 146, 148, 150, 152, 153])                            [91, 92, 144, 146, 148, 150, 152, 153])
148    
149      def test_point_layer(self):      def test_point_layer(self):
150          """Test Layer with point shapes"""          """Test Layer with point shapes"""
151          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
152                             self.open_shapefile("cultural_landmark-point.shp"))                             self.open_shapefile("cultural_landmark-point.shp"))
153            self.failUnless(layer.HasClassification())
154            self.failUnless(layer.HasShapes())
155          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
156          self.assertEquals(layer.NumShapes(), 34)          self.assertEquals(layer.NumShapes(), 34)
157          shape = layer.Shape(0)          shape = layer.Shape(0)
158          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
159                                      [(-22.711074829101562, 66.36572265625)])                                     [[(-22.711074829101562, 66.36572265625)]])
160          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
161                                   [-23.806047439575195, 63.405960083007812,                                   [-23.806047439575195, 63.405960083007812,
162                                    -15.12291431427002, 66.36572265625])                                    -15.12291431427002, 66.36572265625])
163          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1)),          shapes = layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1))
164            self.assertEquals([s.ShapeID() for s in shapes],
165                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])                            [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])
166    
167        def test_point_layer_with_projection(self):
168            """Test Layer with point shapes and a projection"""
169            # We use mock data here so that we have precise control over the
170            # values
171            table = MemoryTable([("FOO", FIELDTYPE_STRING)], [("bla",)])
172            store = mockgeo.SimpleShapeStore(SHAPETYPE_POINT, [[[(10,10)]]], table)
173            layer = self.layer = Layer("Test Layer", store)
174    
175            # Rotation by 45 degrees counter clockwise. This detects a bug
176            # in the ShapesInRegion method which transforms the bounding box
177            # by only transforming two opposite corners because they have
178            # the same x or y coordinates after application of the
179            # projection or its inverse.
180            proj = mockgeo.AffineProjection((1, 1, -1, 1, 0, 0))
181            layer.SetProjection(proj)
182    
183            self.assertEquals(layer.BoundingBox(), (10, 10, 10, 10))
184            self.assertEquals(layer.LatLongBoundingBox(), (10.0, 0.0, 10.0, 0.0))
185            shapes = layer.ShapesInRegion((0, 0, 20, 20))
186            self.assertEquals([s.ShapeID() for s in shapes], [0])
187    
188      def test_empty_layer(self):      def test_empty_layer(self):
189          """Test Layer with empty shape file"""          """Test Layer with empty shape file"""
190          # create an empty shape file          # create an empty shape file
# Line 185  class TestLayer(unittest.TestCase, suppo Line 213  class TestLayer(unittest.TestCase, suppo
213    
214      def test_raster_layer(self):      def test_raster_layer(self):
215          if not Thuban.Model.resource.has_gdal_support():          if not Thuban.Model.resource.has_gdal_support():
216              return              raise support.SkipTest("No gdal support")
217    
218          filename = self.build_path("island.tif")          filename = self.build_path("island.tif")
219          layer = RasterLayer("Test RasterLayer", filename)          layer = RasterLayer("Test RasterLayer", filename)
220            self.failIf(layer.HasClassification())
221            self.failIf(layer.HasShapes())
222          self.assertEquals(layer.GetImageFilename(), filename)          self.assertEquals(layer.GetImageFilename(), filename)
223          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
224                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
# Line 207  class TestLayer(unittest.TestCase, suppo Line 237  class TestLayer(unittest.TestCase, suppo
237              layer.SetShapeStore(derived)              layer.SetShapeStore(derived)
238              self.assert_(layer.ShapeStore() is derived)              self.assert_(layer.ShapeStore() is derived)
239    
240              # check that an exception is raised when the number              self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
241              # of shapes differ from the number of rows in a table.              self.assertEquals(layer.NumShapes(), 839)
242              layer2 = Layer("Test Layer",              shape = layer.Shape(32)
243                             self.open_shapefile("political.shp"))              self.assertPointListEquals(shape.Points(),
244              store2 = layer2.ShapeStore()                                         [[(-15.082174301147, 66.277381896972),
245              self.assertRaises(ValueError,                                           (-15.026350021362, 66.273391723632)]])
246                                DerivedShapeStore, store2, store.Table())              self.assertFloatSeqEqual(layer.BoundingBox(),
247                                         [-24.450359344482422, 63.426830291748047,
248                                          -13.55668830871582, 66.520111083984375])
249                shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
250                self.assertEquals([s.ShapeID() for s in shapes],
251                                  [613, 726, 838])
252    
253                self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
254                                         [-15.082174301147461, 66.27339172363281,
255                                          -15.026350021362305, 66.27738189697265])
256    
257          finally:          finally:
258              store = derived = None              store = derived = None
             layer2.Destroy()  
             store2 = None  
259    
260    
261  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
# Line 231  class SetShapeStoreTests(unittest.TestCa Line 268  class SetShapeStoreTests(unittest.TestCa
268                                            "cultural_landmark-point.dbf")                                            "cultural_landmark-point.dbf")
269          self.store = self.session.OpenShapefile(self.shapefilename)          self.store = self.session.OpenShapefile(self.shapefilename)
270          self.layer = Layer("test layer", self.store)          self.layer = Layer("test layer", self.store)
271          self.classification = Classification(field = "CLPTLABEL")          self.classification = Classification()
272          self.classification.AppendGroup(ClassGroupSingleton("FARM"))          self.classification.AppendGroup(ClassGroupSingleton("FARM"))
273            self.layer.SetClassificationColumn("CLPTLABEL")
274          self.layer.SetClassification(self.classification)          self.layer.SetClassification(self.classification)
275          self.layer.UnsetModified()          self.layer.UnsetModified()
276          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
# Line 254  class SetShapeStoreTests(unittest.TestCa Line 292  class SetShapeStoreTests(unittest.TestCa
292          """          """
293          cls = self.layer.GetClassification()          cls = self.layer.GetClassification()
294          self.assert_(cls is self.classification)          self.assert_(cls is self.classification)
295          self.assertEquals(cls.GetField(), "CLPTLABEL")          field = self.layer.GetClassificationColumn()
296          self.assertEquals(cls.GetFieldType(), FIELDTYPE_STRING)          self.assertEquals(field, "CLPTLABEL")
297            self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
298          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
299          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
300    
# Line 298  class SetShapeStoreTests(unittest.TestCa Line 337  class SetShapeStoreTests(unittest.TestCa
337                               (self.layer, LAYER_SHAPESTORE_REPLACED)])                               (self.layer, LAYER_SHAPESTORE_REPLACED)])
338    
339    
340  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
341    
342      """Test cases for Layer method that modify the layer.      """Test cases for Layer method that modify the layer.
343      """      """
# Line 318  class TestLayerLegend(unittest.TestCase, Line 357  class TestLayerLegend(unittest.TestCase,
357          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
358                               self.subscribe_with_params,                               self.subscribe_with_params,
359                               LAYER_VISIBILITY_CHANGED)                               LAYER_VISIBILITY_CHANGED)
360            self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
361                                 LAYER_CHANGED)
362    
363      def tearDown(self):      def tearDown(self):
364          """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 369  class TestLayerLegend(unittest.TestCase,
369          self.session = None          self.session = None
370          self.clear_messages()          self.clear_messages()
371    
372      def test_initial_settings(self):      def test_sanity(self):
373          """Test Layer's initial legend attributes"""          """TestLayerModification Sanity Checks"""
374          # test default settings          # test default settings
375          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)  
376          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
377          # no messages should have been produced          # no messages should have been produced
378          self.check_messages([])          self.check_messages([])
# Line 349  class TestLayerLegend(unittest.TestCase, Line 387  class TestLayerLegend(unittest.TestCase,
387          # the layer.          # the layer.
388          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
389    
390            def test_set_classification(self):
391            """Test Layer.SetClassification"""
392            classification = Classification()
393            classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
394    
395            self.layer.SetClassification(classification)
396            self.layer.SetClassificationColumn("AREA")
397    
398            self.check_messages([(self.layer, LAYER_CHANGED),
399                                 (self.layer, LAYER_CHANGED)])
400            self.failUnless(self.layer.WasModified())
401    
402            self.clear_messages()
403            self.layer.UnsetModified()
404    
405            # change only the classification column. This should issue a
406            # LAYER_CHANGED message as well.
407            self.layer.SetClassificationColumn("PERIMETER")
408    
409            self.check_messages([(self.layer, LAYER_CHANGED)])
410            self.failUnless(self.layer.WasModified())
411    
412    
413  #  #
414  # the tree info now contains Color objects which are difficult to test  # the tree info now contains Color objects which are difficult to test
415  #  #
Legend:
Removed from v.1262  
changed lines
  Added in v.1593
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26