rgeo-dschee 0.5.4

data/test/spherical_geographic/calculations_test.rb

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

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

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

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

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

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

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

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

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