/[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 331 by bh, Fri Sep 20 14:34:23 2002 UTC revision 1088 by bh, Wed May 28 12:42:23 2003 UTC
# Line 1  Line 1 
1  # Copyright (c) 2002 by Intevation GmbH  # Copyright (c) 2002, 2003 by Intevation GmbH
2  # Authors:  # Authors:
3  # Bernhard Herzog <[email protected]>  # Bernhard Herzog <[email protected]>
4  #  #
# Line 20  import support Line 20  import support
20  support.initthuban()  support.initthuban()
21    
22  import shapelib  import shapelib
23    import dbflib
24    
25  from Thuban.Model.layer import Layer, SHAPETYPE_POLYGON, SHAPETYPE_ARC, \  from Thuban.Model.session import Session
26       SHAPETYPE_POINT  from Thuban.Model.layer import BaseLayer, Layer, RasterLayer, \
27         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_VISIBILITY_CHANGED
30  from Thuban.Model.color import Color  from Thuban.Model.color import Color
31    from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
32    from Thuban.Model.proj import Projection
33    from Thuban.Model.data import DerivedShapeStore
34    from Thuban.Model.classification import Classification, ClassGroupSingleton
35    
36  class TestLayer(unittest.TestCase, support.FileTestMixin,  class TestLayer(unittest.TestCase, support.FileTestMixin,
37                  support.FloatComparisonMixin):                  support.FloatComparisonMixin):
# Line 37  class TestLayer(unittest.TestCase, suppo Line 43  class TestLayer(unittest.TestCase, suppo
43          for i in range(len(test)):          for i in range(len(test)):
44              self.assertFloatSeqEqual(test[i], value[i])              self.assertFloatSeqEqual(test[i], value[i])
45    
46        def setUp(self):
47            """Create a session self.session and initialize self.layer to None"""
48            self.session = Session("Test session for %s" % self.__class__)
49            self.layer = None
50    
51        def tearDown(self):
52            """Call the layer's Destroy method and set session and layer to None"""
53            self.session = None
54            if self.layer is not None:
55                self.layer.Destroy()
56                self.layer = None
57    
58        def build_path(self, filename):
59            return os.path.join("..", "Data", "iceland", filename)
60    
61        def open_shapefile(self, filename):
62            """Open and return a shapestore for filename in the iceland data set"""
63            return self.session.OpenShapefile(self.build_path(filename))
64    
65        def test_base_layer(self):
66            layer = self.layer = BaseLayer("Test BaseLayer")
67            self.assertEquals(layer.Title(), "Test BaseLayer")
68            self.failUnless(layer.Visible())
69    
70            # toggle visibility
71            layer.SetVisible(False)
72            self.failIf(layer.Visible())
73    
74            layer.SetVisible(True)
75            self.failUnless(layer.Visible())
76    
77            self.failIf(layer.HasClassification())
78            self.assertEquals(layer.GetProjection(), None)
79    
80            # set/get projection
81            proj = Projection(["proj=utm", "zone=26"])
82    
83            layer.SetProjection(proj)
84            self.failUnless(layer.GetProjection() is proj)
85    
86            # __init__ with other arguments
87            layer = BaseLayer("Test BaseLayer", False, proj)
88            self.failIf(layer.Visible())
89            self.failUnless(layer.GetProjection() is proj)
90    
91      def test_arc_layer(self):      def test_arc_layer(self):
92          """Test Layer with arc shapes"""          """Test Layer with arc shapes"""
93          layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
94                        os.path.join("..", "Data", "iceland", "roads-line.shp"))                                     self.open_shapefile("roads-line.shp"))
         self.assertEquals(layer.Title(), "Test Layer")  
95          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)          self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
96          self.assertEquals(layer.NumShapes(), 839)          self.assertEquals(layer.NumShapes(), 839)
97          shape = layer.Shape(32)          shape = layer.Shape(32)
# Line 54  class TestLayer(unittest.TestCase, suppo Line 104  class TestLayer(unittest.TestCase, suppo
104          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),          self.assertEquals(layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25)),
105                            [613, 726, 838])                            [613, 726, 838])
106    
107            self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
108                              [-15.082174301147461, 66.27339172363281,
109                               -15.026350021362305, 66.27738189697265])
110    
111            shape = layer.Shape(33)
112            self.assertFloatTuplesEqual(shape.Points(),
113                                        [(-22.248506546020508, 66.30645751953125),
114                                         (-22.232730865478516, 66.294075012207031),
115                                         (-22.23158073425293,  66.287689208984375),
116                                         (-22.246318817138672, 66.270065307617188)])
117    
118            self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),
119                                     [-22.248506546020508, 66.270065307617188,
120                                      -15.026350021362305, 66.30645751953125])
121    
122            self.assertEquals(layer.ShapesBoundingBox([]), None)
123            self.assertEquals(layer.ShapesBoundingBox(None), None)
124    
125      def test_polygon_layer(self):      def test_polygon_layer(self):
126          """Test Layer with polygon shapes"""          """Test Layer with polygon shapes"""
127          layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
128                        os.path.join("..", "Data", "iceland", "political.shp"))                                     self.open_shapefile("political.shp"))
         self.assertEquals(layer.Title(), "Test Layer")  
129          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
130          self.assertEquals(layer.NumShapes(), 156)          self.assertEquals(layer.NumShapes(), 156)
131          shape = layer.Shape(4)          shape = layer.Shape(4)
# Line 75  class TestLayer(unittest.TestCase, suppo Line 142  class TestLayer(unittest.TestCase, suppo
142    
143      def test_point_layer(self):      def test_point_layer(self):
144          """Test Layer with point shapes"""          """Test Layer with point shapes"""
145          layer = Layer("Test Layer",          layer = self.layer = Layer("Test Layer",
146                        os.path.join("..", "Data", "iceland",                             self.open_shapefile("cultural_landmark-point.shp"))
                                    "cultural_landmark-point.shp"))  
         self.assertEquals(layer.Title(), "Test Layer")  
