Thuban/Model/proj.py

# Copyright (c) 2001, 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.

__version__ = "$Revision$"

from types import StringTypes

from Thuban import _
from Thuban.Lib.connector import Publisher

import Projection
BaseProjection = Projection.Projection
del Projection

from messages import PROJECTION_ADDED, PROJECTION_REPLACED, PROJECTION_REMOVED

PROJ_UNITS_METERS  = 1
PROJ_UNITS_DEGREES = 2

class Projection(BaseProjection):

    """A proj4 projection object that remembers the parameters"""

    def __init__(self, params, name = None, epsg = None):
        """Initialize the Projection

        Parameters:

        params -- a list of 'parameter=value' strings

        name -- (optional) The name of the projectin. If None or omitted
                it defaults to 'Unknown' in the local language.

        epsg -- (optional) The EPSG code as a string.
        """
        BaseProjection.__init__(self, params)

        if name is None:
            self.name = _("Unknown")
        elif isinstance(name, StringTypes):
            self.name = name

        self.epsg = epsg
        self.params = params

    def ForwardBBox(self, bbox):
        """Return the bounding box of the corners of the bounding box bbox
        """
        # This is not really the correct way to determine the bbox of a
        # projected shape, but for now it works well enough
        llx, lly, urx, ury = bbox
        xs = []; ys = []
        x, y = self.Forward(llx, lly)
        xs.append(x); ys.append(y)
        x, y = self.Forward(llx, ury)
        xs.append(x); ys.append(y)
        x, y = self.Forward(urx, ury)
        xs.append(x); ys.append(y)
        x, y = self.Forward(urx, lly)
        xs.append(x); ys.append(y)
        
        return min(xs), min(ys), max(xs), max(ys)

    def GetName(self):
        """Return the name of the projection."""
        return self.name

    def Label(self):
        if self.epsg:
            return "EPSG % 5s %s" % (self.epsg, self.name)
        return self.name

    def EPSGCode(self):
        """Return the EPSG code as a string or None if there is none"""
        return self.epsg

    def GetParameter(self, param):
        """Return the projection value for the given parameter.

        If 'param' exists as a valid parameter return the associated
        value as a string. If the parameter does not have a value (like
        e.g. the 'south' parameter for utm) then the value is the
        parameter name itself.

        If the parameter doesn't exist return an empty string.
        """

        for pair in self.params:
            if "=" in pair:
                p, v = pair.split("=")
            else:
                p = v = pair
            if p == param:
                return v

        return ""

    def GetAllParameters(self):
        """Return list of 'parameter=value' strings"""
        return self.params

    def GetProjectedUnits(self):
        if self.GetParameter("proj") == "latlong":
            return PROJ_UNITS_DEGREES
        else:
            return PROJ_UNITS_METERS

    def __repr__(self):
        return self.name + ": " + repr(self.params)


class ProjFile(Publisher):

    def __init__(self, filename):
        """Intialize the ProjFile.

        filename -- name of the file that this ProjFile represents.
        """

        self.__projs = []

        self.SetFilename(filename)

    def Add(self, proj):
        """Add the projection to the end of the file."""
        self.__projs.append(proj)
        self.issue(PROJECTION_ADDED, proj)

    def Remove(self, proj):
        """Remove the object proj from the projection file.

        Raises a ValueError is proj is not found.
        """
        self.__projs.remove(proj)
        self.issue(PROJECTION_REMOVED, proj)

    def Replace(self, oldproj, newproj):
        """Replace the object 'oldproj' with 'newproj'.

        Raises ValueError if oldproj is not in the file.
        """
        self.__projs[self.__projs.index(oldproj)] = newproj
        self.issue(PROJECTION_REPLACED, oldproj, newproj)

    def GetFilename(self):
        """Return the filename where the ProjFile was read or will be
        written to.
        """

        return self.__filename

    def SetFilename(self, filename):
        """Set the filename where the ProjFile will be written to."""
        self.__filename = filename

    def GetProjections(self):
        """Return a list of the projections in the order they were read
        from the file or will be written.

        This is not a deep copy list, so any modifications made to the
        Projection objects will be written to the file.
        """

        return self.__projs

1	bh	1797	# Copyright (c) 2001, 2003 by Intevation GmbH
2	bh	6	# 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			__version__ = "$Revision$"
9
10	bh	1824	from types import StringTypes
11
12	jonathan	745	from Thuban import _
13	bh	1824	from Thuban.Lib.connector import Publisher
14	jonathan	745
15	bh	6	import Projection
16			BaseProjection = Projection.Projection
17			del Projection
18
19	bh	1824	from messages import PROJECTION_ADDED, PROJECTION_REPLACED, PROJECTION_REMOVED
20
21	jonathan	1250	PROJ_UNITS_METERS = 1
22			PROJ_UNITS_DEGREES = 2
23
24	bh	6	class Projection(BaseProjection):
25
26			"""A proj4 projection object that remembers the parameters"""
27
28	bh	1815	def __init__(self, params, name = None, epsg = None):
29			"""Initialize the Projection
30
31			Parameters:
32
33			params -- a list of 'parameter=value' strings
34
35			name -- (optional) The name of the projectin. If None or omitted
36			it defaults to 'Unknown' in the local language.
37
38			epsg -- (optional) The EPSG code as a string.
39	jonathan	745	"""
40	bh	6	BaseProjection.__init__(self, params)
41	jonathan	745
42	jonathan	758	if name is None:
43			self.name = _("Unknown")
44			elif isinstance(name, StringTypes):
45			self.name = name
46	jonathan	745
47	bh	1815	self.epsg = epsg
48	jonathan	758	self.params = params
49
50	bh	6	def ForwardBBox(self, bbox):
51			"""Return the bounding box of the corners of the bounding box bbox
52			"""
53			# This is not really the correct way to determine the bbox of a
54			# projected shape, but for now it works well enough
55			llx, lly, urx, ury = bbox
56			xs = []; ys = []
57			x, y = self.Forward(llx, lly)
58			xs.append(x); ys.append(y)
59			x, y = self.Forward(llx, ury)
60			xs.append(x); ys.append(y)
61			x, y = self.Forward(urx, ury)
62			xs.append(x); ys.append(y)
63			x, y = self.Forward(urx, lly)
64			xs.append(x); ys.append(y)
65	jonathan	758
66	bh	6	return min(xs), min(ys), max(xs), max(ys)
67	jonathan	695
68			def GetName(self):
69	jonathan	738	"""Return the name of the projection."""
70	jonathan	695	return self.name
71
72	bh	1815	def Label(self):
73			if self.epsg:
74			return "EPSG % 5s %s" % (self.epsg, self.name)
75			return self.name
76
77			def EPSGCode(self):
78			"""Return the EPSG code as a string or None if there is none"""
79			return self.epsg
80
81	jonathan	708	def GetParameter(self, param):
82	jonathan	738	"""Return the projection value for the given parameter.
83	jonathan	708
84	bh	1797	If 'param' exists as a valid parameter return the associated
85			value as a string. If the parameter does not have a value (like
86			e.g. the 'south' parameter for utm) then the value is the
87			parameter name itself.
88
89			If the parameter doesn't exist return an empty string.
90	jonathan	738	"""
91
92	jonathan	708	for pair in self.params:
93	bh	1797	if "=" in pair:
94			p, v = pair.split("=")
95			else:
96			p = v = pair
97	jonathan	708	if p == param:
98			return v
99
100			return ""
101
102			def GetAllParameters(self):
103	jonathan	738	"""Return list of 'parameter=value' strings"""
104	jonathan	695	return self.params
105
106	jonathan	1250	def GetProjectedUnits(self):
107			if self.GetParameter("proj") == "latlong":
108			return PROJ_UNITS_DEGREES
109			else:
110			return PROJ_UNITS_METERS
111
112	jonathan	695	def __repr__(self):
113	jonathan	726	return self.name + ": " + repr(self.params)
114	jonathan	695
115	bh	1815
116	bh	1824	class ProjFile(Publisher):
117	jonathan	695
118			def __init__(self, filename):
119	jonathan	738	"""Intialize the ProjFile.
120	jonathan	695
121	jonathan	738	filename -- name of the file that this ProjFile represents.
122			"""
123
124			self.__projs = []
125
126			self.SetFilename(filename)
127	bh	1824
128	jonathan	695	def Add(self, proj):
129	bh	1802	"""Add the projection to the end of the file."""
130			self.__projs.append(proj)
131	bh	1824	self.issue(PROJECTION_ADDED, proj)
132	jonathan	695
133	jonathan	726	def Remove(self, proj):
134	jonathan	758	"""Remove the object proj from the projection file.
135	jonathan	726
136	jonathan	738	Raises a ValueError is proj is not found.
137			"""
138			self.__projs.remove(proj)
139	bh	1824	self.issue(PROJECTION_REMOVED, proj)
140	jonathan	695
141	jonathan	758	def Replace(self, oldproj, newproj):
142			"""Replace the object 'oldproj' with 'newproj'.
143	bh	1824
144	jonathan	758	Raises ValueError if oldproj is not in the file.
145			"""
146			self.__projs[self.__projs.index(oldproj)] = newproj
147	bh	1824	self.issue(PROJECTION_REPLACED, oldproj, newproj)
148	jonathan	758
149	jonathan	738	def GetFilename(self):
150			"""Return the filename where the ProjFile was read or will be
151			written to.
152			"""
153
154			return self.__filename
155
156			def SetFilename(self, filename):
157			"""Set the filename where the ProjFile will be written to."""
158			self.__filename = filename
159
160	jonathan	695	def GetProjections(self):
161	jonathan	738	"""Return a list of the projections in the order they were read
162			from the file or will be written.
163
164			This is not a deep copy list, so any modifications made to the
165			Projection objects will be written to the file.
166			"""
167
168			return self.__projs
169
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision