/[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 1551 by bh, Wed Aug 6 17:21:07 2003 UTC
# Line 23  import shapelib Line 23  import shapelib
23  import dbflib  import dbflib
24    
25  from Thuban.Model.session import Session  from Thuban.Model.session import Session
26  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer, \  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer
27       SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT  from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
28  from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \  from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \
29       LAYER_VISIBILITY_CHANGED, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED       LAYER_VISIBILITY_CHANGED, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED
 from Thuban.Model.color import Color  
30  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
31  from Thuban.Model.proj import Projection  from Thuban.Model.proj import Projection
32  from Thuban.Model.data import DerivedShapeStore  from Thuban.Model.data import DerivedShapeStore
33  from Thuban.Model.classification import Classification, ClassGroupSingleton  from Thuban.Model.classification import Classification, ClassGroupSingleton, \
34         ClassGroupRange
35    
36  import Thuban.Model.resource  import Thuban.Model.resource
37    
# Line 40  class TestLayer(unittest.TestCase, suppo Line 40  class TestLayer(unittest.TestCase, suppo
40    
41      """Test cases for different layer (shape) types"""      """Test cases for different layer (shape) types"""
42    
43      def assertFloatTuplesEqual(self, test, value):      def assertPointListEquals(self, test, value):
44          """Assert equality of two lists of tuples of float"""          """Assert equality of two lists of lists of tuples of float"""
45          for i in range(len(test)):          for i in range(len(test)):
46              self.assertFloatSeqEqual(test[i], value[i])              self.assertEquals(len(test[i]), len(value[i]))
47                for j in range(len(test[i])):
48                    self.assertFloatSeqEqual(test[i][j], value[i][j])
49    
50      def setUp(self):      def setUp(self):
51          """Create a session self.session and initialize self.layer to None"""          """Create a session self.session and initialize self.layer to None"""
# Line 77  class TestLayer(unittest.TestCase, suppo Line 79  class TestLayer(unittest.TestCase, suppo
79          self.failUnless(layer.Visible())          self.failUnless(layer.Visible())
80    
81          self.failIf(layer.HasClassification())          self.failIf(layer.HasClassification())
82            self.failIf(layer.HasShapes())
83    
84          self.assertEquals(layer.GetProjection(), None)          self.assertEquals(layer.GetProjection(), None)
85    
86          # set/get projection          # set/get projection
# Line 94  class TestLayer(unittest.TestCase, suppo Line 98  class TestLayer(unittest.TestCase, suppo
98          """Test Layer with arc shapes"""          """Test Layer with arc shapes"""
99          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
100                                     self.open_shapefile("roads-line.shp"))                                     self.open_shapefile("roads-line.shp"))
101            self.failUnless(layer.HasClassification())
102            self.failUnless(layer.HasShapes())
103          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
104          self.assertEquals(layer.NumShapes(), 839)          self.assertEquals(layer.NumShapes(), 839)
105          shape = layer.Shape(32)          shape = layer.Shape(32)
106          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
107                                      [(-15.082174301147461, 66.27738189697265),                                     [[(-15.082174301147461, 66.27738189697265),
108                                       (-15.026350021362305, 66.27339172363281)])                                       (-15.026350021362305, 66.27339172363281)]])
109          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
110                                   [-24.450359344482422, 63.426830291748047,                                   [-24.450359344482422, 63.426830291748047,
111                                    -13.55668830871582, 66.520111083984375])                                    -13.55668830871582, 66.520111083984375])
# Line 111  class TestLayer(unittest.TestCase, suppo Line 117  class TestLayer(unittest.TestCase, suppo
117                             -15.026350021362305, 66.27738189697265])                             -15.026350021362305, 66.27738189697265])
118    
119          shape = layer.Shape(33)          shape = layer.Shape(33)
120          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
121                                      [(-22.248506546020508, 66.30645751953125),                                     [[(-22.24850654602050, 66.30645751953125),
122                                       (-22.232730865478516, 66.294075012207031),                                       (-22.23273086547851, 66.29407501220703),
123                                       (-22.23158073425293,  66.287689208984375),                                       (-22.23158073425293,  66.2876892089843),
124                                       (-22.246318817138672, 66.270065307617188)])                                       (-22.24631881713867, 66.27006530761718)]])
125    
126          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),          self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),
127                                   [-22.248506546020508, 66.270065307617188,                                   [-22.248506546020508, 66.270065307617188,
# Line 128  class TestLayer(unittest.TestCase, suppo Line 134  class TestLayer(unittest.TestCase, suppo
134          """Test Layer with polygon shapes"""          """Test Layer with polygon shapes"""
135          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
136                                     self.open_shapefile("political.shp"))                                     self.open_shapefile("political.shp"))
137            self.failUnless(layer.HasClassification())
138            self.failUnless(layer.HasShapes())
139          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
140          self.assertEquals(layer.NumShapes(), 156)          self.assertEquals(layer.NumShapes(), 156)
141          shape = layer.Shape(4)          shape = layer.Shape(4)
142          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
143                                      [(-22.406391143798828, 64.714111328125),                                     [[(-22.40639114379882, 64.714111328125),
144                                       (-22.41621208190918, 64.71600341796875),                                       (-22.41621208190918, 64.7160034179687),
145                                       (-22.406051635742188, 64.719200134277344),                                       (-22.40605163574218, 64.719200134277),
146                                       (-22.406391143798828, 64.714111328125)])                                       (-22.40639114379882, 64.714111328125)]])
147          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
148                                   [-24.546524047851562, 63.286754608154297,                                   [-24.546524047851562, 63.286754608154297,
149                                    -13.495815277099609, 66.563774108886719])                                    -13.495815277099609, 66.563774108886719])
# Line 146  class TestLayer(unittest.TestCase, suppo Line 154  class TestLayer(unittest.TestCase, suppo
154          """Test Layer with point shapes"""          """Test Layer with point shapes"""
155          layer = self.layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
156                             self.open_shapefile("cultural_landmark-point.shp"))                             self.open_shapefile("cultural_landmark-point.shp"))
157            self.failUnless(layer.HasClassification())
158            self.failUnless(layer.HasShapes())
159          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
160          self.assertEquals(layer.NumShapes(), 34)          self.assertEquals(layer.NumShapes(), 34)
161          shape = layer.Shape(0)          shape = layer.Shape(0)
162          self.assertFloatTuplesEqual(shape.Points(),          self.assertPointListEquals(shape.Points(),
163                                      [(-22.711074829101562, 66.36572265625)])                                     [[(-22.711074829101562, 66.36572265625)]])
164          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
165                                   [-23.806047439575195, 63.405960083007812,                                   [-23.806047439575195, 63.405960083007812,
166                                    -15.12291431427002, 66.36572265625])                                    -15.12291431427002, 66.36572265625])
# Line 189  class TestLayer(unittest.TestCase, suppo Line 199  class TestLayer(unittest.TestCase, suppo
199    
200          filename = self.build_path("island.tif")          filename = self.build_path("island.tif")
201          layer = RasterLayer("Test RasterLayer", filename)          layer = RasterLayer("Test RasterLayer", filename)
202            self.failIf(layer.HasClassification())
203            self.failIf(layer.HasShapes())
204          self.assertEquals(layer.GetImageFilename(), filename)          self.assertEquals(layer.GetImageFilename(), filename)
205          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
206                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
# Line 207  class TestLayer(unittest.TestCase, suppo Line 219  class TestLayer(unittest.TestCase, suppo
219              layer.SetShapeStore(derived)              layer.SetShapeStore(derived)
220              self.assert_(layer.ShapeStore() is derived)              self.assert_(layer.ShapeStore() is derived)
221    
222              # check that an exception is raised when the number              self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
223              # of shapes differ from the number of rows in a table.              self.assertEquals(layer.NumShapes(), 839)
224              layer2 = Layer("Test Layer",              shape = layer.Shape(32)
225                             self.open_shapefile("political.shp"))              self.assertPointListEquals(shape.Points(),
226              store2 = layer2.ShapeStore()                                         [[(-15.082174301147, 66.277381896972),
227              self.assertRaises(ValueError,                                           (-15.026350021362, 66.273391723632)]])
228                                DerivedShapeStore, store2, store.Table())              self.assertFloatSeqEqual(layer.BoundingBox(),
229                                         [-24.450359344482422, 63.426830291748047,
230                                          -13.55668830871582, 66.520111083984375])
231                self.assertEquals(layer.ShapesInRegion((-24.0, 64.0,
232                                                        -23.75, 64.25)),
233                                  [613, 726, 838])
234    
235                self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
236                                         [-15.082174301147461, 66.27339172363281,
237                                          -15.026350021362305, 66.27738189697265])
238    
239          finally:          finally:
240              store = derived = None              store = derived = None
             layer2.Destroy()  
             store2 = None  
241    
242    
243  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
# Line 231  class SetShapeStoreTests(unittest.TestCa Line 250  class SetShapeStoreTests(unittest.TestCa
250                                            "cultural_landmark-point.dbf")                                            "cultural_landmark-point.dbf")
251          self.store = self.session.OpenShapefile(self.shapefilename)          self.store = self.session.OpenShapefile(self.shapefilename)
252          self.layer = Layer("test layer", self.store)          self.layer = Layer("test layer", self.store)
253          self.classification = Classification(field = "CLPTLABEL")          self.classification = Classification()
254          self.classification.AppendGroup(ClassGroupSingleton("FARM"))          self.classification.AppendGroup(ClassGroupSingleton("FARM"))
255            self.layer.SetClassificationColumn("CLPTLABEL")
256          self.layer.SetClassification(self.classification)          self.layer.SetClassification(self.classification)
257          self.layer.UnsetModified()          self.layer.UnsetModified()
258          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
# Line 254  class SetShapeStoreTests(unittest.TestCa Line 274  class SetShapeStoreTests(unittest.TestCa
274          """          """
275          cls = self.layer.GetClassification()          cls = self.layer.GetClassification()
276          self.assert_(cls is self.classification)          self.assert_(cls is self.classification)
277          self.assertEquals(cls.GetField(), "CLPTLABEL")          field = self.layer.GetClassificationColumn()
278          self.assertEquals(cls.GetFieldType(), FIELDTYPE_STRING)          self.assertEquals(field, "CLPTLABEL")
279            self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
280          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
281          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
282    
# Line 298  class SetShapeStoreTests(unittest.TestCa Line 319  class SetShapeStoreTests(unittest.TestCa
319                               (self.layer, LAYER_SHAPESTORE_REPLACED)])                               (self.layer, LAYER_SHAPESTORE_REPLACED)])
320    
321    
322  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
323    
324      """Test cases for Layer method that modify the layer.      """Test cases for Layer method that modify the layer.
325      """      """
# Line 318  class TestLayerLegend(unittest.TestCase, Line 339  class TestLayerLegend(unittest.TestCase,
339          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
340                               self.subscribe_with_params,                               self.subscribe_with_params,
341                               LAYER_VISIBILITY_CHANGED)                               LAYER_VISIBILITY_CHANGED)
342            self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
343                                 LAYER_CHANGED)
344    
345      def tearDown(self):      def tearDown(self):
346          """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 351  class TestLayerLegend(unittest.TestCase,
351          self.session = None          self.session = None
352          self.clear_messages()          self.clear_messages()
353    
354      def test_initial_settings(self):      def test_sanity(self):
355          """Test Layer's initial legend attributes"""          """TestLayerModification Sanity Checks"""
356          # test default settings          # test default settings
357          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)  
358          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
359          # no messages should have been produced          # no messages should have been produced
360          self.check_messages([])          self.check_messages([])
# Line 349  class TestLayerLegend(unittest.TestCase, Line 369  class TestLayerLegend(unittest.TestCase,
369          # the layer.          # the layer.
370          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
371    
372            def test_set_classification(self):
373            """Test Layer.SetClassification"""
374            classification = Classification()
375            classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
376    
377            self.layer.SetClassification(classification)
378            self.layer.SetClassificationColumn("AREA")
379    
380            self.check_messages([(self.layer, LAYER_CHANGED),
381                                 (self.layer, LAYER_CHANGED)])
382            self.failUnless(self.layer.WasModified())
383    
384            self.clear_messages()
385            self.layer.UnsetModified()
386    
387            # change only the classification column. This should issue a
388            # LAYER_CHANGED message as well.
389            self.layer.SetClassificationColumn("PERIMETER")
390    
391            self.check_messages([(self.layer, LAYER_CHANGED)])
392            self.failUnless(self.layer.WasModified())
393    
394    
395  #  #
396  # the tree info now contains Color objects which are difficult to test  # the tree info now contains Color objects which are difficult to test
397  #  #
Legend:
Removed from v.1262  
changed lines
  Added in v.1551
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26