Thuban/Model/proj.py

# Copyright (c) 2001, 2003, 2006 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
# Bernhard Reiter <[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
import locale

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

def _do_we_have_to_work_around_broken_proj():
    """ If we have a problematic locale, check if proj results are good. """
    if locale.localeconv()['decimal_point'] != '.':
        params = ["proj=latlong", "to_meter=0.01745", "ellps=clrk66"]
        proj = BaseProjection(params)
        result1 = proj.Forward(1,1)

        savedlocale = locale.getlocale(locale.LC_NUMERIC)
        locale.setlocale(locale.LC_NUMERIC, "C")

        proj = BaseProjection(params)
        result2 = proj.Forward(1,1)

        try:
            locale.setlocale(locale.LC_NUMERIC, savedlocale)
        except:
            # python under some circumstances (observed 2.3.5-2 Debian Sarge)
            # does not accept savedlocale directly 
            # deviating from the documentation
            locale.setlocale(locale.LC_NUMERIC, savedlocale[0])
        if result1 != result2:
            return True
    return False

class Projection(BaseProjection):
    """A proj4 projection object that remembers the parameters.

    The proj library is not robust against decimal_point != '.' locales.
    Since python 2.4 calls C extensions with the set locale, it can create
    a problem.  It seems that calling
        self.assuregoodlocale()
        self.assureinitlocale()
    before BaseProjection.__init__() is enough to work around this.

    We assuming that the locale stays the same after a projection
    has been initialised 
    and thus we can return to it in self.assureinitlocale().
    """

    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 projection. If None or omitted
                it defaults to 'Unknown' in the local language.

        epsg -- (optional) The EPSG code as a string.
        """
        self.initlocale = locale.getlocale(locale.LC_NUMERIC)
        self.work_around_broken_proj = _do_we_have_to_work_around_broken_proj()

        self.assuregoodlocale()
        BaseProjection.__init__(self, params)
        self.assureinitlocale()

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

        self.epsg = epsg
        self.params = params

    def assuregoodlocale(self):
        if self.work_around_broken_proj:
            locale.setlocale(locale.LC_NUMERIC, "C")

    def assureinitlocale(self):
        if self.work_around_broken_proj:
            locale.setlocale(locale.LC_NUMERIC, self.initlocale)

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

    def ForwardBBox(self, bbox):
        """Return the bounding box of the corners of the bounding box bbox
        """
        return self._transform_bbox(self.Forward, bbox)

    def InverseBBox(self, bbox):
        return self._transform_bbox(self.Inverse, bbox)

    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") in [ 'latlong', 'longlat' ]:
            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	bernhard	2698	# Copyright (c) 2001, 2003, 2006 by Intevation GmbH
2	bh	6	# Authors:
3			# Bernhard Herzog <[email protected]>
4	bernhard	2698	# Bernhard Reiter <[email protected]>
5	bh	6	#
6			# This program is free software under the GPL (>=v2)
7			# Read the file COPYING coming with Thuban for details.
8			__version__ = "$Revision$"
9
10	bh	1824	from types import StringTypes
11	bernhard	2698	import locale
12	bh	1824
13	jonathan	745	from Thuban import _
14	bh	1824	from Thuban.Lib.connector import Publisher
15	jonathan	745
16	bh	6	import Projection
17			BaseProjection = Projection.Projection
18			del Projection
19
20	bh	1824	from messages import PROJECTION_ADDED, PROJECTION_REPLACED, PROJECTION_REMOVED
21
22	jonathan	1250	PROJ_UNITS_METERS = 1
23			PROJ_UNITS_DEGREES = 2
24
25	bernhard	2698	def _do_we_have_to_work_around_broken_proj():
26			""" If we have a problematic locale, check if proj results are good. """
27			if locale.localeconv()['decimal_point'] != '.':
28			params = ["proj=latlong", "to_meter=0.01745", "ellps=clrk66"]
29			proj = BaseProjection(params)
30			result1 = proj.Forward(1,1)
31
32			savedlocale = locale.getlocale(locale.LC_NUMERIC)
33			locale.setlocale(locale.LC_NUMERIC, "C")
34
35			proj = BaseProjection(params)
36			result2 = proj.Forward(1,1)
37
38	bernhard	2708	try:
39			locale.setlocale(locale.LC_NUMERIC, savedlocale)
40			except:
41			# python under some circumstances (observed 2.3.5-2 Debian Sarge)
42			# does not accept savedlocale directly
43			# deviating from the documentation
44			locale.setlocale(locale.LC_NUMERIC, savedlocale[0])
45	bernhard	2698	if result1 != result2:
46			return True
47			return False
48
49	bh	6	class Projection(BaseProjection):
50	bernhard	2698	"""A proj4 projection object that remembers the parameters.
51	bh	6
52	bernhard	2699	The proj library is not robust against decimal_point != '.' locales.
53			Since python 2.4 calls C extensions with the set locale, it can create
54			a problem. It seems that calling
55	bernhard	2698	self.assuregoodlocale()
56			self.assureinitlocale()
57	bernhard	2699	before BaseProjection.__init__() is enough to work around this.
58	bh	6
59	bernhard	2698	We assuming that the locale stays the same after a projection
60			has been initialised
61			and thus we can return to it in self.assureinitlocale().
62			"""
63
64	bh	1815	def __init__(self, params, name = None, epsg = None):
65			"""Initialize the Projection
66
67			Parameters:
68
69			params -- a list of 'parameter=value' strings
70
71	bernhard	2698	name -- (optional) The name of the projection. If None or omitted
72	bh	1815	it defaults to 'Unknown' in the local language.
73
74			epsg -- (optional) The EPSG code as a string.
75	jonathan	745	"""
76	bernhard	2698	self.initlocale = locale.getlocale(locale.LC_NUMERIC)
77			self.work_around_broken_proj = _do_we_have_to_work_around_broken_proj()
78
79			self.assuregoodlocale()
80	bh	6	BaseProjection.__init__(self, params)
81	bernhard	2698	self.assureinitlocale()
82	jonathan	745
83	jonathan	758	if name is None:
84			self.name = _("Unknown")
85			elif isinstance(name, StringTypes):
86			self.name = name
87	jonathan	745
88	bh	1815	self.epsg = epsg
89	jonathan	758	self.params = params
90
91	bernhard	2698	def assuregoodlocale(self):
92			if self.work_around_broken_proj:
93			locale.setlocale(locale.LC_NUMERIC, "C")
94
95			def assureinitlocale(self):
96			if self.work_around_broken_proj:
97			locale.setlocale(locale.LC_NUMERIC, self.initlocale)
98
99	bh	1982	def _transform_bbox(self, trafo, bbox):
100	bh	6	# This is not really the correct way to determine the bbox of a
101	bh	1982	# projected bbox, but for now it works well enough
102	bh	6	llx, lly, urx, ury = bbox
103			xs = []; ys = []
104	bh	1982	for x, y in ((llx, lly), (llx, ury), (urx, lly), (urx, ury)):
105			x, y = trafo(x, y)
106			xs.append(x); ys.append(y)
107	bh	6	return min(xs), min(ys), max(xs), max(ys)
108	jonathan	695
109	bh	1982	def ForwardBBox(self, bbox):
110			"""Return the bounding box of the corners of the bounding box bbox
111			"""
112			return self._transform_bbox(self.Forward, bbox)
113
114			def InverseBBox(self, bbox):
115			return self._transform_bbox(self.Inverse, bbox)
116
117	jonathan	695	def GetName(self):
118	jonathan	738	"""Return the name of the projection."""
119	jonathan	695	return self.name
120
121	bh	1815	def Label(self):
122			if self.epsg:
123			return "EPSG % 5s %s" % (self.epsg, self.name)
124			return self.name
125
126			def EPSGCode(self):
127			"""Return the EPSG code as a string or None if there is none"""
128			return self.epsg
129
130	jonathan	708	def GetParameter(self, param):
131	jonathan	738	"""Return the projection value for the given parameter.
132	jonathan	708
133	bh	1797	If 'param' exists as a valid parameter return the associated
134			value as a string. If the parameter does not have a value (like
135			e.g. the 'south' parameter for utm) then the value is the
136			parameter name itself.
137
138			If the parameter doesn't exist return an empty string.
139	jonathan	738	"""
140
141	jonathan	708	for pair in self.params:
142	bh	1797	if "=" in pair:
143			p, v = pair.split("=")
144			else:
145			p = v = pair
146	jonathan	708	if p == param:
147			return v
148
149			return ""
150
151			def GetAllParameters(self):
152	jonathan	738	"""Return list of 'parameter=value' strings"""
153	jonathan	695	return self.params
154
155	jonathan	1250	def GetProjectedUnits(self):
156	jan	1860	if self.GetParameter("proj") in [ 'latlong', 'longlat' ]:
157	jonathan	1250	return PROJ_UNITS_DEGREES
158			else:
159			return PROJ_UNITS_METERS
160
161	jonathan	695	def __repr__(self):
162	jonathan	726	return self.name + ": " + repr(self.params)
163	jonathan	695
164	bh	1815
165	bh	1824	class ProjFile(Publisher):
166	jonathan	695
167			def __init__(self, filename):
168	jonathan	738	"""Intialize the ProjFile.
169	jonathan	695
170	jonathan	738	filename -- name of the file that this ProjFile represents.
171			"""
172
173			self.__projs = []
174
175			self.SetFilename(filename)
176	bh	1824
177	jonathan	695	def Add(self, proj):
178	bh	1802	"""Add the projection to the end of the file."""
179			self.__projs.append(proj)
180	bh	1824	self.issue(PROJECTION_ADDED, proj)
181	jonathan	695
182	jonathan	726	def Remove(self, proj):
183	jonathan	758	"""Remove the object proj from the projection file.
184	jonathan	726
185	jonathan	738	Raises a ValueError is proj is not found.
186			"""
187			self.__projs.remove(proj)
188	bh	1824	self.issue(PROJECTION_REMOVED, proj)
189	jonathan	695
190	jonathan	758	def Replace(self, oldproj, newproj):
191			"""Replace the object 'oldproj' with 'newproj'.
192	bh	1824
193	jonathan	758	Raises ValueError if oldproj is not in the file.
194			"""
195			self.__projs[self.__projs.index(oldproj)] = newproj
196	bh	1824	self.issue(PROJECTION_REPLACED, oldproj, newproj)
197	jonathan	758
198	jonathan	738	def GetFilename(self):
199			"""Return the filename where the ProjFile was read or will be
200			written to.
201			"""
202
203			return self.__filename
204
205			def SetFilename(self, filename):
206			"""Set the filename where the ProjFile will be written to."""
207			self.__filename = filename
208
209	jonathan	695	def GetProjections(self):
210	jonathan	738	"""Return a list of the projections in the order they were read
211			from the file or will be written.
212
213			This is not a deep copy list, so any modifications made to the
214			Projection objects will be written to the file.
215			"""
216
217			return self.__projs
218
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision