shapes 0.1 → 0.2

data/ext/shapes/shapes.c

@@ -5,12 +5,43 @@
 #include "shapes.h"
 
 void Init_shapeslib() {
-	VALUE shapesModule = rb_define_module("ShapesLib");
+	VALUE shapesModule = rb_define_module("ShapesLib"); //Create ShapesLib module
+	
+	//Define some classes to store our C data in
 	shapeClass = rb_define_class_under(shapesModule,"ShapeFile",rb_cObject);
+	dbfClass = rb_define_class_under(shapesModule,"DBF",rb_cObject);
+	
+	// Bridge for ShapeFile IO
 	rb_define_module_function(shapesModule,"open_shape",OpenSHP,1);
 	rb_define_module_function(shapesModule,"close_shape",CloseSHP,1);
 	rb_define_module_function(shapesModule,"create_shape",CreateSHP,2);
+	
+	// ShapeFile manipulation
 	rb_define_module_function(shapesModule,"create_object",CreateObject,6);
+	
+	// DBF IO
+	rb_define_module_function(shapesModule,"open_dbf",OpenDBF,1);
+	rb_define_module_function(shapesModule,"create_dbf",CreateDBF,1);
+	rb_define_module_function(shapesModule,"close_dbf",CloseDBF,1);
+	
+	// DBF manipulation
+	rb_define_module_function(shapesModule,"dbf_field_count",RDBFFieldCount,1);
+	rb_define_module_function(shapesModule,"dbf_record_count",RDBFRecordCount,1);
+	rb_define_module_function(shapesModule,"dbf_field_index",RDBFFieldIndex,2);
+	rb_define_module_function(shapesModule,"dbf_field_type",RDBFGetFieldType,2);
+	rb_define_module_function(shapesModule,"dbf_add_field",RDBFAddField,5);
+	
+	//Attribute read / write
+	rb_define_module_function(shapesModule,"dbf_read_int",RDBFReadInt,3);
+	rb_define_module_function(shapesModule,"dbf_read_double",RDBFReadDouble,3);
+	rb_define_module_function(shapesModule,"dbf_read_string",RDBFReadString,3);
+	rb_define_module_function(shapesModule,"dbf_attribute_null?",RDBFIsAttributeNull,3);
+	rb_define_module_function(shapesModule,"dbf_write_integer",RDBFWriteInt,4);
+	rb_define_module_function(shapesModule,"dbf_write_double",RDBFWriteDouble,4);
+	rb_define_module_function(shapesModule,"dbf_write_string",RDBFWriteString,4);
+	rb_define_module_function(shapesModule,"dbf_write_null",RDBFWriteNull,3);
+	rb_define_module_function(shapesModule,"dbf_record_deleted?",RDBFIsRecordDeleted,2);
+	rb_define_module_function(shapesModule,"dbf_delete_record",RDBFDeleteRecord,3);
 }
 
 VALUE OpenSHP(VALUE klass,VALUE filename) {
@@ -111,12 +142,321 @@ VALUE CloseSHP(VALUE klass,VALUE handle) {
 	return Qtrue;
 }
 
+//DBF IO
+VALUE OpenDBF(VALUE klass,VALUE filename) {
+	VALUE rubyObject;
+	struct rbDBF *openedFile;
+	rubyObject = Data_Make_Struct(dbfClass,struct rbDBF,NULL,freeDBF,openedFile);
+	
+	const char *cFileName = StringValueCStr(filename);
+	openedFile->fileHandle = DBFOpen(cFileName,"rb+");
+	openedFile->open = 1;
+	
+	rb_obj_call_init(rubyObject,0,0);
+	return rubyObject;
+}
+
+VALUE CreateDBF(VALUE klass,VALUE filename) {
+	VALUE rubyObject;
+	struct rbDBF *createdFile;
+	rubyObject = Data_Make_Struct(dbfClass,struct rbDBF,NULL,freeDBF,createdFile);
+	
+	const char *cFileName = StringValueCStr(filename);
+	
+	createdFile->fileHandle = DBFCreate(cFileName);
+	createdFile->open = 1;
+	
+	rb_obj_call_init(rubyObject,0,0);
+	return rubyObject;
+}
+
+VALUE CloseDBF(VALUE klass,VALUE handle) {
+	struct rbDBF *dbfFile;
+	Data_Get_Struct(handle,struct rbDBF,dbfFile);
+	DBFHandle fileHandle = dbfFile->fileHandle;
+	dbfFile->open = 0;
+	DBFClose(fileHandle);
+	return Qtrue;
+}
+
+//DBF Manipulation
+
+VALUE RDBFFieldCount(VALUE klass,VALUE handle) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int fieldCount = DBFGetFieldCount(d);
+	VALUE rv = INT2NUM(fieldCount);
+	
+	return rv;
+}
+
+VALUE RDBFRecordCount(VALUE klass,VALUE handle) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int recordCount = DBFGetRecordCount(d);
+	VALUE rv = INT2NUM(recordCount);
+	
+	return rv;
+}
+
+VALUE RDBFFieldIndex(VALUE klass,VALUE handle,VALUE fieldName) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	const char *cFieldName = StringValueCStr(fieldName);
+	
+	int index = DBFGetFieldIndex(d,cFieldName);
+	VALUE rv = INT2NUM(index);
+	
+	return rv;
+}
+
+VALUE RDBFGetFieldType(VALUE klass,VALUE handle,VALUE fieldIndex) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cFieldIndex = NUM2INT(fieldIndex);
+	
+	DBFFieldType fieldType = DBFGetFieldInfo(d,cFieldIndex,NULL,NULL,NULL);
+	
+	VALUE fieldSymbol;
+	
+	switch (fieldType) {
+	case FTString:
+		fieldSymbol = ID2SYM(rb_intern("string"));
+		break;
+	case FTInteger:
+		fieldSymbol = ID2SYM(rb_intern("integer"));
+		break;
+	case FTDouble:
+		fieldSymbol = ID2SYM(rb_intern("double"));
+		break;
+	case FTLogical:
+		fieldSymbol = ID2SYM(rb_intern("logical"));
+		break;
+	case FTInvalid:
+		fieldSymbol = ID2SYM(rb_intern("invalid"));
+		break;
+	}
+	
+	return fieldSymbol;
+}
+
+VALUE RDBFAddField(VALUE klass,VALUE handle,VALUE fieldName,VALUE fieldType,VALUE width,VALUE decimals) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	const char *cFieldName = StringValueCStr(fieldName);
+	const char *cFieldType = StringValueCStr(fieldType);
+	
+	int cWidth    = NUM2INT(width);
+	int cDecimals = NUM2INT(decimals);
+	
+	DBFFieldType ft = FieldTypeFromString(cFieldType);
+	int fieldNumber = DBFAddField(d,cFieldName,ft,cWidth,cDecimals);
+	VALUE rv = INT2NUM(fieldNumber);
+	
+	return rv;
+}
+
+VALUE RDBFReadInt(VALUE klass,VALUE handle,VALUE row,VALUE field) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cField = NUM2INT(field);
+	
+	int r = DBFReadIntegerAttribute(d,cRow,cField);
+	VALUE rv = INT2NUM(r);
+	
+	return rv;
+}
+
+VALUE RDBFReadDouble(VALUE klass,VALUE handle,VALUE row,VALUE field) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cField = NUM2INT(field);
+	
+	double r = DBFReadDoubleAttribute(d,cRow,cField);
+	VALUE rv = DOUBLE2NUM(r);
+	
+	return rv;
+}
+
+VALUE RDBFReadString(VALUE klass,VALUE handle,VALUE row,VALUE field) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cField = NUM2INT(field);
+	
+	const char *r = DBFReadStringAttribute(d,cRow,cField);
+	VALUE rv = rb_str_new2(r);
+	
+	return rv;
+}
+
+VALUE RDBFIsAttributeNull(VALUE klass,VALUE handle,VALUE row,VALUE field) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cField = NUM2INT(field);
+	
+	VALUE rv = Qfalse;
+	
+	if (DBFIsAttributeNull(d,cRow,cField) == TRUE) {
+		rv = Qtrue;
+	}
+	
+	return rv;
+}
+
+VALUE RDBFWriteInt(VALUE klass,VALUE handle,VALUE row,VALUE field,VALUE val) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cField = NUM2INT(field);
+	int cVal = NUM2INT(val);
+	
+	VALUE rv;
+	
+	if (DBFWriteIntegerAttribute(d,cRow,cField,cVal) == TRUE) {
+		rv = Qtrue;
+	} else {
+		rv = Qfalse;		
+	}
+	
+	return rv;
+}
+
+VALUE RDBFWriteDouble(VALUE klass,VALUE handle,VALUE row,VALUE field,VALUE val) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cField = NUM2INT(field);
+	double cVal = NUM2DBL(val);
+	
+	VALUE rv;
+	
+	if (DBFWriteDoubleAttribute(d,cRow,cField,cVal) == TRUE) {
+		rv = Qtrue;
+	} else {
+		rv = Qfalse;		
+	}
+	
+	return rv;
+}
+
+VALUE RDBFWriteString(VALUE klass,VALUE handle,VALUE row,VALUE field,VALUE val) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cField = NUM2INT(field);
+	const char *cVal = StringValueCStr(val);
+	
+	VALUE rv;
+	
+	if (DBFWriteStringAttribute(d,cRow,cField,cVal) == TRUE) {
+		rv = Qtrue;
+	} else {
+		rv = Qfalse;		
+	}
+	
+	return rv;
+}
+
+VALUE RDBFWriteNull(VALUE klass,VALUE handle,VALUE row,VALUE field) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cField = NUM2INT(field);
+	
+	VALUE rv;
+	
+	if (DBFWriteNULLAttribute(d,cRow,cField) == TRUE) {
+		rv = Qtrue;
+	} else {
+		rv = Qfalse;		
+	}
+	
+	return rv;
+}
+
+VALUE RDBFIsRecordDeleted(VALUE klass,VALUE handle,VALUE row) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	
+	VALUE rv;
+	
+	if (DBFIsRecordDeleted(d,cRow) == TRUE) {
+		rv = Qtrue;
+	} else {
+		rv = Qfalse;
+	}
+	
+	return rv;
+}
+
+VALUE RDBFDeleteRecord(VALUE klass,VALUE handle,VALUE row,VALUE val) {
+	struct rbDBF *dbf;
+	Data_Get_Struct(handle,struct rbDBF,dbf);
+	DBFHandle d = dbf->fileHandle;
+	
+	int cRow = NUM2INT(row);
+	int cVal  = NUM2INT(val);
+	
+	int deleted = DBFMarkRecordDeleted(d,cRow,cVal);
+	
+	VALUE rv;
+	
+	if (deleted == TRUE) {
+		rv = Qtrue;	
+	} else {
+		rv = Qfalse;		
+	}
+	
+	return rv;
+}
+
 void freeShapeFile(struct rbShapeFile *f) {
 	if (f->open) {
+		f->open = 0;
 		SHPClose(f->fileHandle);	
 	}
 }
 
+void freeDBF(struct rbDBF *f) {
+	if (f->open) {
+		f->open = 0;
+		DBFClose(f->fileHandle);
+	}
+}
+
 int ShapeFromString(const char *cShapeType) {
 	int shape;
 	
@@ -133,4 +473,22 @@ int ShapeFromString(const char *cShapeType) {
 	}
 	
 	return shape;
+}
+
+DBFFieldType FieldTypeFromString(const char *cFieldType) {
+	DBFFieldType fieldType;
+	
+	if (strcmp(cFieldType,"string") == 0) {
+		fieldType = FTString;
+	} else if (strcmp(cFieldType,"integer") == 0) {
+		fieldType = FTInteger;
+	} else if (strcmp(cFieldType,"double") == 0) {
+		fieldType = FTDouble;		
+	} else if (strcmp(cFieldType,"logical") == 0) {
+		fieldType = FTLogical;
+	} else {
+		fieldType = FTInvalid;
+	}
+	
+	return fieldType;
 }

data/ext/shapes/shapes.h

@@ -1,12 +1,53 @@
+#define TRUE		1
+#define	FALSE		0
+
 struct rbShapeFile {
 	int open;
 	SHPHandle fileHandle;
 };
 
+struct rbDBF {
+	int open;
+	DBFHandle fileHandle;
+};
+
 VALUE shapeClass;
+VALUE dbfClass;
+
+// ShapeFile IO
 VALUE OpenSHP(VALUE klass,VALUE filename);
 VALUE CreateSHP(VALUE klass,VALUE filename,VALUE shapeType);
 VALUE CloseSHP(VALUE klass,VALUE handle);
+
+//ShapeFile manipulation
 VALUE CreateObject(VALUE klass,VALUE handle,VALUE shapeType,VALUE numVertices,VALUE x,VALUE y,VALUE z);
+
+//DBF IO
+VALUE OpenDBF(VALUE klass,VALUE filename);
+VALUE CreateDBF(VALUE klass,VALUE filename);
+VALUE CloseDBF(VALUE klass,VALUE handle);
+
+//DBF Manipulation
+
+VALUE RDBFFieldCount(VALUE klass,VALUE handle);
+VALUE RDBFRecordCount(VALUE klass,VALUE handle);
+VALUE RDBFFieldIndex(VALUE klass,VALUE handle,VALUE fieldName);
+VALUE RDBFGetFieldType(VALUE klass,VALUE handle,VALUE fieldIndex);
+VALUE RDBFAddField(VALUE klass,VALUE handle,VALUE fieldName,VALUE fieldType,VALUE width,VALUE decimals);
+
+// DBF read / write
+VALUE RDBFReadInt(VALUE klass,VALUE handle,VALUE row,VALUE field);
+VALUE RDBFReadDouble(VALUE klass,VALUE handle,VALUE row,VALUE field);
+VALUE RDBFReadString(VALUE klass,VALUE handle,VALUE row,VALUE field);
+VALUE RDBFIsAttributeNull(VALUE klass,VALUE handle,VALUE row,VALUE field);
+VALUE RDBFWriteInt(VALUE klass,VALUE handle,VALUE row,VALUE field,VALUE val);
+VALUE RDBFWriteDouble(VALUE klass,VALUE handle,VALUE row,VALUE field,VALUE val);
+VALUE RDBFWriteString(VALUE klass,VALUE handle,VALUE row,VALUE field,VALUE val);
+VALUE RDBFWriteNull(VALUE klass,VALUE handle,VALUE row,VALUE field);
+VALUE RDBFIsRecordDeleted(VALUE klass,VALUE handle,VALUE row);
+VALUE RDBFDeleteRecord(VALUE klass,VALUE handle,VALUE row,VALUE val);
+	
 void freeShapeFile(struct rbShapeFile *f);
-int ShapeFromString(const char *cShapeType);
+void freeDBF(struct rbDBF *f);
+int ShapeFromString(const char *cShapeType);
+DBFFieldType FieldTypeFromString(const char *cFieldType);

data/lib/shapes/geometry.rb

@@ -1,22 +1,33 @@
 module Shapes
-  class Point
-    attr_accessor :longitude, :latitude, :altitude, :projection
+  class GeoObject
+    attr_accessor :attributes
     
-    def initialize(lat = nil,long = nil,alt = nil,proj = :wgs84)
+    def initialize(*args)
+      self.attributes = Hash.new
+    end  
+  end
+  
+  class Point < GeoObject
+    attr_accessor :longitude, :latitude, :altitude
+    
+    def initialize(lat = nil,long = nil,alt = nil,attributes = {})
+      super
       self.latitude   = lat
       self.longitude  = long
       self.altitude = alt
-      self.projection = proj
+      self.attributes = attributes
     end
   end
   
-  class Polygon
+  class Polygon < GeoObject
     attr_accessor :vertices, :num_vertices
     
-    def initialize(vertices = nil,num_vertices = 4)
+    def initialize(vertices = nil,num_vertices = 4,attributes = {})
+      super
       self.vertices = vertices if Array === vertices
       self.vertices ||= []
       self.num_vertices = num_vertices
+      self.attributes = {}
     end
     
     def add_point(p)

data/lib/shapes/shape_file.rb

@@ -1,63 +1,117 @@
 module Shapes
   class ShapeFile
-    attr_accessor :handle
+    attr_accessor :handle, :dbf_handle, :fields
     
     def initialize(afile = nil,stype = nil)
       if afile and stype
         self.handle = ShapesLib::create_shape afile, stype.to_s
+        self.dbf_handle = ShapesLib::create_dbf afile
       elsif afile
         self.handle = ShapesLib::open_shape afile
+        self.dbf_handle = Shapeslib::open_dbf afile
       else
         return self # get out of the function if no handle was passed
       end
       
+      self.fields = Hash.new
+      
       # but if we attempted to create a handle, make sure
       # it actually returned something valid
       return self.handle unless self.handle
+      return self.dbf_handle unless self.dbf_handle
     end
     
     def self.create(filename,shape_type,&block)
-      shape_handle = ShapesLib::create_shape filename, shape_type.to_s
-      return shape_handle unless shape_handle
-      
-      inst = new
-      inst.handle = shape_handle
+      inst = new filename, shape_type
+      return inst unless inst
       
       inst.define(&block)
       
-      ShapesLib::close_shape shape_handle
+      inst.close
+      return true
     end
     
     def self.open(filename,&block)
-      shape_handle = ShapesLib::open_shape filename
-      return shape_handle unless shape_handle
-      
-      inst = new
-      inst.handle = shape_handle
+      inst = new filename
+      return inst unless inst
       
       inst.define(&block)
       
-      ShapesLib::close_shape shape_handle
+      inst.close
+      return true
+    end
+    
+    def add_field(field_name,field_type,width = 255,decimals = 0)
+      rv = ShapesLib::dbf_add_field self.dbf_handle, field_name.to_s, field_type.to_s, width, decimals
+      self.fields[field_name] =  {
+        name: field_name,
+        type: field_type,
+        width: width,
+        decimals: decimals,
+        field_number: rv
+      }
+      return rv
+    end
+    
+    def close
+      ShapesLib::close_shape self.handle
+      ShapesLib::close_dbf self.dbf_handle
     end
     
     def define(&block)
       instance_eval(&block)
     end
     
+    def save_attribute(key,value,row)
+      return false if self.fields[key].nil?
+      
+      d = self.dbf_handle
+      field_info = self.fields[key]
+      field_name = key.to_s
+      field_type = field_info[:type]
+      field_number = field_info[:field_number]
+      width = field_info[:width]
+      decimals = field_info[:decimals]
+      
+      saved = case field_type
+      when :string then ShapesLib::dbf_write_string d, row, field_number, value.to_s
+      when :integer then ShapesLib::dbf_write_integer d, row, field_number, value.to_i
+      when :double then ShapesLib::dbf_write_double d, row, field_number, value.to_f
+      end
+      
+      return saved
+    end
+    
     def point(p)
-      ShapesLib::create_object self.handle, 'point', 1, [p.longitude], [p.latitude], [p.altitude]
+      i = ShapesLib::create_object self.handle, 'point', 1, [p.longitude], [p.latitude], [p.altitude]
+      attrs = p.attributes
+      
+      attrs.each {|key,val| save_attribute(key,val,i) }
+      return i
     end
     
     def polygon(p)
-      ShapesLib::create_object self.handle, 'polygon', p.num_vertices, p.xs, p.ys, p.zs
+      i = ShapesLib::create_object self.handle, 'polygon', p.num_vertices, p.xs, p.ys, p.zs
+      attrs = p.attributes
+      
+      attrs.each {|key,val| save_attribute(key,val,i) }
+      return i
     end
     
     def arc(a)
-      ShapesLib::create_object self.handle, 'arc', a.num_vertices, a.xs, p.ys, p.zs
+      i = ShapesLib::create_object self.handle, 'arc', a.num_vertices, a.xs, p.ys, p.zs
+      attrs = a.attributes
+      
+      attrs.each {|key,val| save_attribute(key,val,i)}
+      return i
     end
     
     def multipoint(mp)
-      ShapesLib::create_object self.handle, 'multipoint', mp.num_vertices, mp.xs, mp.ys, mp.zs
+      i = ShapesLib::create_object self.handle, 'multipoint', mp.num_vertices, mp.xs, mp.ys, mp.zs
+      attrs = mp.attributes
+      
+      attrs.each {|key,val| save_attribute(key,val,i) }
+      return i
     end
   end
 end

data/lib/shapes/version.rb

@@ -1,3 +1,3 @@
 module Shapes
-  VERSION = "0.1"
+  VERSION = "0.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shapes
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-30 00:00:00.000000000 Z
+date: 2012-12-31 00:00:00.000000000 Z
 dependencies: []
 description: A simple ruby library for writing shape files
 email: