Thuban/Model/resource.py

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

"""Handle resources loaded from files such as projections"""

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


import os
import os.path
import weakref

import Thuban
from Thuban import _

from Thuban.Lib.fileutil import get_application_dir

from Thuban.Model.xmlreader import XMLReader
from Thuban.Model.xmlwriter import XMLWriter
from Thuban.Model.proj import Projection, ProjFile
from xml.sax import SAXParseException

projdir = \
        os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Projections")


PROJ_EXT = ".proj"

has_gdal_support = lambda: False
try:
    # first try to see if our extension module is there. if it 
    # wasn't even compiled, we obviously don't have gdal support.
    import gdalwarp

    # now try to import the python extension. if this doesn't
    # exist then we can't do anything.
    import gdal

    """Return True if the gdal library is available."""
    has_gdal_support = lambda: True
except ImportError:
    pass

projfile_cache = weakref.WeakValueDictionary()

def clear_proj_file_cache():
    """Clear the cache of ProjFile objects maintained by read_proj_file.

    This function is probably only useful for the test suite.
    """
    projfile_cache.clear()

def read_proj_file(filename):
    """Read a .proj file and return a ProjFile object and warnings

    The return value is a tuple with the ProjFile object and a list of
    strings with warnings messages that might have been generated by the
    proj file parser.

    The objects returned cached so that reading the same file
    (identified by its absolute name) several times yields the same
    ProjFile object. The cache uses weak references so the objects will
    be removed from the cache once the last reference an object in the
    cache is removed.

    Raises IOError if the file cannot be opened, OSError if the file
    cannot be read and SAXParseException if the file is not valid XML.
    """
    filename = os.path.abspath(filename)
    if filename in projfile_cache:
        return projfile_cache[filename], []
    else:
        handler = ProjFileReader()
        handler.read(filename)
        proj_file = handler.GetProjFile()
        projfile_cache[filename] = proj_file
        return proj_file, handler.GetWarnings()

def write_proj_file(pf):
    """Write a single .proj file

    Raises IOError if the file cannot be written.
    """

    saver = ProjFileSaver(pf)
    saver.write(pf.GetFilename())

#
# Constants for the get_system_proj_file function
#

# The default projection file with a few predefined projections
DEFAULT_PROJ_FILE = "defaults.proj"

# The epsg projections.
EPSG_PROJ_FILE = "epsg.proj"

# Deprecated EPSG projections.
EPSG_DEPRECATED_PROJ_FILE = "epsg-deprecated.proj"

def get_system_proj_file(filename):
    """Return the projections from the indicated file and a list with warnings

    The filename argument should be the name of a file in the directory
    with Thuban's default projection files (Resources/Projections/). If
    possible callers should not use hardwired string literal for the
    name to avoid unnecessary duplication. Instead they should use one
    of the predefined constants, currently DEFAULT_PROJ_FILE,
    EPSG_PROJ_FILE or EPSG_DEPRECATED_PROJ_FILE.

    The return value is a tuple with the projections in a ProjFile
    object and a list of strings with warning messages. The warnings
    list is usually empty but may contain messages about ignored errors.

    If the file could could not be opened return an empty projection
    file object set to store data in the indicated default file.
    """
    fullname = os.path.join(projdir, filename)
    try:
        return read_proj_file(fullname)
    except (OSError, IOError, SAXParseException), val:
        msg = _('Could not read "%s": %s') % (fullname, str(val))
        return ProjFile(fullname), [msg]

def get_user_proj_file():
    """Return the user's projections and a list with warnings

    The projections read from the user's thuban projection file (usually
    in ~/.thuban/user.proj). The return value is a tuple with the
    projections in a ProjFile object and a list of strings with warning
    messages. The warnings list is usually empty but may contain
    messages about ignored errors.

    If the file could could not be opened return an empty projection
    file object set to store data in the default file.
    """
    usrdir  = get_application_dir()
    filename = os.path.join(usrdir, "user.proj")
    try:
        return read_proj_file(filename)
    except (OSError, IOError, SAXParseException), val:
        msg = _('Could not read "%s": %s') % (filename, str(val))
        return ProjFile(filename), [msg]


class ProjFileReader(XMLReader):

    def __init__(self):
        XMLReader.__init__(self)
        self.projfile = ProjFile("")
        self.warnings = []

        XMLReader.AddDispatchers(self,
            {'projection': ("start_projection", "end_projection"),
             'parameter':  ("start_parameter", None)})

    def read(self, file_or_filename):
        XMLReader.read(self, file_or_filename)

        self.projfile.SetFilename(XMLReader.GetFilename(self))

    def start_projection(self, name, qname, attrs):
        self.params = []
        name = self.encode(attrs.get((None, 'name')))
        if name is None:
            name = _("Unknown")
        self.name = name
        self.epsg = self.encode(attrs.get((None, 'epsg')))

    def end_projection(self, name, qname):
        try:
            proj = Projection(self.params, self.name, epsg = self.epsg)
        except IOError, val:
            self.warnings.append(_('Error in projection "%s": %s')
                                 % (self.name, str(val)))
        else:
            self.projfile.Add(proj)

    def start_parameter(self, name, qname, attrs):
        s = attrs.get((None, 'value'))
        s = str(s) # we can't handle unicode in proj
        self.params.append(s)

    def GetProjFile(self):
        return self.projfile

    def GetWarnings(self):
        """Return the list of warning messages that may have been produced"""
        return self.warnings


class ProjFileSaver(XMLWriter):

    def __init__(self, pf):
        XMLWriter.__init__(self)
        self.__pf = pf

    def write(self, file_or_filename):
        XMLWriter.write(self, file_or_filename)

        self.write_header("projectionlist", "projfile.dtd")
        self.write_projfile(self.__pf)
        self.close()

    def write_projfile(self, pf):

        self.open_element("projectionlist")

        for p in pf.GetProjections():
            attrs = {"name": p.GetName()}
            if p.EPSGCode():
                attrs["epsg"] = p.EPSGCode()
            self.open_element("projection", attrs)

            for param in p.GetAllParameters():
                self.write_element("parameter", {"value": param})

            self.close_element("projection")

        self.close_element("projectionlist")


