/[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 1452 by bh, Fri Jul 18 12:57:59 2003 UTC revision 2339 by silke, Fri Aug 20 16:59:21 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
31  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable  from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
# 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                                  [[[(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            self.assertFloatSeqEqual(layer.ClipBoundingBox((-180, -6, 100, +120)),
194                                    (90.0, -6, 100, 11.1616263))
195            shapes = layer.ShapesInRegion((-180, -170, 200, +120))
196            print "Shapes", shapes
197            self.assertEquals([s.ShapeID() for s in shapes],[0])
198    
199      def test_empty_layer(self):      def test_empty_layer(self):
200          """Test Layer with empty shape file"""          """Test Layer with empty shape file"""
201          # create an empty shape file          # create an empty shape file
# Line 176  class TestLayer(unittest.TestCase, suppo Line 207  class TestLayer(unittest.TestCase, suppo
207          dbffilename = self.temp_file_name("layer_empty.dbf")          dbffilename = self.temp_file_name("layer_empty.dbf")
208          dbf = dbflib.create(dbffilename)          dbf = dbflib.create(dbffilename)
209          dbf.add_field("NAME", dbflib.FTString, 20, 0)          dbf.add_field("NAME", dbflib.FTString, 20, 0)
210            dbf.close()
211    
212          # Now try to open it.          # Now try to open it.
213          layer = self.layer = Layer("Empty Layer",          layer = self.layer = Layer("Empty Layer",
# Line 193  class TestLayer(unittest.TestCase, suppo Line 225  class TestLayer(unittest.TestCase, suppo
225    
226      def test_raster_layer(self):      def test_raster_layer(self):
227          if not Thuban.Model.resource.has_gdal_support():          if not Thuban.Model.resource.has_gdal_support():
228              return              raise support.SkipTest("No gdal support")
229    
230          filename = self.build_path("island.tif")          filename = self.build_path("island.tif")
231          layer = RasterLayer("Test RasterLayer", filename)          layer = RasterLayer("Test RasterLayer", filename)
232          self.failIf(layer.HasClassification())          self.failIf(layer.HasClassification())
233          self.failIf(layer.HasShapes())          self.failIf(layer.HasShapes())
234          self.assertEquals(layer.GetImageFilename(), filename)          self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
235          self.assertFloatSeqEqual(layer.BoundingBox(),          self.assertFloatSeqEqual(layer.BoundingBox(),
236                                   [-24.5500000, 63.2833330,                                   [-24.5500000, 63.2833330,
237                                    -13.4916670, 66.5666670])                                    -13.4916670, 66.5666670])
# Line 217  class TestLayer(unittest.TestCase, suppo Line 249  class TestLayer(unittest.TestCase, suppo
249              layer.SetShapeStore(derived)              layer.SetShapeStore(derived)
250              self.assert_(layer.ShapeStore() is derived)              self.assert_(layer.ShapeStore() is derived)
251    
252              # check that an exception is raised when the number              self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
253              # of shapes differ from the number of rows in a table.              self.assertEquals(layer.NumShapes(), 839)
254              layer2 = Layer("Test Layer",              shape = layer.Shape(32)
255                             self.open_shapefile("political.shp"))              self.assertPointListEquals(shape.Points(),
256              store2 = layer2.ShapeStore()                                         [[(-15.082174301147, 66.277381896972),
257              self.assertRaises(ValueError,                                           (-15.026350021362, 66.273391723632)]])
258                                DerivedShapeStore, store2, store.Table())              self.assertFloatSeqEqual(layer.BoundingBox(),
259                                         [-24.450359344482422, 63.426830291748047,
260                                          -13.55668830871582, 66.520111083984375])
261                shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
262                self.assertEquals([s.ShapeID() for s in shapes],
263                                  [613, 726, 838])
264    
265                self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
266                                         [-15.082174301147461, 66.27339172363281,
267                                          -15.026350021362305, 66.27738189697265])
268    
269          finally:          finally:
270              store = derived = None              store = derived = None
             layer2.Destroy()  
             store2 = None  
271    
272    
273  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):  class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
# Line 322  class TestLayerModification(unittest.Tes Line 361  class TestLayerModification(unittest.Tes
361          """          """
362          self.clear_messages()          self.clear_messages()
363          self.session = Session("Test session for %s" % self.__class__)          self.session = Session("Test session for %s" % self.__class__)
364          filename = os.path.join("..", "Data", "iceland", "political.shp")          self.filename = os.path.join("..", "Data", "iceland", "political.shp")
365          self.layer = Layer("Test Layer",          self.layer = Layer("Test Layer",
366                             self.session.OpenShapefile(filename))                             self.session.OpenShapefile(self.filename))
367          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
368                               LAYER_LEGEND_CHANGED)                               LAYER_LEGEND_CHANGED)
369          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
# Line 383  class TestLayerModification(unittest.Tes Line 422  class TestLayerModification(unittest.Tes
422          self.failUnless(self.layer.WasModified())          self.failUnless(self.layer.WasModified())
423    
424    
425  #      def test_tree_info(self):
426  # the tree info now contains Color objects which are difficult to test          """Test Layer.TreeInfo"""
427  #          self.assertEquals(self.layer.TreeInfo(),
428  #   def test_tree_info(self):                            ("Layer 'Test Layer'",
429  #       """Test Layer.TreeInfo"""                             ['Filename: %s' % os.path.abspath(self.filename),
430  #       self.assertEquals(self.layer.TreeInfo(),                              'Shown',
431  #                         ("Layer 'Test Layer'",                              'Shapes: 156',
432  #                          ['Shown',                     'Extent (lat-lon): (-24.5465, 63.2868, -13.4958, 66.5638)',
433  #                           'Shapes: 156',                              'Shapetype: Polygon',
434  #                           ('Extent (lat-lon):'                              self.layer.GetClassification()]))
 #                            ' (-24.5465, 63.2868, -13.4958, 66.5638)'),  
 #                           'Shapetype: Polygon',  
 #                           'Fill: None',  
 #                           'Outline: (0.000, 0.000, 0.000)']))  
435    
436    
437  if __name__ == "__main__":  if __name__ == "__main__":
Legend:
Removed from v.1452  
changed lines
  Added in v.2339
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26