147          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)          self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
148          self.assertEquals(layer.NumShapes(), 34)          self.assertEquals(layer.NumShapes(), 34)
149          shape = layer.Shape(0)          shape = layer.Shape(0)
# Line 96  class TestLayer(unittest.TestCase, suppo Line 161  class TestLayer(unittest.TestCase, suppo
161          shapefilename = self.temp_file_name("layer_empty.shp")          shapefilename = self.temp_file_name("layer_empty.shp")
162          shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)          shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)
163          shp.close()          shp.close()
164            # create an empty DBF file too because Thuban can't cope yet
165          layer = Layer("Empty Layer", shapefilename)          # with missing DBF file.
166            dbffilename = self.temp_file_name("layer_empty.dbf")
167            dbf = dbflib.create(dbffilename)
168            dbf.add_field("NAME", dbflib.FTString, 20, 0)
169    
170            # Now try to open it.
171            layer = self.layer = Layer("Empty Layer",
172                                       self.session.OpenShapefile(shapefilename))
173          self.assertEquals(layer.BoundingBox(), None)          self.assertEquals(layer.BoundingBox(), None)
174          self.assertEquals(layer.LatLongBoundingBox(), None)          self.assertEquals(layer.LatLongBoundingBox(), None)
175          self.assertEquals(layer.NumShapes(), 0)          self.assertEquals(layer.NumShapes(), 0)
176    
177        def test_get_field_type(self):
178            """Test Layer.GetFieldType()"""
179            layer = self.layer = Layer("Test Layer",
180                                       self.open_shapefile("roads-line.shp"))
181            self.assertEquals(layer.GetFieldType("LENGTH"), FIELDTYPE_DOUBLE)
182            self.assertEquals(layer.GetFieldType("non existing"), None)
183    
184        def test_raster_layer(self):
185            filename = self.build_path("island.tif")
186            layer = RasterLayer("Test RasterLayer", filename)
187            self.assertEquals(layer.GetImageFilename(), filename)
188            self.assertFloatSeqEqual(layer.BoundingBox(),
189                                     [-24.5500000, 63.2833330,
190                                      -13.4916670, 66.5666670])
191            self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
192                                     [-24.5500000, 63.2833330,
193                                      -13.4916670, 66.5666670])
194    
195        def test_derived_store(self):
196            """Test layer with derived store"""
197            layer = self.layer = Layer("Test Layer",
198                                       self.open_shapefile("roads-line.shp"))
199            try:
200                store = layer.ShapeStore()
201                derived = DerivedShapeStore(store, store.Table())
202                layer.SetShapeStore(derived)
203                self.assert_(layer.ShapeStore() is derived)
204            finally:
205                store = derived = None
206    
207    
208    class SetShapeStoreTests(unittest.TestCase):
209    
210        def setUp(self):
211            """Create a layer with a classification as self.layer"""
212            self.session = Session("Test session for %s" % self.__class__)
213            self.shapefilename = os.path.join("..", "Data", "iceland",
214                                              "cultural_landmark-point.dbf")
215            self.store = self.session.OpenShapefile(self.shapefilename)
216            self.layer = Layer("test layer", self.store)
217            self.classification = Classification(field = "CLPTLABEL")
218            self.classification.AppendGroup(ClassGroupSingleton("FARM"))
219            self.layer.SetClassification(self.classification)
220    
221        def tearDown(self):
222            self.layer.Destroy()
223            self.session.Destroy()
224            self.session = self.layer = self.store = self.classification = None
225    
226        def test_sanity(self):
227            """SetShapeStoreTests sanity check"""
228            cls = self.layer.GetClassification()
229            self.assert_(cls is self.classification)
230            self.assertEquals(cls.GetField(), "CLPTLABEL")
231            self.assertEquals(cls.GetFieldType(), FIELDTYPE_STRING)
232            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
233    
234        def test_set_shape_store_different_field_name(self):
235            """Test Layer.SetShapeStore() with different column name"""
236            memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
237                          [("bla",)] * self.layer.ShapeStore().Table().NumRows())
238            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
239            # The classification should contain only the default group now.
240            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
241    
242        def test_set_shape_store_same_field(self):
243            """Test Layer.SetShapeStore() with same column name and type"""
244            memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_STRING)],
245                          [("bla",)] * self.layer.ShapeStore().Table().NumRows())
246            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
247            # The classification should be the same as before
248            self.assert_(self.layer.GetClassification() is self.classification)
249    
250        def test_set_shape_store_same_field_different_type(self):
251            """Test Layer.SetShapeStore() with same column name but different type
252            """
253            memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_DOUBLE)],
254                          [(0.0,)] * self.layer.ShapeStore().Table().NumRows())
255            self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
256            # The classification should contain only the default group now.
257            self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
258    
259    
260  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):  class TestLayerLegend(unittest.TestCase, support.SubscriberMixin):
261    
# Line 109  class TestLayerLegend(unittest.TestCase, Line 263  class TestLayerLegend(unittest.TestCase,
263      """      """
264    
265      def setUp(self):      def setUp(self):
266          """Clear the list of received messages and create a layer          """Clear the list of received messages and create a layer and a session
267    
268          The layer is bound to self.layer.          The layer is bound to self.layer and the session to self.session.
269          """          """
270          self.clear_messages()          self.clear_messages()
271            self.session = Session("Test session for %s" % self.__class__)
272            filename = os.path.join("..", "Data", "iceland", "political.shp")
273          self.layer = Layer("Test Layer",          self.layer = Layer("Test Layer",
274                             os.path.join("..", "Data", "iceland",                             self.session.OpenShapefile(filename))
                                         "political.shp"))  
275          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,          self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
276                               LAYER_LEGEND_CHANGED)                               LAYER_LEGEND_CHANGED)
277          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,          self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
# Line 127  class TestLayerLegend(unittest.TestCase, Line 282  class TestLayerLegend(unittest.TestCase,
282          """Clear the list of received messages and explictly destroy self.layer          """Clear the list of received messages and explictly destroy self.layer
283          """          """
284          self.layer.Destroy()          self.layer.Destroy()
285            self.layer = None
286            self.session.Destroy()
287            self.session = None
288          self.clear_messages()          self.clear_messages()
289    
290      def test_initial_settings(self):      def test_initial_settings(self):
291          """Test Layer's initial legend attributes"""          """Test Layer's initial legend attributes"""
292          # test default settings          # test default settings
293          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
294          self.assertEquals(self.layer.fill, None)          #self.assertEquals(self.layer.fill, None)
295          self.assertEquals(self.layer.stroke.hex(), "#000000")          #self.assertEquals(self.layer.stroke.hex(), "#000000")
296          self.assertEquals(self.layer.stroke_width, 1)          #self.assertEquals(self.layer.stroke_width, 1)
297          self.assertEquals(self.layer.Visible(), 1)          self.assertEquals(self.layer.Visible(), 1)
298          # no messages should have been produced          # no messages should have been produced
299          self.check_messages([])          self.check_messages([])
300    
     def test_fill(self):  
         """Test Layer's fill attribute"""  
         # modify the fill  
         self.layer.SetFill(Color(0.5, 1.0, 0.75))  
         self.check_messages([(self.layer, LAYER_LEGEND_CHANGED)])  
         self.assertEquals(self.layer.fill.hex().lower(), "#7fffbf")  
         self.assert_(self.layer.WasModified())  
   
     def test_stroke(self):  
         """Test Layer's stroke attribute"""  
         self.layer.SetStroke(Color(0.5, 1.0, 0.75))  
         self.assertEquals(self.layer.stroke.hex().lower(), "#7fffbf")  
         self.check_messages([(self.layer, LAYER_LEGEND_CHANGED)])  
         self.assert_(self.layer.WasModified())  
   
     def test_stroke_width(self):  
         """Test Layer's stroke_width attribute"""  
         self.layer.SetStrokeWidth(3.0)  
         self.assertEquals(self.layer.stroke_width, 3.0)  
         self.check_messages([(self.layer, LAYER_LEGEND_CHANGED)])  
         self.assert_(self.layer.WasModified())  
   
301      def test_visibility(self):      def test_visibility(self):
302          """Test Layer visibility"""          """Test Layer visibility"""
303          self.layer.SetVisible(0)          self.layer.SetVisible(0)
# Line 172  class TestLayerLegend(unittest.TestCase, Line 308  class TestLayerLegend(unittest.TestCase,
308          # the layer.          # the layer.
309          self.failIf(self.layer.WasModified())          self.failIf(self.layer.WasModified())
310    
311      def test_tree_info(self):      
312          """Test Layer.TreeInfo"""  #
313          self.assertEquals(self.layer.TreeInfo(),  # the tree info now contains Color objects which are difficult to test
314                            ("Layer 'Test Layer'",  #
315                             ['Shown',  #   def test_tree_info(self):
316                              'Shapes: 156',  #       """Test Layer.TreeInfo"""
317                              ('Extent (lat-lon):'  #       self.assertEquals(self.layer.TreeInfo(),
318                               ' (-24.5465, 63.2868, -13.4958, 66.5638)'),  #                         ("Layer 'Test Layer'",
319                              'Shapetype: Polygon',  #                          ['Shown',
320                              'Fill: None',  #                           'Shapes: 156',
321                              'Outline: (0.000, 0.000, 0.000)']))  #                           ('Extent (lat-lon):'
322    #                            ' (-24.5465, 63.2868, -13.4958, 66.5638)'),
323    #                           'Shapetype: Polygon',
324    #                           'Fill: None',
325    #                           'Outline: (0.000, 0.000, 0.000)']))
326    
327    
328  if __name__ == "__main__":  if __name__ == "__main__":
329      unittest.main()      support.run_tests()
Legend:
Removed from v.331  
changed lines
  Added in v.1088
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26