rgeo 0.5.3 → 0.6.0

data/test/spherical_geographic/calculations_test.rb

@@ -1,167 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the internal calculations for simple spherical
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module SphericalGeographic # :nodoc:
-      class TestCalculations < ::Test::Unit::TestCase # :nodoc:
-        def assert_close_enough(v1_, v2_)
-          diff_ = (v1_ - v2_).abs
-          # denom_ = (v1_ + v2_).abs
-          # diff_ /= denom_ if denom_ > 0.01
-          assert(diff_ < 0.00000001, "#{v1_} is not close to #{v2_}")
-        end
-
-        def test_point_eql
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          assert_equal(point1_, point2_)
-        end
-
-        def test_point_from_latlng
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.from_latlon(45, -45)
-          assert_close_enough(0.5, point1_.x)
-          assert_close_enough(-0.5, point1_.y)
-          assert_close_enough(::Math.sqrt(2) * 0.5, point1_.z)
-        end
-
-        def test_point_dot_one
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 1)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 1)
-          assert_close_enough(1.0, point1_ * point2_)
-        end
-
-        def test_point_dot_minusone
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 1)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(-1, -1, -1)
-          assert_close_enough(-1.0, point1_ * point2_)
-        end
-
-        def test_point_dot_zero
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, -1, 0)
-          assert_close_enough(0.0, point1_ * point2_)
-        end
-
-        def test_point_cross
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, -1, 0)
-          assert_close_enough(-1.0, (point1_ % point2_).z)
-        end
-
-        def test_point_cross_coincident
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          assert_nil(point1_ % point2_)
-        end
-
-        def test_point_cross_opposite
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(-1, 0, 0)
-          assert_nil(point1_ % point2_)
-        end
-
-        def test_distance_coincident
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          assert_equal(0.0, point1_.dist_to_point(point2_))
-        end
-
-        def test_distance_opposite
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(-1, 0, 0)
-          assert_close_enough(::Math::PI, point1_.dist_to_point(point2_))
-        end
-
-        def test_distance_right_angle
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -1, 0)
-          assert_close_enough(::Math::PI / 2, point1_.dist_to_point(point2_))
-        end
-
-        def test_arc_axis
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, -1, 0)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          assert_close_enough(-1.0, arc1_.axis.z)
-        end
-
-        def test_arc_axis2
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000001, 0)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          assert_close_enough(1.0, arc1_.axis.z)
-        end
-
-        def test_arc_intersects_point_off
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000002, 0)
-          point3_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000001, 0.1)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          assert_equal(false, arc1_.contains_point?(point3_))
-        end
-
-        def test_arc_intersects_point_between
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000002, 0)
-          point3_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000001, 0)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          assert_equal(true, arc1_.contains_point?(point3_))
-        end
-
-        def test_arc_intersects_point_endpoint
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000002, 0)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          assert_equal(true, arc1_.contains_point?(point1_))
-        end
-
-        def test_arc_intersects_arc_true
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0.1, 1)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -0.1, 1)
-          point3_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(-0.1, 0, 1)
-          point4_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0.1, 0, 1)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          arc2_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point3_, point4_)
-          assert_equal(true, arc1_.intersects_arc?(arc2_))
-        end
-
-        def test_arc_intersects_arc_parallel
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0.1, 1)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -0.1, 1)
-          point3_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0.1, 0.1, 1)
-          point4_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0.1, -0.1, 1)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          arc2_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point3_, point4_)
-          assert_equal(false, arc1_.intersects_arc?(arc2_))
-        end
-
-        def test_arc_intersects_arc_separated_tee
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0.1, 1)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -0.1, 1)
-          point3_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0.1, 0, 1)
-          point4_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0.2, 0, 1)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          arc2_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point3_, point4_)
-          assert_equal(false, arc1_.intersects_arc?(arc2_))
-        end
-
-        def test_arc_intersects_arc_connected_tee
-          point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0.1, 1)
-          point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -0.1, 1)
-          point3_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0, 1)
-          point4_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0.1, 0, 1)
-          arc1_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point1_, point2_)
-          arc2_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point3_, point4_)
-          assert_equal(true, arc1_.intersects_arc?(arc2_))
-        end
-      end
-    end
-  end
-end

data/test/spherical_geographic/factory_test.rb

@@ -1,27 +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 SphericalGeographic # :nodoc:
-      class TestFactory < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geographic.spherical_factory
-          @srid = 4055
-        end
-
-        include ::RGeo::Tests::Common::FactoryTests
-
-        undef_method :test_srid_preserved_through_geom_operations
-      end
-    end
-  end
-end

data/test/spherical_geographic/geometry_collection_test.rb

@@ -1,31 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the simple spherical 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 SphericalGeographic # :nodoc:
-      class TestGeometryCollection < ::Test::Unit::TestCase # :nodoc:
-        def create_factory
-          @factory = ::RGeo::Geographic.spherical_factory
-        end
-
-        include ::RGeo::Tests::Common::GeometryCollectionTests
-
-        undef_method :test_fully_equal
-        undef_method :test_geometrically_equal
-        undef_method :test_empty_equal
-        undef_method :test_not_equal
-        undef_method :test_empty_collection_envelope
-        undef_method :test_empty_collection_boundary
-      end
-    end
-  end
-end

data/test/spherical_geographic/line_string_test.rb

@@ -1,31 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the simple spherical 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 SphericalGeographic # :nodoc:
-      class TestLineString < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geographic.spherical_factory
-        end
-
-        include ::RGeo::Tests::Common::LineStringTests
-
-        undef_method :test_fully_equal
-        undef_method :test_geometrically_equal_but_different_type
-        undef_method :test_geometrically_equal_but_different_type2
-        undef_method :test_geometrically_equal_but_different_overlap
-        undef_method :test_empty_equal
-        undef_method :test_not_equal
-      end
-    end
-  end
-end

data/test/spherical_geographic/multi_line_string_test.rb

@@ -1,29 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the simple spherical 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 SphericalGeographic # :nodoc:
-      class TestMultiLineString < ::Test::Unit::TestCase # :nodoc:
-        def create_factory
-          @factory = ::RGeo::Geographic.spherical_factory
-        end
-
-        include ::RGeo::Tests::Common::MultiLineStringTests
-
-        undef_method :test_fully_equal
-        undef_method :test_geometrically_equal
-        undef_method :test_not_equal
-        undef_method :test_length
-      end
-    end
-  end
-end

data/test/spherical_geographic/multi_point_test.rb

@@ -1,31 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the simple spherical 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 SphericalGeographic # :nodoc:
-      class TestMultiPoint < ::Test::Unit::TestCase # :nodoc:
-        def create_factory(opts_ = {})
-          @factory = ::RGeo::Geographic.spherical_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/spherical_geographic/multi_polygon_test.rb

@@ -1,31 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the simple spherical 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 SphericalGeographic # :nodoc:
-      class TestMultiPolygon < ::Test::Unit::TestCase # :nodoc:
-        def create_factories
-          @factory = ::RGeo::Geographic.spherical_factory
-          @lenient_factory = ::RGeo::Geographic.spherical_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/spherical_geographic/point_test.rb

@@ -1,78 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the simple spherical point implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/point_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module SphericalGeographic # :nodoc:
-      class TestPoint < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geographic.spherical_factory(buffer_resolution: 8)
-          @zfactory = ::RGeo::Geographic.spherical_factory(has_z_coordinate: true)
-          @mfactory = ::RGeo::Geographic.spherical_factory(has_m_coordinate: true)
-          @zmfactory = ::RGeo::Geographic.spherical_factory(has_z_coordinate: true, has_m_coordinate: true)
-        end
-
-        include ::RGeo::Tests::Common::PointTests
-
-        def test_latlon
-          point_ = @factory.point(21, -22)
-          assert_equal(21, point_.longitude)
-          assert_equal(-22, point_.latitude)
-        end
-
-        def test_antimeridian_positive
-          point_ = @factory.point(180, 85)
-          assert_equal(180, point_.longitude)
-          assert_equal(85, point_.latitude)
-        end
-
-        def test_antimeridian_netagive
-          point_ = @factory.point(-180, -85)
-          assert_equal(-180, point_.longitude)
-          assert_equal(-85, point_.latitude)
-        end
-
-        def test_srid
-          point_ = @factory.point(11, 12)
-          assert_equal(4055, point_.srid)
-        end
-
-        def test_distance
-          point1_ = @factory.point(0, 10)
-          point2_ = @factory.point(0, 10)
-          point3_ = @factory.point(0, 40)
-          assert_in_delta(0, point1_.distance(point2_), 0.0001)
-          assert_in_delta(::Math::PI / 6.0 * ::RGeo::Geographic::SphericalMath::RADIUS, point1_.distance(point3_), 0.0001)
-        end
-
-        def test_floating_point_perturbation
-          # A naive way of wrapping longitudes to [-180,180] might cause
-          # perturbation due to floating point errors. Make sure this
-          # doesn't happen.
-          point_ = @factory.point(-98.747534, 38.057583)
-          assert_equal(-98.747534, point_.x)
-        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/spherical_geographic/polygon_test.rb

@@ -1,28 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the simple spherical polygon implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/polygon_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module SphericalGeographic # :nodoc:
-      class TestPolygon < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geographic.spherical_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