ffi-geos 2.4.0 → 2.5.0

data/test/geometry/num_goemetries_tests.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class GeometryTests < Minitest::Test
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  def test_num_geometries
+    simple_tester(:num_geometries, 1, 'POINT(0 0)')
+    simple_tester(:num_geometries, 2, 'MULTIPOINT (0 1, 2 3)')
+    simple_tester(:num_geometries, 1, 'LINESTRING (0 0, 2 3)')
+    simple_tester(:num_geometries, 2, 'MULTILINESTRING ((0 1, 2 3), (10 10, 3 4))')
+    simple_tester(:num_geometries, 1, 'POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))')
+    simple_tester(:num_geometries, 2, 'MULTIPOLYGON(
+      ((0 0, 1 0, 1 1, 0 1, 0 0)),
+      ((10 10, 10 14, 14 14, 14 10, 10 10),
+      (11 11, 11 12, 12 12, 12 11, 11 11)))')
+    simple_tester(:num_geometries, 6, 'GEOMETRYCOLLECTION (
+      MULTIPOLYGON (
+        ((0 0, 1 0, 1 1, 0 1, 0 0)),
+        ((10 10, 10 14, 14 14, 14 10, 10 10),
+        (11 11, 11 12, 12 12, 12 11, 11 11))
+      ),
+      POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0)),
+      MULTILINESTRING ((0 0, 2 3), (10 10, 3 4)),
+      LINESTRING (0 0, 2 3),
+      MULTIPOINT (0 0, 2 3),
+      POINT (9 0))')
+  end
+end

data/test/geometry/num_interior_rings_tests.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class GeometryNumInteriorRingsTests < Minitest::Test
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  def test_num_interior_rings
+    simple_tester(:num_interior_rings, 0, 'POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))')
+    simple_tester(:num_interior_rings, 1, 'POLYGON (
+      (10 10, 10 14, 14 14, 14 10, 10 10),
+      (11 11, 11 12, 12 12, 12 11, 11 11)
+    )')
+    simple_tester(:num_interior_rings, 2, 'POLYGON (
+      (10 10, 10 14, 14 14, 14 10, 10 10),
+      (11 11, 11 12, 12 12, 12 11, 11 11),
+      (13 11, 13 12, 13.5 12, 13.5 11, 13 11))')
+
+    assert_raises(NoMethodError) do
+      read('POINT (0 0)').num_interior_rings
+    end
+  end
+end

data/test/geometry/orient_polygons_tests.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe '#orient_polygons' do
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  it 'does not overwrite the original geometry' do
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:orient_polygons)
+
+    geom = read('POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))')
+
+    result = geom.orient_polygons(true)
+
+    assert_equal('POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))', write(geom))
+    assert_equal('POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))', write(result))
+    refute_same(geom, result)
+  end
+
+  it 'does overwrite the original geometry with bang method' do
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:orient_polygons!)
+
+    geom = read('POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))')
+
+    result = geom.orient_polygons!(true)
+
+    assert_equal('POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))', write(geom))
+    assert_equal('POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))', write(result))
+    assert_same(geom, result)
+  end
+
+  it 'handles empty polygons' do
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:orient_polygons)
+
+    simple_tester(
+      :orient_polygons,
+      'POLYGON EMPTY',
+      'POLYGON EMPTY'
+    )
+  end
+
+  it 'hole orientation is opposite to shell' do
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:orient_polygons)
+
+    simple_tester(
+      :orient_polygons,
+      'POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 1 2, 2 2, 2 1, 1 1))',
+      'POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))'
+    )
+
+    simple_tester(
+      :orient_polygons,
+      'POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))',
+      'POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1))',
+      true
+    )
+  end
+
+  it 'ensures all polygons in collection are processed' do
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:orient_polygons)
+
+    simple_tester(
+      :orient_polygons,
+      'MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 1 2, 2 2, 2 1, 1 1)), ((100 100, 200 100, 200 200, 100 100)))',
+      'MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), ((100 100, 200 100, 200 200, 100 100)))'
+    )
+
+    simple_tester(
+      :orient_polygons,
+      'MULTIPOLYGON (((0 0, 0 10, 10 10, 10 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), ((100 100, 200 200, 200 100, 100 100)))',
+      'MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), ((100 100, 200 100, 200 200, 100 100)))',
+      true
+    )
+  end
+
+  it 'polygons in collection are oriented, closed linestring unchanged' do
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:orient_polygons)
+
+    simple_tester(
+      :orient_polygons,
+      'GEOMETRYCOLLECTION (POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), LINESTRING (100 100, 200 100, 200 200, 100 100))',
+      'GEOMETRYCOLLECTION (POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0), (1 1, 2 1, 2 2, 1 2, 1 1)), LINESTRING (100 100, 200 100, 200 200, 100 100))',
+      true
+    )
+  end
+
+  it 'nested collection handled correctly' do
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:orient_polygons)
+
+    simple_tester(
+      :orient_polygons,
+      'GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0)))))',
+      'GEOMETRYCOLLECTION (GEOMETRYCOLLECTION (MULTIPOLYGON (((0 0, 10 0, 10 10, 0 10, 0 0)))))'
+    )
+  end
+end

data/test/geometry/point_on_surface_tests.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class GeometryPointOnSurfaceTests < Minitest::Test
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  def test_point_on_surface_and_representative_point
+    %w{
+      point_on_surface
+      representative_point
+    }.each do |method|
+      simple_tester(
+        method,
+        'POINT (0 0)',
+        'POINT (0 0)'
+      )
+
+      simple_tester(
+        method,
+        'POINT (5 0)',
+        'LINESTRING(0 0, 5 0, 10 0)'
+      )
+
+      simple_tester(
+        method,
+        'POINT (5 5)',
+        'POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))'
+      )
+    end
+  end
+end

data/test/geometry/polygon_hull_simplify_tests.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+describe '#polygon_hull_simplify' do
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  def tester(expected, geom, *args, **options)
+    skip unless ENV['FORCE_TESTS'] || !geom.respond_to?(:polygon_hull_simplify)
+
+    simple_tester(:polygon_hull_simplify, expected, geom, *args, **options)
+  end
+
+  it 'handles a POLYGON' do
+    tester(
+      'POLYGON ((10 90, 50 90, 90 90, 90 10, 10 10, 10 90))',
+      'POLYGON ((10 90, 40 60, 20 40, 40 20, 70 50, 40 30, 30 40, 60 70, 50 90, 90 90, 90 10, 10 10, 10 90))',
+      0.5,
+      outer: true
+    )
+
+    tester(
+      'POLYGON ((10 90, 40 60, 30 40, 60 70, 50 90, 90 90, 90 10, 10 10, 10 90))',
+      'POLYGON ((10 90, 40 60, 20 40, 40 20, 70 50, 40 30, 30 40, 60 70, 50 90, 90 90, 90 10, 10 10, 10 90))',
+      0.7,
+      outer: true
+    )
+
+    tester(
+      'POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))',
+      'POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))',
+      0.7,
+      outer: true
+    )
+  end
+
+  it 'handles an empty POLYGON' do
+    tester('POLYGON EMPTY', 'POLYGON EMPTY', 0.5, outer: true)
+  end
+
+  it 'handles a mode' do
+    tester(
+      'POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))',
+      'POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))',
+      0.7,
+      mode: :area_ratio,
+      outer: true
+    )
+  end
+end

