Extensions/umn_mapserver/mapfile.py

# -*- coding:latin1 -*-
# Copyright (C) 2004 by Intevation GmbH
# Authors:
# Jan Schüngel <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Classes to represent '.map'-file Objects.

The following Classes, which are implemented in
mapscript are not implemented yet in this extension:

 DBFInfo, errorObj, fontSetObj, graticuleObj, imageObj, itemObj,
 labelCacheMemberObj, labelCacheObj, labelObj, legendObj, lineObj,
 markerCacheMembet, msTiledSHPLayerInfo, OutputFormat, pointObj, queryMapObj,
 referenzMapObj, resultCacheMemberObj, resultCacheObj, scalebarObj,
 shapefileObj, shapeObj, styleObj, symbolObj, symbolSetObj, VectorObj, WebObj
"""

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


# ##################################################
#
# import necessary modules from python and/or thuban
#
# ##################################################

import os

from Thuban.Model.color import Color, Transparent 

from mapscript import layerObj, classObj, colorObj, styleObj, rectObj, \
                      colorObj

# ###################################
#
# Definition of dictionaries
#
# ###################################

shp_type = { 0:'point',
             1:'line',
             2:'polygon',
             3:'raster',
             4:'annotation',
             5:'circle',
             6:'query'}


# ##################################################
#
# Class Definition 
#
# ##################################################

# ##################################################
# General Classes that are not all explicitly defined through
# a mapfile, but rather some helper-classes.

class MF_Rectangle:
    """
    Represents an rectanle with the bottom left
    and top right corner.
    """
    def __init__(self,mf_rect):
        self._rect = mf_rect
    
    def get_minx(self):
        return self._rect.minx

    def get_miny(self):
        return self._rect.miny

    def get_maxx(self):
        return self._rect.maxx

    def get_maxy(self):
        return self._rect.maxy
    
    def get_rect(self):
        return (self._rect.minx,self._rect.miny,self._rect.maxx,self._rect.maxy)

    def set_rect(self, minx, miny, maxx, maxy):
        self._rect.minx = minx
        self._rect.miny = miny
        self._rect.maxx = maxx
        self._rect.maxy = maxy

class MF_Color:
    """
    The corresponding MapScript object contains also the
    attribute pen which defines the stroke of the feature.
    But this actually has nothing to do with the color and
    therefore is not support here.
    
    It needs to be discussed with the MapServer developers
    whether pen would better be moved to another class.
    
    The hex color definition which is also supported by
    mapscript and Thuban is not supported as it does
    not add any capability.
    
    color is definied as RGB 0..255
    """    
    def __init__(self, mf_color):
        self._color = mf_color

        self._tbc_red = (float(self.get_red())/255)
        self._tbc_green = (float(self.get_green())/255)
        self._tbc_blue = (float(self.get_blue())/255)
        self._thubancolor = Color(self._tbc_red, self._tbc_green, self._tbc_blue)

    # TODO : Check if it is necessary to use rgb colors alone
    # or whether it is sufficient to only use the Thuban Color.
    # In some it is necessary as red == -1 indicates that no color
    # is set.
    def get_red(self):
        return self._color.red

    def get_green(self):
        return self._color.green

    def get_blue(self):
        return self._color.blue
        
    def get_mfcolor(self):
        return self._color

    def get_thubancolor(self):
        return self._thubancolor     

    def set_thubancolor(self, thuban_color):
        if thuban_color != Transparent:
            self._color.red = int(thuban_color.red * 255)
            self._color.green = int(thuban_color.green * 255)
            self._color.blue = int(thuban_color.blue * 255)
            self._thubancolor = thuban_color


class MF_Size:
    """
    Handle sizes.
    This is not implemented as a Class in mapscript but 
    seems to be helpful.
    """
  
    def __init__(self, mf_width, mf_height):
        self._width = mf_width
        self._height = mf_height
    
    def get_width(self):
        return self._width
    
    def get_height(self):
        return self._height
    
    def set_size(self, newwidth, newheight):
        self._width = newwidth
        self._height = newheight


class MF_Metadata:
    """
    Metadata is not a Object in mapscript witch can be used
    by ease. Only the infos can get with the functions
    "getFirstMetaDataKey", "getNextMetaDataKey" and "getMetaData".
    To get some special Metadata you need a key. So the metadata will
    saved as an dictionary to geht the information with the key here.
    
    The metadata obj will be created and filled with infos like
    the following code sample:
    
    self.metadata = MF_Metadata()
        try:
            self.metafkey = varia.getFirstMetaDataKey()
        except:
            self.metadata = None
        else:
            while self.metafkey:
                self.metakeydata = varia.getMetaData(self.metafkey)
                self.metadata.add_metadata(self.metafkey,self.metakeydata)
                self.metafkey = varia.getNextMetaDataKey(self.metafkey)
                
    Metadata are not really needed at the moment.
    """

    def __init__(self):
        self.data = {}
       
    def get_metadata(self):
        return self.data
    
    def get_metadatabykey(self, key):
        return self.data[key]
    
    def add_metadata(self, key, data):
        self.data[key] = data

# ##################################################
# Classes for MapServer Objects as they are
# explicitly defined in a mapfile

class MF_Symbol:
    """
    defines a single symbol which is used in the Symbolset
    
    name, type, sizex, sizey, points, numpoints, filled, stylelength,
    style, imagepath, transparent, transparentcolor, character, antialias,
    font, gap, position, linecap, linejoin, linejoinmaxsize, setPoints(),
    getPoints(), setStyle()
    """
    
    def __init__(self, mf_symbol):
        print "nothing"

class MF_SymbolSet:
    """
    defines a set of symbols, may be there can only be one
    
    filename, imagecachesize, numsymbols, symbol, getSymbol(),
    getSymbolByName(), index(), appendSymbol(), removeSymbol(),
    save()    
    """
    
    # TODO: include the symbolset, but found only the possibility to
    # create an extra symbol file and not to include it direct to the 
    # mapfile itself
    def __init__(self, mf_symbolset):
        print "nothing"


class MF_Class:
    """
    The following parameters and functions, which the mapscript style obj
    contains, are used:
    styles, numstyles, name,
    getExpressionString(), setExpression(), getMetaData(), getFirstMetaDataKey(),
    getNextMetaDataKey(), getStyle()

    The following parameters and functions are not used:
    status, label, title, template, type, minscale, maxscale, layer, 
    debig, keyimage,
    setExpression(), setText(), setMetaData(), drawLegendIcon(),
    createLegendIcon(), insertStyle(), removeStyle(), moveStyleUp(),
    moveStyleDown()
    """
    def __init__(self, mf_class):
        """
        Initialized a class from them given mapscript Class Object
        with a list of the included styles.
        Metadata Object will be created from the Metadata informations
        wich are holt as a List i think.
        """
        self._clazz = mf_class
        self._styles = []
        self._numstyles = mf_class.numstyles
        for i in range(0,self._numstyles,1):
            self._styles.append(MF_Style(mf_class.getStyle(i)))
        
        if self._clazz.getExpressionString() == '"(null)"':
            self._expression = None
        else:
            self._expression = self._clazz.getExpressionString()
        
        self.metadata = MF_Metadata()
        try:
            self.metafkey = mf_class.getFirstMetaDataKey()
        except:
            self.metadata = None
        else:
            while self.metafkey:
                self.metakeydata = mf_class.getMetaData(self.metafkey)
                self.metadata.add_metadata(self.metafkey,self.metakeydata)
                self.metafkey = mf_class.getNextMetaDataKey(self.metafkey)

    def get_styles(self):
        return self._styles
    
    def get_name(self):
        return self._clazz.name
        
    def get_keyimage(self):
        return self._clazz.keyimage
        
    def get_expressionstring(self):
        return self._expression
    
    def set_name(self, newname):
        self._clazz.name = newname
    
    def set_expressionstring(self, newstring):
        self._clazz.setExpression(newstring)
        self._expression = self._clazz.getExpressionString()
    
    def add_thubanstyle(self, tb_style, type="default"):
        new_styleobj = MF_Style(styleObj(self._clazz))
        if type == "line":
            new_styleobj.set_color(tb_style.GetLineColor())
        elif type == "circle":
            # set a default symbol to show circles not only a small dot
            # symbol "circle" must create before
            # TODO: create a Symbol (more see MF_SymbolSet)
            new_styleobj.set_symbol('circle')
        else:
            new_styleobj.set_size(tb_style.GetLineWidth())
            new_styleobj.set_linecolor(tb_style.GetLineColor())
            new_styleobj.set_color(tb_style.GetFill())


class MF_Layer:
    """
    The following parameters and functions, which the mapscript style obj
    contains, are used:

    classitem, numclasses, name, data, type
    getClass(), getProjection(), getExtent(), getMetaData(),
    getFirstMetaDataKey(), getNextMetaDataKey(), status, 


    The following paramters and functions are not used:
    index, map, header, footer, template, groupe, tolerance,
    toleranceunits, symbolscale, minscale, maxscale, labelminscale
    labelmaxscale, sizeunits, maxfeatures, offsite, transform, labelcache
    postlabelcache, labelitem, labelsizeitem, labelangleitem, labelitemindex
    labelsizeitemindex, labelangleitemindex, tileitem, tileindex, units
    connection, connectiontype, numitems, filteritem, styleitem, requires
    labelrequires, transparency, dump, debug, numprocessing, numjoins,
    removeClass(), open(), close(), getShape(), getNumResults(), getResult()
    getItem(), promote(), demote(), draw(), drawQuery(), queryByAttributes()
    queryByPoint(), queryByRect(), queryByFeatures(), queryByShape(),
    setFilter(), setFilterString(), setWKTProjection(), setProjection()
    addFeature(), getNumFeatures(), setMetaData(), removeMetaData(),
    getWMSFeatureInfoURL(), executeWFSGetFeature(), applySLD(), applySLDURL()
    enerateSLD(), moveClassUp(), moveClassDown(), setProcessing(),
    getProcessing(), clearProcessing()   
    """

    def __init__(self, mf_layer):
        """
        Creates the Layer Object from the mapscript Layer Object.
        the class objects in the layer object will be stored in
        an array. The metadata are created as a new object.
        """
       
        self._mf_layer = mf_layer

        # Create Classes 
        # there could be more then 1 
        self._numclasses = mf_layer.numclasses
        i = -1
        self._classes = []
        while i < self._numclasses-1:
            i += 1
            self._classes.append(MF_Class(self._mf_layer.getClass(i)))
            
        self._projection = MF_Projection(self._mf_layer.getProjection())
        
        # Variable extent will not used for RasterLayer
        # this variable is not necessary, because it comes directly
        # from the shp file
        try:
            self._extent = MF_Rectangle(self._mf_layer.getExtent())
        except:
            self._extent = None

        # Create Metadata
        self._metadata = MF_Metadata()
        try:
            self._metafkey = self._mf_layer.getFirstMetaDataKey()
        except:
            self._metadata = None
        else:
            while self._metafkey:
                self._metakeydata = self._mf_layer.getMetaData(self._metafkey)
                self._metadata.add_metadata(self._metafkey,self._metakeydata)
                self._metafkey = self._mf_layer.getNextMetaDataKey(self._metafkey)

    def get_name(self):
        return self._mf_layer.name
    
    def get_data(self):
        return self._mf_layer.data
        
    def get_classes(self):
        return self._classes
        
    def get_type(self):
        return shp_type[self._mf_layer.type]

    def get_classitem(self):
        return self._mf_layer.classitem

    def get_projection(self):
        return self._projection
    
    def get_status(self):
        # returns a integer value
        # 0 = off, 1 = on, 2 = default(always on)
        if self._mf_layer.status == 0:
            return False
        else:
            return True
        #return self._mf_layer.status
    
    def set_name(self, newname):
        self._mf_layer.name = newname 
    
    def set_data(self, newdata):
        self._mf_layer.data = newdata[:-4]
    
    def set_status(self, newstatus):
        # status can set to true or false from thuban.
        # but mapserver supports the default value
        self._mf_layer.status = newstatus
    
    def set_classitem(self, tb_field):
        self._mf_layer.classitem = tb_field
    
    def set_type(self, tb_type):
        # if type = arc its a in shapetype line
        if tb_type == "arc":
            self._mf_layer.type = 1
        if shp_type.has_key(tb_type):
            self._mf_layer.type = tb_type
        else:
            for shp_paar_nr in shp_type:
               if shp_type[shp_paar_nr] == tb_type:
                   self._mf_layer.type = shp_paar_nr
                   return
    
    def set_projection(self, newprojection):
        self._mfnewprojstring = ""
        if newprojection:
            self._newparams = newprojection.GetAllParameters()
            for field in self._newparams:
                self._mfnewprojstring = self._mfnewprojstring+ "," + field
            self._mf_layer.setProjection(self._mfnewprojstring[1:])
            self._projection.set_projection(newprojection)
        else:        
            print "no projection"
    
    def add_thubanclass(self, tb_class):
        new_class = MF_Class(classObj(self._mf_layer))
        new_class.set_name(tb_class.GetLabel())
        if self.get_type() == "line":
            new_class.add_thubanstyle(tb_class.GetProperties(), type="line")
        else:
            new_class.add_thubanstyle(tb_class.GetProperties())
        if tb_class.GetDisplayText() == "DEFAULT":
            return
            #new_class.set_expressionstring('/./')
        else:
            new_class.set_expressionstring(str(tb_class.GetDisplayText()))
        self._classes.append(new_class)

class MF_Map:
    """
    The following parameters and functions, which the mapscript style obj
    contains, are used:

    name, numlayers, extent, shapepath, imagecolor, imagetype, getLayer,
    getProjection, getMetaData, getFirstMetaDataKey, getNextMetaDataKey,
    save(), setExtent(), height, width, setProjection()

    
    The following parameters and functions are not used:
    status, maxsize, layers, symbolset, fontset, labelcache,
    transparent, interlace, imagequality, cellsize, units, debug, datapattern,
    templatepattern, configoptions
    zoomPoint(), zoomRectangle(), zoomScale(), getLayerOrder(), setLayerOrder(),
    clone(), removeLayer(), getLayerByName(), getSymbolByName(),
    prepareQuery(), prepareImage(), setImageType(), setOutputFormat(), draw(),
    drawQuery(), drawLegend(), drawScalebar(), embedLegend(), drawLabelCache(),
    nextLabel(), queryByPoint(), queryByRecht(), queryByFeatures(), queryByShape(),
    setWKTProjection(), saveQuery(), saveQueryASGML(),
    setMetaData(), removeMetaData(), setSymbolSet(), getNumSymbols(), setFontSet(),
    saveMapContext(), loadMapContext(), moveLayerUp(), moveLayerDown(),
    getLayersDrawingOrder(), setLayersDrawingOrder(), setConfigOption(),
    getConfigOption(), applyConfigOptions(), applySLD(), applySLDURL(), gernerateSLD(),
    procecssTemplate(), processLegemdTemplate(), processQueryTemplate(),
    getOutputFormatByName(), appendOutputFormat(), removeOutputFormat(),
    """
    
    def __init__(self, mf_map):
        """
        Create the map object from the mapfile mapobject which is given.

        All layers in the mapfile will be written to an array.
        """

        self._mf_map = mf_map
        self._extent = MF_Rectangle(self._mf_map.extent)
        self._imagecolor = MF_Color(self._mf_map.imagecolor)

        # if the map name is not set it will return a MS string.
        if self._mf_map.name != "MS":
            self._name = self._mf_map.name
        else:
            self._name = None
            
        self._projection = MF_Projection(self._mf_map.getProjection())

        # Initial Layer List
        self._layers = []
        self._numlayers = self._mf_map.numlayers
        self._i = 0
        while self._i < self._numlayers:
            self._layers.append(MF_Layer(self._mf_map.getLayer(self._i)))
            self._i += 1

        # Shapepath if not set, shapepath will be empty
        if self._mf_map.shapepath:
            self._shapepath = self._mf_map.shapepath
        else:
            self._shapepath = ""

        # Create Metadata
        self._metadata = MF_Metadata()
        try:
            self._metafkey = self._mf_map.getFirstMetaDataKey()
        except:
            self._metadata = None
        else:
            while self._metafkey:
                self._metakeydata = self._mf_map.getMetaData(self._metafkey)
                self._metadata.add_metadata(self._metafkey,self._metakeydata)
                self._metafkey = self._mf_map.getNextMetaDataKey(self._metafkey)
    
    def get_extent(self):
        return self._extent
        
    def get_layers(self):
        return self._layers
    
    def get_projection(self):
        return self._projection
    
    def get_name(self):
        return self._name
    
    def get_shapepath(self):
        return self._shapepath # where are the shape files located..
    
    def get_imagetype(self):
        return self._imagetype
    
    def get_layerorder(self):
        # shows the order of layer as list
        return self._mf_map.getLayerOrder()    
    
    def set_name(self, newname):
        # whitespace musst be replaced, either no
        # mapfile will be shown in the mapserver
        newname = newname.replace(" ","_")
        self._name = newname
        self._mf_map.name = newname
    
    def set_extent(self, newextent):
        # TODO: add the shown extend here instead of the total
        self._newrect = MF_Rectangle(rectObj())
        self._newrect.set_rect(newextent[0],newextent[1],newextent[2],newextent[3])
        self._mf_map.setExtent(newextent[0],newextent[1],newextent[2],newextent[3])
    
    def set_size(self, newwidth, newheight):
        self._mf_map.width = newwidth
        self._mf_map.height = newheight
    
    def set_projection(self, projection):
        self._mfnewprojstring = ""
        self._newparams = projection.GetAllParameters()
        for field in self._newparams:
            self._mfnewprojstring = self._mfnewprojstring+ "," + field
        self._mf_map.setProjection(self._mfnewprojstring[1:])
        self._projection.set_projection(projection)
      
    def add_thubanlayer(self, tb_layer):
        new_layer = MF_Layer(layerObj(self._mf_map))
        new_layer.set_name(tb_layer.Title())
        
        # TODO: implement relative pathnames
        # yet only absolute pathnames in the LayerObj are set
        new_layer.set_data(tb_layer.ShapeStore().FileName())
        
        new_layer.set_status(tb_layer.Visible())
        new_layer.set_type(tb_layer.ShapeType())
        
        # set the projection to the layer.
        # if the layer has its own definition use is, else use the main projection
        if tb_layer.GetProjection():
            new_layer.set_projection(tb_layer.GetProjection())
        else:
            new_layer.set_projection(self._projection.get_projection())
        
        if tb_layer.GetClassificationColumn():
            new_layer.set_classitem(tb_layer.GetClassificationColumn())
        if tb_layer.GetProjection():
            new_layer.set_projection(tb_layer.GetProjection())
        if tb_layer.GetClassification().GetNumGroups() > 0:
            for group in range(0, tb_layer.GetClassification().GetNumGroups(), 1):
                new_layer.add_thubanclass(tb_layer.GetClassification().GetGroup(group))
            new_layer.add_thubanclass(tb_layer.GetClassification().GetDefaultGroup())
        else:
            new_layer.add_thubanclass(tb_layer.GetClassification().GetDefaultGroup())
        self._layers.append(new_layer)
    
    def save_map(self, filepath):
        # save the Map
        # maybe an own saver can implement here
        self._mf_map.save(filepath)
        
class MF_Projection:
    """
    The following parameter, which the mapscript style obj contains is used:

    numargs
    """
    
    def __init__(self, mf_projection):
        """
        Create a projection object from the given mapscript projection
        object. If it is a epsg code the extracted from the string
        (e.g."init=epsg:xxxx"), else the projection parameters will
        be splitted and an array with the parameters will be creaded.
        """
        self._mfprojstring = mf_projection
        self._projstring = self._mfprojstring
        self._epsgcode = None
        self._params = None
        if self._mfprojstring:
            if self._mfprojstring.find("init=epsg:") != -1:
                self._initcode, self._epsgcode = self._mfprojstring.split(':')
            else:  
                self._params = []  
                self._params = self._mfprojstring.split("+")
                if self._params[0] == "":
                    self._params.remove("")

    def epsg_code_to_projection(self, epsg):
        """
        Find the projection for the given epsg code.
    
        Copied from Extension/wms/layer.py
    
        epsg -- EPSG code as string
        """
        #Needed only for this function
        from Thuban.Model.resource import get_system_proj_file, EPSG_PROJ_FILE, \
                                          EPSG_DEPRECATED_PROJ_FILE

        proj_file, warnings = get_system_proj_file(EPSG_PROJ_FILE)

        for proj in proj_file.GetProjections():
            if proj.EPSGCode() == epsg:
                return proj
            
        proj_file, warnings = get_system_proj_file(EPSG_DEPRECATED_PROJ_FILE)
        for proj in proj_file.GetProjections():
            if proj.EPSGCode() == epsg:
                return proj
        return None
    
    def get_params(self):
        #Parameter from the mf_projectionstring as Array
        return self._params
        
    def get_epsgcode(self):
        # returnes the epsg number
        return self._epsgcode
        
    def get_epsgproj(self):
        # get an epsg projectionobject
        return self.epsg_code_to_projection(self._epsgcode)
    
    def get_projection(self):
        return self._projstring
    
    def set_projection(self, newprojection):
        self._projstring = newprojection
        self._params = newprojection.GetAllParameters()
        self._mfnewprojstring = ""
        for field in self._params:
            self._mfnewprojstring = self._mfnewprojstring+ "+" + field
        self._mfprojstring = self._mfnewprojstring

class MF_Style:
    """
    The following parameters, which the mapscript style obj
    contains, are used:
    
    color, backgroundcolor, outlinecolor, size, symbolname

    The following are not used:
    symbol, sizescaled, minsize, maxsize, offsetx, offsety,
    antialias
    """
 
    def __init__(self, mf_style):
        """
        Create a style object from the given mapscript style object.
        The color Object from the color and the outlinecolor parameter
        will be created. if the color (red, green or blue) is -1 there
        is no definition in the mapfile and so there is no color object,
        it will set to 'None'.
        """
        self._style = mf_style
        if self._style.color.red == -1:
            self._maincolor = None
        else:
            self._maincolor = MF_Color(self._style.color)
        self._color = MF_Color(self._style.color)
        if self._style.outlinecolor.red == -1:
            self._outlinecolor = None
        else:
            self._outlinecolor = MF_Color(self._style.outlinecolor)
    
    def get_color(self):
        return self._color
    
    def get_outlinecolor(self):
        return self._outlinecolor
   
    def get_size(self):
        return self._style.size
    
    def set_linecolor(self, tb_color):
        self._color = tb_color
        new_linecolor = MF_Color(colorObj())
        new_linecolor.set_thubancolor(tb_color)
        self._outlinecolor = new_linecolor
        self._style.outlinecolor = new_linecolor.get_mfcolor()
    
    def set_color(self, tb_color):
        self._color = tb_color
        new_color = MF_Color(colorObj())
        new_color.set_thubancolor(tb_color)
        self._color = new_color
        self._style.color = new_color.get_mfcolor()
    
    def set_size(self, newsize):
        self._style.size = newsize
    
    def set_symbolname(self, newsymbol):
        # its possible to use stringnames instead of numbers
        self._style.symbolname = 'circle'

Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision