WIP-pyshapelib-bramz/test/test_layer.py

# Copyright (c) 2002, 2003 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"])

        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_point_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_POINT, [[[(10,10)]]], table)
        layer = self.layer = Layer("Test Layer", store)

        # Rotation by 45 degrees counter clockwise. This detects a bug
        # in the ShapesInRegion method which transforms the bounding box
        # by only transforming two opposite corners because they have
        # the same x or y coordinates after application of the
        # projection or its inverse.
        proj = mockgeo.AffineProjection((1, 1, -1, 1, 0, 0))
        layer.SetProjection(proj)

        self.assertEquals(layer.BoundingBox(), (10, 10, 10, 10))
        self.assertEquals(layer.LatLongBoundingBox(), (10.0, 0.0, 10.0, 0.0))
        shapes = layer.ShapesInRegion((0, 0, 20, 20))
        self.assertEquals([s.ShapeID() for s in shapes], [0])

    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)

        # 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__)
        filename = os.path.join("..", "Data", "iceland", "political.shp")
        self.layer = Layer("Test Layer",
                           self.session.OpenShapefile(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())


#
# the tree info now contains Color objects which are difficult to test
#
#   def test_tree_info(self):
#       """Test Layer.TreeInfo"""
#       self.assertEquals(self.layer.TreeInfo(),
#                         ("Layer 'Test Layer'",
#                          ['Shown',
#                           'Shapes: 156',
#                           ('Extent (lat-lon):'
#                            ' (-24.5465, 63.2868, -13.4958, 66.5638)'),
#                           'Shapetype: Polygon',
#                           'Fill: None',
#                           'Outline: (0.000, 0.000, 0.000)']))


if __name__ == "__main__":
    support.run_tests()
1	bh	599	# Copyright (c) 2002, 2003 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			proj = Projection(["proj=utm", "zone=26"])
83
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	1587	def test_point_layer_with_projection(self):
169			"""Test Layer with point shapes and a projection"""
170			# We use mock data here so that we have precise control over the
171			# values
172			table = MemoryTable([("FOO", FIELDTYPE_STRING)], [("bla",)])
173			store = mockgeo.SimpleShapeStore(SHAPETYPE_POINT, [[[(10,10)]]], table)
174			layer = self.layer = Layer("Test Layer", store)
175
176			# Rotation by 45 degrees counter clockwise. This detects a bug
177			# in the ShapesInRegion method which transforms the bounding box
178			# by only transforming two opposite corners because they have
179			# the same x or y coordinates after application of the
180			# projection or its inverse.
181			proj = mockgeo.AffineProjection((1, 1, -1, 1, 0, 0))
182			layer.SetProjection(proj)
183
184			self.assertEquals(layer.BoundingBox(), (10, 10, 10, 10))
185			self.assertEquals(layer.LatLongBoundingBox(), (10.0, 0.0, 10.0, 0.0))
186	bh	1593	shapes = layer.ShapesInRegion((0, 0, 20, 20))
187			self.assertEquals([s.ShapeID() for s in shapes], [0])
188	bh	1587
189	bh	331	def test_empty_layer(self):
190			"""Test Layer with empty shape file"""
191			# create an empty shape file
192			shapefilename = self.temp_file_name("layer_empty.shp")
193			shp = shapelib.create(shapefilename, shapelib.SHPT_POLYGON)
194			shp.close()
195	bh	336	# create an empty DBF file too because Thuban can't cope yet
196			# with missing DBF file.
197			dbffilename = self.temp_file_name("layer_empty.dbf")
198			dbf = dbflib.create(dbffilename)
199			dbf.add_field("NAME", dbflib.FTString, 20, 0)
200	bh	331
201	bh	336	# Now try to open it.
202	bh	996	layer = self.layer = Layer("Empty Layer",
203			self.session.OpenShapefile(shapefilename))
204	bh	331	self.assertEquals(layer.BoundingBox(), None)
205			self.assertEquals(layer.LatLongBoundingBox(), None)
206			self.assertEquals(layer.NumShapes(), 0)
207
208	bh	839	def test_get_field_type(self):
209			"""Test Layer.GetFieldType()"""
210	bh	996	layer = self.layer = Layer("Test Layer",
211			self.open_shapefile("roads-line.shp"))
212	bh	839	self.assertEquals(layer.GetFieldType("LENGTH"), FIELDTYPE_DOUBLE)
213			self.assertEquals(layer.GetFieldType("non existing"), None)
214	bh	331
215	jonathan	947	def test_raster_layer(self):
216	jonathan	1174	if not Thuban.Model.resource.has_gdal_support():
217	bh	1555	raise support.SkipTest("No gdal support")
218	jonathan	1174
219	jonathan	947	filename = self.build_path("island.tif")
220			layer = RasterLayer("Test RasterLayer", filename)
221	jonathan	1278	self.failIf(layer.HasClassification())
222			self.failIf(layer.HasShapes())
223	bh	1599	self.assertEquals(layer.GetImageFilename(), os.path.abspath(filename))
224	jonathan	947	self.assertFloatSeqEqual(layer.BoundingBox(),
225			[-24.5500000, 63.2833330,
226			-13.4916670, 66.5666670])
227			self.assertFloatSeqEqual(layer.LatLongBoundingBox(),
228			[-24.5500000, 63.2833330,
229			-13.4916670, 66.5666670])
230	bh	839
231	bh	996	def test_derived_store(self):
232			"""Test layer with derived store"""
233			layer = self.layer = Layer("Test Layer",
234			self.open_shapefile("roads-line.shp"))
235			try:
236			store = layer.ShapeStore()
237			derived = DerivedShapeStore(store, store.Table())
238			layer.SetShapeStore(derived)
239			self.assert_(layer.ShapeStore() is derived)
240	jonathan	1262
241	bh	1538	self.assertEquals(layer.ShapeType(), SHAPETYPE_ARC)
242			self.assertEquals(layer.NumShapes(), 839)
243			shape = layer.Shape(32)
244	bh	1551	self.assertPointListEquals(shape.Points(),
245			[[(-15.082174301147, 66.277381896972),
246			(-15.026350021362, 66.273391723632)]])
247	bh	1538	self.assertFloatSeqEqual(layer.BoundingBox(),
248			[-24.450359344482422, 63.426830291748047,
249			-13.55668830871582, 66.520111083984375])
250	bh	1593	shapes = layer.ShapesInRegion((-24.0, 64.0, -23.75, 64.25))
251			self.assertEquals([s.ShapeID() for s in shapes],
252	bh	1538	[613, 726, 838])
253	jonathan	1262
254	bh	1538	self.assertFloatSeqEqual(layer.ShapesBoundingBox([32]),
255			[-15.082174301147461, 66.27339172363281,
256			-15.026350021362305, 66.27738189697265])
257
258	bh	996	finally:
259			store = derived = None
260	jonathan	947
261	bh	996
262	bh	1142	class SetShapeStoreTests(unittest.TestCase, support.SubscriberMixin):
263	bh	1088
264			def setUp(self):
265			"""Create a layer with a classification as self.layer"""
266	bh	1142	self.clear_messages()
267	bh	1088	self.session = Session("Test session for %s" % self.__class__)
268			self.shapefilename = os.path.join("..", "Data", "iceland",
269			"cultural_landmark-point.dbf")
270			self.store = self.session.OpenShapefile(self.shapefilename)
271			self.layer = Layer("test layer", self.store)
272	jonathan	1438	self.classification = Classification()
273	bh	1088	self.classification.AppendGroup(ClassGroupSingleton("FARM"))
274	bh	1452	self.layer.SetClassificationColumn("CLPTLABEL")
275	bh	1088	self.layer.SetClassification(self.classification)
276	bh	1142	self.layer.UnsetModified()
277			self.layer.Subscribe(LAYER_SHAPESTORE_REPLACED,
278			self.subscribe_with_params,
279			LAYER_SHAPESTORE_REPLACED)
280			self.layer.Subscribe(LAYER_CHANGED,
281			self.subscribe_with_params, LAYER_CHANGED)
282	bh	1088
283			def tearDown(self):
284	bh	1142	self.clear_messages()
285	bh	1088	self.layer.Destroy()
286			self.session.Destroy()
287			self.session = self.layer = self.store = self.classification = None
288
289			def test_sanity(self):
290	bh	1142	"""SetShapeStoreTests sanity check
291
292			Test the initial state of the test case instances after setUp.
293			"""
294	bh	1088	cls = self.layer.GetClassification()
295			self.assert_(cls is self.classification)
296	bh	1452	field = self.layer.GetClassificationColumn()
297	jonathan	1438	self.assertEquals(field, "CLPTLABEL")
298			self.assertEquals(self.layer.GetFieldType(field), FIELDTYPE_STRING)
299	bh	1088	self.assertEquals(self.layer.GetClassification().GetNumGroups(), 1)
300	bh	1142	self.failIf(self.layer.WasModified())
301	bh	1088
302	bh	1142	def test_set_shape_store_modified_flag(self):
303			"""Test whether Layer.SetShapeStore() sets the modified flag"""
304			memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
305			[("bla",)] * self.layer.ShapeStore().Table().NumRows())
306			self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
307
308			self.assert_(self.layer.WasModified())
309
310	bh	1088	def test_set_shape_store_different_field_name(self):
311			"""Test Layer.SetShapeStore() with different column name"""
312			memtable = MemoryTable([("FOO", FIELDTYPE_STRING)],
313			[("bla",)] * self.layer.ShapeStore().Table().NumRows())
314			self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
315			# The classification should contain only the default group now.
316			self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
317	bh	1142	self.check_messages([(self.layer, LAYER_CHANGED),
318			(self.layer, LAYER_SHAPESTORE_REPLACED)])
319	bh	1088
320			def test_set_shape_store_same_field(self):
321			"""Test Layer.SetShapeStore() with same column name and type"""
322			memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_STRING)],
323			[("bla",)] * self.layer.ShapeStore().Table().NumRows())
324			self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
325			# The classification should be the same as before
326			self.assert_(self.layer.GetClassification() is self.classification)
327	bh	1142	self.check_messages([(self.layer, LAYER_SHAPESTORE_REPLACED)])
328	bh	1088
329			def test_set_shape_store_same_field_different_type(self):
330			"""Test Layer.SetShapeStore() with same column name but different type
331			"""
332			memtable = MemoryTable([("CLPTLABEL", FIELDTYPE_DOUBLE)],
333			[(0.0,)] * self.layer.ShapeStore().Table().NumRows())
334			self.layer.SetShapeStore(DerivedShapeStore(self.store, memtable))
335			# The classification should contain only the default group now.
336			self.assertEquals(self.layer.GetClassification().GetNumGroups(), 0)
337	bh	1142	self.check_messages([(self.layer, LAYER_CHANGED),
338			(self.layer, LAYER_SHAPESTORE_REPLACED)])
339	bh	1088
340
341	bh	1452	class TestLayerModification(unittest.TestCase, support.SubscriberMixin):
342	bh	331
343			"""Test cases for Layer method that modify the layer.
344			"""
345
346			def setUp(self):
347	bh	723	"""Clear the list of received messages and create a layer and a session
348	bh	331
349	bh	723	The layer is bound to self.layer and the session to self.session.
350	bh	331	"""
351			self.clear_messages()
352	bh	723	self.session = Session("Test session for %s" % self.__class__)
353			filename = os.path.join("..", "Data", "iceland", "political.shp")
354	bh	331	self.layer = Layer("Test Layer",
355	bh	723	self.session.OpenShapefile(filename))
356	bh	331	self.layer.Subscribe(LAYER_LEGEND_CHANGED, self.subscribe_with_params,
357			LAYER_LEGEND_CHANGED)
358			self.layer.Subscribe(LAYER_VISIBILITY_CHANGED,
359			self.subscribe_with_params,
360			LAYER_VISIBILITY_CHANGED)
361	bh	1452	self.layer.Subscribe(LAYER_CHANGED, self.subscribe_with_params,
362			LAYER_CHANGED)
363	bh	331
364			def tearDown(self):
365			"""Clear the list of received messages and explictly destroy self.layer
366			"""
367			self.layer.Destroy()
368	bh	723	self.layer = None
369			self.session.Destroy()
370			self.session = None
371	bh	331	self.clear_messages()
372
373	bh	1452	def test_sanity(self):
374			"""TestLayerModification Sanity Checks"""
375	bh	331	# test default settings
376			self.failIf(self.layer.WasModified())
377			self.assertEquals(self.layer.Visible(), 1)
378			# no messages should have been produced
379			self.check_messages([])
380
381			def test_visibility(self):
382			"""Test Layer visibility"""
383			self.layer.SetVisible(0)
384			self.assertEquals(self.layer.Visible(), 0)
385			self.check_messages([(self.layer, LAYER_VISIBILITY_CHANGED)])
386
387			# currently, modifying the visibility doesn't count as changing
388			# the layer.
389			self.failIf(self.layer.WasModified())
390
391	bh	1452	def test_set_classification(self):
392			"""Test Layer.SetClassification"""
393			classification = Classification()
394			classification.AppendGroup(ClassGroupRange((0.0, 0.1)))
395
396			self.layer.SetClassification(classification)
397			self.layer.SetClassificationColumn("AREA")
398
399			self.check_messages([(self.layer, LAYER_CHANGED),
400			(self.layer, LAYER_CHANGED)])
401			self.failUnless(self.layer.WasModified())
402
403			self.clear_messages()
404			self.layer.UnsetModified()
405
406			# change only the classification column. This should issue a
407			# LAYER_CHANGED message as well.
408			self.layer.SetClassificationColumn("PERIMETER")
409
410			self.check_messages([(self.layer, LAYER_CHANGED)])
411			self.failUnless(self.layer.WasModified())
412
413
414	jonathan	395	#
415			# the tree info now contains Color objects which are difficult to test
416			#
417			# def test_tree_info(self):
418			# """Test Layer.TreeInfo"""
419			# self.assertEquals(self.layer.TreeInfo(),
420			# ("Layer 'Test Layer'",
421			# ['Shown',
422			# 'Shapes: 156',
423			# ('Extent (lat-lon):'
424			# ' (-24.5465, 63.2868, -13.4958, 66.5638)'),
425			# 'Shapetype: Polygon',
426			# 'Fill: None',
427			# 'Outline: (0.000, 0.000, 0.000)']))
428	bh	331
429
430			if __name__ == "__main__":
431	bh	599	support.run_tests()
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision