rgeo-dschee 0.5.4

data/test/simple_cartesian/multi_line_string_test.rb

@@ -0,0 +1,28 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple cartesian multi line string implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_line_string_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleCartesian # :nodoc:
+      class TestMultiLineString < ::Test::Unit::TestCase # :nodoc:
+        def create_factory
+          @factory = ::RGeo::Cartesian.simple_factory
+        end
+
+        include ::RGeo::Tests::Common::MultiLineStringTests
+
+        undef_method :test_fully_equal
+        undef_method :test_geometrically_equal
+        undef_method :test_not_equal
+      end
+    end
+  end
+end

data/test/simple_cartesian/multi_point_test.rb

@@ -0,0 +1,31 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple cartesian multi point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_point_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleCartesian # :nodoc:
+      class TestMultiPoint < ::Test::Unit::TestCase # :nodoc:
+        def create_factory(opts_ = {})
+          @factory = ::RGeo::Cartesian.simple_factory(opts_)
+        end
+
+        include ::RGeo::Tests::Common::MultiPointTests
+
+        undef_method :test_fully_equal
+        undef_method :test_geometrically_equal
+        undef_method :test_not_equal
+        undef_method :test_union
+        undef_method :test_difference
+        undef_method :test_intersection
+      end
+    end
+  end
+end

data/test/simple_cartesian/multi_polygon_test.rb

@@ -0,0 +1,31 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple cartesian multi polygon implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_polygon_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleCartesian # :nodoc:
+      class TestMultiPolygon < ::Test::Unit::TestCase # :nodoc:
+        def create_factories
+          @factory = ::RGeo::Cartesian.simple_factory
+          @lenient_factory = ::RGeo::Cartesian.simple_factory(lenient_multi_polygon_assertions: true)
+        end
+
+        include ::RGeo::Tests::Common::MultiPolygonTests
+
+        undef_method :test_creation_wrong_type
+        undef_method :test_creation_overlapping
+        undef_method :test_creation_connected
+        undef_method :test_equal
+        undef_method :test_not_equal
+      end
+    end
+  end
+end

data/test/simple_cartesian/point_test.rb

@@ -0,0 +1,50 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple cartesian point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/point_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleCartesian # :nodoc:
+      class TestPoint < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Cartesian.simple_factory(srid: 1, buffer_resolution: 8)
+          @zfactory = ::RGeo::Cartesian.simple_factory(srid: 1, has_z_coordinate: true)
+          @mfactory = ::RGeo::Cartesian.simple_factory(srid: 1, has_m_coordinate: true)
+          @zmfactory = ::RGeo::Cartesian.simple_factory(srid: 1, has_z_coordinate: true, has_m_coordinate: true)
+        end
+
+        include ::RGeo::Tests::Common::PointTests
+
+        def test_srid
+          point_ = @factory.point(11, 12)
+          assert_equal(1, point_.srid)
+        end
+
+        def test_distance
+          point1_ = @factory.point(2, 2)
+          point2_ = @factory.point(7, 14)
+          assert_in_delta(13, point1_.distance(point2_), 0.0001)
+        end
+
+        undef_method :test_disjoint
+        undef_method :test_intersects
+        undef_method :test_touches
+        undef_method :test_crosses
+        undef_method :test_within
+        undef_method :test_contains
+        undef_method :test_overlaps
+        undef_method :test_intersection
+        undef_method :test_union
+        undef_method :test_difference
+        undef_method :test_sym_difference
+      end
+    end
+  end
+end

data/test/simple_cartesian/polygon_test.rb

@@ -0,0 +1,28 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple cartesian polygon implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/polygon_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleCartesian # :nodoc:
+      class TestPolygon < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Cartesian.simple_factory
+        end
+
+        include ::RGeo::Tests::Common::PolygonTests
+
+        undef_method :test_fully_equal
+        undef_method :test_geometrically_equal_but_ordered_different
+        undef_method :test_geometrically_equal_but_different_directions
+      end
+    end
+  end
+end

data/test/simple_mercator/factory_test.rb

