Extensions/importAPR/importAPR.py

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

"""
Import a ArcView project file (.apr) and convert it
to Thuban.
"""

__version__ = "$Revision$"

import os, sys

from math import ceil
from types import StringType

from wxPython.wx import *

from Thuban.Model.extension import Extension
from Thuban.Model.base import TitledObject, Modifiable
from Thuban.UI.command import registry, Command
import Thuban.UI.mainwindow
from Thuban import _
from Thuban.Model.layer import Layer
from Thuban.Model.classification import ClassGroupRange, ClassGroupProperties,\
                                        ClassGroupSingleton

from odb import ODBBaseObject
from apr import APR_LClass, APR_TClr

class ODBExtension(Extension):
    def TreeInfo(self):
        return (_("Extension: %s") % self.title,
                [ object.TreeInfo() for object in self.objects ])

class APR_BLnSym(ODBBaseObject):
    _obj_refs = [ 'Color' ]
    _values = [ 'Width', 'Pattern' ]

    def GetThubanProp(self):
        """Create a Thuban ClassGroupProperty from this object and
        return it.
        """
        prop = ClassGroupProperties()
        prop.SetLineColor(self.Get('Color').GetThubanColor())
        prop.SetLineWidth(int(ceil(float(self.Get('Width')))))
        return prop

class APR_BMkSym(ODBBaseObject):
    _obj_refs = [ 'Color', 'BgColor' ]
    _values = [ 'Angle', 'Size' ]

    def GetThubanProp(self):
        """Create a Thuban ClassGroupProperty from this object and
        return it.

        In Thuban, the points have all the same size,
        but we can vary the width of the line.
        """
        prop = ClassGroupProperties()
        prop.SetLineWidth(int(ceil(float(self.Get('Size')))))
        prop.SetLineColor(self.Get('Color').GetThubanColor())
        prop.SetFill(self.Get('BgColor').GetThubanColor())
        return prop

class APR_BShSym(ODBBaseObject):
    _obj_refs = [ 'Color', 'OutlineColor', 'BgColor' ]
    _values = [ 'OutlineWidth' ]

    def GetThubanProp(self):
        """Create a Thuban ClassGroupProperty from this object and
        return it.
        """
        prop = ClassGroupProperties()
        # Don't know what BgColor is good for
        prop.SetLineWidth(int(ceil(float(self.Get('OutlineWidth')))))
        prop.SetLineColor(self.Get('OutlineColor').GetThubanColor())
        prop.SetFill(self.Get('Color').GetThubanColor())
        return prop

class APR_FTheme(ODBBaseObject):
    _obj_refs = [ 'Source', 'Legend' ]

class APR_Legend(ODBBaseObject):
    """Legend object.
    There could one or more Class objects. Each class corresponds to a
    Child in the Symbols.
    """
    _obj_refs = [ 'FieldNames', 'Symbols', 'Class', 'NullSym',
                  'NullValues', 'StatValues' ]

class APR_Project(ODBBaseObject):
    _obj_refs = [ 'Doc' ]

class APR_ShpSrc(ODBBaseObject):
    _obj_refs = [ 'Name' ]

class APR_SrcName(ODBBaseObject):
    _obj_refs = [ 'FileName' ]

class APR_SymList(ODBBaseObject):
    _obj_refs = [ 'Child' ]

class APR_View(ODBBaseObject):
    _obj_refs = [ 'Theme' ]

class ODB(TitledObject, Modifiable):

    def __init__(self):
        TitledObject.__init__(self, 'ODB Object')
        self._objects = {}
        self._version = None
        self._filename = None
        self.name = None # required for Thuban.model.extension.Extension

    def SetFileName(self, fname):
        self._filename = fname
        self.name = fname

    def AddObject(self, object):
        self._objects[object.number] = object

    def GetObjects(self):
        return self._objects

    def GetProject(self):
        """Return the main Root if it is a Project, else None."""
        # it is assumed that the first object is the ODB object
        if self._objects[1].type != 'ODB':
            return None
        if self._objects[1].FirstRootClassName != 'Project':
            return None

        # it is assumed that the second object is the first root
        o = self._objects[2]
        if o.type != 'Project':
            return None
        return o

    def TreeInfo(self):
        items = []
        items.append(_('Format version: %s') % self._version)
        p = self.GetProject()
        items.append(_('Project Name: %s') % p.Name)
        for doc in p.Get('Doc'):
            items.append(doc.TreeInfo())
        return [_("ODB File '%s'" % self._filename), items]

def parse_apr(fname):
    """Load a ArcView project file.

    fname  -- Filename of the .apr file

    Return: the ODB class object.
    """
    odb = ODB()
    odb.SetFileName(fname)

    apr = open(fname, 'r').readlines()

    # get the version from the first line (eg. from "/3.1")
    odb._version = apr.pop(0)[1:]

    i = 0
    in_object = False
    for line in apr:
        i += 1
        if line[0] == '(':
            line = line[1:]
            type, number = line.split('.')
            number = int(number)
            class_name = 'APR_' + type
            try:
                clazz = eval(class_name)
                object = clazz(odb, type, number)
            except:
                object = ODBBaseObject(odb, type, number)
            in_object = True
            continue
        if line[0] == ')':
            in_object = False
            odb.AddObject(object)
        if in_object:
            line = line.strip()
            if len(line) == 0: continue
            try:
                property, value = line.split(':', 1)
                property = property.strip()
                value = value.strip()
            except:
                print "Error in line %d:" % i, line
                continue
            if value[0] == '"':
                value = value[1:-1]
            setattr(object, property, value)
    return odb

def import_apr_dialog(context):
    """Request filename from user and run importing of apr file.

    context -- The Thuban context.
    """
    dlg = wxFileDialog(context.mainwindow,
                       _("Select APR file"), ".", "",
                       _("ArcView Project Files (*.apr)|*.apr|") +
                       _("All Files (*.*)|*.*"),
                       wxOPEN|wxOVERWRITE_PROMPT)
    if dlg.ShowModal() == wxID_OK:
        filename = dlg.GetPath()
        dlg.Destroy()
    else:
        return

    odb = parse_apr(filename)
    if odb is None:
        context.mainwindow.RunMessageBox(_("Import APR"), _("Loading failed"))
        return
    else:
        context.mainwindow.RunMessageBox(_("Import APR"),
                                         _("%d objects loaded" % 
                                            len(odb.GetObjects().keys())))

    # find the views of the APR file
    views = {}
    p = odb.GetProject()
    for doc in p.Get('Doc'):
        if doc.type != 'View':
            continue
        views[doc.Name] = doc

    # it is possible that a APR file has no view at all
    if len(views) == 0:
        context.mainwindow.RunMessageBox(_("Import APR"),
                _("No view found in APR file"))
        return

    # let the user select one of the views
    if len(views) > 1:
        titles = views.keys()
        dlg = wxSingleChoiceDialog(context.mainwindow,
                                   _('Pick a View to import:'),
                                   _('Import APR'), titles,
                                   style = wxDEFAULT_DIALOG_STYLE | 
                                           wxRESIZE_BORDER)
        if dlg.ShowModal() == wxID_OK:
            view = views[views.keys()[dlg.GetSelection()]]
        else:
            return
    else:
        view = views[views.keys()[0]]

    # load the themes of the View as layers into Thuban
    count_theme = 0
    count_theme_fail = 0
    for theme in view.Get('Theme'):
        if theme.type !=  'FTheme':
            continue
        count_theme += 1
        filename = theme.Get('Source').Get('Name').Get('FileName').Path
        try:
            store = context.application.Session().OpenShapefile(filename)
        except IOError:
            # the layer couldn't be opened
            context.mainwindow.RunMessageBox(_('Add Layer'),
                           _("Can't open the file '%s'.") % filename)
            count_theme_fail += 1
        else:
            title = theme.Name
            apr_legend = theme.Get('Legend')

            map = context.mainwindow.canvas.Map()

            # create layer
            layer = Layer(title, store)

            # set the field for classification (if there is one in the apr)
            if hasattr(apr_legend, 'FieldNames'):
                apr_fieldname = apr_legend.Get('FieldNames').S
                # unfortunately, the APR file does not store the actual
                # Name of the column, but always makes the first character
                # a capital letter, the rest lower case.
                # Therefore, we have to search through the table of the
                # layer to find out the correct spelling.
                table_columns = layer.ShapeStore().Table().Columns()
                for column in table_columns:
                    if apr_fieldname.lower() == column.name.lower():
                        layer.SetClassificationColumn(column.name)
                        break

            clazz = layer.GetClassification()
            apr_classes = apr_legend.Get('Class')
            if not isinstance(apr_classes, list):
                apr_classes = [ apr_classes ]
            apr_symbols = apr_legend.Get('Symbols').Get('Child')
            if not isinstance(apr_symbols, list):
                apr_symbols = [ apr_symbols ]
            i = -1
            for symbol in apr_symbols:
                i += 1

                if hasattr(apr_classes[i], 'IsNoData'):
                    group = clazz.GetDefaultGroup()
                    group.SetLabel(apr_classes[i].Label)
                    continue

                # create a new group property from the symbol
                prop = symbol.GetThubanProp()

                # build range
                range = apr_classes[i].GetThubanRange()

                if isinstance(range, StringType):
                    new_group = ClassGroupSingleton(value = range,
                                    props = prop,
                                    label = apr_classes[i].GetLabel())
                else:
                    new_group = ClassGroupRange(_range = range,
                                    props = prop,
                                    label = apr_classes[i].GetLabel())
                clazz.AppendGroup(new_group)

            map.AddLayer(layer)

    map.SetTitle(view.Name)

    # fit the new map to the window
    context.mainwindow.canvas.FitMapToWindow()

    context.mainwindow.RunMessageBox(_('Import APR'),
        _('Imported %d out of %d themes of view "%s" ...') % \
            (count_theme - count_theme_fail, count_theme, view.Name))

    # import_apr as an extension to Thuban
    if context.session.HasExtensions():
        for ext in context.session.Extensions():
            if ext.Title() == apr_import_extension.Title():
                ext.AddObject(odb)
                return

    # no extension found, so lets make a new
    context.session.AddExtension(apr_import_extension)
    apr_import_extension.AddObject(odb)

