shapelib 0.7.0

data/doc/style.css

@@ -0,0 +1,136 @@
+/*
+ * style.css: CSS style definition file
+ * taken from srwiki
+ * originally for `Rubyavailable' <URL:http://www.jin.gr.jp/~nahi/Ruby/*>
+ */
+
+body {
+/*    background: #EEEEEE;
+*/
+    background: white;
+    color: black;
+    margin-left: 2%;
+    margin-right: 2%;
+    /* font-size: 10.5pt; */
+    font-family: verdana, arial, helvetica, Sans-Serif;
+}
+
+h1 {
+    font-family: "times roman", verdana, sans-serif; 
+    /* text-align: right; */
+/*
+    color: #FFFFFF;
+    background: #33AA99;
+*/
+    color: #5040f0;
+    background: #f0f0f0;
+    margin-top: 1%;
+    margin-right: 10%;
+    border-top: #dddddd 4px solid;
+    border-left: #e0e0e0 4px solid;
+    border-right: #e0e0e0 4px solid;
+    border-bottom: #eeeeee 4px solid;
+}
+
+h2, h3, h4, h5, h6 {
+    font-family: verdana, arial, helvetica, Sans-Serif;
+}
+
+h2 {
+    color: #FFFFFF;
+    background: #5040f0;
+    margin-right: 30%;
+    border-bottom: #9080f0 3px solid;
+}
+
+h3 {
+    color: #5040f0;
+    border-left: #9080f0 0.5em solid;
+    border-bottom: #5040f0 4px solid;
+    margin-right: 50%;
+}
+
+div.header p.status { text-align: right; }
+div.header p.last-modified { text-align: left; }
+
+/*
+li p {
+    margin-top: -1ex;
+}
+*/
+
+dt {
+    font-weight: bold;
+    margin-top: 2ex;
+    margin-left: 1em;
+}
+
+td {
+  color: black;
+}
+
+/*
+a {
+  color: #0000f0;
+}
+*/
+
+a:hover {
+  color: red;
+}
+
+address {
+    color: gray;
+    background: #EEEEEE;
+    text-align: right;
+    font-family: Times, serif;
+    font-style: normal;
+    font-variant: normal;
+    font-weight: normal;
+}
+
+var {
+    color: #408000;
+}
+
+em {
+    color: #004080;
+    font-family: arial, helvetica, Sans-Serif, gothic;
+    font-style: normal;
+    font-variant: normal;
+    font-weight: bold;
+}
+
+pre {
+    border-right: #646464 1px solid;
+    padding-right: 0.5em;
+    border-top: #646464 1px solid;
+    padding-top: 0.5em;
+    border-left: #646464 1px solid;
+    padding-left: 0.5em;
+    border-bottom: #646464 1px solid;
+    padding-bottom: 0.5em;
+    margin-left: 1em;
+    margin-right: 2em;
+    white-space: pre;
+    background-color: #e6e6e6;
+    color: black;
+}
+
+span.download {
+    font-weight: normal;
+    color: blue;
+    background: #EEEEEE;
+}
+
+.label-not-found {
+    color: #FF4400;
+}
+
+.path {
+    font-family: Verdana, Arial, Helvetica, sans-serif;
+}
+
+.navi {
+    text-align: right;
+}

data/ext/shapelib_ext/depend

@@ -0,0 +1,49 @@
+MYNAME = ruby-shapelib
+
+main.o:: sflist.h splist.h shpplus.h valconv.h sfcode.h spcode.h \
+	spwkt.h
+shpplus.o:: shpplus.h
+
+RD2 = rd2 -r rd/rd2html-lib --with-css=style.css
+
+doc: Interface.html
+Interface.html: Interface.rd
+	$(RD2) --html-title="$(MYNAME) API" $< > $@
+
+#rpm:
+#	$(MAKE) -f build.mk rpm
+
+clean2: clean
+	-rm -f test*
+
+tags: main.c shpplus.c sfcode.h sflist.h shpplus.h spcode.h \
+    splist.h valconv.h spwkt.h
+	ctags *.h *.c
+
+test: shapelib.so
+	$(RUBY) $(RUBYOPT) ztest1.rb
+
+distcrean: clean
+	-rm -f mkmf.log Makefile
+
+TARDIR=..
+
+tar:
+	$(MAKE) tar.b VERSION=`awk '/Version:/ {print $$2}' $(MYNAME).spec`
+
+tar.b:
+	cvs export -r HEAD -d $(MYNAME)-$(VERSION) $(MYNAME)
+	tar -czf $(TARDIR)/$(MYNAME)-$(VERSION).tar.gz $(MYNAME)-$(VERSION)/*
+	rm -rf $(MYNAME)-$(VERSION)
+
+rpm:
+	$(MAKE) rpm.b VERSION=`awk '/Version:/ {print $$2}' $(MYNAME).spec`
+
+rpm.b:
+	test -d $(RPM)/../rpm/SPECS
+	test ! -d $(MYNAME)-$(VERSION) || rm -rf $(MYNAME)-$(VERSION)
+	cvs export -r HEAD -d $(MYNAME)-$(VERSION) $(MYNAME)
+	tar -czf $(RPM)/SOURCES/$(MYNAME).tar.gz $(MYNAME)-$(VERSION)/*
+	rm -rf $(MYNAME)-$(VERSION)
+	cp $(MYNAME).spec $(RPM)/SPECS
+	rpmbuild -ba $(RPM)/SPECS/$(MYNAME).spec

data/ext/shapelib_ext/extconf.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby
+require 'mkmf'
+
+HEADER_DIRS = [
+  '/opt/local/include',
+  '/usr/local/include',
+  '/usr/include',
+]
+
+LIB_DIRS = [
+  '/opt/local/lib',
+  '/usr/local/lib',
+  '/usr/lib',
+]
+
+dir_config('shapelib', HEADER_DIRS, LIB_DIRS)
+have_header('shapefil.h') or have_header('libshp/shapefil.h') or raise 'shapefil.h not found'
+have_library('shp') or raise 'libshp not found'
+create_makefile('shapelib_ext')

data/ext/shapelib_ext/main.c

@@ -0,0 +1,102 @@
+#include <ruby.h>
+#if defined(HAVE_SHAPEFIL_H)
+	#include <shapefil.h>
+#endif
+#if defined(HAVE_LIBSHP_SHAPEFIL_H)
+	#include <libshp/shapefil.h>
+#endif
+#include "shpplus.h"
+
+typedef struct {
+    const char *mname;
+    VALUE (*func)();
+    int argc;
+} method_table_entry;
+
+typedef struct {
+    const char *name;
+    VALUE val;
+} const_table_entry;
+
+static VALUE mShapeLib;
+static VALUE cShapeFile;
+static VALUE cShape;
+static VALUE cPoint;
+static VALUE cPointM;
+static VALUE cPointZ;
+static VALUE cArc;
+static VALUE cArcM;
+static VALUE cArcZ;
+static VALUE cPolygon;
+static VALUE cPolygonM;
+static VALUE cPolygonZ;
+static VALUE cMultiPoint;
+static VALUE cMultiPointM;
+static VALUE cMultiPointZ;
+static VALUE cMultiPatch;
+
+/* code begins here */
+
+#include "valconv.h"
+#include "sfcode.h"
+#include "sflist.h"
+#include "spcode.h"
+#include "spwkt.h"
+#include "splist.h"
+
+static void register_consts(VALUE klass, const_table_entry *table)
+{
+    const_table_entry *p;
+    for (p = table; p->name; p++) {
+	rb_define_const(klass, p->name, p->val);
+    }
+}
+
+static void register_methods(VALUE klass, method_table_entry *table)
+{
+    method_table_entry *p;
+    for (p = table; p->mname; p++) {
+	rb_define_method(klass, p->mname, p->func, p->argc);
+    }
+}
+
+void Init_shapelib_ext()
+{
+    mShapeLib = rb_define_module("Shapelib");
+    cShapeFile = rb_define_class_under(mShapeLib, "ShapeFile", rb_cObject);
+    cShape = rb_define_class_under(mShapeLib, "Shape", rb_cObject);
+    cPoint = rb_define_class_under(mShapeLib, "Point", cShape);
+    cPointM = rb_define_class_under(mShapeLib, "PointM", cPoint);
+    cPointZ = rb_define_class_under(mShapeLib, "PointZ", cPointM);
+    cArc = rb_define_class_under(mShapeLib, "Arc", cShape);
+    cArcM = rb_define_class_under(mShapeLib, "ArcM", cArc);
+    cArcZ = rb_define_class_under(mShapeLib, "ArcZ", cArcM);
+    cPolygon = rb_define_class_under(mShapeLib, "Polygon", cShape);
+    cPolygonM = rb_define_class_under(mShapeLib, "PolygonM", cPolygon);
+    cPolygonZ = rb_define_class_under(mShapeLib, "PolygonZ", cPolygonM);
+    cMultiPoint = rb_define_class_under(mShapeLib, "MultiPoint", cShape);
+    cMultiPointM = rb_define_class_under(mShapeLib, "MultiPointM", cMultiPoint);
+    cMultiPointZ = rb_define_class_under(mShapeLib, "MultiPointZ", cMultiPointM);
+    cMultiPatch = rb_define_class_under(mShapeLib, "MultiPatch", cShape);
+    rb_define_module_function(mShapeLib, "new_point", sl_m_new_point, -1);
+    rb_define_singleton_method(cShapeFile, "new", sf_s_new, -1);
+    rb_define_singleton_method(cShapeFile, "open", sf_s_open, -1);
+    rb_define_singleton_method(cShape, "new", sp_s_new, 1);
+    rb_define_singleton_method(cPoint, "new", pt_s_new, -1);
+    rb_define_singleton_method(cPointM, "new", ptm_s_new, -1);
+    rb_define_singleton_method(cPointZ, "new", ptz_s_new, -1);
+    rb_define_singleton_method(cArc, "new", arc_s_new, -1);
+    rb_define_singleton_method(cArcM, "new", arcm_s_new, -1);
+    rb_define_singleton_method(cArcZ, "new", arcz_s_new, -1);
+    rb_define_singleton_method(cPolygon, "new", pl_s_new, -1);
+    rb_define_singleton_method(cPolygonM, "new", plm_s_new, -1);
+    rb_define_singleton_method(cPolygonZ, "new", plz_s_new, -1);
+    rb_define_singleton_method(cMultiPoint, "new", mp_s_new, -1);
+    rb_define_singleton_method(cMultiPointM, "new", mpm_s_new, -1);
+    rb_define_singleton_method(cMultiPointZ, "new", mpz_s_new, -1);
+    rb_define_singleton_method(cMultiPatch, "new", mpatch_s_new, -1);
+    register_consts(mShapeLib, sl_consts);
+    register_methods(cShapeFile, sf_methods);
+    register_methods(cShape, sp_methods);
+    register_methods(cPoint, pt_methods);
+}

data/ext/shapelib_ext/sfcode.h

@@ -0,0 +1,284 @@
+/* sfcode.h */
+/*
+ * see bottom of the file for constructor
+ */
+
+static VALUE sf_add_field(int argc, VALUE *args, VALUE obj)
+{
+    shapefile_t *self;
+    VALUE name, field_type, field_width, decimal_place;
+    int r, atype, width, wdeci;
+
+    rb_scan_args(argc, args, "31",
+	    &name, &field_type, &field_width, &decimal_place);
+    SECURE(name);
+    StringValue(name);
+    atype = Ruby2FieldType(field_type);
+    width = NUM2INT(field_width);
+    wdeci = NIL_P(decimal_place) ? 0 : NUM2INT(decimal_place);
+    if (atype == FTDouble && argc == 3) {
+	rb_raise(rb_eArgError, "specify decimal places for Float attribute");
+    }
+    Data_Get_Struct(obj, shapefile_t, self);
+    r = shapefile_add_field(self, RSTRING_PTR(name), atype, width, wdeci);
+    return obj;
+}
+
+static VALUE sf_close(VALUE obj)
+{
+    shapefile_t *self;
+    Data_Get_Struct(obj, shapefile_t, self);
+    return INT2FIX(shapefile_close(self));
+}
+
+static VALUE sf_field_count(VALUE obj)
+{
+    shapefile_t *self;
+    int r;
+    Data_Get_Struct(obj, shapefile_t, self);
+    r = shapefile_field_count(self);
+    return INT2FIX(r);
+}
+
+static int Ruby2FieldIndex(shapefile_t *sfile, VALUE field)
+{
+    if (FIXNUM_P(field)) {
+	return FIX2INT(field);
+    } else {
+	SECURE(field);
+	return shapefile_field_index(sfile, StringValuePtr(field));
+    }
+}
+
+static VALUE sf_delete_shape(VALUE obj, VALUE ishape)
+{
+    shapefile_t *self;
+    Data_Get_Struct(obj, shapefile_t, self);
+    shapefile_delete_shape(self, NUM2INT(ishape));
+    return Qnil;
+}
+
+static VALUE sf_field_index(VALUE obj, VALUE name)
+{
+    shapefile_t *self;
+    int ifield;
+    Data_Get_Struct(obj, shapefile_t, self);
+    ifield = Ruby2FieldIndex(self, name);
+    return (ifield < 0) ? Qnil : INT2FIX(ifield);
+}
+
+static VALUE sf_field_name(VALUE obj, VALUE index)
+{
+    shapefile_t *self;
+    const char *name;
+    Data_Get_Struct(obj, shapefile_t, self);
+    name = shapefile_field_name(self, NUM2INT(index));
+    return name ? rb_str_new2(name) : Qnil;
+}
+
+static VALUE sf_field_type(VALUE obj, VALUE field)
+{
+    shapefile_t *self;
+    int ifield;
+    Data_Get_Struct(obj, shapefile_t, self);
+    ifield = Ruby2FieldIndex(self, field);
+    return FieldType2Ruby(shapefile_field_type(self, ifield));
+}
+
+static VALUE sf_field_width(VALUE obj, VALUE field)
+{
+    shapefile_t *self;
+    int ifield;
+    Data_Get_Struct(obj, shapefile_t, self);
+    ifield = Ruby2FieldIndex(self, field);
+    return INT2FIX(shapefile_field_width(self, ifield));
+}
+
+static VALUE sf_field_decimals(VALUE obj, VALUE field)
+{
+    shapefile_t *self;
+    int ifield;
+    Data_Get_Struct(obj, shapefile_t, self);
+    ifield = Ruby2FieldIndex(self, field);
+    return INT2FIX(shapefile_field_decimals(self, ifield));
+}
+
+static VALUE sf_fields(VALUE obj)
+{
+    shapefile_t *self;
+    VALUE r;
+    int fc, i;
+    Data_Get_Struct(obj, shapefile_t, self);
+    fc = shapefile_field_count(self);
+    if (fc < 0)
+	return Qnil;
+    r = rb_ary_new2(fc);
+    for (i = 0; i < fc; i++) {
+	const char *fieldname;
+	fieldname = shapefile_field_name(self, i);
+	rb_ary_push(r, rb_str_new2(fieldname));
+    }
+    return r;
+}
+
+static VALUE sf_maxbound(VALUE obj)
+{
+    shapefile_t *self;
+    double bound[4];
+    double z;
+    Data_Get_Struct(obj, shapefile_t, self);
+    shapefile_bound(self, NULL, bound);
+    z = bound[2];
+    bound[2] = bound[3];
+    bound[3] = z;
+    return DoubleUnpack(bound, 4);
+}
+
+static VALUE sf_minbound(VALUE obj)
+{
+    shapefile_t *self;
+    double bound[4];
+    double z;
+    Data_Get_Struct(obj, shapefile_t, self);
+    shapefile_bound(self, bound, NULL);
+    z = bound[2];
+    bound[2] = bound[3];
+    bound[3] = z;
+    return DoubleUnpack(bound, 4);
+}
+
+static VALUE sf_read(int argc, VALUE *args, VALUE obj)
+{
+    shapefile_t *self;
+    shape_t *s;
+    VALUE ishape, r;
+    int irec;
+    rb_scan_args(argc, args, "01", &ishape);
+    Data_Get_Struct(obj, shapefile_t, self);
+    irec = NIL_P(ishape) ? -1 : NUM2INT(ishape);
+    s = shapefile_read(self, irec);
+    if (s == NULL)
+	return Qnil;
+    r = Data_Wrap_Struct(cShape, 0, shape_close, s);
+    return r;
+}
+
+static VALUE sf_rewind(VALUE obj)
+{
+    shapefile_t *self;
+    Data_Get_Struct(obj, shapefile_t, self);
+    self->irec = 0;
+    return obj;
+}
+
+static VALUE sf_each(VALUE obj)
+{
+    VALUE row;
+    sf_rewind(obj);
+    while (1) {
+	row = sf_read(0, NULL, obj);
+	if (NIL_P(row))
+	    break;
+	rb_yield(row);
+    }
+    return Qnil;
+}
+
+static VALUE sf_shape_type(VALUE obj)
+{
+    shapefile_t *self;
+    Data_Get_Struct(obj, shapefile_t, self);
+    return ShapeType2Ruby(shapefile_shape_type(self));
+}
+
+static VALUE sf_size(VALUE obj)
+{
+    shapefile_t *self;
+    int r;
+    Data_Get_Struct(obj, shapefile_t, self);
+    r = shapefile_size(self);
+    if (r < 0)
+	rb_raise(rb_eRuntimeError, "size %d", r);
+    return INT2FIX(r);
+}
+
+static VALUE sf_write(int argc, VALUE *args, VALUE obj)
+{
+    shape_t	*shape;
+    shapefile_t *self;
+    int		r, irec;
+    if (argc < 1 || argc > 2) {
+	rb_raise(rb_eArgError, "usage: Shapefile#write shape, [irec = -1]");
+    }
+    Data_Get_Struct(obj, shapefile_t, self);
+    Data_Get_Struct(args[0], shape_t, shape);
+    irec = ((argc == 2) ? NUM2INT(args[1]) : -1);
+    r = shapefile_write(self, irec, shape);
+    return INT2FIX(r);
+}
+
+/*
+ * constructor
+ */
+
+static VALUE YieldIfPossible(VALUE proc, VALUE sf)
+{
+    if (!NIL_P(proc)) {
+	rb_funcall(proc, rb_intern("call"), 1, sf);
+	sf_close(sf);
+	return Qnil;
+    } else {
+	return sf;
+    }
+}
+
+static VALUE sf_s_open(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE fnam, mode, sf, proc;
+    shapefile_t *sfile;
+    rb_scan_args(argc, argv, "11&", &fnam, &mode, &proc);
+    SECURE(fnam);
+    sfile = shapefile_open(StringValuePtr(fnam), 
+	(NIL_P(mode) ? "rb" : StringValuePtr(mode))
+	);
+    sf = Data_Wrap_Struct(klass, 0, shapefile_close, sfile);
+    return YieldIfPossible(proc, sf);
+}
+
+static VALUE sf_s_new(int argc, VALUE *argv, VALUE klass)
+{
+    VALUE fnam, shapetype, attrs, sf, proc;
+    shapefile_t *sfile;
+    int stype;
+    int i;
+    if (argc > 3 || argc < 2) {
+	rb_raise(rb_eArgError,
+	"usage: ShapeLib::Shapefile.new filename, shapetype, attrs = []");
+	return Qnil;
+    }
+    rb_scan_args(argc, argv, "21&", &fnam, &shapetype, &attrs, &proc);
+    SECURE(fnam);
+    if ((stype = Ruby2ShapeType(shapetype)) == -1) {
+	rb_raise(rb_eArgError, "shapetype must be Shape subclass");
+    }
+    if (argc > 2) {
+	if (T_ARRAY != TYPE(attrs)) {
+	    rb_raise(rb_eArgError, "attrs must be Array");
+	}
+    }
+    sfile = shapefile_new(StringValuePtr(fnam), stype);
+    if (sfile == NULL) {
+	rb_raise(rb_eRuntimeError, "shapefile_new failed");
+    }
+    sf = Data_Wrap_Struct(klass, 0, shapefile_close, sfile);
+    if (argc > 2) {
+	for (i = 0; i < RARRAY_LEN(attrs); i++) {
+	    VALUE p = RARRAY_PTR(attrs)[i];
+	    if (T_ARRAY != TYPE(p)) {
+		rb_raise(rb_eArgError, "non-array content in attrs");
+	    }
+	    sf_add_field(RARRAY_LEN(p), RARRAY_PTR(p), sf);
+	}
+    }
+    return YieldIfPossible(proc, sf);
+}