rgeo 0.5.3 → 0.6.0

data/test/simple_cartesian/multi_line_string_test.rb

@@ -1,28 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,31 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,31 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,50 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,28 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,25 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,24 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,24 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,26 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,29 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,25 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,55 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,24 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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

@@ -1,173 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# 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