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

__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
        ids = []
        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):
                ids.append(i)
        return ids


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