/[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 1438 by jonathan, Wed Jul 16 13:25:30 2003 UTC revision 1983 by bh, Thu Nov 27 15:57:23 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 82  class TestLayer(unittest.TestCase, suppo Line 79  class TestLayer(unittest.TestCase, suppo
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 101  class TestLayer(unittest.TestCase, suppo Line 98  class TestLayer(unittest.TestCase, suppo
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 115  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 137  class TestLayer(unittest.TestCase, suppo Line 135  class TestLayer(unittest.TestCase, suppo
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):
# Line 157  class TestLayer(unittest.TestCase, suppo Line 156  class TestLayer(unittest.TestCase, suppo
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                                  [[[(9884848.1401601825, 5607709.9111020016),
175                                     (11298371.027199602, 9287809.2948032897)]]],
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            layer.SetProjection(proj)
181    
182            self.assertFloatSeqEqual(layer.BoundingBox(),
183                                     (9884848.1401601825, 5607709.9111020016,
184                                      11298371.027199602, 9287809.2948032897))
185            self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
186                                     (90.0, -8.899852, 120, 11.16092))
187            shapes = layer.ShapesInRegion((100, -10, 150, +10))
188            self.assertEquals([s.ShapeID() for s in shapes], [0])
189            self.assertFloatSeqEqual(layer.ShapesBoundingBox([0]),
190                                     (90.0, -8.899852, 120, 11.16092))
191    
192      def test_empty_layer(self):      def test_empty_layer(self):
193          """Test Layer with empty shape file"""          """Test Layer with empty shape file"""
194          # create an empty shape file          # create an empty shape file
# Line 176  class TestLayer(unittest.TestCase, suppo Line 200  class TestLayer(unittest.TestCase, suppo
200          dbffilename = self.temp_file_name("layer_empty.dbf")          dbffilename = self.temp_file_name("layer_empty.dbf")
201          dbf = dbflib.create(dbffilename)          dbf = dbflib.create(dbffilename)
202          dbf.add_field("NAME", dbflib.FTString, 20, 0)          dbf.add_field("NAME", dbflib.FTString, 20, 0)
203            dbf.close()
204    
205          # Now try to open it.          # Now try to open it.
206          layer = self.layer = Layer("Empty Layer",          layer = self.layer = Layer("Empty Layer",
# Line 193  class TestLayer(unittest.TestCase, suppo Line 218  class TestLayer(unittest.TestCase, suppo
218    
219      def test_raster_layer(self):      def test_raster_layer(self):
220          if not Thuban.Model.resource.has_gdal_support():          if not Thuban.Model.resource.has_gdal_support():
221              return              raise support.SkipTest("No gdal support")
222    
223          filename = self.build_path("island.tif")          filename = self.build_path("island.tif")
224          layer = RasterLayer("Test RasterLayer", filename)          layer = RasterLayer("Test RasterLayer", filename)
225          self.failIf(layer.HasClassification())          self.failIf(layer.HasClassification())
226          self.failIf(layer.HasShapes())          self.failIf(layer.HasShapes())
227          self.assertEquals(layer.GetImageFilename(), filename)          self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
228          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
229                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
230                                    -13.4916670, 66.5666670])                                    -13.4916670, 66.5666670])
# Line 217  class TestLayer(unittest.TestCase, suppo Line 242  class TestLayer(unittest.TestCase, suppo
242              layer.SetShapeStore(derived)              layer.SetShapeStore(derived)
243              self.assert_(layer.ShapeStore() is derived)              self.assert_(layer.ShapeStore() is derived)
244    
245              # check that an exception is raised when the number              self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
246              # of shapes differ from the number of rows in a table.              self.assertEquals(layer.NumShapes(), 839)
247              layer2 = Layer("Test Layer",              shape = layer.Shape(32)
248                             self.open_shapefile("political.shp"))              self.assertPointListEquals(shape.Points(),
249              store2 = layer2.ShapeStore()                                         [[(-15.082174301147, 66.277381896972),
250              self.assertRaises(ValueError,                                           (-15.026350021362, 66.273391723632)]])
251                                DerivedShapeStore, store2, store.Table())              self.assertFloatSeqEqual(layer.BoundingBox(),
252                                         [-24.450359344482422, 63.426830291748047,
253                                          -13.55668830871582, 66.520111083984375])
254                shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
255                self.assertEquals([s.ShapeID() for s in shapes],
256                                  [613, 726, 838])
257    
258                self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
259                                         [-15.082174301147461, 66.27339172363281,
260                                          -15.026350021362305, 66.27738189697265])
261    
262          finally:          finally:
263              store = derived = None              store = derived = None
             layer2.Destroy()  
             store2 = None  
264    
265    
266  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
# Line 243  class SetShapeStoreTests(unittest.TestCa Line 275  class SetShapeStoreTests(unittest.TestCa
275          self.layer = Layer("test layer", self.store)          self.layer = Layer("test layer", self.store)
276          self.classification = Classification()          self.classification = Classification()
277          self.classification.AppendGroup(ClassGroupSingleton("FARM"))          self.classification.AppendGroup(ClassGroupSingleton("FARM"))
278          self.layer.SetClassificationField("CLPTLABEL")          self.layer.SetClassificationColumn("CLPTLABEL")
279          self.layer.SetClassification(self.classification)          self.layer.SetClassification(self.classification)
280          self.layer.UnsetModified()          self.layer.UnsetModified()
281          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,          self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
# Line 265  class SetShapeStoreTests(unittest.TestCa Line 297  class SetShapeStoreTests(unittest.TestCa
297          """          """
298          cls = self.layer.GetClassification()          cls = self.layer.GetClassification()
299          self.assert_(cls is self.classification)          self.assert_(cls is self.classification)
300          field = self.layer.GetClassificationField()          field = self.layer.GetClassificationColumn()
301          self.assertEquals(field, "CLPTLABEL")          self.assertEquals(field, "CLPTLABEL")
302          self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)          self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
303          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)          self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
# Line 310  class SetShapeStoreTests(unittest.TestCa Line 342  class SetShapeStoreTests(unittest.TestCa
342                               (self.layer, LAYER_SHAPESTORE_REPLACED)])                               (self.layer, LAYER_SHAPESTORE_REPLACED)])
343    
344    
345  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
346    
347      """Test cases for Layer method that modify the layer.      """Test cases for Layer method that modify the layer.
348      """      """
# Line 330  class TestLayerLegend(unittest.TestCase, Line 362  class TestLayerLegend(unittest.TestCase,
362          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
363                               self.subscribe_with_params,                               self.subscribe_with_params,
364                               LAYER_VISIBILITY_CHANGED)                               LAYER_VISIBILITY_CHANGED)
365            self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
366                                 LAYER_CHANGED)
367    
368      def tearDown(self):      def tearDown(self):
369          """Clear the list of received messages and explictly destroy self.layer          """Clear the list of received messages and explictly destroy self.layer
# Line 340  class TestLayerLegend(unittest.TestCase, Line 374  class TestLayerLegend(unittest.TestCase,
374          self.session = None          self.session = None
375          self.clear_messages()          self.clear_messages()
376    
377      def test_initial_settings(self):      def test_sanity(self):
378          """Test Layer's initial legend attributes"""          """TestLayerModification Sanity Checks"""
379          # test default settings          # test default settings
380          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)  
381          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
382          # no messages should have been produced          # no messages should have been produced
383          self.check_messages([])          self.check_messages([])
# Line 361  class TestLayerLegend(unittest.TestCase, Line 392  class TestLayerLegend(unittest.TestCase,
392          # the layer.          # the layer.
393          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
394    
395            def test_set_classification(self):
396            """Test Layer.SetClassification"""
397            classification = Classification()
398            classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
399    
400            self.layer.SetClassification(classification)
401            self.layer.SetClassificationColumn("AREA")
402    
403            self.check_messages([(self.layer, LAYER_CHANGED),
404                                 (self.layer, LAYER_CHANGED)])
405            self.failUnless(self.layer.WasModified())
406    
407            self.clear_messages()
408            self.layer.UnsetModified()
409    
410            # change only the classification column. This should issue a
411            # LAYER_CHANGED message as well.
412            self.layer.SetClassificationColumn("PERIMETER")
413    
414            self.check_messages([(self.layer, LAYER_CHANGED)])
415            self.failUnless(self.layer.WasModified())
416    
417    
418  #  #
419  # the tree info now contains Color objects which are difficult to test  # the tree info now contains Color objects which are difficult to test
420  #  #
Legend:
Removed from v.1438  
changed lines
  Added in v.1983
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26