if __name__ == "__main__": # import_apr executed as a command line tool
    if len(sys.argv) == 2:
        odb = parse_apr(sys.argv[1])
        print "%d objects loaded" % len(odb.GetObjects().keys())

        def print_structured_list(lst, indent = ''):
            for item in lst:
                if isinstance(item, StringType):
                    print indent + item
                elif isinstance(item, list):
                    print_structured_list(item, indent + ' ')

        print_structured_list(odb.TreeInfo())
        sys.exit(0)
    else:
        print 'usage: %s apr-file' % sys.argv[0]
        sys.exit(1)

apr_import_extension = ODBExtension('APR Import')

# register the new command
registry.Add(Command('import-apr', _('Import apr-file...'), import_apr_dialog,
                         helptext = _('Import a ArcView project file')))

# find the experimental menu (create it anew if not found)
main_menu = Thuban.UI.mainwindow.main_menu
experimental_menu = main_menu.find_menu('experimental')
if experimental_menu is None:
    experimental_menu = main_menu.InsertMenu('experimental', _('Experimenta&l'))

# finally add the new entry to the experimental menu
experimental_menu.InsertItem('import-apr')
1	jan	1728	# Copyright (C) 2003 by Intevation GmbH
2			# Authors:
3			# Jan-Oliver Wagner <[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			"""
9			Import a ArcView project file (.apr) and convert it
10			to Thuban.
11			"""
12
13			__version__ = "$Revision$"
14
15			import os, sys
16
17			from math import ceil
18			from types import StringType
19
20			from wxPython.wx import *
21
22			from Thuban.Model.extension import Extension
23			from Thuban.Model.base import TitledObject, Modifiable
24			from Thuban.UI.command import registry, Command
25			import Thuban.UI.mainwindow
26			from Thuban import _
27			from Thuban.Model.layer import Layer
28			from Thuban.Model.classification import ClassGroupRange, ClassGroupProperties,\
29			ClassGroupSingleton
30
31			from odb import ODBBaseObject
32			from apr import APR_LClass, APR_TClr
33
34			class ODBExtension(Extension):
35			def TreeInfo(self):
36			return (_("Extension: %s") % self.title,
37			[ object.TreeInfo() for object in self.objects ])
38
39			class APR_BLnSym(ODBBaseObject):
40			_obj_refs = [ 'Color' ]
41			_values = [ 'Width', 'Pattern' ]
42
43			def GetThubanProp(self):
44			"""Create a Thuban ClassGroupProperty from this object and
45			return it.
46			"""
47			prop = ClassGroupProperties()
48			prop.SetLineColor(self.Get('Color').GetThubanColor())
49			prop.SetLineWidth(int(ceil(float(self.Get('Width')))))
50			return prop
51
52			class APR_BMkSym(ODBBaseObject):
53			_obj_refs = [ 'Color', 'BgColor' ]
54			_values = [ 'Angle', 'Size' ]
55
56			def GetThubanProp(self):
57			"""Create a Thuban ClassGroupProperty from this object and
58			return it.
59
60			In Thuban, the points have all the same size,
61			but we can vary the width of the line.
62			"""
63			prop = ClassGroupProperties()
64			prop.SetLineWidth(int(ceil(float(self.Get('Size')))))
65			prop.SetLineColor(self.Get('Color').GetThubanColor())
66			prop.SetFill(self.Get('BgColor').GetThubanColor())
67			return prop
68
69			class APR_BShSym(ODBBaseObject):
70			_obj_refs = [ 'Color', 'OutlineColor', 'BgColor' ]
71			_values = [ 'OutlineWidth' ]
72
73			def GetThubanProp(self):
74			"""Create a Thuban ClassGroupProperty from this object and
75			return it.
76			"""
77			prop = ClassGroupProperties()
78			# Don't know what BgColor is good for
79			prop.SetLineWidth(int(ceil(float(self.Get('OutlineWidth')))))
80			prop.SetLineColor(self.Get('OutlineColor').GetThubanColor())
81			prop.SetFill(self.Get('Color').GetThubanColor())
82			return prop
83
84			class APR_FTheme(ODBBaseObject):
85			_obj_refs = [ 'Source', 'Legend' ]
86
87			class APR_Legend(ODBBaseObject):
88			"""Legend object.
89			There could one or more Class objects. Each class corresponds to a
90			Child in the Symbols.
91			"""
92			_obj_refs = [ 'FieldNames', 'Symbols', 'Class', 'NullSym',
93			'NullValues', 'StatValues' ]
94
95			class APR_Project(ODBBaseObject):
96			_obj_refs = [ 'Doc' ]
97
98			class APR_ShpSrc(ODBBaseObject):
99			_obj_refs = [ 'Name' ]
100
101			class APR_SrcName(ODBBaseObject):
102			_obj_refs = [ 'FileName' ]
103
104			class APR_SymList(ODBBaseObject):
105			_obj_refs = [ 'Child' ]
106
107			class APR_View(ODBBaseObject):
108			_obj_refs = [ 'Theme' ]
109
110			class ODB(TitledObject, Modifiable):
111
112			def __init__(self):
113			TitledObject.__init__(self, 'ODB Object')
114			self._objects = {}
115			self._version = None
116			self._filename = None
117			self.name = None # required for Thuban.model.extension.Extension
118
119			def SetFileName(self, fname):
120			self._filename = fname
121			self.name = fname
122
123			def AddObject(self, object):
124			self._objects[object.number] = object
125
126			def GetObjects(self):
127			return self._objects
128
129			def GetProject(self):
130			"""Return the main Root if it is a Project, else None."""
131			# it is assumed that the first object is the ODB object
132			if self._objects[1].type != 'ODB':
133			return None
134			if self._objects[1].FirstRootClassName != 'Project':
135			return None
136
137			# it is assumed that the second object is the first root
138			o = self._objects[2]
139			if o.type != 'Project':
140			return None
141			return o
142
143			def TreeInfo(self):
144			items = []
145			items.append(_('Format version: %s') % self._version)
146			p = self.GetProject()
147			items.append(_('Project Name: %s') % p.Name)
148			for doc in p.Get('Doc'):
149			items.append(doc.TreeInfo())
150			return [_("ODB File '%s'" % self._filename), items]
151
152			def parse_apr(fname):
153			"""Load a ArcView project file.
154
155			fname -- Filename of the .apr file
156
157			Return: the ODB class object.
158			"""
159			odb = ODB()
160			odb.SetFileName(fname)
161
162			apr = open(fname, 'r').readlines()
163
164			# get the version from the first line (eg. from "/3.1")
165			odb._version = apr.pop(0)[1:]
166
167			i = 0
168			in_object = False
169			for line in apr:
170			i += 1
171			if line[0] == '(':
172			line = line[1:]
173			type, number = line.split('.')
174			number = int(number)
175			class_name = 'APR_' + type
176			try:
177			clazz = eval(class_name)
178			object = clazz(odb, type, number)
179			except:
180			object = ODBBaseObject(odb, type, number)
181			in_object = True
182			continue
183			if line[0] == ')':
184			in_object = False
185			odb.AddObject(object)
186			if in_object:
187			line = line.strip()
188			if len(line) == 0: continue
189			try:
190			property, value = line.split(':', 1)
191			property = property.strip()
192			value = value.strip()
193			except:
194			print "Error in line %d:" % i, line
195			continue
196			if value[0] == '"':
197			value = value[1:-1]
198			setattr(object, property, value)
199			return odb
200
201			def import_apr_dialog(context):
202			"""Request filename from user and run importing of apr file.
203
204			context -- The Thuban context.
205			"""
206			dlg = wxFileDialog(context.mainwindow,
207			_("Select APR file"), ".", "",
208			_("ArcView Project Files (.apr)\|.apr\|") +
209			_("All Files (.)\|."),
210			wxOPEN\|wxOVERWRITE_PROMPT)
211			if dlg.ShowModal() == wxID_OK:
212			filename = dlg.GetPath()
213			dlg.Destroy()
214			else:
215			return
216
217			odb = parse_apr(filename)
218			if odb is None:
219			context.mainwindow.RunMessageBox(_("Import APR"), _("Loading failed"))
220			return
221			else:
222			context.mainwindow.RunMessageBox(_("Import APR"),
223			_("%d objects loaded" %
224			len(odb.GetObjects().keys())))
225
226			# find the views of the APR file
227			views = {}
228			p = odb.GetProject()
229			for doc in p.Get('Doc'):
230			if doc.type != 'View':
231			continue
232			views[doc.Name] = doc
233
234			# it is possible that a APR file has no view at all
235			if len(views) == 0:
236			context.mainwindow.RunMessageBox(_("Import APR"),
237			_("No view found in APR file"))
238			return
239
240			# let the user select one of the views
241			if len(views) > 1:
242			titles = views.keys()
243			dlg = wxSingleChoiceDialog(context.mainwindow,
244			_('Pick a View to import:'),
245			_('Import APR'), titles,
246			style = wxDEFAULT_DIALOG_STYLE \|
247			wxRESIZE_BORDER)
248			if dlg.ShowModal() == wxID_OK:
249			view = views[views.keys()[dlg.GetSelection()]]
250			else:
251			return
252			else:
253			view = views[views.keys()[0]]
254
255			# load the themes of the View as layers into Thuban
256			count_theme = 0
257			count_theme_fail = 0
258			for theme in view.Get('Theme'):
259			if theme.type != 'FTheme':
260			continue
261			count_theme += 1
262			filename = theme.Get('Source').Get('Name').Get('FileName').Path
263			try:
264			store = context.application.Session().OpenShapefile(filename)
265			except IOError:
266			# the layer couldn't be opened
267			context.mainwindow.RunMessageBox(_('Add Layer'),
268			_("Can't open the file '%s'.") % filename)
269			count_theme_fail += 1
270			else:
271			title = theme.Name
272			apr_legend = theme.Get('Legend')
273
274			map = context.mainwindow.canvas.Map()
275
276			# create layer
277			layer = Layer(title, store)
278
279			# set the field for classification (if there is one in the apr)
280			if hasattr(apr_legend, 'FieldNames'):
281			apr_fieldname = apr_legend.Get('FieldNames').S
282			# unfortunately, the APR file does not store the actual
283			# Name of the column, but always makes the first character
284			# a capital letter, the rest lower case.
285			# Therefore, we have to search through the table of the
286			# layer to find out the correct spelling.
287			table_columns = layer.ShapeStore().Table().Columns()
288			for column in table_columns:
289			if apr_fieldname.lower() == column.name.lower():
290			layer.SetClassificationColumn(column.name)
291			break
292
293			clazz = layer.GetClassification()
294			apr_classes = apr_legend.Get('Class')
295			if not isinstance(apr_classes, list):
296			apr_classes = [ apr_classes ]
297			apr_symbols = apr_legend.Get('Symbols').Get('Child')
298			if not isinstance(apr_symbols, list):
299			apr_symbols = [ apr_symbols ]
300			i = -1
301			for symbol in apr_symbols:
302			i += 1
303
304			if hasattr(apr_classes[i], 'IsNoData'):
305			group = clazz.GetDefaultGroup()
306			group.SetLabel(apr_classes[i].Label)
307			continue
308
309			# create a new group property from the symbol
310			prop = symbol.GetThubanProp()
311
312	jan	1734	# build range
313			range = apr_classes[i].GetThubanRange()
314
315			if isinstance(range, StringType):
316			new_group = ClassGroupSingleton(value = range,
317	jan	1728	props = prop,
318			label = apr_classes[i].GetLabel())
319			else:
320			new_group = ClassGroupRange(_range = range,
321			props = prop,
322			label = apr_classes[i].GetLabel())
323			clazz.AppendGroup(new_group)
324
325			map.AddLayer(layer)
326
327			map.SetTitle(view.Name)
328
329			# fit the new map to the window
330			context.mainwindow.canvas.FitMapToWindow()
331
332			context.mainwindow.RunMessageBox(_('Import APR'),
333			_('Imported %d out of %d themes of view "%s" ...') % \
334			(count_theme - count_theme_fail, count_theme, view.Name))
335
336			# import_apr as an extension to Thuban
337			if context.session.HasExtensions():
338			for ext in context.session.Extensions():
339			if ext.Title() == apr_import_extension.Title():
340			ext.AddObject(odb)
341			return
342
343			# no extension found, so lets make a new
344			context.session.AddExtension(apr_import_extension)
345			apr_import_extension.AddObject(odb)
346
347			if __name__ == "__main__": # import_apr executed as a command line tool
348			if len(sys.argv) == 2:
349			odb = parse_apr(sys.argv[1])
350			print "%d objects loaded" % len(odb.GetObjects().keys())
351
352			def print_structured_list(lst, indent = ''):
353			for item in lst:
354			if isinstance(item, StringType):
355			print indent + item
356			elif isinstance(item, list):
357			print_structured_list(item, indent + ' ')
358
359			print_structured_list(odb.TreeInfo())
360			sys.exit(0)
361			else:
362			print 'usage: %s apr-file' % sys.argv[0]
363			sys.exit(1)
364
365			apr_import_extension = ODBExtension('APR Import')
366
367			# register the new command
368			registry.Add(Command('import-apr', _('Import apr-file...'), import_apr_dialog,
369			helptext = _('Import a ArcView project file')))
370
371			# find the experimental menu (create it anew if not found)
372			main_menu = Thuban.UI.mainwindow.main_menu
373			experimental_menu = main_menu.find_menu('experimental')
374			if experimental_menu is None:
375			experimental_menu = main_menu.InsertMenu('experimental', _('Experimenta&l'))
376
377			# finally add the new entry to the experimental menu
378			experimental_menu.InsertItem('import-apr')
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision