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))

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