/* 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(parts) != 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
