rgeo 0.1.13 → 0.1.14

data/ext/geos_c_impl/point.c

@@ -94,11 +94,11 @@ static VALUE method_point_y(VALUE self)
 }
 
 
-static VALUE method_point_z(VALUE self)
+static VALUE get_3d_point(VALUE self, int flag)
 {
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
-  if (self_geom && GEOSHasZ_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom) == 1) {
+  if (self_geom && RGEO_FACTORY_DATA_FROM_GEOMETRY(self)->flags & flag) {
     const GEOSCoordSequence* coord_seq = GEOSGeom_getCoordSeq_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
     if (coord_seq) {
       double val;
@@ -111,25 +111,32 @@ static VALUE method_point_z(VALUE self)
 }
 
 
+static VALUE method_point_z(VALUE self)
+{
+  return get_3d_point(self, RGEO_FACTORYFLAGS_SUPPORTS_Z);
+}
+
+
+static VALUE method_point_m(VALUE self)
+{
+  return get_3d_point(self, RGEO_FACTORYFLAGS_SUPPORTS_M);
+}
+
+
 static VALUE method_point_eql(VALUE self, VALUE rhs)
 {
   VALUE result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
-    result = rgeo_geos_coordseqs_eql(RGEO_CONTEXT_FROM_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(rhs));
+    result = rgeo_geos_coordseqs_eql(RGEO_CONTEXT_FROM_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(rhs), RGEO_FACTORY_DATA_FROM_GEOMETRY(self)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
   }
   return result;
 }
 
 
-static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y)
-{
-  return rgeo_create_geos_point_2d(factory, rb_num2dbl(x), rb_num2dbl(y));
-}
-
-
-static VALUE cmethod_create3d(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE z)
+static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE z)
 {
-  return rgeo_create_geos_point_3d(factory, rb_num2dbl(x), rb_num2dbl(y), rb_num2dbl(z));
+  return rgeo_create_geos_point(factory, rb_num2dbl(x), rb_num2dbl(y),
+    RGEO_FACTORY_DATA_PTR(factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M ? rb_num2dbl(z) : 0);
 }
 
 
@@ -137,39 +144,21 @@ void rgeo_init_geos_point(RGeo_Globals* globals)
 {
   VALUE geos_point_class = rb_define_class_under(globals->geos_module, "PointImpl", rb_const_get_at(globals->geos_module, rb_intern("GeometryImpl")));
   
-  rb_define_module_function(geos_point_class, "create", cmethod_create, 3);
-  rb_define_module_function(geos_point_class, "create3d", cmethod_create3d, 4);
+  rb_define_module_function(geos_point_class, "create", cmethod_create, 4);
   
   rb_define_method(geos_point_class, "eql?", method_point_eql, 1);
   rb_define_method(geos_point_class, "geometry_type", method_point_geometry_type, 0);
   rb_define_method(geos_point_class, "x", method_point_x, 0);
   rb_define_method(geos_point_class, "y", method_point_y, 0);
   rb_define_method(geos_point_class, "z", method_point_z, 0);
+  rb_define_method(geos_point_class, "m", method_point_m, 0);
 }
 
 
-VALUE rgeo_create_geos_point_2d(VALUE factory, double x, double y)
-{
-  VALUE result = Qnil;
-  GEOSCoordSequence* coord_seq = GEOSCoordSeq_create_r(RGEO_CONTEXT_FROM_FACTORY(factory), 1, 2);
-  if (coord_seq) {
-    if (GEOSCoordSeq_setX_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, x)) {
-      if (GEOSCoordSeq_setY_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, y)) {
-        GEOSGeometry* geom = GEOSGeom_createPoint_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq);
-        if (geom) {
-          result = rgeo_wrap_geos_geometry(factory, geom, rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->geos_module, rb_intern("PointImpl")));
-        }
-      }
-    }
-  }
-  return result;
-}
-
-
-VALUE rgeo_create_geos_point_3d(VALUE factory, double x, double y, double z)
+VALUE rgeo_create_geos_point(VALUE factory, double x, double y, double z)
 {
   VALUE result = Qnil;
-  GEOSCoordSequence* coord_seq = GEOSCoordSeq_create_r(RGEO_CONTEXT_FROM_FACTORY(factory), 1, 2);
+  GEOSCoordSequence* coord_seq = GEOSCoordSeq_create_r(RGEO_CONTEXT_FROM_FACTORY(factory), 1, 3);
   if (coord_seq) {
     if (GEOSCoordSeq_setX_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, x)) {
       if (GEOSCoordSeq_setY_r(RGEO_CONTEXT_FROM_FACTORY(factory), coord_seq, 0, y)) {

data/ext/geos_c_impl/point.h

@@ -51,15 +51,10 @@ RGEO_BEGIN_C
 */
 void rgeo_init_geos_point(RGeo_Globals* globals);
 
-/*
-  Creates a 2d point and returns the ruby object.
-*/
-VALUE rgeo_create_geos_point_2d(VALUE factory, double x, double y);
-
 /*
   Creates a 3d point and returns the ruby object.
 */
-VALUE rgeo_create_geos_point_3d(VALUE factory, double x, double y, double z);
+VALUE rgeo_create_geos_point(VALUE factory, double x, double y, double z);
 
 
 RGEO_END_C

data/ext/geos_c_impl/polygon.c

@@ -54,7 +54,7 @@ static VALUE method_polygon_eql(VALUE self, VALUE rhs)
 {
   VALUE result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
-    result = rgeo_geos_polygons_eql(RGEO_CONTEXT_FROM_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(rhs));
+    result = rgeo_geos_polygons_eql(RGEO_CONTEXT_FROM_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(self), RGEO_GET_GEOS_GEOMETRY(rhs), RGEO_FACTORY_DATA_FROM_GEOMETRY(self)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
   }
   return result;
 }
@@ -214,11 +214,11 @@ void rgeo_init_geos_polygon(RGeo_Globals* globals)
 }
 
 
-VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2)
+VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z)
 {
   VALUE result = Qnil;
   if (geom1 && geom2) {
-    result = rgeo_geos_coordseqs_eql(context, GEOSGetExteriorRing_r(context, geom1), GEOSGetExteriorRing_r(context, geom2));
+    result = rgeo_geos_coordseqs_eql(context, GEOSGetExteriorRing_r(context, geom1), GEOSGetExteriorRing_r(context, geom2), check_z);
     if (RTEST(result)) {
       int len1 = GEOSGetNumInteriorRings_r(context, geom1);
       int len2 = GEOSGetNumInteriorRings_r(context, geom2);
@@ -226,7 +226,7 @@ VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* ge
         if (len1 == len2) {
           int i;
           for (i=0; i<len1; ++i) {
-            result = rgeo_geos_coordseqs_eql(context, GEOSGetInteriorRingN_r(context, geom1, i), GEOSGetInteriorRingN_r(context, geom2, i));
+            result = rgeo_geos_coordseqs_eql(context, GEOSGetInteriorRingN_r(context, geom1, i), GEOSGetInteriorRingN_r(context, geom2, i), check_z);
             if (!RTEST(result)) {
               break;
             }

data/ext/geos_c_impl/polygon.h

@@ -58,7 +58,7 @@ void rgeo_init_geos_polygon(RGeo_Globals* globals);
   Returns Qtrue if the polygons are equal, Qfalse if they are inequal, or
   Qnil if an error occurs.
 */
-VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2);
+VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
 
 
 RGEO_END_C

data/lib/rgeo.rb

@@ -78,6 +78,7 @@ paths_ = [
   'errors',
   'features',
   'impl_helpers',
+  'wkrep',
   'geos',
   'cartesian',
   'geography',

data/lib/rgeo/cartesian/simple_factory.rb

@@ -57,6 +57,8 @@ module RGeo
       
       def initialize(opts_={})
         @srid = opts_[:srid].to_i
+        @support_z = opts_[:support_z_coordinate] ? true : false
+        @support_m = opts_[:support_m_coordinate] ? true : false
       end
       
       
@@ -75,24 +77,38 @@ module RGeo
       end
       
       
+      # See ::RGeo::Features::Factory#has_capability?
+      
+      def has_capability?(name_)
+        case name_
+        when :z_coordinate
+          @support_z
+        when :m_coordinate
+          @support_m
+        else
+          nil
+        end
+      end
+      
+      
       # See ::RGeo::Features::Factory#parse_wkt
       
       def parse_wkt(str_)
-        ImplHelpers::Serialization.parse_wkt(str_, self)
+        WKRep::WKTParser.new(self, :support_higher_dimensions => true).parse(str_)
       end
       
       
       # See ::RGeo::Features::Factory#parse_wkb
       
       def parse_wkb(str_)
-        ImplHelpers::Serialization.parse_wkb(str_, self)
+        WKRep::WKBParser.new(self).parse(str_)
       end
       
       
       # See ::RGeo::Features::Factory#point
       
-      def point(x_, y_)
-        SimplePointImpl.new(self, x_, y_) rescue nil
+      def point(x_, y_, *extra_)
+        SimplePointImpl.new(self, x_, y_, *extra_) rescue nil
       end
       
       

data/lib/rgeo/errors.rb

@@ -53,6 +53,14 @@ module RGeo
     class InvalidGeometry < RGeoError
     end
     
+    # The specified capability is not supported
+    class UnsupportedCapability < RGeoError
+    end
+    
+    # Parsing failed
+    class ParseError < RGeoError
+    end
+    
   end
   
   

data/lib/rgeo/features/factory.rb

@@ -71,6 +71,36 @@ module RGeo
       end
       
       
+      # Determine support for the given capability, identified by a
+      # symbolic name. This method may be used to test this factory, and
+      # any features created by it, to determine whether they support
+      # certain capabilities or operations. Most queries return a boolean
+      # value, though some may return other values to indicate different
+      # levels of support. Generally speaking, if a query returns a false
+      # or nil value, support for that capability is not guaranteed, and
+      # calls related to that function may fail or raise exceptions.
+      # 
+      # Each capability must have a symbolic name. Names that have no
+      # periods are considered well-known names and are reserved for use
+      # by RGeo. If you want to define your own capabilities, use a name
+      # that is namespaced, such as <tt>:'mycompany.mycapability'</tt>.
+      # 
+      # Currently defined standard capabilities are:
+      # 
+      # <tt>:z_coordinate</tt>::
+      #   Supports a "z" coordinate. When an implementation supports
+      #   z_coordinate, the Factory#epoint and Point#z methods are
+      #   available.
+      # <tt>:m_coordinate</tt>::
+      #   Supports a "m" coordinate. When an implementation supports
+      #   m_coordinate, the Factory#epoint and Point#m methods are
+      #   available.
+      
+      def has_capability?(name_)
+        nil
+      end
+      
+      
       # Parse the given string in well-known-text format and return the
       # resulting feature. Returns nil if the string couldn't be parsed.
       
@@ -89,8 +119,12 @@ module RGeo
       
       # Create a feature of type Point.
       # The x and y parameters should be Float values.
+      # 
+      # The extra parameters should be the Z and/or M coordinates, if the
+      # capabilities are supported. If both Z and M capabilities are
+      # supported, Z should be passed first.
       
-      def point(x_, y_)
+      def point(x_, y_, *extra_)
         nil
       end
       

data/lib/rgeo/features/point.rb

@@ -90,6 +90,28 @@ module RGeo
       end
       
       
+      # Returns the z-coordinate for this Point as a floating-point
+      # scalar value.
+      # 
+      # This method may not be available if the point's factory does
+      # not support the <tt>z_coordinate</tt> capability.
+      
+      def z
+        raise Errors::MethodUnimplemented
+      end
+      
+      
+      # Returns the m-coordinate for this Point as a floating-point
+      # scalar value.
+      # 
+      # This method may not be available if the point's factory does
+      # not support the <tt>m_coordinate</tt> capability.
+      
+      def m
+        raise Errors::MethodUnimplemented
+      end
+      
+      
     end
   
     

data/lib/rgeo/features/polygon.rb

@@ -117,7 +117,7 @@ module RGeo
       # 
       # === Notes
       # 
-      # Returns an object that supports the LineString interface, or nil
+      # Returns an object that supports the LinearRing interface, or nil
       # if the given n is out of range.
       
       def interior_ring_n(n_)
@@ -133,7 +133,6 @@ module RGeo
       end
       
       
-      
     end
   
     

data/lib/rgeo/features/types.rb

@@ -39,7 +39,7 @@ module RGeo
   module Features
     
     
-    # These methods are available as class methods (not instance methods)
+    # These methods are available as module methods (not instance methods)
     # of the various feature types.
     # For example, you may determine whether a feature object is a
     # point by calling:
@@ -78,6 +78,21 @@ module RGeo
       alias_method :===, :check_type
       
       
+      # Returns true if this type is the same type or a subtype of the
+      # given type.
+      
+      def subtype_of?(type_)
+        self == type_ || self.include?(type_)
+      end
+      
+      
+      # Returns the OpenGIS type name of this type.
+      
+      def type_name
+        self.name.sub('RGeo::Features::', '')
+      end
+      
+      
     end
     
     
@@ -135,7 +150,14 @@ module RGeo
           force_new_ ? obj_.dup : obj_
         elsif ntype_ == type_
           if type_ == Point
-            nfactory_.point(obj_.x, obj_.y)
+            extra_ = []
+            if nfactory_.has_capability?(:z_coordinate)
+              extra_ << (factory_.has_capability?(:z_coordinate) ? obj_.z : 0.0)
+            end
+            if nfactory_.has_capability?(:m_coordinate)
+              extra_ << (factory_.has_capability?(:m_coordinate) ? obj_.m : 0.0)
+            end
+            nfactory_.point(obj_.x, obj_.y, *extra_)
           elsif type_ == Line
             nfactory_.line(obj_.start_point, obj_.end_point)
           elsif type_ == LinearRing
@@ -165,24 +187,56 @@ module RGeo
             else
               nil
             end
-          elsif ntype_ == Line && type_ == LineString
-            if obj_.num_points == 2
+          elsif ntype_ == Point
+            nil
+          elsif ntype_ == Line
+            if type_ == LineString && obj_.num_points == 2
               nfactory_.line(obj_.point_n(0), obj_.point_n(1))
             else
               nil
             end
-          elsif ntype_ == LinearRing && type_ == LineString
-            nfactory_.linear_ring(obj_.points)
-          elsif ntype_ == LineString && (type_ == Line || type_ == LinearRing)
-            nfactory_.line_string(obj_.points)
-          elsif ntype_ == MultiPoint && type_ == GeometryCollection
-            nfactory_.multi_point(obj_)
-          elsif ntype_ == MultiLineString && type_ == GeometryCollection
-            nfactory_.multi_line_string(obj_)
-          elsif ntype_ == MultiPolygon && type_ == GeometryCollection
-            nfactory_.multi_polygon(obj_)
-          elsif ntype_ == GeometryCollection && (type_ == MultiPoint || type_ == MultiLineString || type_ == MultiPolygon)
-            nfactory_.collection(obj_)
+          elsif ntype_ == LinearRing
+            if type_ == LineString
+              nfactory_.linear_ring(obj_.points)
+            else
+              nil
+            end
+          elsif ntype_ == LineString
+            if type_ == Line || type_ == LinearRing
+              nfactory_.line_string(obj_.points)
+            else
+              nil
+            end
+          elsif ntype_ == MultiPoint
+            if type_ == Point
+              nfactory_.multi_point([obj_])
+            elsif type_ == GeometryCollection
+              nfactory_.multi_point(obj_)
+            else
+              nil
+            end
+          elsif ntype_ == MultiLineString
+            if type_ == Line || type_ == LinearRing || type_ == LineString
+              nfactory_.multi_line_string([obj_])
+            elsif type_ == GeometryCollection
+              nfactory_.multi_line_string(obj_)
+            else
+              nil
+            end
+          elsif ntype_ == MultiPolygon
+            if type_ == Polygon
+              nfactory_.multi_polygon([obj_])
+            elsif type_ == GeometryCollection
+              nfactory_.multi_polygon(obj_)
+            else
+              nil
+            end
+          elsif ntype_ == GeometryCollection
+            if type_ == MultiPoint || type_ == MultiLineString || type_ == MultiPolygon
+              nfactory_.collection(obj_)
+            else
+              nfactory_.collection([obj_])
+            end
           else
             nil
           end