WIP-pyshapelib-bramz/test/test_layer.py

# Copyright (c) 2002, 2003, 2004 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Test the Layer class
"""

__version__ = "$Revision$"
# $Source$
# $Id$

import os
import unittest

import mockgeo
import support
support.initthuban()

import shapelib
import dbflib

from Thuban.Model.session import Session
from Thuban.Model.layer import BaseLayer, Layer, RasterLayer
from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \
     LAYER_VISIBILITY_CHANGED, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED
from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
from Thuban.Model.proj import Projection
from Thuban.Model.data import DerivedShapeStore
from Thuban.Model.classification import Classification, ClassGroupSingleton, \
     ClassGroupRange

import Thuban.Model.resource

class TestLayer(unittest.TestCase, support.FileTestMixin,
                support.FloatComparisonMixin):

    """Test cases for different layer (shape) types"""

    def setUp(self):
        """Create a session self.session and initialize self.layer to None"""
        self.session = Session("Test session for %s" % self.__class__)
        self.layer = None

    def tearDown(self):
        """Call the layer's Destroy method and set session and layer to None"""
        self.session.Destroy()
        self.session = None
        if self.layer is not None:
            self.layer.Destroy()
            self.layer = None

    def build_path(self, filename):
        return os.path.join("..", "Data", "iceland", filename)

    def open_shapefile(self, filename):
        """Open and return a shapestore for filename in the iceland data set"""
        return self.session.OpenShapefile(self.build_path(filename))

    def test_base_layer(self):
        layer = self.layer = BaseLayer("Test BaseLayer")
        self.assertEquals(layer.Title(), "Test BaseLayer")
        self.failUnless(layer.Visible())

        # toggle visibility
        layer.SetVisible(False)
        self.failIf(layer.Visible())

        layer.SetVisible(True)
        self.failUnless(layer.Visible())

        self.failIf(layer.HasClassification())
        self.failIf(layer.HasShapes())

        self.assertEquals(layer.GetProjection(), None)

        # set/get projection
        proj = Projection(["proj=utm", "zone=26", "ellps=clrk66"])

        layer.SetProjection(proj)
        self.failUnless(layer.GetProjection() is proj)

        # __init__ with other arguments
        layer = BaseLayer("Test BaseLayer", False, proj)
        self.failIf(layer.Visible())
        self.failUnless(layer.GetProjection() is proj)

    def test_arc_layer(self):
        """Test Layer with arc shapes"""
        layer = self.layer = Layer("Test Layer",
                                   self.open_shapefile("roads-line.shp"))
        self.failUnless(layer.HasClassification())
        self.failUnless(layer.HasShapes())
        self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
        self.assertEquals(layer.NumShapes(), 839)
        shape = layer.Shape(32)
        self.assertPointListEquals(shape.Points(),
                                   [[(-15.082174301147461, 66.27738189697265),
                                     (-15.026350021362305, 66.27339172363281)]])
        self.assertFloatSeqEqual(layer.BoundingBox(),
                                 [-24.450359344482422, 63.426830291748047,
                                  -13.55668830871582, 66.520111083984375])
        shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
        self.assertEquals([s.ShapeID() for s in shapes],
                          [613, 726, 838])

        self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]), 
                          [-15.082174301147461, 66.27339172363281,
                           -15.026350021362305, 66.27738189697265])

        shape = layer.Shape(33)
        self.assertPointListEquals(shape.Points(),
                                   [[(-22.24850654602050, 66.30645751953125),
                                     (-22.23273086547851, 66.29407501220703),
                                     (-22.23158073425293,  66.2876892089843),
                                     (-22.24631881713867, 66.27006530761718)]])

        self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]), 
                                 [-22.248506546020508, 66.270065307617188,
                                  -15.026350021362305, 66.30645751953125])

        self.assertEquals(layer.ShapesBoundingBox([]), None)
        self.assertEquals(layer.ShapesBoundingBox(None), None)

    def test_polygon_layer(self):
        """Test Layer with polygon shapes"""
        layer = self.layer = Layer("Test Layer",
                                   self.open_shapefile("political.shp"))
        self.failUnless(layer.HasClassification())
        self.failUnless(layer.HasShapes())
        self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
        self.assertEquals(layer.NumShapes(), 156)
        shape = layer.Shape(4)
        self.assertPointListEquals(shape.Points(),
                                   [[(-22.40639114379882, 64.714111328125),
                                     (-22.41621208190918, 64.7160034179687),
                                     (-22.40605163574218, 64.719200134277),
                                     (-22.40639114379882, 64.714111328125)]])
        self.assertFloatSeqEqual(layer.BoundingBox(),
                                 [-24.546524047851562, 63.286754608154297,
                                  -13.495815277099609, 66.563774108886719])
        shapes = layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1))
        self.assertEquals([s.ShapeID() for s in shapes],
                          [91, 92, 144, 146, 148, 150, 152, 153])

    def test_point_layer(self):
        """Test Layer with point shapes"""
        layer = self.layer = Layer("Test Layer",
                           self.open_shapefile("cultural_landmark-point.shp"))
        self.failUnless(layer.HasClassification())
        self.failUnless(layer.HasShapes())
        self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
        self.assertEquals(layer.NumShapes(), 34)
        shape = layer.Shape(0)
        self.assertPointListEquals(shape.Points(),
                                   [[(-22.711074829101562, 66.36572265625)]])
        self.assertFloatSeqEqual(layer.BoundingBox(),
                                 [-23.806047439575195, 63.405960083007812,
                                  -15.12291431427002, 66.36572265625])
        shapes = layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1))
        self.assertEquals([s.ShapeID() for s in shapes],
                          [0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])

    def test_arc_layer_with_projection(self):
        """Test Layer with point shapes and a projection"""
        # We use mock data here so that we have precise control over the
        # values
        table = MemoryTable([("FOO", FIELDTYPE_STRING)], [("bla",)])
        store = mockgeo.SimpleShapeStore(SHAPETYPE_ARC,
                              [[[(9884828.7209840547, 5607720.9774499247),
                                 (11298336.04640449, 9287823.2044059951)]]],
                                         table)
        layer = self.layer = Layer("Test Layer", store)

        proj = Projection(["proj=lcc", "lon_0=0", "lat_1=20n", "lat_2=60n",
                           "ellps=clrk66"])
        layer.SetProjection(proj)

        self.assertFloatSeqEqual(layer.BoundingBox(),
                                 (9884828.7209840547, 5607720.9774499247,
                                  11298336.04640449, 9287823.2044059951))
        self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
                                 (90.0, -8.90043373, 120, 11.1616263))
        shapes = layer.ShapesInRegion((100, -10, 150, +10))
        self.assertEquals([s.ShapeID() for s in shapes], [0])
        self.assertFloatSeqEqual(layer.ShapesBoundingBox([0]),
                                 (90.0, -8.90043373, 120, 11.1616263))

    def test_empty_layer(self):
        """Test Layer with empty shape file"""
        # create an empty shape file
        shapefilename = self.temp_file_name("layer_empty.shp")
        shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)
        shp.close()
        # create an empty DBF file too because Thuban can't cope yet
        # with missing DBF file.
        dbffilename = self.temp_file_name("layer_empty.dbf")
        dbf = dbflib.create(dbffilename)
        dbf.add_field("NAME", dbflib.FTString, 20, 0)
        dbf.close()

        # Now try to open it.
        layer = self.layer = Layer("Empty Layer",
                                   self.session.OpenShapefile(shapefilename))
        self.assertEquals(layer.BoundingBox(), None)
        self.assertEquals(layer.LatLongBoundingBox(), None)
        self.assertEquals(layer.NumShapes(), 0)

    def test_get_field_type(self):
        """Test Layer.GetFieldType()"""
        layer = self.layer = Layer("Test Layer",
                                   self.open_shapefile("roads-line.shp"))
        self.assertEquals(layer.GetFieldType("LENGTH"), FIELDTYPE_DOUBLE)
        self.assertEquals(layer.GetFieldType("non existing"), None)

    def test_raster_layer(self):
        if not Thuban.Model.resource.has_gdal_support():
            raise support.SkipTest("No gdal support")

        filename = self.build_path("island.tif")
        layer = RasterLayer("Test RasterLayer", filename)
        self.failIf(layer.HasClassification())
        self.failIf(layer.HasShapes())
        self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
        self.assertFloatSeqEqual(layer.BoundingBox(),
                                 [-24.5500000, 63.2833330,
                                  -13.4916670, 66.5666670])
        self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
                                 [-24.5500000, 63.2833330,
                                  -13.4916670, 66.5666670])

    def test_derived_store(self):
        """Test layer with derived store"""
        layer = self.layer = Layer("Test Layer",
                                   self.open_shapefile("roads-line.shp"))
        try:
            store = layer.ShapeStore()
            derived = DerivedShapeStore(store, store.Table())
            layer.SetShapeStore(derived)
            self.assert_(layer.ShapeStore() is derived)

            self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
            self.assertEquals(layer.NumShapes(), 839)
            shape = layer.Shape(32)
            self.assertPointListEquals(shape.Points(),
                                       [[(-15.082174301147, 66.277381896972),
                                         (-15.026350021362, 66.273391723632)]])
            self.assertFloatSeqEqual(layer.BoundingBox(),
                                     [-24.450359344482422, 63.426830291748047,
                                      -13.55668830871582, 66.520111083984375])
            shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
            self.assertEquals([s.ShapeID() for s in shapes],
                              [613, 726, 838])

            self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
                                     [-15.082174301147461, 66.27339172363281,
                                      -15.026350021362305, 66.27738189697265])

        finally:
            store = derived = None


class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):

    def setUp(self):
        """Create a layer with a classification as self.layer"""
        self.clear_messages()
        self.session = Session("Test session for %s" % self.__class__)
        self.shapefilename = os.path.join("..", "Data", "iceland",
                                          "cultural_landmark-point.dbf")
        self.store = self.session.OpenShapefile(self.shapefilename)
        self.layer = Layer("test layer", self.store)
        self.classification = Classification()
        self.classification.AppendGroup(ClassGroupSingleton("FARM"))
        self.layer.SetClassificationColumn("CLPTLABEL")
        self.layer.SetClassification(self.classification)
        self.layer.UnsetModified()
        self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
                             self.subscribe_with_params,
                             LAYER_SHAPESTORE_REPLACED)
        self.layer.Subscribe(LAYER_CHANGED,
                             self.subscribe_with_params, LAYER_CHANGED)

    def tearDown(self):
        self.clear_messages()
        self.layer.Destroy()
        self.session.Destroy()
        self.session = self.layer = self.store = self.classification = None

    def test_sanity(self):
        """SetShapeStoreTests sanity check

        Test the initial state of the test case instances after setUp.
        """
        cls = self.layer.GetClassification()
        self.assert_(cls is self.classification)
        field = self.layer.GetClassificationColumn()
        self.assertEquals(field, "CLPTLABEL")
        self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
        self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
        self.failIf(self.layer.WasModified())

    def test_set_shape_store_modified_flag(self):
        """Test whether Layer.SetShapeStore() sets the modified flag"""
        memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
                      [("bla",)] * self.layer.ShapeStore().Table().NumRows())
        self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))

        self.assert_(self.layer.WasModified())

    def test_set_shape_store_different_field_name(self):
        """Test Layer.SetShapeStore() with different column name"""
        memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
                      [("bla",)] * self.layer.ShapeStore().Table().NumRows())
        self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
        # The classification should contain only the default group now.
        self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
        self.check_messages([(self.layer, LAYER_CHANGED),
                             (self.layer, LAYER_SHAPESTORE_REPLACED)])

    def test_set_shape_store_same_field(self):
        """Test Layer.SetShapeStore() with same column name and type"""
        memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_STRING)],
                      [("bla",)] * self.layer.ShapeStore().Table().NumRows())
        self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
        # The classification should be the same as before
        self.assert_(self.layer.GetClassification() is self.classification)
        self.check_messages([(self.layer, LAYER_SHAPESTORE_REPLACED)])

    def test_set_shape_store_same_field_different_type(self):
        """Test Layer.SetShapeStore() with same column name but different type
        """
        memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_DOUBLE)],
                      [(0.0,)] * self.layer.ShapeStore().Table().NumRows())
        self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
        # The classification should contain only the default group now.
        self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
        self.check_messages([(self.layer, LAYER_CHANGED),
                             (self.layer, LAYER_SHAPESTORE_REPLACED)])


class TestLayerModification(unittest.TestCase, support.SubscriberMixin):

    """Test cases for Layer method that modify the layer.
    """

    def setUp(self):
        """Clear the list of received messages and create a layer and a session

        The layer is bound to self.layer and the session to self.session.
        """
        self.clear_messages()
        self.session = Session("Test session for %s" % self.__class__)
        self.filename = os.path.join("..", "Data", "iceland", "political.shp")
        self.layer = Layer("Test Layer",
                           self.session.OpenShapefile(self.filename))
        self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
                             LAYER_LEGEND_CHANGED)
        self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
                             self.subscribe_with_params,
                             LAYER_VISIBILITY_CHANGED)
        self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
                             LAYER_CHANGED)

    def tearDown(self):
        """Clear the list of received messages and explictly destroy self.layer
        """
        self.layer.Destroy()
        self.layer = None
        self.session.Destroy()
        self.session = None
        self.clear_messages()

    def test_sanity(self):
        """TestLayerModification Sanity Checks"""
        # test default settings
        self.failIf(self.layer.WasModified())
        self.assertEquals(self.layer.Visible(), 1)
        # no messages should have been produced
        self.check_messages([])

    def test_visibility(self):
        """Test Layer visibility"""
        self.layer.SetVisible(0)
        self.assertEquals(self.layer.Visible(), 0)
        self.check_messages([(self.layer, LAYER_VISIBILITY_CHANGED)])

        # currently, modifying the visibility doesn't count as changing
        # the layer.
        self.failIf(self.layer.WasModified())

    def test_set_classification(self):
        """Test Layer.SetClassification"""
        classification = Classification()
        classification.AppendGroup(ClassGroupRange((0.0, 0.1)))

        self.layer.SetClassification(classification)
        self.layer.SetClassificationColumn("AREA")

        self.check_messages([(self.layer, LAYER_CHANGED),
                             (self.layer, LAYER_CHANGED)])
        self.failUnless(self.layer.WasModified())

        self.clear_messages()
        self.layer.UnsetModified()

        # change only the classification column. This should issue a
        # LAYER_CHANGED message as well.
        self.layer.SetClassificationColumn("PERIMETER")

        self.check_messages([(self.layer, LAYER_CHANGED)])
        self.failUnless(self.layer.WasModified())


    def test_tree_info(self):
        """Test Layer.TreeInfo"""
        self.assertEquals(self.layer.TreeInfo(),
                          ("Layer 'Test Layer'",
                           ['Filename: %s' % os.path.abspath(self.filename),
                            'Shown',
                            'Shapes: 156',
                   'Extent (lat-lon): (-24.5465, 63.2868, -13.4958, 66.5638)',
                            'Shapetype: Polygon',
                            self.layer.GetClassification()]))


if __name__ == "__main__":
    support.run_tests()
1	bh	2229	# Copyright (c) 2002, 2003, 2004 by Intevation GmbH
2	bh	331	# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			"""
9			Test the Layer class
10			"""
11
12			__version__ = "$Revision$"
13			# $Source$
14			# $Id$
15
16			import os
17			import unittest
18
19	bh	1587	import mockgeo
20	bh	331	import support
21			support.initthuban()
22
23			import shapelib
24	bh	336	import dbflib
25	bh	331
26	bh	723	from Thuban.Model.session import Session
27	bh	1538	from Thuban.Model.layer import BaseLayer, Layer, RasterLayer
28			from Thuban.Model.data import SHAPETYPE_POLYGON, SHAPETYPE_ARC, SHAPETYPE_POINT
29	bh	331	from Thuban.Model.messages import LAYER_LEGEND_CHANGED, \
30	bh	1142	LAYER_VISIBILITY_CHANGED, LAYER_SHAPESTORE_REPLACED, LAYER_CHANGED
31	bh	1088	from Thuban.Model.table import FIELDTYPE_DOUBLE, FIELDTYPE_STRING, MemoryTable
32	jonathan	947	from Thuban.Model.proj import Projection
33	bh	996	from Thuban.Model.data import DerivedShapeStore
34	bh	1452	from Thuban.Model.classification import Classification, ClassGroupSingleton, \
35			ClassGroupRange
36	bh	331
37	jonathan	1174	import Thuban.Model.resource
38
39	bh	331	class TestLayer(unittest.TestCase, support.FileTestMixin,
40			support.FloatComparisonMixin):
41
42			"""Test cases for different layer (shape) types"""
43
44	bh	723	def setUp(self):
45	bh	996	"""Create a session self.session and initialize self.layer to None"""
46	bh	723	self.session = Session("Test session for %s" % self.__class__)
47	bh	996	self.layer = None
48	bh	723
49			def tearDown(self):
50	bh	996	"""Call the layer's Destroy method and set session and layer to None"""
51	bh	1681	self.session.Destroy()
52	bh	723	self.session = None
53	bh	996	if self.layer is not None:
54			self.layer.Destroy()
55			self.layer = None
56	bh	723
57	jonathan	947	def build_path(self, filename):
58			return os.path.join("..", "Data", "iceland", filename)
59	bh	996
60	bh	839	def open_shapefile(self, filename):
61			"""Open and return a shapestore for filename in the iceland data set"""
62	jonathan	947	return self.session.OpenShapefile(self.build_path(filename))
63	bh	839
64	jonathan	947	def test_base_layer(self):
65	bh	996	layer = self.layer = BaseLayer("Test BaseLayer")
66	jonathan	947	self.assertEquals(layer.Title(), "Test BaseLayer")
67			self.failUnless(layer.Visible())
68
69			# toggle visibility
70			layer.SetVisible(False)
71			self.failIf(layer.Visible())
72
73			layer.SetVisible(True)
74			self.failUnless(layer.Visible())
75
76			self.failIf(layer.HasClassification())
77	jonathan	1278	self.failIf(layer.HasShapes())
78
79	jonathan	947	self.assertEquals(layer.GetProjection(), None)
80
81			# set/get projection
82	bh	1687	proj = Projection(["proj=utm", "zone=26", "ellps=clrk66"])
83	jonathan	947
84			layer.SetProjection(proj)
85			self.failUnless(layer.GetProjection() is proj)
86
87			# __init__ with other arguments
88			layer = BaseLayer("Test BaseLayer", False, proj)
89			self.failIf(layer.Visible())
90			self.failUnless(layer.GetProjection() is proj)
91
92	bh	331	def test_arc_layer(self):
93			"""Test Layer with arc shapes"""
94	bh	996	layer = self.layer = Layer("Test Layer",
95			self.open_shapefile("roads-line.shp"))
96	jonathan	1278	self.failUnless(layer.HasClassification())
97			self.failUnless(layer.HasShapes())
98	bh	331	self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
99			self.assertEquals(layer.NumShapes(), 839)
100			shape = layer.Shape(32)
101	bh	1551	self.assertPointListEquals(shape.Points(),
102			[[(-15.082174301147461, 66.27738189697265),
103			(-15.026350021362305, 66.27339172363281)]])
104	bh	331	self.assertFloatSeqEqual(layer.BoundingBox(),
105			[-24.450359344482422, 63.426830291748047,
106			-13.55668830871582, 66.520111083984375])
107	bh	1593	shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
108			self.assertEquals([s.ShapeID() for s in shapes],
109	bh	331	[613, 726, 838])
110	jonathan	832
111			self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
112			[-15.082174301147461, 66.27339172363281,
113			-15.026350021362305, 66.27738189697265])
114
115			shape = layer.Shape(33)
116	bh	1551	self.assertPointListEquals(shape.Points(),
117			[[(-22.24850654602050, 66.30645751953125),
118			(-22.23273086547851, 66.29407501220703),
119			(-22.23158073425293, 66.2876892089843),
120			(-22.24631881713867, 66.27006530761718)]])
121	jonathan	832
122			self.assertFloatSeqEqual(layer.ShapesBoundingBox([32, 33]),
123			[-22.248506546020508, 66.270065307617188,
124			-15.026350021362305, 66.30645751953125])
125
126			self.assertEquals(layer.ShapesBoundingBox([]), None)
127			self.assertEquals(layer.ShapesBoundingBox(None), None)
128
129	bh	331	def test_polygon_layer(self):
130			"""Test Layer with polygon shapes"""
131	bh	996	layer = self.layer = Layer("Test Layer",
132			self.open_shapefile("political.shp"))
133	jonathan	1278	self.failUnless(layer.HasClassification())
134			self.failUnless(layer.HasShapes())
135	bh	331	self.assertEquals(layer.ShapeType(), SHAPETYPE_POLYGON)
136			self.assertEquals(layer.NumShapes(), 156)
137			shape = layer.Shape(4)
138	bh	1551	self.assertPointListEquals(shape.Points(),
139			[[(-22.40639114379882, 64.714111328125),
140			(-22.41621208190918, 64.7160034179687),
141			(-22.40605163574218, 64.719200134277),
142			(-22.40639114379882, 64.714111328125)]])
143	bh	331	self.assertFloatSeqEqual(layer.BoundingBox(),
144			[-24.546524047851562, 63.286754608154297,
145			-13.495815277099609, 66.563774108886719])
146	bh	1593	shapes = layer.ShapesInRegion((-24.0, 64.0, -23.9, 64.1))
147			self.assertEquals([s.ShapeID() for s in shapes],
148	bh	331	[91, 92, 144, 146, 148, 150, 152, 153])
149
150			def test_point_layer(self):
151			"""Test Layer with point shapes"""
152	bh	996	layer = self.layer = Layer("Test Layer",
153			self.open_shapefile("cultural_landmark-point.shp"))
154	jonathan	1278	self.failUnless(layer.HasClassification())
155			self.failUnless(layer.HasShapes())
156	bh	331	self.assertEquals(layer.ShapeType(), SHAPETYPE_POINT)
157			self.assertEquals(layer.NumShapes(), 34)
158			shape = layer.Shape(0)
159	bh	1551	self.assertPointListEquals(shape.Points(),
160			[[(-22.711074829101562, 66.36572265625)]])
161	bh	331	self.assertFloatSeqEqual(layer.BoundingBox(),
162			[-23.806047439575195, 63.405960083007812,
163			-15.12291431427002, 66.36572265625])
164	bh	1593	shapes = layer.ShapesInRegion((-24.0, 64.0, -23.80, 64.1))
165			self.assertEquals([s.ShapeID() for s in shapes],
166	bh	331	[0, 1, 2, 3, 4, 5, 27, 28, 29, 30, 31])
167
168	bh	1983	def test_arc_layer_with_projection(self):
169	bh	1587	"""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	bh	1983	store = mockgeo.SimpleShapeStore(SHAPETYPE_ARC,
174	bh	1987	[[[(9884828.7209840547, 5607720.9774499247),
175			(11298336.04640449, 9287823.2044059951)]]],
176	bh	1983	table)
177	bh	1587	layer = self.layer = Layer("Test Layer", store)
178
179	bh	1987	proj = Projection(["proj=lcc", "lon_0=0", "lat_1=20n", "lat_2=60n",
180			"ellps=clrk66"])
181	bh	1587	layer.SetProjection(proj)
182
183	bh	1983	self.assertFloatSeqEqual(layer.BoundingBox(),
184	bh	1987	(9884828.7209840547, 5607720.9774499247,
185			11298336.04640449, 9287823.2044059951))
186	bh	1983	self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
187	bh	1987	(90.0, -8.90043373, 120, 11.1616263))
188	bh	1983	shapes = layer.ShapesInRegion((100, -10, 150, +10))
189	bh	1593	self.assertEquals([s.ShapeID() for s in shapes], [0])
190	bh	1983	self.assertFloatSeqEqual(layer.ShapesBoundingBox([0]),
191	bh	1987	(90.0, -8.90043373, 120, 11.1616263))
192	bh	1587
193	bh	331	def test_empty_layer(self):
194			"""Test Layer with empty shape file"""
195			# create an empty shape file
196			shapefilename = self.temp_file_name("layer_empty.shp")
197			shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)
198			shp.close()
199	bh	336	# create an empty DBF file too because Thuban can't cope yet
200			# with missing DBF file.
201			dbffilename = self.temp_file_name("layer_empty.dbf")
202			dbf = dbflib.create(dbffilename)
203			dbf.add_field("NAME", dbflib.FTString, 20, 0)
204	bh	1768	dbf.close()
205	bh	331
206	bh	336	# Now try to open it.
207	bh	996	layer = self.layer = Layer("Empty Layer",
208			self.session.OpenShapefile(shapefilename))
209	bh	331	self.assertEquals(layer.BoundingBox(), None)
210			self.assertEquals(layer.LatLongBoundingBox(), None)
211			self.assertEquals(layer.NumShapes(), 0)
212
213	bh	839	def test_get_field_type(self):
214			"""Test Layer.GetFieldType()"""
215	bh	996	layer = self.layer = Layer("Test Layer",
216			self.open_shapefile("roads-line.shp"))
217	bh	839	self.assertEquals(layer.GetFieldType("LENGTH"), FIELDTYPE_DOUBLE)
218			self.assertEquals(layer.GetFieldType("non existing"), None)
219	bh	331
220	jonathan	947	def test_raster_layer(self):
221	jonathan	1174	if not Thuban.Model.resource.has_gdal_support():
222	bh	1555	raise support.SkipTest("No gdal support")
223	jonathan	1174
224	jonathan	947	filename = self.build_path("island.tif")
225			layer = RasterLayer("Test RasterLayer", filename)
226	jonathan	1278	self.failIf(layer.HasClassification())
227			self.failIf(layer.HasShapes())
228	bh	1599	self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
229	jonathan	947	self.assertFloatSeqEqual(layer.BoundingBox(),
230			[-24.5500000, 63.2833330,
231			-13.4916670, 66.5666670])
232			self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
233			[-24.5500000, 63.2833330,
234			-13.4916670, 66.5666670])
235	bh	839
236	bh	996	def test_derived_store(self):
237			"""Test layer with derived store"""
238			layer = self.layer = Layer("Test Layer",
239			self.open_shapefile("roads-line.shp"))
240			try:
241			store = layer.ShapeStore()
242			derived = DerivedShapeStore(store, store.Table())
243			layer.SetShapeStore(derived)
244			self.assert_(layer.ShapeStore() is derived)
245	jonathan	1262
246	bh	1538	self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
247			self.assertEquals(layer.NumShapes(), 839)
248			shape = layer.Shape(32)
249	bh	1551	self.assertPointListEquals(shape.Points(),
250			[[(-15.082174301147, 66.277381896972),
251			(-15.026350021362, 66.273391723632)]])
252	bh	1538	self.assertFloatSeqEqual(layer.BoundingBox(),
253			[-24.450359344482422, 63.426830291748047,
254			-13.55668830871582, 66.520111083984375])
255	bh	1593	shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
256			self.assertEquals([s.ShapeID() for s in shapes],
257	bh	1538	[613, 726, 838])
258	jonathan	1262
259	bh	1538	self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
260			[-15.082174301147461, 66.27339172363281,
261			-15.026350021362305, 66.27738189697265])
262
263	bh	996	finally:
264			store = derived = None
265	jonathan	947
266	bh	996
267	bh	1142	class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
268	bh	1088
269			def setUp(self):
270			"""Create a layer with a classification as self.layer"""
271	bh	1142	self.clear_messages()
272	bh	1088	self.session = Session("Test session for %s" % self.__class__)
273			self.shapefilename = os.path.join("..", "Data", "iceland",
274			"cultural_landmark-point.dbf")
275			self.store = self.session.OpenShapefile(self.shapefilename)
276			self.layer = Layer("test layer", self.store)
277	jonathan	1438	self.classification = Classification()
278	bh	1088	self.classification.AppendGroup(ClassGroupSingleton("FARM"))
279	bh	1452	self.layer.SetClassificationColumn("CLPTLABEL")
280	bh	1088	self.layer.SetClassification(self.classification)
281	bh	1142	self.layer.UnsetModified()
282			self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
283			self.subscribe_with_params,
284			LAYER_SHAPESTORE_REPLACED)
285			self.layer.Subscribe(LAYER_CHANGED,
286			self.subscribe_with_params, LAYER_CHANGED)
287	bh	1088
288			def tearDown(self):
289	bh	1142	self.clear_messages()
290	bh	1088	self.layer.Destroy()
291			self.session.Destroy()
292			self.session = self.layer = self.store = self.classification = None
293
294			def test_sanity(self):
295	bh	1142	"""SetShapeStoreTests sanity check
296
297			Test the initial state of the test case instances after setUp.
298			"""
299	bh	1088	cls = self.layer.GetClassification()
300			self.assert_(cls is self.classification)
301	bh	1452	field = self.layer.GetClassificationColumn()
302	jonathan	1438	self.assertEquals(field, "CLPTLABEL")
303			self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
304	bh	1088	self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
305	bh	1142	self.failIf(self.layer.WasModified())
306	bh	1088
307	bh	1142	def test_set_shape_store_modified_flag(self):
308			"""Test whether Layer.SetShapeStore() sets the modified flag"""
309			memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
310			[("bla",)] * self.layer.ShapeStore().Table().NumRows())
311			self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
312
313			self.assert_(self.layer.WasModified())
314
315	bh	1088	def test_set_shape_store_different_field_name(self):
316			"""Test Layer.SetShapeStore() with different column name"""
317			memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
318			[("bla",)] * self.layer.ShapeStore().Table().NumRows())
319			self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
320			# The classification should contain only the default group now.
321			self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
322	bh	1142	self.check_messages([(self.layer, LAYER_CHANGED),
323			(self.layer, LAYER_SHAPESTORE_REPLACED)])
324	bh	1088
325			def test_set_shape_store_same_field(self):
326			"""Test Layer.SetShapeStore() with same column name and type"""
327			memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_STRING)],
328			[("bla",)] * self.layer.ShapeStore().Table().NumRows())
329			self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
330			# The classification should be the same as before
331			self.assert_(self.layer.GetClassification() is self.classification)
332	bh	1142	self.check_messages([(self.layer, LAYER_SHAPESTORE_REPLACED)])
333	bh	1088
334			def test_set_shape_store_same_field_different_type(self):
335			"""Test Layer.SetShapeStore() with same column name but different type
336			"""
337			memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_DOUBLE)],
338			[(0.0,)] * self.layer.ShapeStore().Table().NumRows())
339			self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
340			# The classification should contain only the default group now.
341			self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
342	bh	1142	self.check_messages([(self.layer, LAYER_CHANGED),
343			(self.layer, LAYER_SHAPESTORE_REPLACED)])
344	bh	1088
345
346	bh	1452	class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
347	bh	331
348			"""Test cases for Layer method that modify the layer.
349			"""
350
351			def setUp(self):
352	bh	723	"""Clear the list of received messages and create a layer and a session
353	bh	331
354	bh	723	The layer is bound to self.layer and the session to self.session.
355	bh	331	"""
356			self.clear_messages()
357	bh	723	self.session = Session("Test session for %s" % self.__class__)
358	bh	2229	self.filename = os.path.join("..", "Data", "iceland", "political.shp")
359	bh	331	self.layer = Layer("Test Layer",
360	bh	2229	self.session.OpenShapefile(self.filename))
361	bh	331	self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
362			LAYER_LEGEND_CHANGED)
363			self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
364			self.subscribe_with_params,
365			LAYER_VISIBILITY_CHANGED)
366	bh	1452	self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
367			LAYER_CHANGED)
368	bh	331
369			def tearDown(self):
370			"""Clear the list of received messages and explictly destroy self.layer
371			"""
372			self.layer.Destroy()
373	bh	723	self.layer = None
374			self.session.Destroy()
375			self.session = None
376	bh	331	self.clear_messages()
377
378	bh	1452	def test_sanity(self):
379			"""TestLayerModification Sanity Checks"""
380	bh	331	# test default settings
381			self.failIf(self.layer.WasModified())
382			self.assertEquals(self.layer.Visible(), 1)
383			# no messages should have been produced
384			self.check_messages([])
385
386			def test_visibility(self):
387			"""Test Layer visibility"""
388			self.layer.SetVisible(0)
389			self.assertEquals(self.layer.Visible(), 0)
390			self.check_messages([(self.layer, LAYER_VISIBILITY_CHANGED)])
391
392			# currently, modifying the visibility doesn't count as changing
393			# the layer.
394			self.failIf(self.layer.WasModified())
395
396	bh	1452	def test_set_classification(self):
397			"""Test Layer.SetClassification"""
398			classification = Classification()
399			classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
400
401			self.layer.SetClassification(classification)
402			self.layer.SetClassificationColumn("AREA")
403
404			self.check_messages([(self.layer, LAYER_CHANGED),
405			(self.layer, LAYER_CHANGED)])
406			self.failUnless(self.layer.WasModified())
407
408			self.clear_messages()
409			self.layer.UnsetModified()
410
411			# change only the classification column. This should issue a
412			# LAYER_CHANGED message as well.
413			self.layer.SetClassificationColumn("PERIMETER")
414
415			self.check_messages([(self.layer, LAYER_CHANGED)])
416			self.failUnless(self.layer.WasModified())
417
418
419	bh	2229	def test_tree_info(self):
420			"""Test Layer.TreeInfo"""
421			self.assertEquals(self.layer.TreeInfo(),
422			("Layer 'Test Layer'",
423			['Filename: %s' % os.path.abspath(self.filename),
424			'Shown',
425			'Shapes: 156',
426			'Extent (lat-lon): (-24.5465, 63.2868, -13.4958, 66.5638)',
427			'Shapetype: Polygon',
428			self.layer.GetClassification()]))
429	bh	331
430
431			if __name__ == "__main__":
432	bh	599	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision