libraries/pyshapelib/shapelib.c

/* SWIG (www.swig.org) interface file for shapelib
 *
 * At the moment (Dec 2000) this file is only useful to generate Python
 * bindings. Invoke swig as follows:
 *
 *      swig -python -shadow shapelib.i
 *
 * to generate shapelib_wrap.c and shapelib.py. shapelib_wrap.c
 * defines a bunch of Python-functions that wrap the appripriate
 * shapelib functions and shapelib.py contains an object oriented
 * wrapper around shapelib_wrap.c.
 *
 * Shapelib, and hence this module too, defines two types of objects,
 * shapes and shapefiles.
 */

%module shapelib

/*
 * First, a %{,%}-Block. These blocks are copied verbatim to the
 * shapelib_wrap.c file and are not parsed by SWIG. This is the place to
 * import headerfiles and define helper-functions that are needed by the
 * automatically generated wrappers.
 */

%{

/* import the shapelib headefile. */
#include "shapefil.h"
#include "pyshapelib_api.h"
    
/*
 * Rename a few shapelib functions that are effectively methods with
 * preprocessor macros so that they have the names that swig expects
 * (e.g. the destructor of SHPObject has to be called delete_SHPObject)
 */

#define delete_SHPObject SHPDestroyObject
    
/*
 * The extents() method of SHPObject.
 *
 * Return the extents as a tuple of two 4-element lists with the min.
 * and max. values of x, y, z, m.
 */
static PyObject *
SHPObject_extents(SHPObject *object)
{
    return Py_BuildValue("[dddd][dddd]",
                         object->dfXMin, object->dfYMin, object->dfZMin,
                         object->dfMMin, 
                         object->dfXMax, object->dfYMax, object->dfZMax,
                         object->dfMMax);
}


/*
 * The vertices() method of SHPObject.
 *
 * Return the x and y coords of the vertices as a list of lists of
 * tuples.
 */

static PyObject* build_vertex_list(SHPObject *object, int index, int length);

static PyObject*
SHPObject_vertices(SHPObject *object)
{
    PyObject *result = NULL;
    PyObject *part = NULL;
    int part_idx, vertex_idx;
    int length = 0;


    if (object->nParts > 0)
    {
        /* A multipart shape. Usual for SHPT_ARC and SHPT_POLYGON */
        
        result = PyList_New(object->nParts);
        if (!result)
            return NULL;

        for (part_idx = 0, vertex_idx = 0; part_idx < object->nParts;
             part_idx++)
        {
            if (part_idx < object->nParts - 1)
                length = (object->panPartStart[part_idx + 1]
                          - object->panPartStart[part_idx]);
            else
                length = object->nVertices - object->panPartStart[part_idx];
            
            part = build_vertex_list(object, vertex_idx, length);
            if (!part)
                goto fail;

            if (PyList_SetItem(result, part_idx, part) < 0)
                goto fail;

            vertex_idx += length;
        }
    }
    else
    {
        /* only one part. usual for SHPT_POINT */
        result = build_vertex_list(object, 0, object->nVertices);
    }

    return result;

 fail:
    Py_XDECREF(part);
    Py_DECREF(result);
    return NULL;
}


/* Return the length coordinates of the shape object starting at vertex
 * index as a Python-list of tuples. Helper function for
 * SHPObject_vertices.
 */
static PyObject*
build_vertex_list(SHPObject *object, int index, int length)
{
    int i;
    PyObject * list;
    PyObject * vertex = NULL;

    list = PyList_New(length);
    if (!list)
        return NULL;

    for (i = 0; i < length; i++, index++)
    {
        vertex = Py_BuildValue("dd", object->padfX[index],
                               object->padfY[index]);
        if (!vertex)
            goto fail;
        if (PyList_SetItem(list, i, vertex) < 0)
            goto fail;
    }

    return list;

 fail:
    Py_XDECREF(vertex);
    Py_DECREF(list);
    return NULL;
}


/* The constructor of SHPObject. parts is a list of lists of tuples
 * describing the parts and their vertices just likethe output of the
 * vertices() method. part_type_list is the list of part-types and may
 * be NULL. For the meaning of the part-types and their default value
 * see the Shaplib documentation.
 */
SHPObject * new_SHPObject(int type, int id, PyObject * parts,
                          PyObject * part_type_list)
{
    /* arrays to hold thex and y coordinates of the  vertices */
    double *xs = NULL, *ys = NULL;
    /* number of all vertices of all parts */
    int num_vertices;
    /* number of parts in the list parts */
    int num_parts;
    /* start index of in xs and ys of the part currently worked on */
    int part_start;
    /* array of start indices in xs and ys as expected by shapelib */
    int *part_starts = NULL;

    /* generic counter */
    int i;

    /* array of part types. holds the converted content of
     * part_type_list. Stays NULL of part_type_list is NULL
     */
    int *part_types = NULL;

    /* temporary python objects referring to the the list items being
     * worked on.
     */
    PyObject * part = NULL, *tuple = NULL;

    /* The result object */
    SHPObject *result;

    num_parts = PySequence_Length(parts);
    num_vertices = 0; 

    /* parts and part_types have to have the same lengths */
    if (part_type_list
        && PySequence_Length(part) != PySequence_Length(part_type_list))
    {
        PyErr_SetString(PyExc_TypeError,
                        "parts and part_types have to have the same lengths");
        return NULL;
    }

    /* determine how many vertices there are altogether */
    for (i = 0; i < num_parts; i++)
    {
        PyObject * part = PySequence_GetItem(parts, i);
        if (!part)
            return NULL;
        num_vertices += PySequence_Length(part);
        Py_DECREF(part);
    }

    /* allocate the memory for the various arrays and check for memory
       errors */
    xs = malloc(num_vertices * sizeof(double));
    ys = malloc(num_vertices * sizeof(double));
    part_starts = malloc(num_parts * sizeof(int));
    if (part_type_list)
        part_types = malloc(num_parts * sizeof(int));

    if (!xs || !ys || !part_starts || (part_type_list && !part_types))
    {
        PyErr_NoMemory();
        goto fail;
    }

    /* convert the part types */
    if (part_type_list)
    {
        for (i = 0; i < num_parts; i++)
        {
            PyObject * otype = PySequence_GetItem(part_type_list, i);
            if (!otype)
                return NULL;
            part_types[i] = PyInt_AsLong(otype);
            Py_DECREF(otype);
        }
    }

    /* convert the list of parts */
    part_start = 0;
    for (i = 0; i < num_parts; i++)
    {
        int j, length;

        part = PySequence_GetItem(parts, i);
        length = PySequence_Length(part);
        part_starts[i] = part_start;

        for (j = 0; j < length; j++)
        {
            tuple = PySequence_GetItem(part, j);
            if (!tuple)
                goto fail;

            if (!PyArg_ParseTuple(tuple, "dd", xs + part_start + j,
                                  ys + part_start + j))
            {
                goto fail;
            }
            Py_DECREF(tuple);
            tuple = NULL;
        }
        Py_DECREF(part);
        part = NULL;
        part_start += length;
    }

    result = SHPCreateObject(type, id, num_parts, part_starts, part_types,
                             num_vertices, xs, ys, NULL, NULL);
    free(xs);
    free(ys);
    free(part_starts);
    free(part_types);
    return result;

 fail:
    free(xs);
    free(ys);
    free(part_starts);
    free(part_types);
    Py_XDECREF(part);
    Py_XDECREF(tuple);
    return NULL;
}

%}


/*
 * The SWIG Interface definition.
 */

/* include some common SWIG type definitions and standard exception
   handling code */
%include typemaps.i
%include exception.i


/*
 *  SHPObject -- Represents one shape
 */

/* Exception typemap for the SHPObject constructor. The constructor the
   the wrapper function defined above which returns NULL in case of
   error. */
   
%typemap(python,except) SHPObject*new_SHPObject {
    $function;
    if (PyErr_Occurred())
        return NULL;
}

/* Define the SHPObject struct for SWIG. This has to have the same name
 * as the underlying C-struct in shapfil.h, but we don't have to repeat
 * all the fields here, only those we want to access directly, and we
 * can define methods for the object oriented interface.
 */

typedef struct {

    /* The shape object has two read-only attributes: */

    /* The type of the shape. In the c-struct defined the field is
     * called 'nSHPType' but for the python bindings 'type' is more
     * appropriate.
     */
    %readonly %name(type) int nSHPType;

    /* The id of the shape. Here 'id' is a better name than 'nShapeId'. */
    %readonly %name(id) int nShapeId;

    /* The methods */
    %addmethods {

        /* the constructor */
        SHPObject(int type, int id, PyObject * parts,
                  PyObject * part_types = NULL);

        /* The destructor */
        ~SHPObject();

        /* extents and vertices correspond to the SHPObject_extents and
         * SHPObject_vertices defined above
         */
        PyObject *extents();
        PyObject *vertices();
    }
} SHPObject;


/*
 * ShapeFile --  Represents the shape file
 */

/* Here we do things a little different. We define a new C-struct that
 * holds the SHPHandle. This is mainly done so we can separate the
 * close() method from the destructor but it also helps with exception
 * handling.
 *
 * After the ShapeFile has been opened or created the handle is not
 * NULL. The close() method closes the file and sets handle to NULL as
 * an indicator that the file has been closed.
 */

/* First, define the C-struct */
%{
    typedef struct {
        SHPHandle handle;
    } ShapeFile;
%}

/* define and use some typemaps for the info() method whose
 * C-implementation has four output parameters that are returned through
 * pointers passed into the function. SWIG already has definitions for
 * common types such as int* and we can use those for the first two
 * parameters:
 */
 
%apply int * OUTPUT { int * output_entities }
%apply int * OUTPUT { int * output_type }

/* for the last two, the 4-element arrays of min- and max-values, we
 * have to define our own typemaps:
 */
%typemap (python,ignore) double * extents(double temp[4]) {
    $target = temp;
}

%typemap (python,argout) double * extents {
    PyObject * list = Py_BuildValue("[dddd]",
                                    $source[0], $source[1],
                                    $source[2], $source[3]);
    $target = t_output_helper($target,list);
}

%apply double * extents { double * output_min_bounds }
%apply double * extents { double * output_max_bounds }

/* The first argument to the ShapeFile methods is a ShapeFile pointer.
 * We have to check whether handle is not NULL in most methods but not
 * all. In the destructor and the close method, it's OK for handle to be
 * NULL. We achieve this by checking whether the preprocessor macro
 * NOCHECK_$name is defined. SWIG replaces $name with the name of the
 * function for which the code is inserted. In the %{,%}-block below we
 * define the macros for the destructor and the close() method.
 */


%typemap(python,check) ShapeFile *{
    %#ifndef NOCHECK_$name
    if (!$target || !$target->handle)
        SWIG_exception(SWIG_TypeError, "shapefile already closed");
    %#endif
}

%{
#define NOCHECK_delete_ShapeFile
#define NOCHECK_ShapeFile_close
%}

/* An exception handle for the constructor and the module level open()
 * and create() functions.
 *
 * Annoyingly, we *have* to put braces around the SWIG_exception()
 * calls, at least in the python case, because of the way the macro is
 * written. Of course, always putting braces around the branches of an
 * if-statement is often considered good practice.
 */
%typemap(python,except) ShapeFile * {
    $function;
    if (!$source)
    {
        SWIG_exception(SWIG_MemoryError, "no memory");
    }
    else if (!$source->handle)
    {
        SWIG_exception(SWIG_IOError, "$name failed");
    }
}


/*
 * The SWIG-version of the ShapeFile struct.
 */

typedef struct
{
    /* Only methods and no attributes here: */ 
    %addmethods {

        /* The constructor. Takes two arguments, the filename and the
         * optinal mode which are passed through to SHPOpen (due to the
         * renaming trick)
         */
        ShapeFile(char *file, char * mode = "rb") {
            ShapeFile * self = malloc(sizeof(ShapeFile));
            if (self)
                self->handle = SHPOpen(file, mode);
            return self;
        }

        /* The destructor. Equivalent to SHPClose */
        ~ShapeFile() {
            if (self->handle)
                SHPClose(self->handle);
            free(self);
        }

        /* close the shape file and set handle to NULL */
        void close() {
            if (self->handle)
            {
                SHPClose(self->handle);
                self->handle = NULL;
            }
        }

        /* info() -- Return a tuple (NUM_SHAPES, TYPE, MIN, MAX) where
         * NUM_SHAPES is the number of shapes in the file, TYPE is the
         * shape type and MIN and MAX are 4-element lists with the min.
         * and max. values of the data.
         *
         * The arguments of the underlying shapelib function SHPGetInfo
         * are all output parameters. To tell SWIG this, we have defined
         * some typemaps above
         */
        void info(int * output_entities, int * output_type,
                  double * output_min_bounds, double *output_max_bounds) {
            SHPGetInfo(self->handle, output_entities, output_type,
                       output_min_bounds, output_max_bounds);
        }

        /* Return object number i */
        %new SHPObject * read_object(int i) {
            return SHPReadObject(self->handle, i);
        }

        /* Write an object */
        int write_object(int iShape, SHPObject * psObject) {
            return SHPWriteObject(self->handle, iShape, psObject);
        }

        /* Return the shapelib SHPHandle as a Python CObject */
        PyObject * cobject() {
            return PyCObject_FromVoidPtr(self->handle, NULL);
        }
    }

} ShapeFile;


/*
 * Two module level functions, open() and create() that correspond to
 * SHPOpen and SHPCreate respectively. open() is equivalent to the
 * ShapeFile constructor.
 */

%{
    ShapeFile * open_ShapeFile(const char *filename, const char * mode) {
        ShapeFile * self = malloc(sizeof(ShapeFile));
        if (self)
            self->handle = SHPOpen(filename, mode);
        return self;
    }
%}

%name(open) %new ShapeFile *open_ShapeFile(const char *filename,
                                           const char * mode = "rb");


%{
    ShapeFile * create_ShapeFile(const char *filename, int type) {
        ShapeFile * self = malloc(sizeof(ShapeFile));
        if (self)
            self->handle = SHPCreate(filename, type);
        return self;
    }
%}    

%name(create) %new ShapeFile * create_ShapeFile(const char *filename,
                                                int type);
    

/* Module level function to expose some of the shapelib functions linked
 * with the shapefile C-module to other Python extension modules. This
 * is a kludge to make a Thuban extension work that reads shapes from
 * shapefiles opened by the shapefile module.
 */

%{
    static PyShapeLibAPI the_api = {
        SHPReadObject,
        SHPDestroyObject,
        SHPCreateTree,
        SHPDestroyTree,
        SHPTreeFindLikelyShapes
    };

    PyObject * c_api() {
        return PyCObject_FromVoidPtr(&the_api, NULL);
    }
%}

PyObject * c_api();


/*
 *  Module Level functions 
 */

/* convert shapefile types to names */
%name(type_name) const char *SHPTypeName(int nSHPType);
%name(part_type_name) const char *SHPPartTypeName(int nPartType);


/*
 * Finally, constants copied from shapefil.h
 */

/* -------------------------------------------------------------------- */
/*      Shape types (nSHPType)                                          */
/* -------------------------------------------------------------------- */
#define SHPT_NULL       0
#define SHPT_POINT      1
#define SHPT_ARC        3
#define SHPT_POLYGON    5
#define SHPT_MULTIPOINT 8
#define SHPT_POINTZ     11
#define SHPT_ARCZ       13
#define SHPT_POLYGONZ   15
#define SHPT_MULTIPOINTZ 18
#define SHPT_POINTM     21
#define SHPT_ARCM       23
#define SHPT_POLYGONM   25
#define SHPT_MULTIPOINTM 28
#define SHPT_MULTIPATCH 31


/* -------------------------------------------------------------------- */
/*      Part types - everything but SHPT_MULTIPATCH just uses           */
/*      SHPP_RING.                                                      */
/* -------------------------------------------------------------------- */

#define SHPP_TRISTRIP   0
#define SHPP_TRIFAN     1
#define SHPP_OUTERRING  2
#define SHPP_INNERRING  3
#define SHPP_FIRSTRING  4
#define SHPP_RING       5


1	jan	1611	/* SWIG (www.swig.org) interface file for shapelib
2			*
3			* At the moment (Dec 2000) this file is only useful to generate Python
4			* bindings. Invoke swig as follows:
5			*
6			* swig -python -shadow shapelib.i
7			*
8			* to generate shapelib_wrap.c and shapelib.py. shapelib_wrap.c
9			* defines a bunch of Python-functions that wrap the appripriate
10			* shapelib functions and shapelib.py contains an object oriented
11			* wrapper around shapelib_wrap.c.
12			*
13			* Shapelib, and hence this module too, defines two types of objects,
14			* shapes and shapefiles.
15			*/
16
17			%module shapelib
18
19			/*
20			* First, a %{,%}-Block. These blocks are copied verbatim to the
21			* shapelib_wrap.c file and are not parsed by SWIG. This is the place to
22			* import headerfiles and define helper-functions that are needed by the
23			* automatically generated wrappers.
24			*/
25
26			%{
27
28			/* import the shapelib headefile. */
29			#include "shapefil.h"
30			#include "pyshapelib_api.h"
31
32			/*
33			* Rename a few shapelib functions that are effectively methods with
34			* preprocessor macros so that they have the names that swig expects
35			* (e.g. the destructor of SHPObject has to be called delete_SHPObject)
36			*/
37
38			#define delete_SHPObject SHPDestroyObject
39
40			/*
41			* The extents() method of SHPObject.
42			*
43			* Return the extents as a tuple of two 4-element lists with the min.
44			* and max. values of x, y, z, m.
45			*/
46			static PyObject *
47			SHPObject_extents(SHPObject *object)
48			{
49			return Py_BuildValue("[dddd][dddd]",
50			object->dfXMin, object->dfYMin, object->dfZMin,
51			object->dfMMin,
52			object->dfXMax, object->dfYMax, object->dfZMax,
53			object->dfMMax);
54			}
55
56
57			/*
58			* The vertices() method of SHPObject.
59			*
60			* Return the x and y coords of the vertices as a list of lists of
61			* tuples.
62			*/
63
64			static PyObject* build_vertex_list(SHPObject *object, int index, int length);
65
66			static PyObject*
67			SHPObject_vertices(SHPObject *object)
68			{
69			PyObject *result = NULL;
70			PyObject *part = NULL;
71			int part_idx, vertex_idx;
72			int length = 0;
73
74
75			if (object->nParts > 0)
76			{
77			/* A multipart shape. Usual for SHPT_ARC and SHPT_POLYGON */
78
79			result = PyList_New(object->nParts);
80			if (!result)
81			return NULL;
82
83			for (part_idx = 0, vertex_idx = 0; part_idx < object->nParts;
84			part_idx++)
85			{
86			if (part_idx < object->nParts - 1)
87			length = (object->panPartStart[part_idx + 1]
88			- object->panPartStart[part_idx]);
89			else
90			length = object->nVertices - object->panPartStart[part_idx];
91
92			part = build_vertex_list(object, vertex_idx, length);
93			if (!part)
94			goto fail;
95
96			if (PyList_SetItem(result, part_idx, part) < 0)
97			goto fail;
98
99			vertex_idx += length;
100			}
101			}
102			else
103			{
104			/* only one part. usual for SHPT_POINT */
105			result = build_vertex_list(object, 0, object->nVertices);
106			}
107
108			return result;
109
110			fail:
111			Py_XDECREF(part);
112			Py_DECREF(result);
113			return NULL;
114			}
115
116
117			/* Return the length coordinates of the shape object starting at vertex
118			* index as a Python-list of tuples. Helper function for
119			* SHPObject_vertices.
120			*/
121			static PyObject*
122			build_vertex_list(SHPObject *object, int index, int length)
123			{
124			int i;
125			PyObject * list;
126			PyObject * vertex = NULL;
127
128			list = PyList_New(length);
129			if (!list)
130			return NULL;
131
132			for (i = 0; i < length; i++, index++)
133			{
134			vertex = Py_BuildValue("dd", object->padfX[index],
135			object->padfY[index]);
136			if (!vertex)
137			goto fail;
138			if (PyList_SetItem(list, i, vertex) < 0)
139			goto fail;
140			}
141
142			return list;
143
144			fail:
145			Py_XDECREF(vertex);
146			Py_DECREF(list);
147			return NULL;
148			}
149
150
151
152
153
154			/* The constructor of SHPObject. parts is a list of lists of tuples
155			* describing the parts and their vertices just likethe output of the
156			* vertices() method. part_type_list is the list of part-types and may
157			* be NULL. For the meaning of the part-types and their default value
158			* see the Shaplib documentation.
159			*/
160			SHPObject * new_SHPObject(int type, int id, PyObject * parts,
161			PyObject * part_type_list)
162			{
163			/* arrays to hold thex and y coordinates of the vertices */
164			double xs = NULL, ys = NULL;
165			/* number of all vertices of all parts */
166			int num_vertices;
167			/* number of parts in the list parts */
168			int num_parts;
169			/* start index of in xs and ys of the part currently worked on */
170			int part_start;
171			/* array of start indices in xs and ys as expected by shapelib */
172			int *part_starts = NULL;
173
174			/* generic counter */
175			int i;
176
177			/* array of part types. holds the converted content of
178			* part_type_list. Stays NULL of part_type_list is NULL
179			*/
180			int *part_types = NULL;
181
182			/* temporary python objects referring to the the list items being
183			* worked on.
184			*/
185			PyObject * part = NULL, *tuple = NULL;
186
187			/* The result object */
188			SHPObject *result;
189
190			num_parts = PySequence_Length(parts);
191			num_vertices = 0;
192
193			/* parts and part_types have to have the same lengths */
194			if (part_type_list
195			&& PySequence_Length(part) != PySequence_Length(part_type_list))
196			{
197			PyErr_SetString(PyExc_TypeError,
198			"parts and part_types have to have the same lengths");
199			return NULL;
200			}
201
202			/* determine how many vertices there are altogether */
203			for (i = 0; i < num_parts; i++)
204			{
205			PyObject * part = PySequence_GetItem(parts, i);
206			if (!part)
207			return NULL;
208			num_vertices += PySequence_Length(part);
209			Py_DECREF(part);
210			}
211
212			/* allocate the memory for the various arrays and check for memory
213			errors */
214			xs = malloc(num_vertices * sizeof(double));
215			ys = malloc(num_vertices * sizeof(double));
216			part_starts = malloc(num_parts * sizeof(int));
217			if (part_type_list)
218			part_types = malloc(num_parts * sizeof(int));
219
220			if (!xs \|\| !ys \|\| !part_starts \|\| (part_type_list && !part_types))
221			{
222			PyErr_NoMemory();
223			goto fail;
224			}
225
226			/* convert the part types */
227			if (part_type_list)
228			{
229			for (i = 0; i < num_parts; i++)
230			{
231			PyObject * otype = PySequence_GetItem(part_type_list, i);
232			if (!otype)
233			return NULL;
234			part_types[i] = PyInt_AsLong(otype);
235			Py_DECREF(otype);
236			}
237			}
238
239			/* convert the list of parts */
240			part_start = 0;
241			for (i = 0; i < num_parts; i++)
242			{
243			int j, length;
244
245			part = PySequence_GetItem(parts, i);
246			length = PySequence_Length(part);
247			part_starts[i] = part_start;
248
249			for (j = 0; j < length; j++)
250			{
251			tuple = PySequence_GetItem(part, j);
252			if (!tuple)
253			goto fail;
254
255			if (!PyArg_ParseTuple(tuple, "dd", xs + part_start + j,
256			ys + part_start + j))
257			{
258			goto fail;
259			}
260			Py_DECREF(tuple);
261			tuple = NULL;
262			}
263			Py_DECREF(part);
264			part = NULL;
265			part_start += length;
266			}
267
268			result = SHPCreateObject(type, id, num_parts, part_starts, part_types,
269			num_vertices, xs, ys, NULL, NULL);
270			free(xs);
271			free(ys);
272			free(part_starts);
273			free(part_types);
274			return result;
275
276			fail:
277			free(xs);
278			free(ys);
279			free(part_starts);
280			free(part_types);
281			Py_XDECREF(part);
282			Py_XDECREF(tuple);
283			return NULL;
284			}
285
286			%}
287
288
289
290			/*
291			* The SWIG Interface definition.
292			*/
293
294			/* include some common SWIG type definitions and standard exception
295			handling code */
296			%include typemaps.i
297			%include exception.i
298
299
300			/*
301			* SHPObject -- Represents one shape
302			*/
303
304			/* Exception typemap for the SHPObject constructor. The constructor the
305			the wrapper function defined above which returns NULL in case of
306			error. */
307
308			%typemap(python,except) SHPObject*new_SHPObject {
309			$function;
310			if (PyErr_Occurred())
311			return NULL;
312			}
313
314			/* Define the SHPObject struct for SWIG. This has to have the same name
315			* as the underlying C-struct in shapfil.h, but we don't have to repeat
316			* all the fields here, only those we want to access directly, and we
317			* can define methods for the object oriented interface.
318			*/
319
320			typedef struct {
321
322			/* The shape object has two read-only attributes: */
323
324			/* The type of the shape. In the c-struct defined the field is
325			* called 'nSHPType' but for the python bindings 'type' is more
326			* appropriate.
327			*/
328			%readonly %name(type) int nSHPType;
329
330			/* The id of the shape. Here 'id' is a better name than 'nShapeId'. */
331			%readonly %name(id) int nShapeId;
332
333			/* The methods */
334			%addmethods {
335
336			/* the constructor */
337			SHPObject(int type, int id, PyObject * parts,
338			PyObject * part_types = NULL);
339
340			/* The destructor */
341			~SHPObject();
342
343			/* extents and vertices correspond to the SHPObject_extents and
344			* SHPObject_vertices defined above
345			*/
346			PyObject *extents();
347			PyObject *vertices();
348			}
349			} SHPObject;
350
351
352			/*
353			* ShapeFile -- Represents the shape file
354			*/
355
356			/* Here we do things a little different. We define a new C-struct that
357			* holds the SHPHandle. This is mainly done so we can separate the
358			* close() method from the destructor but it also helps with exception
359			* handling.
360			*
361			* After the ShapeFile has been opened or created the handle is not
362			* NULL. The close() method closes the file and sets handle to NULL as
363			* an indicator that the file has been closed.
364			*/
365
366			/* First, define the C-struct */
367			%{
368			typedef struct {
369			SHPHandle handle;
370			} ShapeFile;
371			%}
372
373			/* define and use some typemaps for the info() method whose
374			* C-implementation has four output parameters that are returned through
375			* pointers passed into the function. SWIG already has definitions for
376			* common types such as int* and we can use those for the first two
377			* parameters:
378			*/
379
380			%apply int * OUTPUT { int * output_entities }
381			%apply int * OUTPUT { int * output_type }
382
383			/* for the last two, the 4-element arrays of min- and max-values, we
384			* have to define our own typemaps:
385			*/
386			%typemap (python,ignore) double * extents(double temp[4]) {
387			$target = temp;
388			}
389
390			%typemap (python,argout) double * extents {
391			PyObject * list = Py_BuildValue("[dddd]",
392			$source[0], $source[1],
393			$source[2], $source[3]);
394			$target = t_output_helper($target,list);
395			}
396
397			%apply double * extents { double * output_min_bounds }
398			%apply double * extents { double * output_max_bounds }
399
400			/* The first argument to the ShapeFile methods is a ShapeFile pointer.
401			* We have to check whether handle is not NULL in most methods but not
402			* all. In the destructor and the close method, it's OK for handle to be
403			* NULL. We achieve this by checking whether the preprocessor macro
404			* NOCHECK_$name is defined. SWIG replaces $name with the name of the
405			* function for which the code is inserted. In the %{,%}-block below we
406			* define the macros for the destructor and the close() method.
407			*/
408
409
410			%typemap(python,check) ShapeFile *{
411			%#ifndef NOCHECK_$name
412			if (!$target \|\| !$target->handle)
413			SWIG_exception(SWIG_TypeError, "shapefile already closed");
414			%#endif
415			}
416
417			%{
418			#define NOCHECK_delete_ShapeFile
419			#define NOCHECK_ShapeFile_close
420			%}
421
422			/* An exception handle for the constructor and the module level open()
423			* and create() functions.
424			*
425			* Annoyingly, we have to put braces around the SWIG_exception()
426			* calls, at least in the python case, because of the way the macro is
427			* written. Of course, always putting braces around the branches of an
428			* if-statement is often considered good practice.
429			*/
430			%typemap(python,except) ShapeFile * {
431			$function;
432			if (!$source)
433			{
434			SWIG_exception(SWIG_MemoryError, "no memory");
435			}
436			else if (!$source->handle)
437			{
438			SWIG_exception(SWIG_IOError, "$name failed");
439			}
440			}
441
442
443			/*
444			* The SWIG-version of the ShapeFile struct.
445			*/
446
447			typedef struct
448			{
449			/* Only methods and no attributes here: */
450			%addmethods {
451
452			/* The constructor. Takes two arguments, the filename and the
453			* optinal mode which are passed through to SHPOpen (due to the
454			* renaming trick)
455			*/
456			ShapeFile(char file, char mode = "rb") {
457			ShapeFile * self = malloc(sizeof(ShapeFile));
458			if (self)
459			self->handle = SHPOpen(file, mode);
460			return self;
461			}
462
463			/* The destructor. Equivalent to SHPClose */
464			~ShapeFile() {
465			if (self->handle)
466			SHPClose(self->handle);
467			free(self);
468			}
469
470			/* close the shape file and set handle to NULL */
471			void close() {
472			if (self->handle)
473			{
474			SHPClose(self->handle);
475			self->handle = NULL;
476			}
477			}
478
479			/* info() -- Return a tuple (NUM_SHAPES, TYPE, MIN, MAX) where
480			* NUM_SHAPES is the number of shapes in the file, TYPE is the
481			* shape type and MIN and MAX are 4-element lists with the min.
482			* and max. values of the data.
483			*
484			* The arguments of the underlying shapelib function SHPGetInfo
485			* are all output parameters. To tell SWIG this, we have defined
486			* some typemaps above
487			*/
488			void info(int * output_entities, int * output_type,
489			double * output_min_bounds, double *output_max_bounds) {
490			SHPGetInfo(self->handle, output_entities, output_type,
491			output_min_bounds, output_max_bounds);
492			}
493
494			/* Return object number i */
495			%new SHPObject * read_object(int i) {
496			return SHPReadObject(self->handle, i);
497			}
498
499			/* Write an object */
500			int write_object(int iShape, SHPObject * psObject) {
501			return SHPWriteObject(self->handle, iShape, psObject);
502			}
503
504			/* Return the shapelib SHPHandle as a Python CObject */
505			PyObject * cobject() {
506			return PyCObject_FromVoidPtr(self->handle, NULL);
507			}
508			}
509
510			} ShapeFile;
511
512
513			/*
514			* Two module level functions, open() and create() that correspond to
515			* SHPOpen and SHPCreate respectively. open() is equivalent to the
516			* ShapeFile constructor.
517			*/
518
519			%{
520			ShapeFile * open_ShapeFile(const char filename, const char mode) {
521			ShapeFile * self = malloc(sizeof(ShapeFile));
522			if (self)
523			self->handle = SHPOpen(filename, mode);
524			return self;
525			}
526			%}
527
528			%name(open) %new ShapeFile open_ShapeFile(const char filename,
529			const char * mode = "rb");
530
531
532			%{
533			ShapeFile * create_ShapeFile(const char *filename, int type) {
534			ShapeFile * self = malloc(sizeof(ShapeFile));
535			if (self)
536			self->handle = SHPCreate(filename, type);
537			return self;
538			}
539			%}
540
541			%name(create) %new ShapeFile * create_ShapeFile(const char *filename,
542			int type);
543
544
545			/* Module level function to expose some of the shapelib functions linked
546			* with the shapefile C-module to other Python extension modules. This
547			* is a kludge to make a Thuban extension work that reads shapes from
548			* shapefiles opened by the shapefile module.
549			*/
550
551			%{
552			static PyShapeLibAPI the_api = {
553			SHPReadObject,
554			SHPDestroyObject,
555			SHPCreateTree,
556			SHPDestroyTree,
557			SHPTreeFindLikelyShapes
558			};
559
560			PyObject * c_api() {
561			return PyCObject_FromVoidPtr(&the_api, NULL);
562			}
563			%}
564
565			PyObject * c_api();
566
567
568			/*
569			* Module Level functions
570			*/
571
572			/* convert shapefile types to names */
573			%name(type_name) const char *SHPTypeName(int nSHPType);
574			%name(part_type_name) const char *SHPPartTypeName(int nPartType);
575
576
577			/*
578			* Finally, constants copied from shapefil.h
579			*/
580
581			/* -------------------------------------------------------------------- */
582			/* Shape types (nSHPType) */
583			/* -------------------------------------------------------------------- */
584			#define SHPT_NULL 0
585			#define SHPT_POINT 1
586			#define SHPT_ARC 3
587			#define SHPT_POLYGON 5
588			#define SHPT_MULTIPOINT 8
589			#define SHPT_POINTZ 11
590			#define SHPT_ARCZ 13
591			#define SHPT_POLYGONZ 15
592			#define SHPT_MULTIPOINTZ 18
593			#define SHPT_POINTM 21
594			#define SHPT_ARCM 23
595			#define SHPT_POLYGONM 25
596			#define SHPT_MULTIPOINTM 28
597			#define SHPT_MULTIPATCH 31
598
599
600			/* -------------------------------------------------------------------- */
601			/* Part types - everything but SHPT_MULTIPATCH just uses */
602			/* SHPP_RING. */
603			/* -------------------------------------------------------------------- */
604
605			#define SHPP_TRISTRIP 0
606			#define SHPP_TRIFAN 1
607			#define SHPP_OUTERRING 2
608			#define SHPP_INNERRING 3
609			#define SHPP_FIRSTRING 4
610			#define SHPP_RING 5
611
612
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision