WIP-pyshapelib-bramz/test/mockgeo.py

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

"""Mock geometric/geographic objects"""

from __future__ import generators

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


class SimpleShape:

    def __init__(self, shapeid, points):
        self.shapeid = shapeid
        self.points = points

    def Points(self):
        return self.points

    def ShapeID(self):
        return self.shapeid

    def RawData(self):
        return self.points

    def compute_bbox(self):
        xs = []
        ys = []
        for part in self.Points():
            for x, y in part:
                xs.append(x)
                ys.append(y)
        return (min(xs), min(ys), max(xs), max(ys))


class SimpleShapeStore:

    """A simple shapestore object which holds its data in memory"""

    def __init__(self, shapetype, shapes, table):
        """Initialize the simple shapestore object.

        The shapetype should be one of the predefined SHAPETYPE_*
        constants. shapes is a list of shape definitions. Each
        definitions is a list of lists of tuples as returned by the
        Shape's Points() method. The table argument should be an object
        implementing the table interface and contain with one row for
        each shape.
        """
        self.shapetype = shapetype
        self.shapes = shapes
        self.table = table
        assert table.NumRows() == len(shapes)

    def ShapeType(self):
        return self.shapetype

    def Table(self):
        return self.table

    def NumShapes(self):
        return len(self.shapes)

    def Shape(self, index):
        return SimpleShape(index, self.shapes[index])

    def BoundingBox(self):
        xs = []
        ys = []
        for shape in self.shapes:
            for part in shape:
                for x, y in part:
                    xs.append(x)
                    ys.append(y)
        return (min(xs), min(ys), max(xs), max(ys))

    def ShapesInRegion(self, bbox):
        left, bottom, right, top = bbox
        if left > right:
            left, right = right, left
        if bottom > top:
            bottom, top = top, bottom
        for i in xrange(len(self.shapes)):
            shape = SimpleShape(i, self.shapes[i])
            sleft, sbottom, sright, stop = shape.compute_bbox()
            if (left <= sright and right >= sleft
                and top >= sbottom and bottom <= stop):
                yield shape

    def AllShapes(self):
        for i in xrange(len(self.shapes)):
            yield SimpleShape(i, self.shapes[i])


class AffineProjection:

    """Projection-like object implemented with an affine transformation

    The transformation matrix is defined by a list of six floats:

           [m11, m21, m12, m22, v1, v2]

    This list is essentially in the same form as used in PostScript.

    This interpreted as the following transformation of (x, y):

            / x \   / m11 m12 \ / x \   / v1 \
        T * |   | = |         | |   | + |    |
            \ y /   \ m21 m22 / \ y /   \ v2 /

    or, in homogeneous coordinates:

                     / m11 m12 v1 \ / x \
                     |            | |   |
                  ^= | m21 m22 v2 | | y |
                     |            | |   |
                     \ 0   0   1  / \ 1 /

    Obviously this is not a real geographic projection, but it's useful
    in test cases because it's simple and the result is easily computed
    in advance.
    """

    def __init__(self, coeff):
        self.coeff = coeff

        # determine the inverse transformation right away. We trust that
        # an inverse exist for the transformations used in the Thuban
        # test suite.
        m11, m21, m12, m22, v1, v2 = coeff
        det = float(m11 * m22 - m12 * m21)
        n11 = m22 / det
        n12 = -m12 / det
        n21 = -m21 / det
        n22 = m11 / det
        self.inv = [n11, n21, n12, n22, -n11*v1 - n12*v2, -n21*v1 - n22*v2]

    def _apply(self, matrix, x, y):
        m11, m21, m12, m22, v1, v2 = matrix
        return (m11 * x + m12 * y + v1), (m21 * x + m22 * y + v2)

    def Forward(self, x, y):
        return self._apply(self.coeff, x, y)

    def Inverse(self, x, y):
        return self._apply(self.inv, x, y)
