root/PCL/trunk/PCL-Core/cartography/geometry/_geommodule.c

/*
# =============================================================================
# Python Cartographic Library. Copyright (C) 2006 Sean C. Gillies
#
# 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., 59 Temple
# Place, Suite 330, Boston, MA 02111-1307 USA
#
# Contact email: sgillies@frii.com
# =============================================================================
*/

#include "Python.h"
#include "structmember.h"

#include "geos_c.h"
#include "proj_api.h"

static PyObject *GEOSError;

typedef struct {
    PyObject_HEAD
    GEOSCoordSeq seq;
    /* Flag for whether seq is an owned (1) or borrowed (0) reference to
       allocated memory */
    int owns;
} CoordSeq;

staticforward PyTypeObject CoordinateSequenceType;

typedef struct {
    PyObject_HEAD
    GEOSGeom geom;
    /* Flag for whether seq is an owned (1) or borrowed (0) reference to
       allocated memory */
    int owns;
} Geometry;

staticforward PyTypeObject GeometryType;

/*
==============================================================================
 CoordinateSequence
==============================================================================
*/

/* === Alloc/dealloc === */

PyObject *
CoordSeq_New(GEOSCoordSeq s)
{
    CoordSeq *self;
    
    if (!s)
        return NULL;
    
    self = PyObject_NEW(CoordSeq, &CoordinateSequenceType);
    if (self == NULL)
    {
        GEOSCoordSeq_destroy(self->seq);
        return NULL;
    }
    
    self->seq = s;
    self->owns = 1;
    return (PyObject *) self;
}

static PyObject *
_createCoordSeq(PyObject *self, PyObject *args)
{
    int size=1;
    int dims=3;
    GEOSCoordSeq s;
    
    if (!PyArg_ParseTuple(args, "i|i", &size, &dims))
        return NULL;
        
    if (size < 1)
    {
        PyErr_SetString(PyExc_ValueError, "Sequence must have size >=1");
        return NULL;
    }
    if (dims < 2 || dims > 3)
    {
        PyErr_SetString(PyExc_ValueError, "Dimensions must be 2 or 3");
        return NULL;
    }
    
    s = (GEOSCoordSeq) GEOSCoordSeq_create(size, dims);
    if (!s)
        return NULL;
    
    return CoordSeq_New(s);
}

static void
CoordSeq_dealloc(CoordSeq *self)
{
    if (self->owns && self->seq != NULL)
    {
        GEOSCoordSeq_destroy(self->seq);
    }
    self->seq = NULL;
    self->ob_type->tp_free((PyObject*) self);
}

static PyObject *
CoordSeq_clone(CoordSeq *self)
{
    CoordSeq *s;
    GEOSCoordSeq new;

    s = (CoordSeq *) self;
    new = GEOSCoordSeq_clone(s->seq);
    if (!new)
        return NULL;

    return (PyObject *) CoordSeq_New(new);
}

/* === Methods === */

static PyObject *
CoordSeq_getSize(CoordSeq *self)
{
    unsigned int size;
    if (GEOSCoordSeq_getSize(self->seq, &size) == 0)
    {
        PyErr_SetString(PyExc_Exception, "Failed to get sequence size");
        return NULL;
    }    
    return Py_BuildValue("i", size);
}

static PyObject *
CoordSeq_getDimensions(CoordSeq *self)
{
    unsigned int dims;
    if (!GEOSCoordSeq_getDimensions(self->seq, &dims))
    {
        PyErr_SetString(PyExc_Exception, "Failed to get sequence dimensions");
        return NULL;
    }    
    return Py_BuildValue("i", dims);
}

static PyObject *
CoordSeq_getX(CoordSeq *self, PyObject *item)
{
    unsigned int num;
    double value;
    long n;
    
    if (!PyInt_Check(item))
    {
                PyErr_SetString(PyExc_TypeError, "index must be an integer");
                return NULL;
        }
    
    GEOSCoordSeq_getSize(self->seq, &num);
    if (num == 0)
    {
        PyErr_SetString(PyExc_Exception, "Sequence has no coordinates");
        return NULL;
    }

    n = PyInt_AS_LONG(item);
    if (n < 0 || n >= num)
    {
        PyErr_Format(PyExc_IndexError,
                "Index is beyond valid range [0:%d]", num);
        return NULL;
    }
    
    if (!GEOSCoordSeq_getX(self->seq, (int)n, &value))
    {
        PyErr_SetString(PyExc_Exception, "Failed to get X");
        return NULL;
    }
    return Py_BuildValue("d", value);
}

static PyObject *
CoordSeq_getY(CoordSeq *self, PyObject *item)
{
    unsigned int num;
    double value;
    long n;
    
    if (!PyInt_Check(item))
    {
                PyErr_SetString(PyExc_TypeError, "index must be an integer");
                return NULL;
        }
    
    GEOSCoordSeq_getSize(self->seq, &num);
    if (num == 0)
    {
        PyErr_SetString(PyExc_Exception, "Sequence has no coordinates");
        return NULL;
    }

    n = PyInt_AS_LONG(item);
    if (n < 0 || n >= num)
    {
        PyErr_Format(PyExc_IndexError,
                "Index is beyond valid range [0:%d]", num);
        return NULL;
    }
    
    if (!GEOSCoordSeq_getY(self->seq, (int)n, &value))
    {
        PyErr_SetString(PyExc_Exception, "Failed to get Y");
        return NULL;
    }
    return Py_BuildValue("d", value);
}

static PyObject *
CoordSeq_getZ(CoordSeq *self, PyObject *item)
{
    unsigned int num;
    double value;
    long n;
    
    if (!PyInt_Check(item))
    {
                PyErr_SetString(PyExc_TypeError, "index must be an integer");
                return NULL;
        }
    
    GEOSCoordSeq_getSize(self->seq, &num);
    if (num == 0)
    {
        PyErr_SetString(PyExc_Exception, "Sequence has no coordinates");
        return NULL;
    }

    n = PyInt_AS_LONG(item);
    if (n < 0 || n >= num)
    {
        PyErr_Format(PyExc_IndexError,
                "Index is beyond valid range [0:%d]", num);
        return NULL;
    }
    
    if (!GEOSCoordSeq_getZ(self->seq, (int)n, &value))
    {
        PyErr_SetString(PyExc_Exception, "Failed to get Z");
        return NULL;
    }
    return Py_BuildValue("d", value);
}

static PyObject *
CoordSeq_setX(CoordSeq *self, PyObject *args)
{
    int n;
    unsigned int num;
    double value;
    if (!PyArg_ParseTuple(args, "id", &n, &value))
    {
                return NULL;
        }
    
    GEOSCoordSeq_getSize(self->seq, &num);
    if (num == 0)
    {
        PyErr_SetString(PyExc_Exception, "Sequence has no coordinates");
        return NULL;
    }

    if (n < 0 || n >= num)
    {
        PyErr_Format(PyExc_IndexError,
                "Index is beyond valid range [0:%d]", num);
        return NULL;
    }
    
    if (!GEOSCoordSeq_setX(self->seq, (int)n, value))
    {
        PyErr_SetString(PyExc_Exception, "Failed to set X");
        return NULL;
    }
    
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
CoordSeq_setY(CoordSeq *self, PyObject *args)
{
    int n;
    unsigned int num;
    double value;
    if (!PyArg_ParseTuple(args, "id", &n, &value))
    {
                return NULL;
        }
    
    GEOSCoordSeq_getSize(self->seq, &num);
    if (num == 0)
    {
        PyErr_SetString(PyExc_Exception, "Sequence has no coordinates");
        return NULL;
    }
    
    if (n < 0 || n >= num)
    {
        PyErr_Format(PyExc_IndexError,
                     "Index is beyond valid range [0:%d]", num);
        return NULL;
    }
    
    if (!GEOSCoordSeq_setY(self->seq, (int)n, value))
    {
        PyErr_SetString(PyExc_Exception, "Failed to set Y");
        return NULL;
    }
    
    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *
CoordSeq_setZ(CoordSeq *self, PyObject *args)
{
    int n;
    unsigned int num;
    double value;
    if (!PyArg_ParseTuple(args, "id", &n, &value))
    {
                return NULL;
        }
    
    GEOSCoordSeq_getSize(self->seq, &num);
    if (num == 0)
    {
        PyErr_SetString(PyExc_Exception, "Sequence has no coordinates");
        return NULL;
    }
    
    if (n < 0 || n >= num)
    {
        PyErr_Format(PyExc_IndexError,
                     "Index is beyond valid range [0:%d]", num);
        return NULL;
    }
    
    if (!GEOSCoordSeq_setZ(self->seq, (int)n, value))
    {
        PyErr_SetString(PyExc_Exception, "Failed to set Z");
        return NULL;
    }
    
    Py_INCREF(Py_None);
    return Py_None;
}

/* === Define Methods === */

static PyMethodDef coordseq_methods[] = {
    {"getSize", (PyCFunction)CoordSeq_getSize, METH_NOARGS, "Returns number of coordinates in the sequence"},
    {"getDimensions", (PyCFunction)CoordSeq_getDimensions, METH_NOARGS, "Returns number of coordinate dimensions"},
    {"clone", (PyCFunction)CoordSeq_clone, METH_NOARGS, "Returns clone"},
    {"getX", (PyCFunction)CoordSeq_getX, METH_O, "Get Nth X, index starting at 0"},
    {"getY", (PyCFunction)CoordSeq_getY, METH_O, "Get Nth Y, index starting at 0"},
    {"getZ", (PyCFunction)CoordSeq_getZ, METH_O, "Get Nth Z, index starting at 0"},
    {"setX", (PyCFunction)CoordSeq_setX, METH_VARARGS, "Set Nth X, index starting at 0"},
    {"setY", (PyCFunction)CoordSeq_setY, METH_VARARGS, "Set Nth Y, index starting at 0"},
    {"setZ", (PyCFunction)CoordSeq_setZ, METH_VARARGS, "Set Nth Z, index starting at 0"},
    {NULL}
};

/* === Define Type === */

static PyTypeObject CoordinateSequenceType = {
    PyObject_HEAD_INIT(NULL)
    0,                              /*ob_size*/
    "GEOSCoordinateSequence", /*tp_name*/
    sizeof(CoordSeq),               /*tp_basicsize*/
    0,                              /*tp_itemsize*/
    (destructor)CoordSeq_dealloc,   /*tp_dealloc*/
    0,                              /*tp_print*/
    0,                              /*tp_getattr*/
    0,                              /*tp_setattr*/
    0,                              /*tp_compare*/
    0,                              /*tp_repr*/
    0,                              /*tp_as_number*/
    0,                              /*tp_as_sequence*/
    0,                              /*tp_as_mapping*/
    0,                              /*tp_hash */
    0,                              /*tp_call*/
    0,                              /*tp_str*/
    0,                              /*tp_getattro*/
    0,                              /*tp_setattro*/
    0,                              /*tp_as_buffer*/
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
    "A GEOS Coordinate Sequence",           /* tp_doc */
    0,                         /* tp_traverse */
    0,                         /* tp_clear */
    0,                         /* tp_richcompare */
    0,                         /* tp_weaklistoffset */
    0,                         /* tp_iter */
    0,                         /* tp_iternext */
    coordseq_methods,             /* tp_methods */
    0,                     /* tp_members */
    0,                         /* tp_getset */
    0,                         /* tp_base */
    0,                         /* tp_dict */
    0,                         /* tp_descr_get */
    0,                         /* tp_descr_set */
    0,                         /* tp_dictoffset */
    0,      /* tp_init */
    0,                         /* tp_alloc */
    0,                 /* tp_new */
};

/*
==============================================================================
 Geometry
==============================================================================
*/

/* === Alloc/dealloc === */

static void
Geometry_dealloc(Geometry *self)
{
    if (self->owns && self->geom != NULL)
    {
        GEOSGeom_destroy(self->geom);
    }
    self->geom = NULL;
    self->ob_type->tp_free((PyObject*) self);
}

PyObject *
Geometry_New(GEOSGeom g)
{
    Geometry *self;
    
    if (!g)
        return NULL;
    
    self = PyObject_NEW(Geometry, &GeometryType);
    if (self == NULL)
    {
        GEOSGeom_destroy(g);
        return NULL;
    }
    
    self->geom = g;
    self->owns = 1;
    return (PyObject *) self;
}

static PyObject *
Geometry_clone(PyObject *self)
{
    Geometry *g;
    GEOSGeom new;

    g = (Geometry *) self;
    if (!g->geom)
    {
        PyErr_SetString(PyExc_Exception, "NULL GEOSGeom");
        return NULL;
    }
    
    new = GEOSGeom_clone(g->geom);
    if (!new)
        return NULL;

    return (PyObject *) Geometry_New(new);
}

static PyObject *
_createGeomFromWKB(PyObject *self, PyObject *args)
{
    unsigned char *data=NULL;
    int size;
    GEOSGeom g;
    
    if (!PyArg_ParseTuple(args, "s#", &data, &size))
        return NULL;

    g = GEOSGeomFromWKB_buf(data, (size_t)size);
    if (!g)
    {
        /* Rely on exception set by GEOS through error_handler */
        return NULL;
    }
        
    return Geometry_New(g);
}

static PyObject *
_updateGeomFromWKB(PyObject *self, PyObject *args)
{
    unsigned char *data=NULL;
    int size;
    GEOSGeom g;
    Geometry *gs;
    
    if (!PyArg_ParseTuple(args, "s#", &data, &size))
        return NULL;

    g = GEOSGeomFromWKB_buf(data, (size_t)size);
    if (!g)
    {
        /* Rely on exception set by GEOS through error_handler */
        return NULL;
    }

    gs = (Geometry *) self;
    if (gs->geom)
        GEOSGeom_destroy(gs->geom);
    gs->geom = g;
    gs->owns = 1;
    
    Py_INCREF(Py_None);
    return Py_None;
}
    
static PyObject *
_createGeomFromWKT(PyObject *self, PyObject *args)
{
    char *data;
    GEOSGeom g;
    
    if (!PyArg_ParseTuple(args, "s", &data))
        return NULL;
        
    g = GEOSGeomFromWKT(data);
    if (!g)
    {
        /* Rely on exception set by GEOS through error_handler */
        return NULL;
    }
    
    return Geometry_New(g);
}

static PyObject *
_updateGeomFromWKT(PyObject *self, PyObject *args)
{
    char *data;
    GEOSGeom g;
    Geometry *gs;

    if (!PyArg_ParseTuple(args, "s", &data))
        return NULL;
        
    g = GEOSGeomFromWKT(data);
    if (!g)
    {
        /* Rely on exception set by GEOS through error_handler */
        return NULL;
    }

    gs = (Geometry *) self;
    if (gs->geom)
        GEOSGeom_destroy(gs->geom);
    gs->geom = g;
    gs->owns = 1;
    
    Py_INCREF(Py_None);
    return Py_None;
}
    
static PyObject *
_createGeomFromCoordSeq(PyObject *self, PyObject *args)
{
    PyObject *seq=NULL;
    int typeid;
    GEOSGeom g;
    CoordSeq *s;
    PyObject *geom;
    unsigned int size=0;
    
    if (!PyArg_ParseTuple(args, "O!i", &CoordinateSequenceType, &seq,  &typeid))
        return NULL;

    s = (CoordSeq *) seq;

    GEOSCoordSeq_getSize(s->seq, &size);
    if (size < 1)
    {
        PyErr_SetString(PyExc_ValueError, "Geometry can not be created from a zero length sequence");
        return NULL;
    }
    
    switch (typeid)
    {
        case GEOS_POINT: