shapelib 0.7.0

data/ext/shapelib_ext/splist.h

@@ -0,0 +1,71 @@
+
+static VALUE sp_to_h(VALUE obj)
+{
+    VALUE h;
+    h = rb_hash_new();
+    rb_hash_aset(h, CSTR2SYM("shape_type"), sp_shape_type(obj));
+    rb_hash_aset(h, CSTR2SYM("shape_id"), sp_shape_id(obj));
+    rb_hash_aset(h, CSTR2SYM("maxbound"), sp_maxbound(obj));
+    rb_hash_aset(h, CSTR2SYM("minbound"), sp_minbound(obj));
+    rb_hash_aset(h, CSTR2SYM("mvals"), sp_mvals(obj));
+    rb_hash_aset(h, CSTR2SYM("n_parts"), sp_n_parts(obj));
+    rb_hash_aset(h, CSTR2SYM("n_vertices"), sp_n_vertices(obj));
+    rb_hash_aset(h, CSTR2SYM("part_start"), sp_part_start(obj));
+    rb_hash_aset(h, CSTR2SYM("part_type"), sp_part_type(obj));
+    rb_hash_aset(h, CSTR2SYM("shape_id"), sp_shape_id(obj));
+    rb_hash_aset(h, CSTR2SYM("shape_type"), sp_shape_type(obj));
+    rb_hash_aset(h, CSTR2SYM("xvals"), sp_xvals(obj));
+    rb_hash_aset(h, CSTR2SYM("yvals"), sp_yvals(obj));
+    rb_hash_aset(h, CSTR2SYM("zvals"), sp_zvals(obj));
+    Attr_to_Hash(h, obj);
+    return h;
+}
+
+static VALUE sp_inspect(VALUE obj)
+{
+    VALUE tos;
+    static ID inspect = 0;
+    static ID id_plus, id_class, id_to_s;
+    static VALUE classnm;
+    if (inspect == 0) {
+	inspect = rb_intern("inspect");
+	id_plus = rb_intern("+");
+	id_class = rb_intern("class");
+	id_to_s = rb_intern("to_s");
+    }
+    classnm = rb_funcall(rb_funcall(obj, id_class, 0), id_to_s, 0);
+    tos = rb_funcall(sp_to_h(obj), inspect, 0);
+    return rb_funcall(classnm, id_plus, 1, tos);
+}
+
+static method_table_entry sp_methods[] = {
+    { "[]",		sp_field_get, 1 },
+    { "[]=",		sp_field_set, 2 },
+    { "inspect",	sp_inspect, 0 },
+    { "maxbound",	sp_maxbound, 0 },
+    { "minbound",	sp_minbound, 0 },
+    { "mvals",		sp_mvals, 0 },
+    { "n_parts",	sp_n_parts, 0 },
+    { "n_vertices",	sp_n_vertices, 0 },
+    { "part_start",	sp_part_start, 0 },
+    { "part_type",	sp_part_type, 0 },
+    { "shape_type",	sp_shape_type, 0 },
+    { "shape_id",	sp_shape_id, 0 },
+    { "to_h",		sp_to_h, 0 },
+    { "to_s",		sp_wkt, 0 },
+    { "rewind_polygon",	sp_rewind, 0 },
+    { "wkt",		sp_wkt, 0 },
+    { "xvals",		sp_xvals, 0 },
+    { "yvals",		sp_yvals, 0 },
+    { "zvals",		sp_zvals, 0 },
+    { NULL, NULL, 0 }
+};
+
+static method_table_entry pt_methods[] = {
+    { "m",		pt_m, 0 },
+    { "wkt",		pt_wkt, 0 },
+    { "x",		pt_x, 0 },
+    { "y",		pt_y, 0 },
+    { "z",		pt_z, 0 },
+    { NULL, NULL, 0 }
+};

data/ext/shapelib_ext/spwkt.h

@@ -0,0 +1,219 @@
+
+/* safer substitute of strcat(3). I believe strcat is too dangerous.
+ */
+static char *StringCat(char *buf, char *src, char *stop)
+{
+    if (*buf)
+	buf = buf + strlen(buf);
+    strncpy(buf, src, stop - buf);
+    *stop = '\0';
+    return buf + strlen(buf);
+}
+
+/* 123..........45678 */
+/* -0.1234567890e-100 */
+static int wkt_dlen = 18;
+static char wkt_dfmt[16] = "%1.10g";
+
+static char *DblFmtCat(char *buf, double x, char *stop)
+{
+    char fbuf[512];
+    sprintf(fbuf, wkt_dfmt, x);
+    return StringCat(buf, fbuf, stop);
+}
+
+static VALUE pt_wkt(VALUE obj)
+{
+    shape_t *self;
+    size_t buflen;
+    char *buf, *cur, *stop;
+    VALUE wkt;
+    Data_Get_Struct(obj, shape_t, self);
+    buflen = wkt_dlen * 2 + 9;
+    cur = buf = xmalloc(buflen + 1);
+    stop = buf + buflen;
+    strcpy(cur, "POINT(");
+    cur = DblFmtCat(cur, self->obj->padfX[0], stop);
+    cur = StringCat(cur, " ", stop);
+    cur = DblFmtCat(cur, self->obj->padfY[0], stop);
+    cur = StringCat(cur, ")", stop);
+    wkt = rb_str_new(buf, strlen(buf));
+    free(buf);
+    return wkt;
+}
+
+static VALUE mp_wkt(VALUE obj)
+{
+    shape_t *self;
+    VALUE wkt;
+    size_t buflen;
+    char *buf, *cur, *stop;
+    int iv;
+    Data_Get_Struct(obj, shape_t, self);
+    buflen = (2 * wkt_dlen + 3) * self->obj->nVertices + 11;
+    cur = buf = xmalloc(buflen + 1);
+    stop = buf + buflen;
+    strcpy(buf, "MULTIPOINT(");
+    for (iv = 0; iv < self->obj->nVertices; iv++) {
+	if (iv)
+	    StringCat(cur, ", ", stop);
+	cur = DblFmtCat(cur, self->obj->padfX[iv], stop);
+	cur = StringCat(cur, " ", stop);
+	cur = DblFmtCat(cur, self->obj->padfY[iv], stop);
+    }
+    StringCat(cur, ")", stop);
+    wkt = rb_str_new(buf, strlen(buf));
+    free(buf);
+    return wkt;
+}
+
+static VALUE WKTSinglePolygon(SHPObject *obj)
+{
+    size_t buflen;
+    VALUE wkt;
+    char *buf, *cur, *stop;
+    int ipart, endvert, ivert;
+    buflen = (2 * wkt_dlen + 3) * obj->nVertices + obj->nParts * 2 + 9;
+    cur = buf = xmalloc(buflen + 1);
+    stop = cur + buflen;
+    strcpy(buf, "POLYGON(");
+    for (ipart = 0; ipart < obj->nParts; ipart++) {
+	if (ipart == obj->nParts - 1) {
+	    endvert = obj->nVertices;
+	} else {
+	    endvert = obj->panPartStart[ipart + 1];
+	}
+	if (ipart)
+	    cur = StringCat(cur, ", ", stop);
+	cur = StringCat(cur, "(", stop);
+	for (ivert = obj->panPartStart[ipart]; ivert < endvert; ivert++) {
+	    if (ivert > obj->panPartStart[ipart])
+		cur = StringCat(cur, ", ", stop);
+	    cur = DblFmtCat(cur, obj->padfX[ivert], stop);
+	    cur = StringCat(cur, " ", stop);
+	    cur = DblFmtCat(cur, obj->padfY[ivert], stop);
+	}
+	cur = StringCat(cur, ")", stop);
+    }
+    cur = StringCat(cur, ")", stop);
+    wkt = rb_str_new(buf, strlen(buf));
+    free(buf);
+    return wkt;
+}
+
+static VALUE pl_wkt(VALUE obj)
+{
+    shape_t *self;
+    Data_Get_Struct(obj, shape_t, self);
+    /* === BUG ===
+     * following code doesn't consider the possibilities:
+     * - there may be multiple outer loop in a Polygon Shape.
+     *   in such a case, it must generate MULTIPOLYGON WKT.
+     * - inner loop (hole) may come before outer loop.
+     */
+    return WKTSinglePolygon(self->obj); 
+#if 0
+    return WKTMultiPolygon(self->obj);
+#endif
+}
+
+static VALUE WKTSingleArc(SHPObject *obj)
+{
+    size_t buflen;
+    VALUE wkt;
+    char *buf, *cur, *stop;
+    int ivert;
+    buflen = (2 * wkt_dlen + 3) * obj->nVertices + 10;
+    cur = buf = xmalloc(buflen + 1);
+    stop = cur + buflen;
+    strcpy(buf, "LINESTRING(");
+    for (ivert = 0; ivert < obj->nVertices; ivert++) {
+	if (ivert)
+	    cur = StringCat(cur, ", ", stop);
+	cur = DblFmtCat(cur, obj->padfX[ivert], stop);
+	cur = StringCat(cur, " ", stop);
+	cur = DblFmtCat(cur, obj->padfY[ivert], stop);
+    }
+    cur = StringCat(cur, ")", stop);
+    wkt = rb_str_new(buf, strlen(buf));
+    free(buf);
+    return wkt;
+}
+
+static VALUE WKTMultiArc(SHPObject *obj)
+{
+    size_t buflen;
+    VALUE wkt;
+    char *buf, *cur, *stop;
+    int ipart, endvert, ivert;
+    buflen = (2 * wkt_dlen + 3) * obj->nVertices + obj->nParts * 1 + 16;
+    cur = buf = xmalloc(buflen + 1);
+    stop = cur + buflen;
+    strcpy(buf, "MULTILINESTRING(");
+    for (ipart = 0; ipart < obj->nParts; ipart++) {
+	if (ipart == obj->nParts - 1) {
+	    endvert = obj->nVertices;
+	} else {
+	    endvert = obj->panPartStart[ipart + 1];
+	}
+	if (ipart)
+	    cur = StringCat(cur, ", ", stop);
+	cur = StringCat(cur, "(", stop);
+	for (ivert = obj->panPartStart[ipart]; ivert < endvert; ivert++) {
+	    if (ivert > obj->panPartStart[ipart])
+		cur = StringCat(cur, ", ", stop);
+	    cur = DblFmtCat(cur, obj->padfX[ivert], stop);
+	    cur = StringCat(cur, " ", stop);
+	    cur = DblFmtCat(cur, obj->padfY[ivert], stop);
+	}
+	cur = StringCat(cur, ")", stop);
+    }
+    cur = StringCat(cur, ")", stop);
+    wkt = rb_str_new(buf, strlen(buf));
+    free(buf);
+    return wkt;
+}
+
+static VALUE arc_wkt(VALUE obj)
+{
+    shape_t *self;
+    Data_Get_Struct(obj, shape_t, self);
+    if (self->obj->nParts > 1) {
+	return WKTMultiArc(self->obj);
+    } else {
+	return WKTSingleArc(self->obj);
+    }
+}
+
+static VALUE sp_wkt(VALUE obj)
+{
+    shape_t *self;
+    Data_Get_Struct(obj, shape_t, self);
+    switch (self->obj->nSHPType) {
+	case SHPT_POINT:
+	case SHPT_POINTM:
+	case SHPT_POINTZ:
+	    return pt_wkt(obj);
+	    break;
+	case SHPT_ARC:
+	case SHPT_ARCM:
+	case SHPT_ARCZ:
+	    return arc_wkt(obj);
+	    break;
+	case SHPT_POLYGON:
+	case SHPT_POLYGONM:
+	case SHPT_POLYGONZ:
+	    return pl_wkt(obj);
+	    break;
+	case SHPT_MULTIPOINT:
+	case SHPT_MULTIPOINTM:
+	case SHPT_MULTIPOINTZ:
+	    return mp_wkt(obj);
+	    break;
+	case SHPT_MULTIPATCH:
+	    return pl_wkt(obj);
+	    break;
+    }
+    rb_bug("invalid shape type %d", self->obj->nSHPType);
+    return Qnil;
+}

data/ext/shapelib_ext/valconv.h

@@ -0,0 +1,313 @@
+/* valconv.h */
+
+#define SECURE(obj) SecureObject((obj), #obj)
+
+#define SHP_NODATA_LIM	-1.0e-38
+#define SHP_NODATA	-2.0e-38
+#define SHP_NUM2DBL(value) (NIL_P(value) ? SHP_NODATA : NUM2DBL(value))
+#define SHP_FLOAT_NEW(f) (((f) < SHP_NODATA_LIM) ? Qnil : rb_float_new((f)))
+#define CSTR2SYM(s) (ID2SYM(rb_intern((s))))
+static int NUM2INT_nil(VALUE v) { return NIL_P(v) ? -1 : NUM2INT(v); }
+
+static const_table_entry sl_consts[] = {
+    { "String", INT2FIX((int)FTString) },
+    { "Integer", INT2FIX((int)FTInteger) },
+    { "Float", INT2FIX((int)FTDouble) },
+    { "Logical", INT2FIX((int)FTLogical) },
+    { NULL, Qnil }
+};
+
+static ID *ShapeTypeNameTable(void)
+{
+    static ID ids[SHPT_MULTIPATCH + 1];
+    if (ids[SHPT_NULL] != 0) {
+	return ids;
+    }
+    ids[SHPT_NULL] = rb_intern("Null");
+    ids[SHPT_POINT] = rb_intern("Point");
+    ids[SHPT_POINTM] = rb_intern("PointM");
+    ids[SHPT_POINTZ] = rb_intern("PointZ");
+    ids[SHPT_ARC] = rb_intern("Arc");
+    ids[SHPT_ARCM] = rb_intern("ArcM");
+    ids[SHPT_ARCZ] = rb_intern("ArcZ");
+    ids[SHPT_POLYGON] = rb_intern("Polygon");
+    ids[SHPT_POLYGONM] = rb_intern("PolygonM");
+    ids[SHPT_POLYGONZ] = rb_intern("PolygonZ");
+    ids[SHPT_MULTIPOINT] = rb_intern("MultiPoint");
+    ids[SHPT_MULTIPOINTM] = rb_intern("MultiPointM");
+    ids[SHPT_MULTIPOINTZ] = rb_intern("MultiPointZ");
+    ids[SHPT_MULTIPATCH] = rb_intern("MultiPatch");
+    return ids;
+}
+
+static ID *FieldTypeNameTable(void)
+{
+    static ID ids[FTInvalid + 1];
+    if (ids[FTString] != 0) {
+	return ids;
+    }
+    ids[FTString] = rb_intern("String");
+    ids[FTInteger] = rb_intern("Integer");
+    ids[FTDouble] = rb_intern("Float");
+    ids[FTLogical] = rb_intern("Logical");
+    ids[FTInvalid] = rb_intern("Invalid");
+    return ids;
+}
+
+#define SHPP_RING 5
+
+static ID *PartTypeNameTable(void)
+{
+    static ID ids[6];
+    if (ids[0] != 0) {
+	return ids;
+    }
+    ids[0] = rb_intern("TriangleStrip");
+    ids[1] = rb_intern("TriangleFan");
+    ids[2] = rb_intern("OuterRing");
+    ids[3] = rb_intern("InnerRing");
+    ids[4] = rb_intern("FirstRing");
+    ids[5] = rb_intern("Ring");
+    return ids;
+}
+
+static int Ruby2PartType(VALUE ptype)
+{
+    ID given, *ids;
+    int i;
+    switch (TYPE(ptype)) {
+	case T_STRING:
+	case T_SYMBOL:
+	    given = rb_to_id(ptype);
+	    ids = PartTypeNameTable();
+	    for (i = 0; i < 6; i++) {
+		if (ids[i] == given)
+		    return i;
+	    }
+	    return -1;
+	    break;
+	case T_FIXNUM:
+	    return FIX2INT(ptype);
+	default:
+	    return NUM2INT(ptype);
+    }
+}
+
+static VALUE PartType2Ruby(int part_type)
+{
+    if (part_type < 0 || part_type > 5) {
+	return INT2NUM(part_type);
+    } else {
+	ID *ids;
+	ids = PartTypeNameTable();
+	return ID2SYM(ids[part_type]);
+    }
+}
+
+static DBFFieldType Ruby2FieldType(VALUE obj)
+{
+    if (FIXNUM_P(obj)) {
+	int ft = FIX2INT(obj);
+	switch (ft) {
+	case FTString:
+	case FTInteger:
+	case FTDouble:
+	case FTLogical:
+	case FTInvalid:
+	    return ft;
+	default:
+	    rb_raise(rb_eArgError, "bad field_type %d", ft);
+	}
+    } else if (TYPE(obj) == T_STRING || TYPE(obj) == T_SYMBOL) {
+	ID given, *table;
+	int i;
+	given = rb_to_id(obj);
+	table = FieldTypeNameTable();
+	for (i = 0; i < FTInvalid; i++) {
+	    if (given == table[i])
+		return i;
+	}
+    }
+    rb_raise(rb_eArgError, "bad field_type");
+}
+
+static VALUE FieldType2Ruby(DBFFieldType ftype)
+{
+    int ft;
+    ft = ftype;
+    if (ft < 0 || ft >= FTInvalid)
+	return INT2FIX(ft);
+    return ID2SYM(FieldTypeNameTable()[ft]);
+}
+
+static VALUE ShapeType2Class(int nSHPType, VALUE klass)
+{
+    switch (nSHPType) {
+    case SHPT_POINT:		return cPoint;
+    case SHPT_POINTM:		return cPointM;
+    case SHPT_POINTZ:		return cPointZ;
+    case SHPT_ARC:		return cArc;
+    case SHPT_ARCM:		return cArcM;
+    case SHPT_ARCZ:		return cArcZ;
+    case SHPT_POLYGON:		return cPolygon;
+    case SHPT_POLYGONM:		return cPolygonM;
+    case SHPT_POLYGONZ:		return cPolygonZ;
+    case SHPT_MULTIPOINT:	return cMultiPoint;
+    case SHPT_MULTIPOINTM:	return cMultiPointM;
+    case SHPT_MULTIPOINTZ:	return cMultiPointZ;
+    case SHPT_MULTIPATCH:	return cMultiPatch;
+    case SHPT_NULL:
+    default:
+	return klass;
+    }
+}
+
+static VALUE ShapeType2Ruby(int nSHPType)
+{
+    ID *ids;
+    switch (nSHPType) {
+    case SHPT_NULL:
+    case SHPT_POINT:	case SHPT_POINTM:	case SHPT_POINTZ:
+    case SHPT_ARC:	case SHPT_ARCM:		case SHPT_ARCZ:
+    case SHPT_POLYGON:	case SHPT_POLYGONM:	case SHPT_POLYGONZ:
+    case SHPT_MULTIPOINT: case SHPT_MULTIPOINTM: case SHPT_MULTIPOINTZ:
+    case SHPT_MULTIPATCH:
+	ids = ShapeTypeNameTable();
+	return ID2SYM(ids[nSHPType]);
+    default:
+	return INT2FIX(nSHPType);
+    }
+}
+
+static int ClassIs(VALUE a, VALUE b)
+{
+    VALUE r;
+    static ID le = 0;
+    if (le == 0) {
+	le = rb_intern("<=");
+    }
+    r = rb_funcall(a, le, 1, b);
+    switch (TYPE(r)) {
+    case T_TRUE:
+	return 1;
+    case T_FALSE:
+    case T_NIL:
+	return 0;
+    default:
+	return -1;
+    }
+}
+
+static int ShapeClass_to_Int(VALUE klass)
+{
+    if (ClassIs(klass, cPoint)) {
+	if (ClassIs(klass, cPointZ)) {
+	    return SHPT_POINTZ;
+	} else if (ClassIs(klass, cPointM)) {
+	    return SHPT_POINTM;
+	}
+	return SHPT_POINT;
+    } else if (ClassIs(klass, cArc)) {
+	if (ClassIs(klass, cArcZ)) {
+	    return SHPT_ARCZ;
+	} else if (ClassIs(klass, cArcM)) {
+	    return SHPT_ARCM;
+	}
+	return SHPT_ARC;
+    } else if (ClassIs(klass, cPolygon)) {
+	if (ClassIs(klass, cPolygonZ)) {
+	    return SHPT_POLYGONZ;
+	} else if (ClassIs(klass, cPolygonM)) {
+	    return SHPT_POLYGONM;
+	}
+	return SHPT_POLYGON;
+    } else if (ClassIs(klass, cMultiPoint)) {
+	if (ClassIs(klass, cMultiPointZ)) {
+	    return SHPT_MULTIPOINTZ;
+	} else if (ClassIs(klass, cMultiPointM)) {
+	    return SHPT_MULTIPOINTM;
+	}
+	return SHPT_MULTIPOINT;
+    } else if (ClassIs(klass, cMultiPatch)) {
+	return SHPT_MULTIPATCH;
+    } else {
+	rb_raise(rb_eArgError, "invalid class");
+    }
+}
+
+static int ShapeSym_to_Int(VALUE stype)
+{
+    ID arg, *ids;
+    int i;
+    ids = ShapeTypeNameTable();
+    arg = rb_to_id(stype);
+    for (i = 0; i <= SHPT_MULTIPATCH; i++) {
+	if (arg == ids[i])
+	    return i;
+    }
+    rb_raise(rb_eArgError, "invalid shape class name");
+    return -1;
+}
+
+static int Ruby2ShapeType(VALUE stype)
+{
+    switch (TYPE(stype)) {
+    case T_FIXNUM:
+	return FIX2INT(stype);
+    case T_CLASS:
+	return ShapeClass_to_Int(stype);
+    case T_STRING:
+    case T_SYMBOL:
+	return ShapeSym_to_Int(stype);
+    default:
+	rb_raise(rb_eArgError, "shape_type is Integer/String/Symbol/Class");
+    }
+}
+
+static VALUE DoubleUnpack(double *dp, unsigned num)
+{
+    VALUE ary;
+    int i;
+    ary = rb_ary_new2(num);
+    for (i = 0; i < num; i++) {
+	rb_ary_push(ary, rb_float_new(dp[i]));
+    }
+    return ary;
+}
+
+static VALUE DoubleUnpackM(double *dp, unsigned num, int mpos)
+{
+    VALUE ary;
+    int i;
+    ary = rb_ary_new2(num);
+    for (i = 0; i < num; i++) {
+	if ((mpos == -1) || (i == mpos)) {
+	    rb_ary_push(ary, SHP_FLOAT_NEW(dp[i]));
+	} else {
+	    rb_ary_push(ary, rb_float_new(dp[i]));
+	}
+    }
+    return ary;
+}
+
+static VALUE IntUnpack(int *up, unsigned num)
+{
+    static ID unpackid;
+    static VALUE unpackfmt = 0;
+    VALUE buf;
+    if (unpackfmt == 0) {
+			unpackid = rb_intern("unpack");
+			unpackfmt = rb_str_new2("i*");
+                        rb_global_variable(&unpackfmt);
+    }
+    buf = rb_str_new((char *)up, sizeof(int) * num);
+    return rb_funcall(buf, unpackid, 1, unpackfmt);
+}
+
+static VALUE SecureObject(VALUE obj, const char *name) {
+    if (OBJ_TAINTED(obj) && rb_safe_level() >= 1) {
+	rb_raise(rb_eSecurityError, "tainted %s", name);
+    }
+    return obj;
+}
+