1	# Copyright (C) 2003 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[email protected]>
4	#
5	# This program is free software under the GPL (>=v2)
6	# Read the file COPYING coming with the software for details.
7
8	"""Mock geometric/geographic objects"""
9
10	from __future__ import generators
11
12	__version__ = "$Revision$"
13	# $Source$
14	# $Id$
15
16
17	class SimpleShape:
18
19	def __init__(self, shapeid, points):
20	self.shapeid = shapeid
21	self.points = points
22
23	def Points(self):
24	return self.points
25
26	def ShapeID(self):
27	return self.shapeid
28
29	def RawData(self):
30	return self.points
31
32	def compute_bbox(self):
33	xs = []
34	ys = []
35	for part in self.Points():
36	for x, y in part:
37	xs.append(x)
38	ys.append(y)
39	return (min(xs), min(ys), max(xs), max(ys))
40
41
42	class SimpleShapeStore:
43
44	"""A simple shapestore object which holds its data in memory"""
45
46	def __init__(self, shapetype, shapes, table):
47	"""Initialize the simple shapestore object.
48
49	The shapetype should be one of the predefined SHAPETYPE_*
50	constants. shapes is a list of shape definitions. Each
51	definitions is a list of lists of tuples as returned by the
52	Shape's Points() method. The table argument should be an object
53	implementing the table interface and contain with one row for
54	each shape.
55	"""
56	self.shapetype = shapetype
57	self.shapes = shapes
58	self.table = table
59	assert table.NumRows() == len(shapes)
60
61	def ShapeType(self):
62	return self.shapetype
63
64	def Table(self):
65	return self.table
66
67	def NumShapes(self):
68	return len(self.shapes)
69
70	def Shape(self, index):
71	return SimpleShape(index, self.shapes[index])
72
73	def BoundingBox(self):
74	xs = []
75	ys = []
76	for shape in self.shapes:
77	for part in shape:
78	for x, y in part:
79	xs.append(x)
80	ys.append(y)
81	return (min(xs), min(ys), max(xs), max(ys))
82
83	def ShapesInRegion(self, bbox):
84	left, bottom, right, top = bbox
85	if left > right:
86	left, right = right, left
87	if bottom > top:
88	bottom, top = top, bottom
89	for i in xrange(len(self.shapes)):
90	shape = SimpleShape(i, self.shapes[i])
91	sleft, sbottom, sright, stop = shape.compute_bbox()
92	if (left <= sright and right >= sleft
93	and top >= sbottom and bottom <= stop):
94	yield shape
95
96	def AllShapes(self):
97	for i in xrange(len(self.shapes)):
98	yield SimpleShape(i, self.shapes[i])
99
100
101	class AffineProjection:
102
103	"""Projection-like object implemented with an affine transformation
104
105	The transformation matrix is defined by a list of six floats:
106
107	[m11, m21, m12, m22, v1, v2]
108
109	This list is essentially in the same form as used in PostScript.
110
111	This interpreted as the following transformation of (x, y):
112
113	/ x \ / m11 m12 \ / x \ / v1 \
114	T * \| \| = \| \| \| \| + \| \|
115	\ y / \ m21 m22 / \ y / \ v2 /
116
117	or, in homogeneous coordinates:
118
119	/ m11 m12 v1 \ / x \
120	\| \| \| \|
121	^= \| m21 m22 v2 \| \| y \|
122	\| \| \| \|
123	\ 0 0 1 / \ 1 /
124
125	Obviously this is not a real geographic projection, but it's useful
126	in test cases because it's simple and the result is easily computed
127	in advance.
128	"""
129
130	def __init__(self, coeff):
131	self.coeff = coeff
132
133	# determine the inverse transformation right away. We trust that
134	# an inverse exist for the transformations used in the Thuban
135	# test suite.
136	m11, m21, m12, m22, v1, v2 = coeff
137	det = float(m11 * m22 - m12 * m21)
138	n11 = m22 / det
139	n12 = -m12 / det
140	n21 = -m21 / det
141	n22 = m11 / det
142	self.inv = [n11, n21, n12, n22, -n11v1 - n12v2, -n21v1 - n22v2]
143
144	def _apply(self, matrix, x, y):
145	m11, m21, m12, m22, v1, v2 = matrix
146	return (m11 * x + m12 * y + v1), (m21 * x + m22 * y + v2)
147
148	def Forward(self, x, y):
149	return self._apply(self.coeff, x, y)
150
151	def Inverse(self, x, y):
152	return self._apply(self.inv, x, y)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision