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 Thuban import _

from types import StringTypes

import Projection
BaseProjection = Projection.Projection
del Projection

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):
        """Initialize the Projection with a list of 
        'parameter=value' strings and an optional name. If 'name' is
        None, the name will be set to 'Unknown' in the local language.
        """

        BaseProjection.__init__(self, params)

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

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

    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)

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

        Raises a ValueError is proj is not found.
        """

        self.__projs.remove(proj)

    def Replace(self, oldproj, newproj):
        """Replace the object 'oldproj' with 'newproj'.
        
        Raises ValueError if oldproj is not in the file.
        """

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