/[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 1174 by jonathan, Thu Jun 12 13:37:29 2003 UTC revision 1768 by bh, Thu Oct 2 15:15:04 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 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_point_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_POINT, [[[(10,10)]]], table)
174            layer = self.layer = Layer("Test Layer", store)
175    
176            # Rotation by 45 degrees counter clockwise. This detects a bug
177            # in the ShapesInRegion method which transforms the bounding box
178            # by only transforming two opposite corners because they have
179            # the same x or y coordinates after application of the
180            # projection or its inverse.
181            proj = mockgeo.AffineProjection((1, 1, -1, 1, 0, 0))
182            layer.SetProjection(proj)
183    
184            self.assertEquals(layer.BoundingBox(), (10, 10, 10, 10))
185            self.assertEquals(layer.LatLongBoundingBox(), (10.0, 0.0, 10.0, 0.0))
186            shapes = layer.ShapesInRegion((0, 0, 20, 20))
187            self.assertEquals([s.ShapeID() for s in shapes], [0])
188    
189      def test_empty_layer(self):      def test_empty_layer(self):
190          """Test Layer with empty shape file"""          """Test Layer with empty shape file"""
191          # create an empty shape file          # create an empty shape file
# Line 168  class TestLayer(unittest.TestCase, suppo Line 197  class TestLayer(unittest.TestCase, suppo
197          dbffilename = self.temp_file_name("layer_empty.dbf")          dbffilename = self.temp_file_name("layer_empty.dbf")
198          dbf = dbflib.create(dbffilename)          dbf = dbflib.create(dbffilename)
199          dbf.add_field("NAME", dbflib.FTString, 20, 0)          dbf.add_field("NAME", dbflib.FTString, 20, 0)
200            dbf.close()
201    
202          # Now try to open it.          # Now try to open it.
203          layer = self.layer = Layer("Empty Layer",          layer = self.layer = Layer("Empty Layer",
# Line 185  class TestLayer(unittest.TestCase, suppo Line 215  class TestLayer(unittest.TestCase, suppo
215    
216      def test_raster_layer(self):      def test_raster_layer(self):
217          if not Thuban.Model.resource.has_gdal_support():          if not Thuban.Model.resource.has_gdal_support():
218              return              raise support.SkipTest("No gdal support")
219    
220          filename = self.build_path("island.tif")          filename = self.build_path("island.tif")
221          layer = RasterLayer("Test RasterLayer", filename)          layer = RasterLayer("Test RasterLayer", filename)
222          self.assertEquals(layer.GetImageFilename(), filename)          self.failIf(layer.HasClassification())
223            self.failIf(layer.HasShapes())
224            self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
225          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
226                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
227                                    -13.4916670, 66.5666670])                                    -13.4916670, 66.5666670])
# Line 206  class TestLayer(unittest.TestCase, suppo Line 238  class TestLayer(unittest.TestCase, suppo
238              derived = DerivedShapeStore(store, store.Table())              derived = DerivedShapeStore(store, store.Table())
239              layer.SetShapeStore(derived)              layer.SetShapeStore(derived)
240              self.assert_(layer.ShapeStore() is derived)              self.assert_(layer.ShapeStore() is derived)
241    
242                self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
243                self.assertEquals(layer.NumShapes(), 839)
244                shape = layer.Shape(32)
245                self.assertPointListEquals(shape.Points(),
246                                           [[(-15.082174301147, 66.277381896972),
247                                             (-15.026350021362, 66.273391723632)]])
248                self.assertFloatSeqEqual(layer.BoundingBox(),
249                                         [-24.450359344482422, 63.426830291748047,
250                                          -13.55668830871582, 66.520111083984375])
251                shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
252                self.assertEquals([s.ShapeID() for s in shapes],
253                                  [613, 726, 838])
254    
255                self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
256                                         [-15.082174301147461, 66.27339172363281,
257                                          -15.026350021362305, 66.27738189697265])
258    
259          finally:          finally:
260              store = derived = None              store = derived = None
261    
# Line 220  class SetShapeStoreTests(unittest.TestCa Line 270  class SetShapeStoreTests(unittest.TestCa
270                                            "cultural_landmark-point.dbf")                                            "cultural_landmark-point.dbf")
271          self.store = self.session.OpenShapefile(self.shapefilename)          self.store = self.session.OpenShapefile(self.shapefilename)
272          self.layer = Layer("test layer", self.store)          self.layer = Layer("test layer", self.store)
273          self.classification = Classification(field = "CLPTLABEL")          self.classification = Classification()
274          self.classification.AppendGroup(ClassGroupSingleton("FARM"))          self.classification.AppendGroup(ClassGroupSingleton("FARM"))
275            self.layer.SetClassificationColumn("CLPTLABEL")
276          self.layer.SetClassification(self.classification)          self.layer.SetClassification(self.classification)
277          self.layer.UnsetModified()          self.layer.UnsetModified()
278          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
# Line 243  class SetShapeStoreTests(unittest.TestCa Line 294  class SetShapeStoreTests(unittest.TestCa
294          """          """
295          cls = self.layer.GetClassification()          cls = self.layer.GetClassification()
296          self.assert_(cls is self.classification)          self.assert_(cls is self.classification)
297          self.assertEquals(cls.GetField(), "CLPTLABEL")          field = self.layer.GetClassificationColumn()
298          self.assertEquals(cls.GetFieldType(), FIELDTYPE_STRING)          self.assertEquals(field, "CLPTLABEL")
299            self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
300          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
301          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
302    
# Line 287  class SetShapeStoreTests(unittest.TestCa Line 339  class SetShapeStoreTests(unittest.TestCa
339                               (self.layer, LAYER_SHAPESTORE_REPLACED)])                               (self.layer, LAYER_SHAPESTORE_REPLACED)])
340    
341    
342  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
343    
344      """Test cases for Layer method that modify the layer.      """Test cases for Layer method that modify the layer.
345      """      """
# Line 307  class TestLayerLegend(unittest.TestCase, Line 359  class TestLayerLegend(unittest.TestCase,
359          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
360                               self.subscribe_with_params,                               self.subscribe_with_params,
361                               LAYER_VISIBILITY_CHANGED)                               LAYER_VISIBILITY_CHANGED)
362            self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
363                                 LAYER_CHANGED)
364    
365      def tearDown(self):      def tearDown(self):
366          """Clear the list of received messages and explictly destroy self.layer          """Clear the list of received messages and explictly destroy self.layer
# Line 317  class TestLayerLegend(unittest.TestCase, Line 371  class TestLayerLegend(unittest.TestCase,
371          self.session = None          self.session = None
372          self.clear_messages()          self.clear_messages()
373    
374      def test_initial_settings(self):      def test_sanity(self):
375          """Test Layer's initial legend attributes"""          """TestLayerModification Sanity Checks"""
376          # test default settings          # test default settings
377          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)  
378          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
379          # no messages should have been produced          # no messages should have been produced
380          self.check_messages([])          self.check_messages([])
# Line 338  class TestLayerLegend(unittest.TestCase, Line 389  class TestLayerLegend(unittest.TestCase,
389          # the layer.          # the layer.
390          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
391    
392            def test_set_classification(self):
393            """Test Layer.SetClassification"""
394            classification = Classification()
395            classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
396    
397            self.layer.SetClassification(classification)
398            self.layer.SetClassificationColumn("AREA")
399    
400            self.check_messages([(self.layer, LAYER_CHANGED),
401                                 (self.layer, LAYER_CHANGED)])
402            self.failUnless(self.layer.WasModified())
403    
404            self.clear_messages()
405            self.layer.UnsetModified()
406    
407            # change only the classification column. This should issue a
408            # LAYER_CHANGED message as well.
409            self.layer.SetClassificationColumn("PERIMETER")
410    
411            self.check_messages([(self.layer, LAYER_CHANGED)])
412            self.failUnless(self.layer.WasModified())
413    
414    
415  #  #
416  # the tree info now contains Color objects which are difficult to test  # the tree info now contains Color objects which are difficult to test
417  #  #
Legend:
Removed from v.1174  
changed lines
  Added in v.1768
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26