data/test/geometry/polygonize_tests.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class GeometryPolygonizeTests < Minitest::Test
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  def test_polygonize
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:polygonize)
+
+    geom_a = read(
+      'GEOMETRYCOLLECTION(
+        LINESTRING(0 0, 10 10),
+        LINESTRING(185 221, 100 100),
+        LINESTRING(185 221, 88 275, 180 316),
+        LINESTRING(185 221, 292 281, 180 316),
+        LINESTRING(189 98, 83 187, 185 221),
+        LINESTRING(189 98, 325 168, 185 221)
+      )'
+    )
+
+    polygonized = geom_a.polygonize
+
+    assert_equal(2, polygonized.length)
+    assert_equal(
+      'POLYGON ((185 221, 88 275, 180 316, 292 281, 185 221))',
+      write(polygonized[0].snap_to_grid(0.1))
+    )
+    assert_equal(
+      'POLYGON ((189 98, 83 187, 185 221, 325 168, 189 98))',
+      write(polygonized[1].snap_to_grid(0.1))
+    )
+  end
+
+  def test_polygonize_with_geometry_arguments
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:polygonize)
+
+    geom_a = read('LINESTRING (100 100, 100 300, 300 300, 300 100, 100 100)')
+    geom_b = read('LINESTRING (150 150, 150 250, 250 250, 250 150, 150 150)')
+
+    polygonized = geom_a.polygonize(geom_b)
+
+    assert_equal(2, polygonized.length)
+    assert_equal(
+      'POLYGON ((100 100, 100 300, 300 300, 300 100, 100 100), (150 150, 250 150, 250 250, 150 250, 150 150))',
+      write(polygonized[0].snap_to_grid(0.1))
+    )
+    assert_equal(
+      'POLYGON ((150 150, 150 250, 250 250, 250 150, 150 150))',
+      write(polygonized[1].snap_to_grid(0.1))
+    )
+  end
+
+  def test_polygonize_valid
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:polygonize_valid)
+
+    geom_a = read(
+      'GEOMETRYCOLLECTION(
+        LINESTRING (100 100, 100 300, 300 300, 300 100, 100 100),
+        LINESTRING (150 150, 150 250, 250 250, 250 150, 150 150)
+      )'
+    )
+
+    polygonized = geom_a.polygonize_valid
+
+    assert_equal(
+      'POLYGON ((100 100, 100 300, 300 300, 300 100, 100 100), (150 150, 250 150, 250 250, 150 250, 150 150))',
+      write(polygonized.snap_to_grid(0.1))
+    )
+  end
+
+  def test_polygonize_cut_edges
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:polygonize_cut_edges)
+
+    geom_a = read(
+      'GEOMETRYCOLLECTION(
+        LINESTRING(0 0, 10 10),
+        LINESTRING(185 221, 100 100),
+        LINESTRING(185 221, 88 275, 180 316),
+        LINESTRING(185 221, 292 281, 180 316),
+        LINESTRING(189 98, 83 187, 185 221),
+        LINESTRING(189 98, 325 168, 185 221)
+      )'
+    )
+
+    cut_edges = geom_a.polygonize_cut_edges
+
+    assert_equal(0, cut_edges.length)
+  end
+
+  def test_polygonize_full
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:polygonize_full)
+
+    writer.rounding_precision = if Geos::GEOS_NICE_VERSION >= '031000'
+      0
+    else
+      3
+    end
+
+    geom_a = read(
+      'GEOMETRYCOLLECTION(
+        LINESTRING(0 0, 10 10),
+        LINESTRING(185 221, 100 100),
+        LINESTRING(185 221, 88 275, 180 316),
+        LINESTRING(185 221, 292 281, 180 316),
+        LINESTRING(189 98, 83 187, 185 221),
+        LINESTRING(189 98, 325 168, 185 221)
+      )'
+    )
+
+    polygonized = geom_a.polygonize_full
+
+    assert_kind_of(Array, polygonized[:rings])
+    assert_kind_of(Array, polygonized[:cuts])
+    assert_kind_of(Array, polygonized[:dangles])
+    assert_kind_of(Array, polygonized[:invalid_rings])
+
+    assert_equal(2, polygonized[:rings].length)
+    assert_equal(0, polygonized[:cuts].length)
+    assert_equal(2, polygonized[:dangles].length)
+    assert_equal(0, polygonized[:invalid_rings].length)
+
+    assert_equal(
+      'POLYGON ((185 221, 88 275, 180 316, 292 281, 185 221))',
+      write(polygonized[:rings][0])
+    )
+
+    assert_equal(
+      'POLYGON ((189 98, 83 187, 185 221, 325 168, 189 98))',
+      write(polygonized[:rings][1])
+    )
+
+    assert_equal(
+      'LINESTRING (185 221, 100 100)',
+      write(polygonized[:dangles][0])
+    )
+
+    assert_equal(
+      'LINESTRING (0 0, 10 10)',
+      write(polygonized[:dangles][1])
+    )
+
+    geom_b = geom_a.union(read('POINT(0 0)'))
+    polygonized = geom_b.polygonize_full
+
+    assert_equal(2, polygonized[:dangles].length)
+    assert_equal(0, polygonized[:invalid_rings].length)
+
+    assert_equal(
+      'LINESTRING (132 146, 100 100)',
+      write(polygonized[:dangles][0])
+    )
+
+    assert_equal(
+      'LINESTRING (0 0, 10 10)',
+      write(polygonized[:dangles][1])
+    )
+  end
+
+  def test_polygonize_with_bad_arguments
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:polygonize_full)
+
+    assert_raises(ArgumentError) do
+      geom = read('POINT(0 0)')
+      geom.polygonize(geom, 'gibberish')
+    end
+  end
+end

data/test/geometry/precision_tests.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class GeometryPrecisionTests < Minitest::Test
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  def test_precision
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:precision)
+
+    geom = read('POLYGON EMPTY')
+    scale = geom.precision
+
+    assert_in_delta(0.0, scale)
+
+    geom_with_precision = geom.with_precision(2.0)
+
+    assert_equal('POLYGON EMPTY', write(geom_with_precision))
+    scale = geom_with_precision.precision
+
+    assert_in_delta(2.0, scale)
+  end
+
+  def test_with_precision
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:with_precision)
+
+    geom = read('LINESTRING(1 0, 2 0)')
+
+    geom_with_precision = geom.with_precision(5.0)
+
+    assert_equal('LINESTRING EMPTY', write(geom_with_precision))
+
+    geom_with_precision = geom.with_precision(5.0, keep_collapsed: true)
+
+    assert_equal('LINESTRING (0 0, 0 0)', write(geom_with_precision))
+  end
+end

data/test/geometry/project_tests.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class GeometryProjectTests < Minitest::Test
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  def test_project_and_project_normalized
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:project)
+
+    geom_a = read('POINT(1 2)')
+    geom_b = read('POINT(3 4)')
+
+    # The method only accept lineal geometries
+    assert_raises(Geos::GEOSException) do
+      geom_a.project(geom_b)
+    end
+
+    geom_a = read('LINESTRING(0 0, 10 0)')
+    geom_b = read('POINT(0 0)')
+
+    assert_equal(0, geom_a.project(geom_b))
+    assert_equal(0, geom_a.project(geom_b, true))
+    assert_equal(0, geom_a.project_normalized(geom_b))
+
+    geom_b = read('POINT(10 0)')
+
+    assert_equal(10, geom_a.project(geom_b))
+    assert_equal(1, geom_a.project(geom_b, true))
+    assert_equal(1, geom_a.project_normalized(geom_b))
+
+    geom_b = read('POINT(5 0)')
+
+    assert_equal(5, geom_a.project(geom_b))
+    assert_in_delta(0.5, geom_a.project(geom_b, true))
+    assert_in_delta(0.5, geom_a.project_normalized(geom_b))
+
+    geom_a = read('MULTILINESTRING((0 0, 10 0),(20 10, 20 20))')
+    geom_b = read('POINT(20 0)')
+
+    assert_equal(10, geom_a.project(geom_b))
+    assert_in_delta(0.5, geom_a.project(geom_b, true))
+    assert_in_delta(0.5, geom_a.project_normalized(geom_b))
+
+    geom_b = read('POINT(20 5)')
+
+    assert_equal(10, geom_a.project(geom_b))
+    assert_in_delta(0.5, geom_a.project(geom_b, true))
+    assert_in_delta(0.5, geom_a.project_normalized(geom_b))
+  end
+end

data/test/geometry/relate_tests.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class GeometryRelateTests < Minitest::Test
+  include TestHelper
+
+  def setup
+    super
+    writer.trim = true
+  end
+
+  def test_relate
+    tester = lambda { |expected, geom_a, geom_b|
+      assert_equal(expected, geom_a.relate(geom_b))
+    }
+
+    geom_a = read('POINT(0 0)')
+    geom_b = read('POINT(0 0)')
+    tester['0FFFFFFF2', geom_a, geom_b]
+
+    geom_a = read('POINT(0 0)')
+    geom_b = read('POINT(1 0)')
+    tester['FF0FFF0F2', geom_a, geom_b]
+
+    geom_a = read('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))')
+    geom_b = read('POINT(1 0)')
+    tester['FF20F1FF2', geom_a, geom_b]
+  end
+
+  def test_relate_pattern
+    tester = lambda { |pattern, geom_a, geom_b, expected|
+      assert_equal(expected, geom_a.relate_pattern(geom_b, pattern))
+    }
+
+    geom_a = read('POINT(0 0)')
+    geom_b = read('POINT(0 0)')
+    tester['0FFFFFFF2', geom_a, geom_b, true]
+    tester['0*******T', geom_a, geom_b, true]
+    tester['0*******1', geom_a, geom_b, false]
+
+    geom_a = read('POINT(0 0)')
+    geom_b = read('POINT(1 0)')
+    tester['FF0FFF0F2', geom_a, geom_b, true]
+    tester['F*******2', geom_a, geom_b, true]
+    tester['T*******2', geom_a, geom_b, false]
+
+    geom_a = read('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))')
+    geom_b = read('POINT(1 0)')
+    tester['FF20F1FF2', geom_a, geom_b, true]
+    tester['F****T**T', geom_a, geom_b, true]
+    tester['T*******2', geom_a, geom_b, false]
+  end
+
+  def test_relate_boundary_node_rule
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:relate_boundary_node_rule)
+
+    geom_a = read('LINESTRING(0 0, 2 4, 5 5, 0 0)')
+    geom_b = read('POINT(0 0)')
+
+    ret = geom_a.relate_boundary_node_rule(geom_b, :ogc)
+
+    assert_equal('0F1FFFFF2', ret)
+
+    ret = geom_a.relate_boundary_node_rule(geom_b, :endpoint)
+
+    assert_equal('FF10FFFF2', ret)
+
+    assert_raises(TypeError) do
+      geom_a.relate_boundary_node_rule(geom_b, :gibberish)
+    end
+  end
+end