1	# Copyright (c) 2003 by Intevation GmbH
2	# Authors:
3	# Jonathan Coles <[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	"""Handle resources loaded from files such as projections"""
9
10	__version__ = "$Revision$"
11	# $Source$
12	# $Id$
13
14
15	import os
16	import os.path
17	import weakref
18
19	import Thuban
20	from Thuban import _
21
22	from Thuban.Lib.fileutil import get_application_dir
23
24	from Thuban.Model.xmlreader import XMLReader
25	from Thuban.Model.xmlwriter import XMLWriter
26	from Thuban.Model.proj import Projection, ProjFile
27	from xml.sax import SAXParseException
28
29	projdir = \
30	os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Projections")
31
32
33	PROJ_EXT = ".proj"
34
35	has_gdal_support = lambda: False
36	try:
37	# first try to see if our extension module is there. if it
38	# wasn't even compiled, we obviously don't have gdal support.
39	import gdalwarp
40
41	# now try to import the python extension. if this doesn't
42	# exist then we can't do anything.
43	import gdal
44
45	"""Return True if the gdal library is available."""
46	has_gdal_support = lambda: True
47	except ImportError:
48	pass
49
50	projfile_cache = weakref.WeakValueDictionary()
51
52	def clear_proj_file_cache():
53	"""Clear the cache of ProjFile objects maintained by read_proj_file.
54
55	This function is probably only useful for the test suite.
56	"""
57	projfile_cache.clear()
58
59	def read_proj_file(filename):
60	"""Read a .proj file and return a ProjFile object and warnings
61
62	The return value is a tuple with the ProjFile object and a list of
63	strings with warnings messages that might have been generated by the
64	proj file parser.
65
66	The objects returned cached so that reading the same file
67	(identified by its absolute name) several times yields the same
68	ProjFile object. The cache uses weak references so the objects will
69	be removed from the cache once the last reference an object in the
70	cache is removed.
71
72	Raises IOError if the file cannot be opened, OSError if the file
73	cannot be read and SAXParseException if the file is not valid XML.
74	"""
75	filename = os.path.abspath(filename)
76	if filename in projfile_cache:
77	return projfile_cache[filename], []
78	else:
79	handler = ProjFileReader()
80	handler.read(filename)
81	proj_file = handler.GetProjFile()
82	projfile_cache[filename] = proj_file
83	return proj_file, handler.GetWarnings()
84
85	def write_proj_file(pf):
86	"""Write a single .proj file
87
88	Raises IOError if the file cannot be written.
89	"""
90
91	saver = ProjFileSaver(pf)
92	saver.write(pf.GetFilename())
93
94	#
95	# Constants for the get_system_proj_file function
96	#
97
98	# The default projection file with a few predefined projections
99	DEFAULT_PROJ_FILE = "defaults.proj"
100
101	# The epsg projections.
102	EPSG_PROJ_FILE = "epsg.proj"
103
104	# Deprecated EPSG projections.
105	EPSG_DEPRECATED_PROJ_FILE = "epsg-deprecated.proj"
106
107	def get_system_proj_file(filename):
108	"""Return the projections from the indicated file and a list with warnings
109
110	The filename argument should be the name of a file in the directory
111	with Thuban's default projection files (Resources/Projections/). If
112	possible callers should not use hardwired string literal for the
113	name to avoid unnecessary duplication. Instead they should use one
114	of the predefined constants, currently DEFAULT_PROJ_FILE,
115	EPSG_PROJ_FILE or EPSG_DEPRECATED_PROJ_FILE.
116
117	The return value is a tuple with the projections in a ProjFile
118	object and a list of strings with warning messages. The warnings
119	list is usually empty but may contain messages about ignored errors.
120
121	If the file could could not be opened return an empty projection
122	file object set to store data in the indicated default file.
123	"""
124	fullname = os.path.join(projdir, filename)
125	try:
126	return read_proj_file(fullname)
127	except (OSError, IOError, SAXParseException), val:
128	msg = _('Could not read "%s": %s') % (fullname, str(val))
129	return ProjFile(fullname), [msg]
130
131	def get_user_proj_file():
132	"""Return the user's projections and a list with warnings
133
134	The projections read from the user's thuban projection file (usually
135	in ~/.thuban/user.proj). The return value is a tuple with the
136	projections in a ProjFile object and a list of strings with warning
137	messages. The warnings list is usually empty but may contain
138	messages about ignored errors.
139
140	If the file could could not be opened return an empty projection
141	file object set to store data in the default file.
142	"""
143	usrdir = get_application_dir()
144	filename = os.path.join(usrdir, "user.proj")
145	try:
146	return read_proj_file(filename)
147	except (OSError, IOError, SAXParseException), val:
148	msg = _('Could not read "%s": %s') % (filename, str(val))
149	return ProjFile(filename), [msg]
150
151
152	class ProjFileReader(XMLReader):
153
154	def __init__(self):
155	XMLReader.__init__(self)
156	self.projfile = ProjFile("")
157	self.warnings = []
158
159	XMLReader.AddDispatchers(self,
160	{'projection': ("start_projection", "end_projection"),
161	'parameter': ("start_parameter", None)})
162
163	def read(self, file_or_filename):
164	XMLReader.read(self, file_or_filename)
165
166	self.projfile.SetFilename(XMLReader.GetFilename(self))
167
168	def start_projection(self, name, qname, attrs):
169	self.params = []
170	name = self.encode(attrs.get((None, 'name')))
171	if name is None:
172	name = _("Unknown")
173	self.name = name
174	self.epsg = self.encode(attrs.get((None, 'epsg')))
175
176	def end_projection(self, name, qname):
177	try:
178	proj = Projection(self.params, self.name, epsg = self.epsg)
179	except IOError, val:
180	self.warnings.append(_('Error in projection "%s": %s')
181	% (self.name, str(val)))
182	else:
183	self.projfile.Add(proj)
184
185	def start_parameter(self, name, qname, attrs):
186	s = attrs.get((None, 'value'))
187	s = str(s) # we can't handle unicode in proj
188	self.params.append(s)
189
190	def GetProjFile(self):
191	return self.projfile
192
193	def GetWarnings(self):
194	"""Return the list of warning messages that may have been produced"""
195	return self.warnings
196
197
198	class ProjFileSaver(XMLWriter):
199
200	def __init__(self, pf):
201	XMLWriter.__init__(self)
202	self.__pf = pf
203
204	def write(self, file_or_filename):
205	XMLWriter.write(self, file_or_filename)
206
207	self.write_header("projectionlist", "projfile.dtd")
208	self.write_projfile(self.__pf)
209	self.close()
210
211	def write_projfile(self, pf):
212
213	self.open_element("projectionlist")
214
215	for p in pf.GetProjections():
216	attrs = {"name": p.GetName()}
217	if p.EPSGCode():
218	attrs["epsg"] = p.EPSGCode()
219	self.open_element("projection", attrs)
220
221	for param in p.GetAllParameters():
222	self.write_element("parameter", {"value": param})
223
224	self.close_element("projection")
225
226	self.close_element("projectionlist")
227
228
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision