/[thuban]/branches/WIP-pyshapelib-bramz/libraries/pyshapelib/shapelibmodule.c
ViewVC logotype

Diff of /branches/WIP-pyshapelib-bramz/libraries/pyshapelib/shapelibmodule.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2743 by bramz, Wed Mar 14 20:53:53 2007 UTC revision 2749 by bramz, Thu Mar 22 19:03:27 2007 UTC
# Line 67  static void shpobject_dealloc(SHPObjectO Line 67  static void shpobject_dealloc(SHPObjectO
67          self->ob_type->tp_free((PyObject*)self);          self->ob_type->tp_free((PyObject*)self);
68  }  }
69    
70    static int unpack_vertex(PyObject* vertex, int vertex_type,
71                    double* xs, double* ys, double* zs, double* ms, int offset);
72    
73  /* The constructor of SHPObject. parts is a list of lists of tuples  /* The constructor of SHPObject. parts is a list of lists of tuples
74  * describing the parts and their vertices just likethe output of the  * describing the parts and their vertices just likethe output of the
75  * vertices() method. part_type_list is the list of part-types and may  * vertices() method. part_type_list is the list of part-types and may
# Line 97  static int shpobject_init(SHPObjectObjec Line 100  static int shpobject_init(SHPObjectObjec
100          int has_m;          int has_m;
101                    
102          int i;          int i;
103          int ok, return_code = -1;          int return_code = -1;
104                    
105          /* first, unpack parameters */          /* first, unpack parameters */
106          if (kwds != NULL && PyDict_Size(kwds) > 0)          if (kwds != NULL && PyDict_Size(kwds) > 0)
# Line 105  static int shpobject_init(SHPObjectObjec Line 108  static int shpobject_init(SHPObjectObjec
108                  PyErr_Format(PyExc_TypeError, "shapelib.SHPObject.__init__ takes no keyword arguments");                  PyErr_Format(PyExc_TypeError, "shapelib.SHPObject.__init__ takes no keyword arguments");
109                  return -1;                  return -1;
110          }          }
111          if (!PyArg_ParseTuple(args, "iiO|O", &type, &id, &parts, &part_type_list)) return -1;          if (!PyArg_ParseTuple(args, "iiO|O:__init__", &type, &id, &parts, &part_type_list)) return -1;
112    
113          /* check parts */          /* check parts */
114          if (!PySequence_Check(parts))          if (!PySequence_Check(parts))
# Line 202  static int shpobject_init(SHPObjectObjec Line 205  static int shpobject_init(SHPObjectObjec
205                  for (j = 0; j < length; ++j)                  for (j = 0; j < length; ++j)
206                  {                  {
207                          PyObject* vertex = PySequence_ITEM(part, j);                          PyObject* vertex = PySequence_ITEM(part, j);
208                          switch (vertex_type)                          if (!unpack_vertex(vertex, vertex_type, xs, ys, zs, ms, part_start + j))
                         {  
                         case vtXY:  
                                 ok = PyArg_ParseTuple(vertex, "dd", xs + part_start + j, ys + part_start + j);  
                                 break;  
                         case vtXYM:  
                                 ok = PyArg_ParseTuple(vertex, "ddd", xs + part_start + j, ys + part_start + j, ms + part_start + j);  
                                 break;  
                         case vtXYZM:  
                                 ms[part_start + j] = 0.;  
                                 ok = PyArg_ParseTuple(vertex, "ddd|d", xs + part_start + j, ys + part_start + j, zs + part_start + j,  
                                         ms + part_start + j);  
                                 break;  
                         }  
                         Py_DECREF(vertex);  
                         if (!ok)  
209                          {                          {
210                                    Py_DECREF(vertex);
211                                  PyErr_SetString(PyExc_TypeError, "at least one vertex is of the wrong format");                                  PyErr_SetString(PyExc_TypeError, "at least one vertex is of the wrong format");
212                                  goto exit;                                  goto exit;
213                          }                          }
214                            Py_DECREF(vertex);
215                  }                  }
216                  Py_DECREF(part);                  Py_DECREF(part);
217                  part = NULL;                  part = NULL;
# Line 242  exit: Line 232  exit:
232          return return_code;          return return_code;
233  }  }
234    
235    /* helper for shpobject_init. Unpacks vertices
236     */
237    static int unpack_vertex(PyObject* vertex, int vertex_type,
238                    double* xs, double* ys, double* zs, double* ms, int offset)
239    {
240            int ok;
241            PyObject* m_object;
242            PyObject *err_type, *err_value, *err_traceback;
243    
244            switch (vertex_type)
245            {
246            case vtXY:
247                    return PyArg_ParseTuple(vertex, "dd:__init__", xs + offset, ys + offset);
248    
249            case vtXYM:
250                    ms[offset] = PYSHAPELIB_NO_DATA;
251                    ok = PyArg_ParseTuple(vertex, "dd|d:__init__", xs + offset, ys + offset, ms + offset);
252                    if (!ok)
253                    {
254                            /* maybe they specified None as M value */
255                            PyErr_Fetch(&err_type, &err_value, &err_traceback);
256                            ok = PyArg_ParseTuple(vertex, "ddO:__init__", xs + offset, ys + offset, &m_object);
257                            if (ok && m_object == Py_None)
258                            {
259                                    Py_XDECREF(err_type);
260                                    Py_XDECREF(err_value);
261                                    Py_XDECREF(err_traceback);
262                            }
263                            else
264                            {
265                                    PyErr_Restore(err_type, err_value, err_traceback);
266                            }
267                    }
268                    return ok;
269    
270            case vtXYZM:
271                    zs[offset] = 0.;
272                    ms[offset] = PYSHAPELIB_NO_DATA;
273                    ok = PyArg_ParseTuple(vertex, "dd|dd:__init__", xs + offset, ys + offset,
274                                    zs + offset, ms + offset);
275                    if (!ok)
276                    {
277                            /* maybe they specified None as M value */
278                            PyErr_Fetch(&err_type, &err_value, &err_traceback);
279                            ok = PyArg_ParseTuple(vertex, "dddO:__init__", xs + offset, ys + offset,
280                                            zs + offset, &m_object);
281                            if (ok && m_object == Py_None)
282                            {
283                                    Py_XDECREF(err_type);
284                                    Py_XDECREF(err_value);
285                                    Py_XDECREF(err_traceback);
286                            }
287                            else
288                            {
289                                    PyErr_Restore(err_type, err_value, err_traceback);
290                            }
291                    }
292                    return ok;
293    
294            default:
295                    PyErr_SetString(PyExc_NotImplementedError, "vertex type not implemented");
296                    return 0;
297            }
298    }
299    
300  /*  /*
301  * The extents() method of SHPObject.  * The extents() method of SHPObject.
302  *  *
# Line 340  static PyObject* build_vertex_list(SHPOb Line 395  static PyObject* build_vertex_list(SHPOb
395                  case vtXYM:                  case vtXYM:
396                          vertex = Py_BuildValue("ddd", object->padfX[index], object->padfY[index],                          vertex = Py_BuildValue("ddd", object->padfX[index], object->padfY[index],
397                                  object->padfM[index]);                                  object->padfM[index]);
398                            break;
399                  case vtXYZM:                  case vtXYZM:
400                          vertex = Py_BuildValue("dddd", object->padfX[index], object->padfY[index],                          vertex = Py_BuildValue("dddd", object->padfX[index], object->padfY[index],
401                                  object->padfZ[index], object->padfM[index]);                                  object->padfZ[index], object->padfM[index]);
# Line 436  static PyObject* shpobject_repr(SHPObjec Line 492  static PyObject* shpobject_repr(SHPObjec
492    
493  static struct PyMethodDef shpobject_methods[] =  static struct PyMethodDef shpobject_methods[] =
494  {  {
495          {"extents", (PyCFunction)shpobject_extents, METH_NOARGS, NULL},          {"extents", (PyCFunction)shpobject_extents, METH_NOARGS,
496          {"vertices", (PyCFunction)shpobject_vertices, METH_NOARGS, NULL},                  "extents() -> ((x_min, y_min, z_min, m_min), (x_max, y_max, z_max, m_max))\n\n"
497          {"part_types", (PyCFunction)shpobject_part_types, METH_NOARGS, NULL},                  "returns the 4D bounding box of the SHPObject"},
498            {"vertices", (PyCFunction)shpobject_vertices, METH_NOARGS,
499                    "vertices() ->  [[(x, y, ...), ...], ...]\n\n"
500                    "Returns a list of object parts, where each part is again a list of vertices. "
501                    "Each vertex is a tuple of two to four doubles, depending on the object type."},
502            {"part_types", (PyCFunction)shpobject_part_types, METH_NOARGS,
503                    "part_types() -> tuple\n\n"
504                    "returns a tuple of integers, each integer indicating the type of the "
505                    "corresponding part in vertices()"},
506          {NULL}          {NULL}
507  };  };
508    
509  static struct PyGetSetDef shpobject_getsetters[] =  static struct PyGetSetDef shpobject_getsetters[] =
510  {  {
511          {"type", (getter)shpobject_type, NULL, NULL },          {"type", (getter)shpobject_type, NULL, "type of the object (read-only)" },
512          {"id", (getter)shpobject_id, NULL, NULL },          {"id", (getter)shpobject_id, NULL, "id of the object (read-only)" },
513          {NULL}          {NULL}
514  };  };
515    
# Line 485  static int shapefile_init(ShapeFileObjec Line 549  static int shapefile_init(ShapeFileObjec
549  {  {
550          char* file;          char* file;
551          char* mode = "rb";          char* mode = "rb";
552          if (kwds != NULL && PyDict_Size(kwds) > 0)          static char *kwlist[] = {"name", "mode", NULL};
553          {          if (!PyArg_ParseTupleAndKeywords(args, kwds, "et|s:__init__", kwlist,
554                  PyErr_Format(PyExc_TypeError, "shapelib.ShapeFile.__init__ takes no keyword arguments");                  Py_FileSystemDefaultEncoding, &file, &mode)) return -1;
                 return -1;  
         }  
         if (!PyArg_ParseTuple(args, "s|s", &file, &mode)) return -1;  
555                    
556          self->handle = SHPOpen(file, mode);          self->handle = SHPOpen(file, mode);
557            if (!self->handle)
558            {
559                    PyErr_SetFromErrnoWithFilename(PyExc_IOError, file);
560            }
561    
562            PyMem_Free(file);
563          return self->handle ? 0 : -1;          return self->handle ? 0 : -1;
564  }  }
565    
# Line 518  static PyObject* shapefile_read_object(S Line 585  static PyObject* shapefile_read_object(S
585          SHPObject* object;          SHPObject* object;
586          SHPObjectObject* result;          SHPObjectObject* result;
587                    
588          if (!PyArg_ParseTuple(args, "i", &index)) return NULL;          if (!PyArg_ParseTuple(args, "i:read_object", &index)) return NULL;
589                    
590          object = SHPReadObject(self->handle, index);              object = SHPReadObject(self->handle, index);    
591          if (!object)          if (!object)
# Line 542  static PyObject* shapefile_write_object( Line 609  static PyObject* shapefile_write_object(
609          int index, result;          int index, result;
610          PyObject* object;          PyObject* object;
611                    
612          if (!PyArg_ParseTuple(args, "iO", &index, &object)) return NULL;          if (!PyArg_ParseTuple(args, "iO:write_object", &index, &object)) return NULL;
613                    
614          if (!PyObject_IsInstance(object, (PyObject*)&SHPObjectType))          if (!PyObject_IsInstance(object, (PyObject*)&SHPObjectType))
615          {          {
# Line 572  static PyObject* shapefile_repr(ShapeFil Line 639  static PyObject* shapefile_repr(ShapeFil
639    
640  static struct PyMethodDef shapefile_methods[] =  static struct PyMethodDef shapefile_methods[] =
641  {  {
642          {"close", (PyCFunction)shapefile_close, METH_NOARGS, "close the shape file" },          {"close", (PyCFunction)shapefile_close, METH_NOARGS,
643          {"info", (PyCFunction)shapefile_info, METH_NOARGS,                  "close() -> None\n\n"
644                  "Return a tuple (NUM_SHAPES, TYPE, MIN, MAX) where NUM_SHAPES is the number of shapes in the file, TYPE is the "                  "close the shape file" },
645                  "shape type and MIN and MAX are 4-element tuples with the min. and max. values of the data." },          {"info", (PyCFunction)shapefile_info, METH_NOARGS,
646          {"read_object", (PyCFunction)shapefile_read_object, METH_VARARGS, "Return object number i" },                  "info() -> (num_shapes, type, (x_min, y_min, z_min, m_min), (x_max, y_max, z_max, m_max))\n\n"
647          {"write_object", (PyCFunction)shapefile_write_object, METH_VARARGS, "Write an object"},                  "returns info about ShapeFile with:\n"
648          {"cobject", (PyCFunction)shapefile_cobject, METH_NOARGS, "Return the shapelib SHPHandle as a Python CObject"},                  "- num_shapes: the number of the objects in the file\n"
649                    "- type: the type of the shape file (SHPT_POINT, SHPT_POLYGON, ...)\n"
650                    "- (x_min, ...), (x_max, ...): 4D bounding box of the data in the shape file" },
651            {"read_object", (PyCFunction)shapefile_read_object, METH_VARARGS,
652                    "read_object(id) -> SHPObject\n\n"
653                    "Returns shape indexed by id" },
654            {"write_object", (PyCFunction)shapefile_write_object, METH_VARARGS,
655                    "write_object(id, object) -> id\n\n"
656                    "Write an object at index id, and returns id."
657                    "If id == -1, the object is appended at the end of the shape file."},
658            {"cobject", (PyCFunction)shapefile_cobject, METH_NOARGS,
659                    "cobject() -> CObject\n\n"
660                    "Return the shapelib SHPHandle as a Python CObject"},
661          {NULL}          {NULL}
662  };  };
663    
# Line 602  static PyObject* shapelib_create(PyObjec Line 681  static PyObject* shapelib_create(PyObjec
681          int type;          int type;
682          ShapeFileObject* result;          ShapeFileObject* result;
683                    
684          if (!PyArg_ParseTuple(args, "si", &file, &type)) return NULL;          if (!PyArg_ParseTuple(args, "eti:create", Py_FileSystemDefaultEncoding, &file, &type)) return NULL;
685                    
686          result = PyObject_New(ShapeFileObject, &ShapeFileType);          result = PyObject_New(ShapeFileObject, &ShapeFileType);
687          if (!result)          if (!result)
688          {          {
689                    PyMem_Free(file);
690                  return PyErr_NoMemory();                  return PyErr_NoMemory();
691          }          }
692                    
693          result->handle = SHPCreate(file, type);          result->handle = SHPCreate(file, type);
694            PyMem_Free(file);
695            
696          if (!result->handle)          if (!result->handle)
697          {          {
698                  PyObject_Del((PyObject*)result);                  PyObject_Del((PyObject*)result);
# Line 638  static PyObject* shapelib_c_api(PyObject Line 720  static PyObject* shapelib_c_api(PyObject
720  static PyObject* shapelib_type_name(PyObject* module, PyObject* args)  static PyObject* shapelib_type_name(PyObject* module, PyObject* args)
721  {  {
722          int type;          int type;
723          if (!PyArg_ParseTuple(args, "i", &type)) return NULL;          if (!PyArg_ParseTuple(args, "i:type_name", &type)) return NULL;
724          return PyString_FromString(SHPTypeName(type));          return PyString_FromString(SHPTypeName(type));
725  }  }
726    
727  static PyObject* shapelib_part_type_name(PyObject* module, PyObject* args)  static PyObject* shapelib_part_type_name(PyObject* module, PyObject* args)
728  {  {
729          int type;          int type;
730          if (!PyArg_ParseTuple(args, "i", &type)) return NULL;          if (!PyArg_ParseTuple(args, "i:part_type_name", &type)) return NULL;
731          return PyString_FromString(SHPPartTypeName(type));          return PyString_FromString(SHPPartTypeName(type));
732  }  }
733    
734  static struct PyMethodDef shapelib_methods[] =  static struct PyMethodDef shapelib_methods[] =
735  {  {
736          {"open", (PyCFunction)shapelib_open, METH_VARARGS, "open a ShapeFile" },          {"open", (PyCFunction)shapelib_open, METH_VARARGS,
737          {"create", (PyCFunction)shapelib_create, METH_VARARGS, "create a ShapeFile" },                  "open(name [, mode='rb']) -> ShapeFile\n\n"
738          {"c_api", (PyCFunction)shapelib_c_api, METH_NOARGS, "get C API of shapelib" },                  "opens a ShapeFile" },
739          {"type_name", (PyCFunction)shapelib_type_name, METH_VARARGS, "return type as string" },          {"create", (PyCFunction)shapelib_create, METH_VARARGS,
740          {"part_type_name", (PyCFunction)shapelib_part_type_name, METH_VARARGS, "return part type as string" },                  "create(name, type) -> ShapeFile\n\n"
741                    "creates a ShapeFile of a certain type (one of SHPT_POINT, SHPT_POLYGON)" },
742            {"c_api", (PyCFunction)shapelib_c_api, METH_NOARGS,
743                    "c_api() -> CObject\n\n"
744                    "get C API of shapelib as a CObject" },
745            {"type_name", (PyCFunction)shapelib_type_name, METH_VARARGS,
746                    "type_name(type) -> string\n\n"
747                    "return type as string" },
748            {"part_type_name", (PyCFunction)shapelib_part_type_name, METH_VARARGS,
749                    "part_type_name(part_type) -> string\n\n"
750                    "return part type as string" },
751          {NULL}          {NULL}
752  };  };
753    
Legend:
Removed from v.2743  
changed lines
  Added in v.2749
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26