rgeo 0.1.10 → 0.1.11

data/lib/rgeo/geos/factory.rb

@@ -66,7 +66,8 @@ module RGeo
         #   example, the buffer around a point to be approximated by a
         #   4-sided polygon. A resolution of 2 would cause that buffer
         #   to be approximated by an 8-sided polygon. The exact behavior
-        #   for different kinds of buffers is not well-defined.
+        #   for different kinds of buffers is internal to GEOS, and is not
+        #   well-specified as far as I can tell.
         # <tt>:srid</tt>::
         #   Set the SRID returned by geometries created by this factory.
         #   Default is 0.
@@ -202,9 +203,9 @@ module RGeo
       end
       
       
-      # See ::RGeo::Features::Factory#convert
+      # See ::RGeo::Features::Factory#coerce
       
-      def convert(original_, force_new_=false)
+      def coerce(original_, force_new_=false)
         return nil unless Geos.supported?
         case original_
         when GeometryImpl
@@ -224,21 +225,21 @@ module RGeo
             PointImpl.create(self, original_.x, original_.y)
           end
         when Features::Line
-          LineImpl.create(self, original_.start_point, original_.end_point)
+          LineImpl.create(self, coerce(original_.start_point), coerce(original_.end_point))
         when Features::LinearRing
-          LinearRingImpl.create(self, original_.points)
+          LinearRingImpl.create(self, original_.points.map{ |g_| coerce(g_) })
         when Features::LineString
-          LineStringImpl.create(self, original_.points)
+          LineStringImpl.create(self, original_.points.map{ |g_| coerce(g_) })
         when Features::Polygon
-          PolygonImpl.create(self, original_.exterior_ring, original_.interior_rings)
+          PolygonImpl.create(self, coerce(original_.exterior_ring), original_.interior_rings.map{ |g_| coerce(g_) })
         when Features::MultiPoint
-          MultiPointImpl.create(self, original_.to_a)
+          MultiPointImpl.create(self, original_.to_a.map{ |g_| coerce(g_) })
         when Features::MultiLineString
-          MultiLineStringImpl.create(self, original_.to_a)
+          MultiLineStringImpl.create(self, original_.to_a.map{ |g_| coerce(g_) })
         when Features::MultiPolygon
-          MultiPolygonImpl.create(self, original_.to_a)
+          MultiPolygonImpl.create(self, original_.to_a.map{ |g_| coerce(g_) })
         when Features::GeometryCollection
-          GeometryCollectionImpl.create(self, original_.to_a)
+          GeometryCollectionImpl.create(self, original_.to_a.map{ |g_| coerce(g_) })
         else
           nil
         end

data/tests/common/geometry_collection_tests.rb

@@ -0,0 +1,220 @@
+# -----------------------------------------------------------------------------
+# 
+# Common tests for geometry collection implementations
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'rgeo'
+
+
+module RGeo
+  module Tests  # :nodoc:
+    module Common  # :nodoc:
+      
+      module GeometryCollectionTests  # :nodoc:
+        
+        
+        def setup
+          @factory = create_factory
+          @point1 = @factory.point(0, 0)
+          @point2 = @factory.point(1, 0)
+          @point3 = @factory.point(-4, 2)
+          @point4 = @factory.point(-5, 3)
+          @line1 = @factory.line_string([@point3, @point4])
+          @line2 = @factory.line_string([@point3, @point4, @point1])
+          @line3 = @factory.line(@point3, @point4)
+        end
+        
+        
+        def test_creation_simple
+          geom_ = @factory.collection([@point1, @line1])
+          assert_not_nil(geom_)
+          assert(::RGeo::Features::GeometryCollection === geom_)
+          assert_equal(::RGeo::Features::GeometryCollection, geom_.geometry_type)
+          assert_equal(2, geom_.num_geometries)
+          assert_equal([@point1, @line1], geom_.to_a)
+        end
+        
+        
+        def test_creation_empty
+          geom_ = @factory.collection([])
+          assert_not_nil(geom_)
+          assert(::RGeo::Features::GeometryCollection === geom_)
+          assert_equal(::RGeo::Features::GeometryCollection, geom_.geometry_type)
+          assert_equal(0, geom_.num_geometries)
+          assert_equal([], geom_.to_a)
+        end
+        
+        
+        def test_creation_save_klass
+          geom_ = @factory.collection([@point1, @line3])
+          assert_not_nil(geom_)
+          assert(::RGeo::Features::GeometryCollection === geom_)
+          assert_equal(::RGeo::Features::GeometryCollection, geom_.geometry_type)
+          assert_equal(2, geom_.num_geometries)
+          assert(geom_[1].eql?(@line3))
+        end
+        
+        
+        def test_creation_compound
+          geom1_ = @factory.collection([@point1, @line1])
+          geom2_ = @factory.collection([@point2, geom1_])
+          assert_not_nil(geom2_)
+          assert(::RGeo::Features::GeometryCollection === geom2_)
+          assert_equal(::RGeo::Features::GeometryCollection, geom2_.geometry_type)
+          assert_equal(2, geom2_.num_geometries)
+          assert(geom2_[1].eql?(geom1_))
+        end
+        
+        
+        def test_creation_compound_save_klass
+          geom1_ = @factory.collection([@point1, @line3])
+          geom2_ = @factory.collection([@point2, geom1_])
+          ::GC.start
+          assert_not_nil(geom2_)
+          assert(::RGeo::Features::GeometryCollection === geom2_)
+          assert_equal(::RGeo::Features::GeometryCollection, geom2_.geometry_type)
+          assert_equal(2, geom2_.num_geometries)
+          assert(::RGeo::Features::Line === geom2_[1][1])
+        end
+        
+        
+        def test_fully_equal
+          geom1_ = @factory.collection([@point1, @line1])
+          geom2_ = @factory.collection([@point1, @line1])
+          assert(geom1_.eql?(geom2_))
+          assert(geom1_.equals?(geom2_))
+        end
+        
+        
+        def test_geometrically_equal
+          geom1_ = @factory.collection([@point2, @line2])
+          geom2_ = @factory.collection([@point2, @line1, @line2])
+          assert(!geom1_.eql?(geom2_))
+          assert(geom1_.equals?(geom2_))
+        end
+        
+        
+        def test_empty_equal
+          geom1_ = @factory.collection([])
+          geom2_ = @factory.collection([])
+          assert(geom1_.eql?(geom2_))
+          assert(geom1_.equals?(geom2_))
+        end
+        
+        
+        def test_not_equal
+          geom1_ = @factory.collection([@point1, @line1])
+          geom2_ = @factory.collection([@point2, @line1])
+          assert(!geom1_.eql?(geom2_))
+          assert(!geom1_.equals?(geom2_))
+        end
+        
+        
+        def test_wkt_creation_simple
+          parsed_geom_ = @factory.parse_wkt('GEOMETRYCOLLECTION(POINT(0 0), LINESTRING(-4 2, -5 3))')
+          built_geom_ = @factory.collection([@point1, @line1])
+          assert_equal(built_geom_, parsed_geom_)
+        end
+        
+        
+        def test_wkt_creation_empty
+          parsed_geom_ = @factory.parse_wkt('GEOMETRYCOLLECTION EMPTY')
+          assert_equal(0, parsed_geom_.num_geometries)
+          assert_equal([], parsed_geom_.to_a)
+        end
+        
+        
+        def test_clone
+          geom1_ = @factory.collection([@point1, @line1])
+          geom2_ = geom1_.clone
+          assert_equal(geom1_, geom2_)
+          assert_equal(::RGeo::Features::GeometryCollection, geom2_.geometry_type)
+          assert_equal(2, geom2_.num_geometries)
+          assert_equal([@point1, @line1], geom2_.to_a)
+        end
+        
+        
+        def test_type_check
+          geom1_ = @factory.collection([@point1, @line1])
+          assert(::RGeo::Features::Geometry.check_type(geom1_))
+          assert(!::RGeo::Features::Point.check_type(geom1_))
+          assert(::RGeo::Features::GeometryCollection.check_type(geom1_))
+          assert(!::RGeo::Features::MultiPoint.check_type(geom1_))
+          geom2_ = @factory.collection([@point1, @point2])
+          assert(::RGeo::Features::Geometry.check_type(geom2_))
+          assert(!::RGeo::Features::Point.check_type(geom2_))
+          assert(::RGeo::Features::GeometryCollection.check_type(geom2_))
+          assert(!::RGeo::Features::MultiPoint.check_type(geom2_))
+        end
+        
+        
+        def test_as_text_wkt_round_trip
+          geom1_ = @factory.collection([@point1, @line1])
+          text_ = geom1_.as_text
+          geom2_ = @factory.parse_wkt(text_)
+          assert_equal(geom1_, geom2_)
+        end
+        
+        
+        def test_as_binary_wkb_round_trip
+          geom1_ = @factory.collection([@point1, @line1])
+          binary_ = geom1_.as_binary
+          geom2_ = @factory.parse_wkb(binary_)
+          assert_equal(geom1_, geom2_)
+        end
+        
+        
+        def test_dimension
+          geom1_ = @factory.collection([@point1, @line1])
+          assert_equal(1, geom1_.dimension)
+          geom2_ = @factory.collection([@point1, @point2])
+          assert_equal(0, geom2_.dimension)
+          geom3_ = @factory.collection([])
+          assert_equal(-1, geom3_.dimension)
+        end
+        
+        
+        def test_is_empty
+          geom1_ = @factory.collection([@point1, @line1])
+          assert(!geom1_.is_empty?)
+          geom2_ = @factory.collection([])
+          assert(geom2_.is_empty?)
+        end
+        
+        
+      end
+      
+    end
+  end
+end

data/tests/common/line_string_tests.rb

@@ -0,0 +1,300 @@
+# -----------------------------------------------------------------------------
+# 
+# Common tests for line string implementations
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'rgeo'
+
+
+module RGeo
+  module Tests  # :nodoc:
+    module Common  # :nodoc:
+      
+      module LineStringTests  # :nodoc:
+        
+        
+        def test_creation_success
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          line1_ = @factory.line_string([point1_, point2_])
+          assert_not_nil(line1_)
+          assert_equal(::RGeo::Features::LineString, line1_.geometry_type)
+          assert_equal(2, line1_.num_points)
+          assert_equal(point1_, line1_.point_n(0))
+          assert_equal(point2_, line1_.point_n(1))
+          line2_ = @factory.line_string([point1_, point2_, point3_])
+          assert_not_nil(line2_)
+          assert_equal(::RGeo::Features::LineString, line2_.geometry_type)
+          assert_equal(3, line2_.num_points)
+          assert_equal(point1_, line2_.point_n(0))
+          assert_equal(point2_, line2_.point_n(1))
+          assert_equal(point3_, line2_.point_n(2))
+          line3_ = @factory.line_string([point1_, point1_])
+          assert_not_nil(line3_)
+          assert_equal(::RGeo::Features::LineString, line3_.geometry_type)
+          assert_equal(2, line3_.num_points)
+          assert_equal(point1_, line3_.point_n(0))
+          assert_equal(point1_, line3_.point_n(1))
+          line4_ = @factory.line_string([])
+          assert_not_nil(line4_)
+          assert_equal(::RGeo::Features::LineString, line4_.geometry_type)
+          assert_equal(0, line4_.num_points)
+        end
+        
+        
+        def test_creation_line_string
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 1)
+          line1_ = @factory.line_string([point1_, point2_, point3_])
+          assert_not_nil(line1_)
+          assert(::RGeo::Features::LineString === line1_)
+          assert(!(::RGeo::Features::LinearRing === line1_))
+          assert(!(::RGeo::Features::Line === line1_))
+          assert_equal(::RGeo::Features::LineString, line1_.geometry_type)
+        end
+        
+        
+        def test_creation_linear_ring
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          line1_ = @factory.linear_ring([point1_, point2_, point3_, point1_])
+          assert_not_nil(line1_)
+          assert(line1_.is_ring?)
+          assert(::RGeo::Features::LinearRing === line1_)
+          assert_equal(::RGeo::Features::LinearRing, line1_.geometry_type)
+          line2_ = @factory.linear_ring([point1_, point2_, point3_])
+          assert_not_nil(line2_)
+          assert(line2_.is_ring?)
+          assert(::RGeo::Features::LinearRing === line2_)
+          assert_equal(4, line2_.num_points)
+          assert_equal(::RGeo::Features::LinearRing, line2_.geometry_type)
+        end
+        
+        
+        def test_creation_line
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line(point1_, point2_)
+          assert_not_nil(line1_)
+          assert(::RGeo::Features::Line === line1_)
+          assert_equal(::RGeo::Features::Line, line1_.geometry_type)
+        end
+        
+        
+        def test_creation_errors
+          point1_ = @factory.point(0, 0)
+          collection_ = point1_.boundary
+          line1_ = @factory.line_string([point1_])
+          assert_nil(line1_)
+          line2_ = @factory.line_string([point1_, collection_])
+          assert_nil(line2_)
+        end
+        
+        
+        def test_fully_equal
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          line1_ = @factory.line_string([point1_, point2_, point3_])
+          point4_ = @factory.point(0, 0)
+          point5_ = @factory.point(0, 1)
+          point6_ = @factory.point(1, 0)
+          line2_ = @factory.line_string([point4_, point5_, point6_])
+          assert(line1_.eql?(line2_))
+          assert(line1_.equals?(line2_))
+        end
+        
+        
+        def test_geometrically_equal_but_different_type
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line_string([point1_, point2_])
+          point4_ = @factory.point(0, 0)
+          point5_ = @factory.point(0, 1)
+          line2_ = @factory.line(point4_, point5_)
+          assert(!line1_.eql?(line2_))
+          assert(line1_.equals?(line2_))
+        end
+        
+        
+        def test_geometrically_equal_but_different_type2
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          line1_ = @factory.line_string([point1_, point2_, point3_, point1_])
+          point4_ = @factory.point(0, 0)
+          point5_ = @factory.point(0, 1)
+          point6_ = @factory.point(1, 0)
+          line2_ = @factory.linear_ring([point4_, point5_, point6_, point4_])
+          assert(!line1_.eql?(line2_))
+          assert(line1_.equals?(line2_))
+        end
+        
+        
+        def test_geometrically_equal_but_different_overlap
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          point3_ = @factory.point(1, 0)
+          line1_ = @factory.line_string([point1_, point2_, point3_])
+          point4_ = @factory.point(0, 0)
+          point5_ = @factory.point(0, 1)
+          point6_ = @factory.point(1, 0)
+          line2_ = @factory.line_string([point4_, point5_, point6_, point5_])
+          assert(!line1_.eql?(line2_))
+          assert(line1_.equals?(line2_))
+        end
+        
+        
+        def test_empty_equal
+          line1_ = @factory.line_string([])
+          line2_ = @factory.line_string([])
+          assert(line1_.eql?(line2_))
+          assert(line1_.equals?(line2_))
+        end
+        
+        
+        def test_not_equal
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line_string([point1_, point2_])
+          point4_ = @factory.point(0, 0)
+          point5_ = @factory.point(0, 1)
+          point6_ = @factory.point(1, 0)
+          line2_ = @factory.line_string([point4_, point5_, point6_])
+          assert(!line1_.eql?(line2_))
+          assert(!line1_.equals?(line2_))
+        end
+        
+        
+        def test_wkt_creation
+          line1_ = @factory.parse_wkt('LINESTRING(21 22, 11 12)')
+          assert_equal(@factory.point(21, 22), line1_.point_n(0))
+          assert_equal(@factory.point(11, 12), line1_.point_n(1))
+          assert_equal(2, line1_.num_points)
+          line2_ = @factory.parse_wkt('LINESTRING(-1 -1, 21 22, 11 12, -1 -1)')
+          assert_equal(@factory.point(-1, -1), line2_.point_n(0))
+          assert_equal(@factory.point(21, 22), line2_.point_n(1))
+          assert_equal(@factory.point(11, 12), line2_.point_n(2))
+          assert_equal(@factory.point(-1, -1), line2_.point_n(3))
+          assert_equal(4, line2_.num_points)
+        end
+        
+        
+        def test_clone
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line_string([point1_, point2_])
+          line2_ = line1_.clone
+          assert_equal(line1_, line2_)
+          assert_equal(2, line2_.num_points)
+          assert_equal(point1_, line2_.point_n(0))
+          assert_equal(point2_, line2_.point_n(1))
+        end
+        
+        
+        def test_type_check
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line_ = @factory.line_string([point1_, point2_])
+          assert(::RGeo::Features::Geometry.check_type(line_))
+          assert(!::RGeo::Features::Point.check_type(line_))
+          assert(!::RGeo::Features::GeometryCollection.check_type(line_))
+          assert(::RGeo::Features::Curve.check_type(line_))
+          assert(::RGeo::Features::LineString.check_type(line_))
+          assert(!::RGeo::Features::LinearRing.check_type(line_))
+        end
+        
+        
+        def test_as_text_wkt_round_trip
+          point1_ = @factory.point(0, 0)
+          point2_ = @factory.point(0, 1)
+          line1_ = @factory.line_string([point1_, point2_])
+          text_ = line1_.as_text
+          line2_ = @factory.parse_wkt(text_)
+          assert_equal(line2_, line1_)
+        end
+        
+        
+        def test_as_binary_wkb_round_trip
+          point1_ = @factory.point(-42, 0)
+          point2_ = @factory.point(0, 193)
+          line1_ = @factory.line_string([point1_, point2_])
+          binary_ = line1_.as_binary
+          line2_ = @factory.parse_wkb(binary_)
+          assert_equal(line2_, line1_)
+        end
+        
+        
+        def test_empty_as_text_wkt_round_trip
+          line1_ = @factory.line_string([])
+          text_ = line1_.as_text
+          line2_ = @factory.parse_wkt(text_)
+          assert(line2_.is_empty?)
+        end
+        
+        
+        def test_empty_as_binary_wkb_round_trip
+          line1_ = @factory.line_string([])
+          binary_ = line1_.as_binary
+          line2_ = @factory.parse_wkb(binary_)
+          assert(line2_.is_empty?)
+        end
+        
+        
+        def test_dimension
+          point1_ = @factory.point(-42, 0)
+          point2_ = @factory.point(0, 193)
+          line1_ = @factory.line_string([point1_, point2_])
+          assert_equal(1, line1_.dimension)
+        end
+        
+        
+        def test_is_empty
+          point1_ = @factory.point(-42, 0)
+          point2_ = @factory.point(0, 193)
+          line1_ = @factory.line_string([point1_, point2_])
+          assert(!line1_.is_empty?)
+          line2_ = @factory.line_string([])
+          assert(line2_.is_empty?)
+        end
+        
+        
+      end
+      
+    end
+  end
+end