tg_geometry 0.3.1 → 0.3.3

data/ext/tg_geometry/vendor/tg/tg.h

@@ -1,7 +1,7 @@
 // https://github.com/tidwall/tg
 //
 // Copyright 2023 Joshua J Baker. All rights reserved.
-// Use of this source code is governed by a license 
+// Use of this source code is governed by a license
 // that can be found in the LICENSE file.
 
 #ifndef TG_H
@@ -26,7 +26,7 @@ struct tg_segment {
 };
 
 /// A rectangle defined by a minimum and maximum coordinates.
-/// Returned by the tg_geom_rect(), tg_ring_rect(), and other \*_rect() 
+/// Returned by the tg_geom_rect(), tg_ring_rect(), and other \*_rect()
 /// functions for getting a geometry's minimum bounding rectangle.
 /// Also used internally for geometry indexing.
 /// @see RectFuncs
@@ -62,10 +62,10 @@ enum tg_geom_type {
 /// Used for polygons, rings, and lines to make the point-in-polygon and
 /// geometry intersection operations fast.
 ///
-/// An index can also be used for efficiently traversing, searching, and 
-/// performing nearest-neighbor (kNN) queries on the segment using 
+/// An index can also be used for efficiently traversing, searching, and
+/// performing nearest-neighbor (kNN) queries on the segment using
 /// tg_ring_index_*() and tg_ring_nearest() functions.
-enum tg_index { 
+enum tg_index {
     TG_DEFAULT,  ///< default is TG_NATURAL or tg_env_set_default_index().
     TG_NONE,     ///< no indexing available, or disabled.
     TG_NATURAL,  ///< indexing with natural ring order, for rings/lines
@@ -73,7 +73,7 @@ enum tg_index {
 };
 
 /// @defgroup GeometryConstructors Geometry constructors
-/// Functions for creating and freeing geometries. 
+/// Functions for creating and freeing geometries.
 /// @{
 struct tg_geom *tg_geom_new_point(struct tg_point point);
 struct tg_geom *tg_geom_new_linestring(const struct tg_line *line);
@@ -110,6 +110,7 @@ const struct tg_poly *tg_geom_poly_at(const struct tg_geom *geom, int index);
 int tg_geom_num_geometries(const struct tg_geom *geom);
 const struct tg_geom *tg_geom_geometry_at(const struct tg_geom *geom, int index);
 const char *tg_geom_extra_json(const struct tg_geom *geom);
+const char *tg_geom_extra_json2(const struct tg_geom *geom, size_t *jsonlen);
 bool tg_geom_is_empty(const struct tg_geom *geom);
 int tg_geom_dims(const struct tg_geom *geom);
 bool tg_geom_has_z(const struct tg_geom *geom);
@@ -240,7 +241,7 @@ bool tg_rect_intersects_point(struct tg_rect a, struct tg_point b);
 /// Functions for working directly with the tg_ring type.
 ///
 /// There are no direct spatial predicates for tg_ring.
-/// If you want to perform operations like "intersects" or "covers" then you 
+/// If you want to perform operations like "intersects" or "covers" then you
 /// must upcast the ring to a tg_geom, like such:
 ///
 /// ```
@@ -265,17 +266,17 @@ int tg_ring_index_spread(const struct tg_ring *ring);
 int tg_ring_index_num_levels(const struct tg_ring *ring);
 int tg_ring_index_level_num_rects(const struct tg_ring *ring, int levelidx);
 struct tg_rect tg_ring_index_level_rect(const struct tg_ring *ring, int levelidx, int rectidx);
-bool tg_ring_nearest_segment(const struct tg_ring *ring, 
+bool tg_ring_nearest_segment(const struct tg_ring *ring,
     double (*rect_dist)(struct tg_rect rect, int *more, void *udata),
     double (*seg_dist)(struct tg_segment seg, int *more, void *udata),
     bool (*iter)(struct tg_segment seg, double dist, int index, void *udata),
     void *udata);
-void tg_ring_line_search(const struct tg_ring *a, const struct tg_line *b, 
-    bool (*iter)(struct tg_segment aseg, int aidx, struct tg_segment bseg, 
+void tg_ring_line_search(const struct tg_ring *a, const struct tg_line *b,
+    bool (*iter)(struct tg_segment aseg, int aidx, struct tg_segment bseg,
         int bidx, void *udata),
     void *udata);
-void tg_ring_ring_search(const struct tg_ring *a, const struct tg_ring *b, 
-    bool (*iter)(struct tg_segment aseg, int aidx, struct tg_segment bseg, 
+void tg_ring_ring_search(const struct tg_ring *a, const struct tg_ring *b,
+    bool (*iter)(struct tg_segment aseg, int aidx, struct tg_segment bseg,
         int bidx, void *udata),
     void *udata);
 double tg_ring_area(const struct tg_ring *ring);
@@ -286,7 +287,7 @@ double tg_ring_perimeter(const struct tg_ring *ring);
 /// Functions for working directly with the tg_line type.
 ///
 /// There are no direct spatial predicates for tg_line.
-/// If you want to perform operations like "intersects" or "covers" then you 
+/// If you want to perform operations like "intersects" or "covers" then you
 /// must upcast the line to a tg_geom, like such:
 ///
 /// ```
@@ -310,13 +311,13 @@ int tg_line_index_spread(const struct tg_line *line);
 int tg_line_index_num_levels(const struct tg_line *line);
 int tg_line_index_level_num_rects(const struct tg_line *line, int levelidx);
 struct tg_rect tg_line_index_level_rect(const struct tg_line *line, int levelidx, int rectidx);
-bool tg_line_nearest_segment(const struct tg_line *line, 
+bool tg_line_nearest_segment(const struct tg_line *line,
     double (*rect_dist)(struct tg_rect rect, int *more, void *udata),
     double (*seg_dist)(struct tg_segment seg, int *more, void *udata),
     bool (*iter)(struct tg_segment seg, double dist, int index, void *udata),
     void *udata);
-void tg_line_line_search(const struct tg_line *a, const struct tg_line *b, 
-    bool (*iter)(struct tg_segment aseg, int aidx, struct tg_segment bseg, 
+void tg_line_line_search(const struct tg_line *a, const struct tg_line *b,
+    bool (*iter)(struct tg_segment aseg, int aidx, struct tg_segment bseg,
         int bidx, void *udata),
     void *udata);
 double tg_line_length(const struct tg_line *line);
@@ -326,7 +327,7 @@ double tg_line_length(const struct tg_line *line);
 /// Functions for working directly with the tg_poly type.
 ///
 /// There are no direct spatial predicates for tg_poly.
-/// If you want to perform operations like "intersects" or "covers" then you 
+/// If you want to perform operations like "intersects" or "covers" then you
 /// must upcast the poly to a tg_geom, like such:
 ///
 /// ```

data/lib/tg/geometry/version.rb

@@ -2,6 +2,6 @@
 
 module TG
   module Geometry
-    VERSION = "0.3.1"
+    VERSION = "0.3.3"
   end
 end

data/lib/tg/geometry.rb

@@ -43,6 +43,30 @@ module TG
       # @!method srid
       #   @return [Integer, nil] SRID metadata; not used for reprojection
       #
+      # @!method distance_to_lnglat_meters(lng, lat)
+      #   Approximate meters in a query-local equirectangular frame. Not geodesy.
+      #   @return [Float]
+      #
+      # @!method boundary_distance_to_lnglat_meters(lng, lat)
+      #   Approximate meters to nearest boundary/segment/point.
+      #   @return [Float]
+      #
+      # @!method nearest_point_lnglat(lng, lat)
+      #   Raw planar nearest boundary/geometry point. Longitude is not wrapped.
+      #   @return [Array(Float, Float)]
+      #
+      # @!method distance_to_xy(x, y)
+      #   Planar distance in input coordinate units.
+      #   @return [Float]
+      #
+      # @!method boundary_distance_to_xy(x, y)
+      #   Planar boundary distance in input coordinate units.
+      #   @return [Float]
+      #
+      # @!method nearest_point_xy(x, y)
+      #   Planar nearest boundary/geometry point in input coordinate units.
+      #   @return [Array(Float, Float)]
+      #
       # @!method to_ewkb(srid: nil)
       #   Writes EWKB with the SRID flag set. Uses explicit srid: when provided,
       #   otherwise Geom#srid. Raises if no SRID is available. to_wkb remains plain.
@@ -68,6 +92,22 @@ module TG
       #   Stored geometries for which tg_geom_contains(stored, query) is true.
       #   Direction: stored contains query. Boundary points are not contained.
       #   @return [Array<Object>] ids in insertion order
+      #
+      # @!method within_distance_lnglat_meters(lng, lat, radius_m, sort: false)
+      #   Rtree bbox prefilter plus exact approximate-meter distance filter.
+      #   @return [Array<Array(Object, Float)>]
+      #
+      # @!method within_distance_ids_lnglat_meters(lng, lat, radius_m)
+      #   Same membership as within_distance_lnglat_meters, ids only.
+      #   @return [Array<Object>]
+      #
+      # @!method within_distance_xy(x, y, radius, sort: false)
+      #   Rtree bbox prefilter plus exact planar distance filter.
+      #   @return [Array<Array(Object, Float)>]
+      #
+      # @!method within_distance_ids_xy(x, y, radius)
+      #   Same membership as within_distance_xy, ids only.
+      #   @return [Array<Object>]
     end
 
     class Line

data/script/vendor_libs.rb

@@ -14,24 +14,24 @@ PINS = {
   tg: {
     repo: "https://github.com/tidwall/tg.git",
     ref: "main",
-    commit: "caf840504eaab4563280cf4ab16d618f69a23720",
-    sha256: "f8e0d904055c209b2a23a2200456f9374ab95cadb69e61b5721d7f8e2500e705",
+    commit: "532fc38e1a7bd440339cf83259a9d7983f04ad69",
+    sha256: "dbf9a49d5ff326974312e94fb39c5687260a2c2b27b10971b24635ed6f79184c",
     target: "tg",
     files: %w[tg.c tg.h LICENSE README.md]
   },
   rtree: {
     repo: "https://github.com/tidwall/rtree.c.git",
-    ref: "v0.5.3",
-    commit: "5717a8a1eb373428ebaae8c1c623f186ec46461f",
-    sha256: "4afc86cbd3abe03730206031a5aff5b8b29d37b055fc356052f6f06e1d1f9a61",
+    ref: "v0.6.1",
+    commit: "eebc774929f89fd5f4095f7c8835a87f2d2fb73f",
+    sha256: "6779f4b2c9df8f199907d26c3fba11bc07c6f923d80881577c19f50119e15177",
     target: "rtree",
     files: %w[rtree.c rtree.h LICENSE README.md]
   },
   json: {
     repo: "https://github.com/tidwall/json.c.git",
     ref: "main",
-    commit: "4aaf99b5c08e4e1364f97500fe5c5d5a2617b4a6",
-    sha256: "059393302de9325ab6ccf79c298234f2b688a59d138103305da317d2d0176fe2",
+    commit: "104d8cbf5d09ceba37d469574cbf5696349bcaf1",
+    sha256: "764155b839b910f45aaaf0d0881a47570d4ef0919465c5117c7658ab3dac0594",
     target: "json",
     files: %w[json.c json.h LICENSE]
   }
@@ -74,6 +74,10 @@ def normalize_tree!(directory)
     next if File.symlink?(path)
 
     if File.file?(path)
+      if %w[.c .h].include?(File.extname(path))
+        source = File.binread(path)
+        File.binwrite(path, source.gsub(/[ \t]+(?=\r?$)/, ""))
+      end
       File.chmod(0o644, path)
       File.utime(NORMALIZED_MTIME, NORMALIZED_MTIME, path)
     elsif File.directory?(path)

data/spec/distance_spec.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "point to geometry distance" do
+  R = 6_371_008.8
+  DEG = Math::PI / 180.0
+
+  def meters_per_lng_at(lat)
+    R * DEG * Math.cos(lat * DEG)
+  end
+
+  def meters_per_lat
+    R * DEG
+  end
+
+  def point_to_segment_distance(px, py, ax, ay, bx, by)
+    dx = bx - ax
+    dy = by - ay
+    len_sq = dx * dx + dy * dy
+    return Math.hypot(px - ax, py - ay) if len_sq.zero?
+
+    t = (((px - ax) * dx) + ((py - ay) * dy)) / len_sq
+    t = 0.0 if t < 0.0
+    t = 1.0 if t > 1.0
+    Math.hypot(px - (ax + t * dx), py - (ay + t * dy))
+  end
+
+  def lnglat_segment_distance_m(query_lng, query_lat, a, b)
+    sx = meters_per_lng_at(query_lat)
+    sy = meters_per_lat
+    ax = sx * (a[0] - query_lng)
+    ay = sy * (a[1] - query_lat)
+    bx = sx * (b[0] - query_lng)
+    by = sy * (b[1] - query_lat)
+    point_to_segment_distance(0.0, 0.0, ax, ay, bx, by)
+  end
+
+  it "implements polygon inside, boundary, outside, and hole semantics" do
+    polygon = TG::Geometry.polygon(
+      [[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]],
+      holes: [[[2, 2], [4, 2], [4, 4], [2, 4], [2, 2]]]
+    )
+
+    expect(polygon.distance_to_xy(5, 5)).to eq(0.0)
+    expect(polygon.boundary_distance_to_xy(5, 5)).to be_within(1e-12).of(Math.sqrt(2.0))
+    expect(polygon.distance_to_xy(0, 5)).to eq(0.0)
+    expect(polygon.boundary_distance_to_xy(0, 5)).to eq(0.0)
+    expect(polygon.distance_to_xy(12, 5)).to be_within(1e-12).of(2.0)
+    expect(polygon.distance_to_xy(3, 3)).to be_within(1e-12).of(1.0)
+  end
+
+  it "uses approximate local meters for lng/lat outside distances" do
+    polygon = TG::Geometry.polygon([[0, 0], [0.01, 0], [0.01, 0.01], [0, 0.01], [0, 0]])
+    distance = polygon.distance_to_lnglat_meters(0.02, 0.005)
+    expected = meters_per_lng_at(0.005) * 0.01
+
+    expect(distance).to be_within(0.01).of(expected)
+    expect(polygon.distance_to_lnglat_meters(0.005, 0.005)).to eq(0.0)
+    expect(polygon.boundary_distance_to_lnglat_meters(0.005, 0.005)).to be > 0.0
+  end
+
+  it "uses minimum distance over multipolygon members" do
+    multipolygon = TG::Geometry.parse_wkt(
+      "MULTIPOLYGON (((0 0, 2 0, 2 2, 0 2, 0 0)), ((10 0, 12 0, 12 2, 10 2, 10 0)))"
+    )
+
+    expect(multipolygon.distance_to_xy(1, 1)).to eq(0.0)
+    expect(multipolygon.distance_to_xy(6, 1)).to be_within(1e-12).of(4.0)
+  end
+
+  it "handles lines, points, multipoints, and mixed geometry collections" do
+    line = TG::Geometry.line_string([[0, 0], [10, 0]])
+    point = TG::Geometry.point(3, 4)
+    multipoint = TG::Geometry.parse_wkt("MULTIPOINT ((0 0), (10 0))")
+    collection = TG::Geometry.parse_wkt(
+      "GEOMETRYCOLLECTION (POLYGON ((20 20, 30 20, 30 30, 20 30, 20 20)), LINESTRING (0 0, 10 0))"
+    )
+
+    expect(line.distance_to_xy(5, 3)).to be_within(1e-12).of(line.boundary_distance_to_xy(5, 3))
+    expect(line.distance_to_xy(5, 3)).to be_within(1e-12).of(3.0)
+    expect(point.distance_to_xy(0, 0)).to be_within(1e-12).of(5.0)
+    expect(multipoint.distance_to_xy(7, 0)).to be_within(1e-12).of(3.0)
+    expect(collection.distance_to_xy(5, 2)).to be_within(1e-12).of(2.0)
+    expect(collection.distance_to_xy(25, 25)).to eq(0.0)
+  end
+
+  it "skips empty members but raises when nothing is measurable" do
+    mixed = TG::Geometry.parse_wkt("GEOMETRYCOLLECTION (POINT EMPTY, POINT (1 1))")
+    all_empty = TG::Geometry.parse_wkt("GEOMETRYCOLLECTION (POINT EMPTY, LINESTRING EMPTY)")
+
+    expect(mixed.distance_to_xy(4, 5)).to be_within(1e-12).of(5.0)
+    expect { all_empty.distance_to_xy(0, 0) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { TG::Geometry.empty_polygon.boundary_distance_to_xy(0, 0) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+
+  it "returns nearest boundary points for interior polygon queries" do
+    polygon = TG::Geometry.polygon([[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]])
+    nearest = polygon.nearest_point_xy(5, 5)
+    boundary_distance = polygon.boundary_distance_to_xy(5, 5)
+
+    expect(polygon.distance_to_xy(5, 5)).to eq(0.0)
+    expect(boundary_distance).to be_within(1e-12).of(5.0)
+    expect(point_to_segment_distance(5, 5, nearest[0], nearest[1], nearest[0], nearest[1])).to be_within(1e-12).of(boundary_distance)
+    expect(nearest[0] == 0.0 || nearest[0] == 10.0 || nearest[1] == 0.0 || nearest[1] == 10.0).to be(true)
+  end
+
+  it "keeps nearest lng/lat raw and does not force-wrap returned longitude" do
+    line = TG::Geometry.line_string([[181, 0], [181, 1]])
+    nearest = line.nearest_point_lnglat(180, 0.5)
+
+    expect(nearest[0]).to be_within(1e-12).of(181.0)
+    expect(nearest[1]).to be_within(1e-12).of(0.5)
+  end
+
+  it "does not wrap antimeridian proximity" do
+    point = TG::Geometry.point(179.9, 0)
+
+    expect(point.distance_to_lnglat_meters(-179.9, 0)).to be > 30_000_000
+    expect(point.covers_xy?(-179.9, 0)).to be(false)
+  end
+
+  it "matches independent local-meter segment math and stays finite near the pole" do
+    line = TG::Geometry.line_string([[0, 0], [0.01, 0]])
+    expected = lnglat_segment_distance_m(0.005, 0.01, [0, 0], [0.01, 0])
+
+    expect(line.distance_to_lnglat_meters(0.005, 0.01)).to be_within(0.001).of(expected)
+    expect(TG::Geometry.point(10, 90).distance_to_lnglat_meters(0, 90)).to be_finite
+    expect(TG::Geometry.point(10, 90).nearest_point_lnglat(0, 90)).to eq([10.0, 90.0])
+  end
+
+  it "keeps Geom and Index memsize unchanged after distance calls" do
+    require "objspace"
+
+    geom = TG::Geometry.polygon([[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]])
+    index = TG::Geometry::Index.build([[:zone, geom]], via: :geom, strategy: :rtree)
+    geom_size = ObjectSpace.memsize_of(geom)
+    index_size = ObjectSpace.memsize_of(index)
+
+    5.times do
+      geom.distance_to_xy(5, 5)
+      geom.nearest_point_lnglat(0.01, 0.01)
+      index.within_distance_xy(5, 5, 10)
+      index.within_distance_lnglat_meters(0.01, 0.01, 2_000)
+    end
+
+    expect(ObjectSpace.memsize_of(geom)).to eq(geom_size)
+    expect(ObjectSpace.memsize_of(index)).to eq(index_size)
+  end
+
+  it "survives GC stress and compaction" do
+    geom = TG::Geometry.line_string([[0, 0], [10, 0]])
+
+    GC.stress = true
+    expect(geom.distance_to_xy(5, 3)).to be_within(1e-12).of(3.0)
+    expect(geom.nearest_point_xy(5, 3)).to eq([5.0, 0.0])
+  ensure
+    GC.stress = false
+    GC.compact if GC.respond_to?(:compact)
+  end
+end
+
+RSpec.describe "Index distance radius queries" do
+  def build_distance_entries
+    [
+      [:zone, TG::Geometry.polygon([[0, 0], [2, 0], [2, 2], [0, 2], [0, 0]])],
+      [:line, TG::Geometry.line_string([[4, 0], [4, 4]])],
+      [:point, TG::Geometry.point(8, 0)]
+    ]
+  end
+
+  it "matches brute force membership for xy and returns filter distances" do
+    entries = build_distance_entries
+    index = TG::Geometry::Index.build(entries, via: :geom, strategy: :rtree)
+
+    srand(1234)
+    30.times do
+      x = rand * 10.0 - 1.0
+      y = rand * 5.0 - 1.0
+      radius = rand * 3.0
+      expected = entries.filter_map do |id, geom|
+        distance = geom.distance_to_xy(x, y)
+        [id, distance] if distance <= radius
+      end
+      actual = index.within_distance_xy(x, y, radius)
+
+      expect(actual.map(&:first)).to eq(expected.map(&:first))
+      actual.each do |id, distance|
+        geom = entries.assoc(id)[1]
+        expect(distance).to be_within(1e-12).of(geom.distance_to_xy(x, y))
+      end
+      expect(index.within_distance_ids_xy(x, y, radius)).to eq(expected.map(&:first))
+    end
+  end
+
+  it "matches brute force membership for lng/lat meters" do
+    entries = [
+      [:zone, TG::Geometry.polygon([[0, 0], [0.02, 0], [0.02, 0.02], [0, 0.02], [0, 0]])],
+      [:line, TG::Geometry.line_string([[0.04, 0], [0.04, 0.04]])],
+      [:point, TG::Geometry.point(0.08, 0)]
+    ]
+    index = TG::Geometry::Index.build(entries, via: :geom, strategy: :rtree)
+
+    srand(5678)
+    30.times do
+      lng = rand * 0.1 - 0.01
+      lat = rand * 0.05 - 0.01
+      radius = rand * 3_000.0
+      expected = entries.filter_map do |id, geom|
+        distance = geom.distance_to_lnglat_meters(lng, lat)
+        [id, distance] if distance <= radius
+      end
+      actual = index.within_distance_lnglat_meters(lng, lat, radius)
+
+      expect(actual.map(&:first)).to eq(expected.map(&:first))
+      actual.each do |id, distance|
+        geom = entries.assoc(id)[1]
+        expect(distance).to be_within(1e-9).of(geom.distance_to_lnglat_meters(lng, lat))
+      end
+      expect(index.within_distance_ids_lnglat_meters(lng, lat, radius)).to eq(expected.map(&:first))
+    end
+  end
+
+  it "sorts filtered pairs by distance only when requested" do
+    entries = build_distance_entries
+    index = TG::Geometry::Index.build(entries, via: :geom, strategy: :rtree)
+    sorted = index.within_distance_xy(3, 1, 10, sort: true)
+
+    expect(sorted.map(&:last)).to eq(sorted.map(&:last).sort)
+    expect(index.within_distance_xy(3, 1, 10, sort: false).map(&:first)).to eq([:zone, :line, :point])
+  end
+
+  it "handles zero radius and near-pole/full-longitude prefilter cases" do
+    zone = TG::Geometry.polygon([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]])
+    pole_point = TG::Geometry.point(90, 90)
+    index = TG::Geometry::Index.build([[:zone, zone], [:pole, pole_point]], via: :geom, strategy: :rtree)
+
+    expect(index.within_distance_ids_xy(0.5, 0.5, 0)).to eq([:zone])
+    expect(index.within_distance_ids_lnglat_meters(0, 90, 1)).to eq([:pole])
+  end
+
+  it "rejects invalid arguments and keywords" do
+    index = TG::Geometry::Index.build(build_distance_entries, via: :geom, strategy: :rtree)
+    geom = TG::Geometry.point(0, 0)
+
+    expect { geom.distance_to_lnglat_meters(Float::NAN, 0) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { geom.distance_to_lnglat_meters(0, Float::INFINITY) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { geom.distance_to_lnglat_meters(181, 0) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { geom.distance_to_lnglat_meters(0, -91) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { geom.distance_to_xy(0, Float::NAN) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { geom.distance_to_xy(0, 0, metric: :meters) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { index.within_distance_xy(0, 0, -1) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { index.within_distance_lnglat_meters(0, 0, Float::INFINITY) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { index.within_distance_xy(0, 0, 1, bogus: true) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { index.within_distance_ids_xy(0, 0, 1, sort: true) }.to raise_error(TG::Geometry::ArgumentError)
+    expect { index.within_distance_ids_lnglat_meters(0, 0, 1, sort: true) }.to raise_error(TG::Geometry::ArgumentError)
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: tg_geometry
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.3
 platform: ruby
 authors:
 - Roman Haydarov
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -64,9 +63,9 @@ description: Defines TG::Geometry with immutable Geom parsing and constructor wr
   wrappers, value Segment wrappers, Registry reload sugar, optional ActiveRecord source
   helpers, and an immutable geofencing-oriented Index with owned and borrowed geometry
   ingestion, flat/rtree strategies, deterministic ordered id results, exact rtree
-  allocation accounting, and native-endian packed point batch queries, and FeatureSource
-  GeoJSON FeatureCollection extraction/build paths over vendored C sources. Ractor
-  support is not claimed.
+  allocation accounting, and native-endian packed point batch queries, explicit local
+  point-to-geometry distance/radius queries, and FeatureSource GeoJSON FeatureCollection
+  extraction/build paths over vendored C sources. Ractor support is not claimed.
 email:
 - romnhajdarov@gmail.com
 executables: []
@@ -81,6 +80,9 @@ files:
 - Rakefile
 - benchmark/_support.rb
 - benchmark/batch_packed_vs_loop.rb
+- benchmark/distance_memory_accounting.rb
+- benchmark/distance_point_geom.rb
+- benchmark/distance_within_radius.rb
 - benchmark/ewkb_roundtrip.rb
 - benchmark/falcon_concurrency.rb
 - benchmark/feature_source.rb
@@ -135,6 +137,7 @@ files:
 - spec/batch_packed_spec.rb
 - spec/concurrency_spec.rb
 - spec/constructors_spec.rb
+- spec/distance_spec.rb
 - spec/error_hardening_spec.rb
 - spec/feature_source_nogvl_spec.rb
 - spec/feature_source_spec.rb
@@ -183,7 +186,6 @@ metadata:
   homepage_uri: https://github.com/roman-haidarov/tg_geometry
   source_code_uri: https://github.com/roman-haidarov/tg_geometry/tree/main
   changelog_uri: https://github.com/roman-haidarov/tg_geometry/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -198,9 +200,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Native extension for TG::Geometry parsing, predicates, immutable indexes,
-  FeatureSource imports, registries, low-level wrappers, and packed point batches
+  FeatureSource imports, registries, low-level wrappers, packed point batches, and
+  local distance queries
 test_files: []