@@ -0,0 +1,25 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the GEOS factory
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/factory_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestFactory < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geographic.simple_mercator_factory
+          @srid = 4326
+        end
+
+        include ::RGeo::Tests::Common::FactoryTests
+      end
+    end
+  end
+end

data/test/simple_mercator/geometry_collection_test.rb

@@ -0,0 +1,24 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple mercator geometry collection implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/geometry_collection_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestGeometryCollection < ::Test::Unit::TestCase # :nodoc:
+        def create_factory
+          ::RGeo::Geographic.simple_mercator_factory
+        end
+
+        include ::RGeo::Tests::Common::GeometryCollectionTests
+      end
+    end
+  end
+end

data/test/simple_mercator/line_string_test.rb

@@ -0,0 +1,24 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple mercator line string implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/line_string_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestLineString < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geographic.simple_mercator_factory
+        end
+
+        include ::RGeo::Tests::Common::LineStringTests
+      end
+    end
+  end
+end

data/test/simple_mercator/multi_line_string_test.rb

@@ -0,0 +1,26 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple mercator multi line string implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_line_string_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestMultiLineString < ::Test::Unit::TestCase # :nodoc:
+        def create_factory
+          ::RGeo::Geographic.simple_mercator_factory
+        end
+
+        include ::RGeo::Tests::Common::MultiLineStringTests
+
+        undef_method :test_length
+      end
+    end
+  end
+end

data/test/simple_mercator/multi_point_test.rb

@@ -0,0 +1,29 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple mercator multi point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_point_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestMultiPoint < ::Test::Unit::TestCase # :nodoc:
+        def create_factory(opts_ = {})
+          ::RGeo::Geographic.simple_mercator_factory(opts_)
+        end
+
+        include ::RGeo::Tests::Common::MultiPointTests
+
+        # These tests suffer from floating point issues
+        undef_method :test_union
+        undef_method :test_difference
+        undef_method :test_intersection
+      end
+    end
+  end
+end

data/test/simple_mercator/multi_polygon_test.rb

@@ -0,0 +1,25 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple mercator multi polygon implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/multi_polygon_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestMultiPolygon < ::Test::Unit::TestCase # :nodoc:
+        def create_factories
+          @factory = ::RGeo::Geographic.simple_mercator_factory
+          @lenient_factory = ::RGeo::Geographic.simple_mercator_factory(lenient_multi_polygon_assertions: true)
+        end
+
+        include ::RGeo::Tests::Common::MultiPolygonTests
+      end
+    end
+  end
+end

data/test/simple_mercator/point_test.rb

@@ -0,0 +1,55 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple mercator point implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/point_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestPoint < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geographic.simple_mercator_factory(buffer_resolution: 8)
+          @zfactory = ::RGeo::Geographic.simple_mercator_factory(has_z_coordinate: true)
+          @mfactory = ::RGeo::Geographic.simple_mercator_factory(has_m_coordinate: true)
+          @zmfactory = ::RGeo::Geographic.simple_mercator_factory(has_z_coordinate: true, has_m_coordinate: true)
+        end
+
+        include ::RGeo::Tests::Common::PointTests
+
+        # TEMP until ffi-geos 0.0.5 is released
+        undef_method :test_buffer
+        # END_TEMP
+
+        def test_has_projection
+          point_ = @factory.point(21, -22)
+          assert(point_.respond_to?(:projection))
+        end
+
+        def test_latlon
+          point_ = @factory.point(21, -22)
+          assert_equal(21, point_.longitude)
+          assert_equal(-22, point_.latitude)
+        end
+
+        def test_srid
+          point_ = @factory.point(11, 12)
+          assert_equal(4326, point_.srid)
+        end
+
+        def test_distance
+          point1_ = @factory.point(11, 12)
+          point2_ = @factory.point(11, 12)
+          point3_ = @factory.point(13, 12)
+          assert_in_delta(0, point1_.distance(point2_), 0.0001)
+          assert_in_delta(222_638, point1_.distance(point3_), 1)
+        end
+      end
+    end
+  end
+end

data/test/simple_mercator/polygon_test.rb

@@ -0,0 +1,24 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple mercator polygon implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+require ::File.expand_path("../common/polygon_tests.rb", ::File.dirname(__FILE__))
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestPolygon < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geographic.simple_mercator_factory
+        end
+
+        include ::RGeo::Tests::Common::PolygonTests
+      end
+    end
+  end
+end

data/test/simple_mercator/window_test.rb

@@ -0,0 +1,173 @@
+# -----------------------------------------------------------------------------
+#
+# Tests for the simple mercator window implementation
+#
+# -----------------------------------------------------------------------------
+
+require "test/unit"
+require "rgeo"
+
+module RGeo
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestWindow < ::Test::Unit::TestCase # :nodoc:
+        def setup
+          @factory = ::RGeo::Geographic.simple_mercator_factory
+        end
+
+        def assert_close_enough(p1_, p2_)
+          assert((p1_.x - p2_.x).abs < 0.00001 && (p1_.y - p2_.y).abs < 0.00001)
+        end
+
+        def assert_contains_approx(p_, mp_)
+          assert(mp_.any? { |q_| (p_.x - q_.x).abs < 0.00001 && (p_.y - q_.y).abs < 0.00001 })
+        end
+
+        def test_limits
+          limits_ = @factory.projection_limits_window
+          assert_in_delta(-20_037_508, limits_.x_min, 1)
+          assert_in_delta(-20_037_508, limits_.y_min, 1)
+          assert_in_delta(20_037_508, limits_.x_max, 1)
+          assert_in_delta(20_037_508, limits_.y_max, 1)
+        end
+
+        def test_limits_unprojected
+          limits_ = @factory.projection_limits_window
+          assert_close_enough(@factory.point(-180, -85.051129), limits_.sw_point)
+          assert_close_enough(@factory.point(180, -85.051129), limits_.se_point)
+          assert_close_enough(@factory.point(-180, 85.051129), limits_.nw_point)
+          assert_close_enough(@factory.point(180, 85.051129), limits_.ne_point)
+          assert_close_enough(@factory.point(0, 0), limits_.center_point)
+        end
+
+        def test_center_point
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-160, -30), @factory.point(170, 30))
+          assert_close_enough(@factory.point(5, 0), window1_.center_point)
+          window2_ = Geographic::ProjectedWindow.for_corners(@factory.point(160, -30), @factory.point(-170, 30))
+          assert_close_enough(@factory.point(175, 0), window2_.center_point)
+        end
+
+        def test_random_point
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-170, 30), @factory.point(-160, 40))
+          20.times { assert(window1_.contains_point?(window1_.random_point)) }
+          window2_ = Geographic::ProjectedWindow.for_corners(@factory.point(170, 30), @factory.point(-170, 40))
+          20.times { assert(window2_.contains_point?(window2_.random_point)) }
+        end
+
+        def test_crosses_seam
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-170, 30), @factory.point(170, 40))
+          assert(!window1_.crosses_seam?)
+          window2_ = Geographic::ProjectedWindow.for_corners(@factory.point(170, 30), @factory.point(-170, 40))
+          assert(window2_.crosses_seam?)
+        end
+
+        def test_degenerate
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-20, 30), @factory.point(-10, 40))
+          assert(!window1_.degenerate?)
+          window2_ = Geographic::ProjectedWindow.for_corners(@factory.point(-20, 30), @factory.point(-20, 40))
+          assert(window2_.degenerate?)
+          window3_ = Geographic::ProjectedWindow.for_corners(@factory.point(-20, 30), @factory.point(-10, 30))
+          assert(window3_.degenerate?)
+        end
+
+        def test_contains_point
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-170, 30), @factory.point(-160, 40))
+          window2_ = Geographic::ProjectedWindow.for_corners(@factory.point(170, 30), @factory.point(-170, 40))
+          point1_ = @factory.point(-169, 32)
+          point2_ = @factory.point(-171, 32)
+          point3_ = @factory.point(-169, 29)
+          point4_ = @factory.point(171, 32)
+          point5_ = @factory.point(169, 32)
+          assert(window1_.contains_point?(point1_))
+          assert(!window1_.contains_point?(point2_))
+          assert(!window1_.contains_point?(point3_))
+          assert(!window2_.contains_point?(point1_))
+          assert(window2_.contains_point?(point2_))
+          assert(window2_.contains_point?(point4_))
+          assert(!window2_.contains_point?(point5_))
+        end
+
+        def test_noseam_contains_window
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(10, 10), @factory.point(30, 30))
+          assert(window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(15, 15), @factory.point(25, 25))))
+
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(5, 15), @factory.point(25, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(15, 15), @factory.point(35, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(0, 15), @factory.point(5, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(35, 15), @factory.point(40, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(5, 15), @factory.point(35, 25))))
+
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(15, 5), @factory.point(25, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(15, 15), @factory.point(25, 35))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(15, 0), @factory.point(25, 5))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(15, 35), @factory.point(25, 40))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(15, 5), @factory.point(25, 35))))
+
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(170, 35), @factory.point(-170, 40))))
+        end
+
+        def test_seam_contains_window
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(160, 10), @factory.point(-160, 30))
+          assert(window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(175, 15), @factory.point(-175, 25))))
+          assert(window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(170, 15), @factory.point(175, 25))))
+          assert(window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(-175, 15), @factory.point(-170, 25))))
+
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(150, 15), @factory.point(170, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(150, 15), @factory.point(-170, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(-170, 15), @factory.point(-150, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(170, 15), @factory.point(-150, 25))))
+
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(-150, 15), @factory.point(150, 25))))
+          assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(150, 15), @factory.point(-150, 25))))
+        end
+
+        def test_scaled_by
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(20, -20), @factory.point(50, 40))
+          window1s_ = window1_.scaled_by(2, 1.5)
+          assert(window1s_.contains_point?(@factory.point(10, -25)))
+          assert(window1s_.contains_point?(@factory.point(60, 45)))
+          assert(!window1s_.contains_point?(@factory.point(0, -25)))
+          assert(!window1s_.contains_point?(@factory.point(10, -35)))
+        end
+
+        def test_scaled_by_across_seam
+          window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(170, -20), @factory.point(-160, 40))
+          window1s_ = window1_.scaled_by(2, 1.5)
+          assert(window1s_.contains_point?(@factory.point(160, -25)))
+          assert(window1s_.contains_point?(@factory.point(-150, 45)))
+          assert(!window1s_.contains_point?(@factory.point(150, -25)))
+          assert(!window1s_.contains_point?(@factory.point(-140, 45)))
+        end
+
+        def test_surrounding_point
+          window1_ = Geographic::ProjectedWindow.surrounding_point(@factory.point(20, -20), 1)
+          assert(window1_.contains_point?(@factory.point(20, -20)))
+          assert(!window1_.contains_point?(@factory.point(20, -21)))
+          assert(!window1_.contains_point?(@factory.point(19, -20)))
+        end
+
+        def test_bounding_1_point
+          window1_ = Geographic::ProjectedWindow.bounding_points([@factory.point(20, -20)]).with_margin(1)
+          assert(window1_.contains_point?(@factory.point(20, -20)))
+          assert(!window1_.contains_point?(@factory.point(20, -21)))
+          assert(!window1_.contains_point?(@factory.point(19, -20)))
+        end
+
+        def test_bounding_2_points
+          window1_ = Geographic::ProjectedWindow.bounding_points([@factory.point(10, 10), @factory.point(30, 30)])
+          assert(window1_.contains_point?(@factory.point(20, 20)))
+          assert(!window1_.contains_point?(@factory.point(5, 20)))
+          assert(!window1_.contains_point?(@factory.point(20, 35)))
+        end
+
+        def test_bounding_2_points_across_seam
+          window1_ = Geographic::ProjectedWindow.bounding_points([@factory.point(-170, 10), @factory.point(170, 30)])
+          assert(window1_.contains_point?(@factory.point(-174, 20)))
+          assert(!window1_.contains_point?(@factory.point(-160, 20)))
+          assert(!window1_.contains_point?(@factory.point(160, 20)))
+          assert(!window1_.contains_point?(@factory.point(-174, 35)))
+        end
+      end
+    end
+  end
+end