Application: gvSIG desktop » gvSIG scripting

# -*- coding: utf-8 -*-

#

# File: geom.py

#

# Copyright (c) 2011 by Model Driven Development sl and Antonio Carrasco Valero

#

# GNU General Public License (GPL)

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

#

#

"""

Utility functions to manage gvSIG geometries

"""

__author__ = """Antonio Carrasco Valero

Model Driven Development sl and Antonio Carrasco Valero

<carrasco@modeldd.org>

Victor Acevedo Royer <vacevedo@gvsig.com> <vacevedor@gmail.com>

"""

__docformat__ = 'plaintext'

from org.gvsig.fmap.geom import Geometry, GeometryLocator

from org.gvsig.tools import ToolsLocator

from org.gvsig.fmap.geom import Geometry

from org.gvsig.fmap.geom.primitive import Line, Polygon, Point

#GeometryTypes

AGGREGATE = Geometry.TYPES.AGGREGATE

ARC = Geometry.TYPES.ARC

CIRCLE = Geometry.TYPES.CIRCLE

CURVE = Geometry.TYPES.CURVE

ELLIPSE = Geometry.TYPES.ELLIPSE

ELLIPTICARC = Geometry.TYPES.ELLIPTICARC

GEOMETRY = Geometry.TYPES.GEOMETRY

MULTICURVE = Geometry.TYPES.MULTICURVE

MULTIPOINT = Geometry.TYPES.MULTIPOINT

MULTISOLID = Geometry.TYPES.MULTISOLID

MULTISURFACE = Geometry.TYPES.MULTISURFACE

NULL = Geometry.TYPES.NULL

POINT = Geometry.TYPES.POINT

SOLID =  Geometry.TYPES.SOLID

SPLINE = Geometry.TYPES.SPLINE

SURFACE = Geometry.TYPES.SURFACE

# Common named geometry types

POLYGON = Geometry.TYPES.SURFACE

LINE = Geometry.TYPES.CURVE

MULTILINE = Geometry.TYPES.MULTICURVE

MULTIPOLYGON = Geometry.TYPES.MULTISURFACE

# geometrySubTypes

D2 = Geometry.SUBTYPES.GEOM2D

D2M = Geometry.SUBTYPES.GEOM2DM

D3 = Geometry.SUBTYPES.GEOM3D

D3M = Geometry.SUBTYPES.GEOM3DM

UNKNOWN = Geometry.SUBTYPES.UNKNOWN

# Dimensions

DIMENSIONS = Geometry.DIMENSIONS

def createGeometry(type, subtype=D2):

    """

    Returns a new geometry with a concrete type and subtype or None if can't

    create geometry.

    :param type: geometry type

    :type type: string

    :param subtype: geometry subtype

    :type type: string

    :return: geometry

    :rtype: geometry

    """

    try:

        geometryManager = GeometryLocator.getGeometryManager()

        geometry = geometryManager.create(type, subtype)

    except:

        return None

    return geometry

def createPoint2D(x=None, y=None):

    if x==None and y==None:

        return createPoint(D2)

    elif x==None or y==None:

        return None

    else:

        return createPoint(D2, x, y)

def createLine2D(vertexes=None):

    if vertexes==None:

        return createLine(D2)

    else:

        return createLine(D2, vertexes)

def createPolygon2D(vertexes=None):

    if vertexes==None:

        return createPolygon(D2)

    else:

        return createPolygon(D2, vertexes)

def createPoint(subtype=D2,*coords):

    """

    Returns a new point with a subtype and sets the value for the X, Y, Z and M

    coordinates (default 0,0,0,0) or None if can't create point

    :param subtype: geometry type

    :type subtype: integer

    :param coords: list of coordinates

    :type coords: list

    :return: point

    :rtype: Geometry

    """

    geometryManager = GeometryLocator.getGeometryManager()

    point = geometryManager.create(POINT, subtype)

    try:

        #If is geometry, transform to a new point type.

        if len(coords)==0:

            return point

        else:

            # Coords with one parameter

            # Check if is a Geometry

            if len(coords)==1: #FIXME

                coords = coords[0]

            if isinstance(coords, Point):

                return coords

            #Check if object have GET attribute

            get = getattr(coords,"__getitem__",None)

            if get != None and len(coords)>=2:

                if subtype==D2:

                    point.setCoordinateAt(Geometry.DIMENSIONS.X, get(0))

                    point.setCoordinateAt(Geometry.DIMENSIONS.Y, get(1))

                elif subtype==D3:

                    point.setCoordinateAt(Geometry.DIMENSIONS.X, get(0))

                    point.setCoordinateAt(Geometry.DIMENSIONS.Y, get(1))

                    try:

                        z = get(2)

                    except:

                        z = 0

                    point.setCoordinateAt(Geometry.DIMENSIONS.Z, z)

                elif subtype==D2M:

                    point.setCoordinateAt(Geometry.DIMENSIONS.X, get(0))

                    point.setCoordinateAt(Geometry.DIMENSIONS.Y, get(1))

                    try:

                        m = get(2)

                    except:

                        m = 0

                    point.setCoordinateAt(point.getDimension()-1, m)

                elif subtype==D3M:

                    point.setCoordinateAt(Geometry.DIMENSIONS.X, get(0))

                    point.setCoordinateAt(Geometry.DIMENSIONS.Y, get(1))

                    try:

                        z = get(2)

                    except:

                        z = 0

                    point.setCoordinateAt(Geometry.DIMENSIONS.Z, z)

                    try:

                        m = get(3)

                    except:

                        m = 0

                    point.setCoordinateAt(point.getDimension()-1, m)

        return point

    except:

        return None

def createMultiPoint(subtype=D2, points=None):

    """

    Returns a new multipoint with a subtype from a list of Points instances.

    Also values of X and Y tuples like ([x1, y1], [x2, y2], ...., [xn, yn]) are

    allowed. If not points returns empty multipoint geometry. If can't create

    geometry return None.

    :param subtype: geometry type

    :type subtype: integer

    :param points: list of points

    :type points: list

    :return: multipoint

    :rtype: multipoint

    """

    multipoint = createGeometry(MULTIPOINT, subtype)

    if points!=None:

        try:

            for point in points:

                if isinstance(point, Geometry):

                    pgeom = point

                else:

                    pgeom = createPoint(subtype, point)

                multipoint.addPrimitive(pgeom)

        except:

            return None

    return multipoint

def createPolygon(subtype=D2, vertexes=None):

    """

    Returns a new polygon with a subtype. Or None if can't create the geometry

    :return: polygon

    :rtype: Geometry

    """

    polygon = createGeometry(SURFACE, subtype)

    if vertexes!= None:

        try:

            for vertex in vertexes:

                vgeom = createPoint(subtype, vertex)

                polygon.addVertex(vgeom)

        except:

            return None

    return polygon

def createMultiPolygon(subtype=D2, polygons=None):

    """

    Returns a new multipolygon with a subtype. or None if can't create geometry

    :return: multipolygon

    :rtype: Geometry

    """

    multipolygon = createGeometry(MULTISURFACE, subtype)

    if polygons!=None:

        try:

            for polygon in polygons:

                if isinstance(polygon, Polygon): #, Polygon)

                    pass

                else:

                    polygon = createPolygon(subtype=subtype,vertexes=polygon)

                multipolygon.addPrimitive(polygon)

        except:

            return None

    return multipolygon

def createLine(subtype=D2, vertexes=None):

    """

    Returns a new line with a subtype or None if can't create geometry

    :return: polygon

    :rtype: Geometry

    """

    line = createGeometry(CURVE, subtype)

    if vertexes!=None:

        try:

            for vertex in vertexes:

                v = createPoint(subtype, vertex)

                line.addVertex(v)

        except:

            return None

    return line

def createMultiLine(subtype=D2, lines=None):

    """

    Create a new multiline with a subtype or None if can't create geometry

    :return: multiline

    :rtype: Geometry

    """

    multiline = createGeometry(MULTILINE, subtype)

    if lines:

        try:

            for line in lines:

                if isinstance(line, Line): #,Line)

                    pass

                else:

                    line = createLine(subtype=subtype, vertexes=line)

                multiline.addPrimitive(line)

        except:

            return None

    return multiline

def createEnvelope(pointMin=None, pointMax=None, dimension=2):

    """

    Returns envelope as a minimum bounding box or rectangle. This envelope is

    equivalent to the GM_Envelope specified in ISO 19107.

    :param pointMax:

    :type pointMax: geometry POINT

    :param pointMin:

    :type pointMin: geometry POINT

    :return: envelope

    :rtype Geometry

    """

    # Coord min point

    get=getattr(pointMin,"__getitem__",None)

    if get != None:

        xmin = get(0)

        ymin = get(1)

    else:

        xmin = pointMin.getX()

        ymin = pointMin.getY()

    # Coord max point

    get=getattr(pointMax,"__getitem__",None)

    if get != None:

        xmax = get(0)

        ymax = get(1)

    else:

        xmax = pointMax.getX()

        ymax = pointMax.getY()

    geometryManager = GeometryLocator.getGeometryManager()

    if pointMax!=None and pointMin!=None:

        envelope = geometryManager.createEnvelope(xmin, ymin, xmax, ymax, dimension)

    else:

        envelope = geometryManager.createEnvelope()

    return envelope

def createGeometryFromWKT(WKT):

    """

    Create geometry from WKT string

    :param WKT

    :type WKT: string

    :return: geometry

    :rtype: Geometry

    """

    geometryManager = GeometryLocator.getGeometryManager()

    geometry = geometryManager.createFrom(WKT)

    return geometry

def main():

  pass