geodetic 0.3.2 → 0.5.0

data/examples/08_geodetic_arithmetic.rb

@@ -0,0 +1,393 @@
+#!/usr/bin/env ruby
+
+# Demonstration of Geodetic Arithmetic
+# Shows how operators compose geometry from coordinates, vectors, and distances:
+#   +  builds geometry (Segments, Paths, Circles)
+#   *  translates geometry (Coordinates, Segments, Paths, Circles, Polygons)
+# Also demonstrates the Vector class and Path#to_corridor.
+
+require_relative "../lib/geodetic"
+
+include Geodetic
+
+LLA      = Coordinate::LLA
+Distance = Geodetic::Distance
+Vector   = Geodetic::Vector
+Bearing  = Geodetic::Bearing
+
+# ── Notable locations ────────────────────────────────────────────
+
+seattle  = LLA.new(lat: 47.6205, lng: -122.3493, alt: 0.0)
+portland = LLA.new(lat: 45.5152, lng: -122.6784, alt: 0.0)
+sf       = LLA.new(lat: 37.7749, lng: -122.4194, alt: 0.0)
+la       = LLA.new(lat: 34.0522, lng: -118.2437, alt: 0.0)
+nyc      = LLA.new(lat: 40.7128, lng: -74.0060,  alt: 0.0)
+
+puts "=== Geodetic Arithmetic Demo ==="
+puts
+
+# ── 1. Building Segments with + ──────────────────────────────────
+
+puts "--- 1. Coordinate + Coordinate → Segment ---"
+puts
+
+seg = seattle + portland
+puts <<~SEG
+  seattle + portland
+  Type:    #{seg.class}
+  Start:   #{seg.start_point.to_s(4)}
+  End:     #{seg.end_point.to_s(4)}
+  Length:  #{seg.length.to_km.to_s(1)}
+  Bearing: #{seg.bearing}
+SEG
+
+# Cross-system: UTM + LLA works
+utm = portland.to_utm
+cross_seg = seattle + utm
+puts <<~CROSS
+  Cross-system: seattle (LLA) + portland (UTM)
+  Length: #{cross_seg.length.to_km.to_s(1)}
+CROSS
+puts
+
+# ── 2. Building Paths with + ────────────────────────────────────
+
+puts "--- 2. Chaining + → Path ---"
+puts
+
+path = seattle + portland + sf + la
+puts <<~PATH
+  seattle + portland + sf + la
+  Type:           #{path.class}
+  Waypoints:      #{path.size}
+  First:          #{path.first.to_s(4)}
+  Last:           #{path.last.to_s(4)}
+  Total distance: #{path.total_distance.to_km.to_s(1)}
+PATH
+
+# Coordinate + Segment → Path
+seg = portland + sf
+path2 = seattle + seg
+puts <<~CSEG
+  seattle + (portland + sf)
+  Waypoints: #{path2.size}  (seattle → portland → sf)
+CSEG
+
+# Segment + Segment → Path
+seg1 = seattle + portland
+seg2 = sf + la
+path3 = seg1 + seg2
+puts <<~SSEG
+  (seattle + portland) + (sf + la)
+  Waypoints: #{path3.size}  (seattle → portland → sf → la)
+SSEG
+puts
+
+# ── 3. Coordinate + Distance → Circle ───────────────────────────
+
+puts "--- 3. Coordinate + Distance → Circle ---"
+puts
+
+radius = Distance.km(50)
+circle = seattle + radius
+puts <<~CIRC
+  seattle + Distance.km(50)
+  Type:     #{circle.class}
+  Centroid: #{circle.centroid.to_s(4)}
+  Radius:   #{circle.radius} m
+
+  Portland inside 50km circle? #{circle.includes?(portland)}
+  SF inside 50km circle?       #{circle.includes?(sf)}
+CIRC
+
+# Distance + Coordinate also works
+circle2 = Distance.km(50) + seattle
+puts <<~CIRC2
+  Distance.km(50) + seattle  (commutative)
+  Same circle? #{circle.centroid == circle2.centroid && circle.radius == circle2.radius}
+CIRC2
+puts
+
+# ── 4. Vector Construction ──────────────────────────────────────
+
+puts "--- 4. Vectors ---"
+puts
+
+v = Vector.new(distance: 100_000, bearing: 45.0)
+puts <<~VEC
+  Vector(100km, 45°)
+  Distance:  #{v.distance.to_km}
+  Bearing:   #{v.bearing} (#{v.bearing.to_compass})
+  North:     #{v.north.round(1)} m
+  East:      #{v.east.round(1)} m
+  Magnitude: #{v.magnitude.round(1)} m
+VEC
+
+# From a Segment
+seg = seattle + portland
+v_from_seg = seg.to_vector
+puts <<~VSEG
+  Vector.from_segment(seattle → portland)
+  Distance: #{v_from_seg.distance.to_km.to_s(1)}
+  Bearing:  #{v_from_seg.bearing} (#{v_from_seg.bearing.to_compass})
+VSEG
+
+# From components
+v2 = Vector.from_components(north: 1000, east: 1000)
+puts <<~VCOMP
+  Vector.from_components(north: 1000, east: 1000)
+  Distance: #{v2.distance.to_s(1)}
+  Bearing:  #{v2.bearing}
+VCOMP
+puts
+
+# ── 5. Vector Arithmetic ────────────────────────────────────────
+
+puts "--- 5. Vector Arithmetic ---"
+puts
+
+north = Vector.new(distance: 1000, bearing: 0.0)
+east  = Vector.new(distance: 1000, bearing: 90.0)
+
+sum = north + east
+puts <<~VADD
+  north(1km) + east(1km)
+  Result:  #{sum.distance.to_s(1)} at #{sum.bearing}
+  (1km north + 1km east = #{sum.distance.meters.round(1)}m at 45°)
+VADD
+
+scaled = north * 5
+puts <<~VSCALE
+  north(1km) * 5
+  Result: #{scaled.distance.to_km}
+VSCALE
+
+reversed = north.reverse
+puts <<~VREV
+  north(1km).reverse
+  Bearing: #{reversed.bearing} (#{reversed.bearing.to_compass})
+VREV
+
+cancelled = north + north.reverse
+puts <<~VCANCEL
+  north + north.reverse
+  Zero? #{cancelled.zero?}
+VCANCEL
+
+puts <<~VDOT
+  Dot & Cross products:
+  north.dot(east)   = #{north.dot(east).round(1)}  (perpendicular → 0)
+  north.dot(north)  = #{north.dot(north).round(1)}  (parallel → magnitude²)
+  north.cross(east) = #{north.cross(east).round(1)}  (perpendicular → area)
+VDOT
+puts
+
+# ── 6. Coordinate + Vector → Segment (Vincenty Direct) ──────────
+
+puts "--- 6. Coordinate + Vector → Segment ---"
+puts
+
+v = Vector.new(distance: 100_000, bearing: 45.0)
+seg = seattle + v
+puts <<~CV
+  seattle + Vector(100km, 45° NE)
+  Type:    #{seg.class}
+  Start:   #{seg.start_point.to_s(4)}
+  End:     #{seg.end_point.to_s(4)}
+  Length:  #{seg.length.to_km.to_s(1)}
+  Bearing: #{seg.bearing}
+CV
+
+# Vector + Coordinate → Segment (prepend via reverse)
+seg2 = v + seattle
+puts <<~VC
+  Vector(100km, 45° NE) + seattle
+  Start:   #{seg2.start_point.to_s(4)}  (100km SW of seattle)
+  End:     #{seg2.end_point.to_s(4)}  (seattle)
+  Length:  #{seg2.length.to_km.to_s(1)}
+VC
+puts
+
+# ── 7. Extending with Vectors ───────────────────────────────────
+
+puts "--- 7. Extending Geometry with Vectors ---"
+puts
+
+# Segment + Vector → Path
+seg = seattle + portland
+detour_east = Vector.new(distance: 50_000, bearing: 90.0)
+path = seg + detour_east
+puts <<~SV
+  (seattle + portland) + Vector(50km east)
+  Type:      #{path.class}
+  Waypoints: #{path.size}
+  Last point #{path.last.lng > portland.lng ? "is east of" : "is NOT east of"} portland
+SV
+
+# Vector + Segment → Path (prepend)
+approach = Vector.new(distance: 30_000, bearing: 180.0)
+path2 = approach + seg
+puts <<~VS
+  Vector(30km south) + (seattle + portland)
+  Type:      #{path2.class}
+  Waypoints: #{path2.size}
+  First point #{path2.first.lat > seattle.lat ? "is north of" : "is NOT north of"} seattle
+  (reversed: 30km south → first point is 30km north)
+VS
+
+# Path + Vector → Path
+route = seattle + portland + sf
+extend_south = Vector.new(distance: 200_000, bearing: 180.0)
+route2 = route + extend_south
+puts <<~PV
+  (seattle + portland + sf) + Vector(200km south)
+  Waypoints: #{route2.size}
+  Last point latitude: #{route2.last.lat.round(4)} (south of SF's #{sf.lat})
+PV
+puts
+
+# ── 8. Translation with * ───────────────────────────────────────
+
+puts "--- 8. Translation with * ---"
+puts
+
+shift_east = Vector.new(distance: 100_000, bearing: 90.0)
+
+# Coordinate
+p2 = seattle * shift_east
+puts <<~TC
+  Coordinate * Vector(100km east)
+  seattle:    #{seattle.to_s(4)}
+  translated: #{p2.to_s(4)}
+  seattle.translate(v) also works: #{seattle.translate(shift_east).to_s(4)}
+TC
+
+# Segment
+seg = seattle + portland
+seg2 = seg * shift_east
+puts <<~TS
+  Segment * Vector(100km east)
+  Original length: #{seg.length.to_km.to_s(1)}
+  Shifted length:  #{seg2.length.to_km.to_s(1)}  (preserved)
+  Start moved east: #{seg2.start_point.lng > seg.start_point.lng}
+TS
+
+# Path
+route = seattle + portland + sf
+route2 = route * shift_east
+puts <<~TP
+  Path * Vector(100km east)
+  Original waypoints: #{route.size}
+  Shifted waypoints:  #{route2.size}  (preserved)
+  All moved east: #{route.coordinates.zip(route2.coordinates).all? { |a, b| b.lng > a.lng }}
+TP
+
+# Circle
+circle = seattle + Distance.km(25)
+circle2 = circle * shift_east
+puts <<~TCIR
+  Circle * Vector(100km east)
+  Original centroid: #{circle.centroid.to_s(4)}
+  Shifted centroid:  #{circle2.centroid.to_s(4)}
+  Radius preserved:  #{circle.radius == circle2.radius}
+TCIR
+
+# Polygon
+a = LLA.new(lat: 47.5, lng: -122.5, alt: 0)
+b = LLA.new(lat: 47.5, lng: -122.2, alt: 0)
+c = LLA.new(lat: 47.7, lng: -122.35, alt: 0)
+poly = Areas::Polygon.new(boundary: [a, b, c])
+poly2 = poly * shift_east
+puts <<~TPOLY
+  Polygon * Vector(100km east)
+  Original centroid: #{poly.centroid.to_s(4)}
+  Shifted centroid:  #{poly2.centroid.to_s(4)}
+TPOLY
+puts
+
+# ── 9. + vs * with Vector ───────────────────────────────────────
+
+puts "--- 9. Key Distinction: + vs * ---"
+puts
+
+v = Vector.new(distance: 50_000, bearing: 0.0)
+journey     = seattle + v   # Segment (the journey)
+destination = seattle * v   # Coordinate (just the result)
+
+puts <<~DIFF
+  v = Vector(50km north)
+
+  seattle + v  → #{journey.class}
+    start: #{journey.start_point.to_s(4)}
+    end:   #{journey.end_point.to_s(4)}
+
+  seattle * v  → #{destination.class}
+    result: #{destination.to_s(4)}
+
+  The endpoint equals the translated point:
+    #{journey.end_point == destination}
+DIFF
+puts
+
+# ── 10. Corridors ───────────────────────────────────────────────
+
+puts "--- 10. Path Corridors ---"
+puts
+
+route = seattle + portland + sf
+corridor = route.to_corridor(width: 50_000)
+puts <<~CORR
+  route.to_corridor(width: 50_000)  (50km wide)
+  Type:     #{corridor.class}
+  Vertices: #{corridor.boundary.size} (#{route.size} left + #{route.size} right + 1 closing)
+
+  Portland inside corridor? #{corridor.includes?(portland)}
+CORR
+
+# Translate the corridor
+shifted_corridor = corridor * Vector.new(distance: 200_000, bearing: 90.0)
+puts <<~SCORR
+  corridor * Vector(200km east)
+  Portland still inside shifted corridor? #{shifted_corridor.includes?(portland)}
+SCORR
+puts
+
+# ── 11. Composing Operations ────────────────────────────────────
+
+puts "--- 11. Composing Operations ---"
+puts
+
+# Build a route, translate it, make a corridor
+v = Vector.new(distance: 100_000, bearing: 90.0)
+shifted_route = (seattle + portland + sf) * v
+corridor = shifted_route.to_corridor(width: Distance.km(20))
+puts <<~COMPOSE
+  ((seattle + portland + sf) * Vector(100km east)).to_corridor(width: 20km)
+  Route waypoints:   #{shifted_route.size}
+  Corridor vertices: #{corridor.boundary.size}
+COMPOSE
+
+# Vector arithmetic to build displacement
+leg1 = Vector.new(distance: 50_000, bearing: 0.0)    # 50km north
+leg2 = Vector.new(distance: 30_000, bearing: 90.0)   # 30km east
+combined = leg1 + leg2
+seg = seattle + combined
+puts <<~VECMATH
+  Combined vector: north(50km) + east(30km)
+  Resultant: #{combined.distance.to_km.to_s(1)} at #{combined.bearing}
+  Segment from seattle: #{seg.length.to_km.to_s(1)} at #{seg.bearing}
+VECMATH
+
+# Scale a vector to create multiple equidistant points
+base = Vector.new(distance: 100_000, bearing: 45.0)
+points = (1..5).map { |i| seattle * (base * i) }
+puts <<~EQUI
+  5 equidistant points at 100km intervals, bearing 45° NE:
+EQUI
+points.each_with_index do |pt, i|
+  d = seattle.distance_to(pt).to_km
+  puts "    #{i + 1}. #{pt.to_s(4)}  (#{d.to_s(0)} from seattle)"
+end
+
+puts
+puts "=== Done ==="

data/examples/README.md

@@ -76,10 +76,44 @@ Demonstrates the `Geodetic::Path` class with a walking route through Manhattan.
 - **Equality** comparing paths by coordinates and order
 - **Subpath extraction** with `between` and **splitting** with `split_at`
 - **Interpolation** finding coordinates at a given distance along the path with `at_distance`
-- **Bounding box** with `bounds` returning an `Areas::Rectangle`
+- **Bounding box** with `bounds` returning an `Areas::BoundingBox`
 - **Polygon conversion** with `to_polygon` (validates no self-intersection)
 - **Path intersection** detection with `intersects?`
 - **Path-to-Path closest points** finding the nearest pair between two paths
 - **Path-to-Area closest points** for Circle and Polygon areas
 - **Reverse** to create the return route
 - **Feature integration** wrapping a Path with label and metadata
+
+## 07 - Segments and Shapes
+
+Demonstrates `Geodetic::Segment` and the polygon subclasses (`Triangle`, `Rectangle`, `Pentagon`, `Hexagon`, `Octagon`) using landmarks around the National Mall in Washington DC. Covers:
+
+- **Segment properties** including `length`/`distance`, `bearing`, `midpoint`/`centroid`
+- **Segment operations** with `interpolate`, `project`, `reverse`
+- **Membership testing** with `includes?` (vertex check) and `contains?` (on-segment check)
+- **Intersection detection** between crossing and parallel segments
+- **Triangle construction** in four modes: isosceles, equilateral by side, equilateral by radius, arbitrary vertices
+- **Triangle predicates** with `equilateral?`, `isosceles?`, `scalene?`, and `side_lengths`
+- **Rectangle construction** from a `Segment` centerline (or two-point array) plus width
+- **Rectangle properties** with `centerline`, `center`, `height`, `bearing`, `square?`
+- **Regular polygons** (Pentagon, Hexagon, Octagon) from center and radius
+- **Polygon segments** accessing edges as `Segment` objects
+- **Bounding boxes** via `to_bounding_box` on any polygon subclass
+- **Containment testing** with `includes?` across different shapes
+- **Feature integration** wrapping Segment and area geometries with labels and metadata
+
+## 08 - Geodetic Arithmetic
+
+Demonstrates the operator-based geometry system and the `Geodetic::Vector` class using West Coast cities. Covers:
+
+- **Building Segments with +** combining two coordinates, including cross-system (LLA + UTM)
+- **Chaining + into Paths** with Coordinate + Coordinate + Coordinate, Coordinate + Segment, and Segment + Segment
+- **Coordinate + Distance → Circle** with commutative Distance + Coordinate
+- **Vector construction** from distance/bearing, from a Segment (`to_vector`), and from north/east components
+- **Vector arithmetic** with addition, subtraction, scalar multiplication, reverse, zero cancellation, dot product, and cross product
+- **Coordinate + Vector → Segment** solving the Vincenty direct problem, and Vector + Coordinate for the reverse
+- **Extending geometry with Vectors** using Segment + Vector, Vector + Segment, and Path + Vector
+- **Translation with \*** shifting Coordinates, Segments, Paths, Circles, and Polygons by a Vector (also available as `.translate`)
+- **Key distinction: + vs \*** where `P + V` returns a Segment (the journey) and `P * V` returns a Coordinate (the destination)
+- **Path corridors** with `to_corridor(width:)` converting a path into a polygon, and translating the corridor
+- **Composing operations** chaining arithmetic, vector math, and corridors in single expressions

data/lib/geodetic/areas/bounding_box.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../coordinate/lla'
+
+module Geodetic
+  module Areas
+    class BoundingBox
+      attr_reader :nw, :se, :centroid
+
+      # Define an axis-aligned bounding box by its NW and SE corners.
+      # Accepts any coordinate that responds to to_lla.
+      #
+      #   BoundingBox.new(
+      #     nw: LLA.new(lat: 41.0, lng: -75.0),
+      #     se: LLA.new(lat: 40.0, lng: -74.0)
+      #   )
+      def initialize(nw:, se:)
+        @nw = nw.is_a?(Coordinate::LLA) ? nw : nw.to_lla
+        @se = se.is_a?(Coordinate::LLA) ? se : se.to_lla
+
+        raise ArgumentError, "NW corner must have higher latitude than SE corner" if @nw.lat < @se.lat
+        raise ArgumentError, "NW corner must have lower longitude than SE corner" if @nw.lng > @se.lng
+
+        @centroid = Coordinate::LLA.new(
+          lat: (@nw.lat + @se.lat) / 2.0,
+          lng: (@nw.lng + @se.lng) / 2.0,
+          alt: 0.0
+        )
+      end
+
+      def ne
+        Coordinate::LLA.new(lat: @nw.lat, lng: @se.lng, alt: 0.0)
+      end
+
+      def sw
+        Coordinate::LLA.new(lat: @se.lat, lng: @nw.lng, alt: 0.0)
+      end
+
+      def includes?(a_point)
+        lla = a_point.respond_to?(:to_lla) ? a_point.to_lla : a_point
+        lla.lat >= @se.lat && lla.lat <= @nw.lat &&
+          lla.lng >= @nw.lng && lla.lng <= @se.lng
+      end
+
+      def excludes?(a_point)
+        !includes?(a_point)
+      end
+
+      alias_method :include?, :includes?
+      alias_method :exclude?, :excludes?
+      alias_method :inside?,  :includes?
+      alias_method :outside?, :excludes?
+    end
+
+  end
+end

data/lib/geodetic/areas/circle.rb

@@ -24,6 +24,14 @@ module Geodetic
       alias_method :exclude?, :excludes?
       alias_method :inside?,  :includes?
       alias_method :outside?, :excludes?
+
+      def *(other)
+        raise ArgumentError, "expected a Vector, got #{other.class}" unless other.is_a?(Vector)
+
+        self.class.new(centroid: other.destination_from(@centroid), radius: @radius)
+      end
+
+      alias_method :translate, :*
     end
   end
 end

data/lib/geodetic/areas/hexagon.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "regular_polygon"
+
+module Geodetic
+  module Areas
+    class Hexagon < RegularPolygon
+      SIDES = 6
+    end
+  end
+end

data/lib/geodetic/areas/octagon.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "regular_polygon"
+
+module Geodetic
+  module Areas
+    class Octagon < RegularPolygon
+      SIDES = 8
+    end
+  end
+end

data/lib/geodetic/areas/pentagon.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "regular_polygon"
+
+module Geodetic
+  module Areas
+    class Pentagon < RegularPolygon
+      SIDES = 5
+    end
+  end
+end

data/lib/geodetic/areas/polygon.rb

@@ -7,29 +7,26 @@ module Geodetic
     class Polygon
       attr_reader :boundary, :centroid
 
-      def initialize(boundary:)
+      def initialize(boundary:, validate: true)
         raise ArgumentError, "A Polygon requires more than #{boundary.length} points on its boundary" unless boundary.length > 2
 
         @boundary = boundary.dup
         @boundary << boundary[0] unless boundary.first == boundary.last
 
-        centroid_lat = 0.0
-        centroid_lng = 0.0
-        area = 0.0
-
-        0.upto(@boundary.length - 2) do |i|
-          cross = @boundary[i].lng * @boundary[i + 1].lat - @boundary[i + 1].lng * @boundary[i].lat
-          area += 0.5 * cross
-          centroid_lng += (@boundary[i].lng + @boundary[i + 1].lng) * cross
-          centroid_lat += (@boundary[i].lat + @boundary[i + 1].lat) * cross
-        end
+        validate_no_self_intersection! if validate
 
-        centroid_lng /= (6.0 * area)
-        centroid_lat /= (6.0 * area)
+        compute_centroid
+      end
 
-        @centroid = Coordinate::LLA.new(lat: centroid_lat, lng: centroid_lng, alt: 0.0)
+      # Returns Segment objects for each edge of the polygon.
+      # Returns Segment objects for each side of the polygon.
+      def segments
+        @segments ||= @boundary.each_cons(2).map { |a, b| Segment.new(a, b) }
       end
 
+      alias edges segments
+      alias border segments
+
       def includes?(a_point)
         turn_angle = 0.0
 
@@ -52,6 +49,59 @@ module Geodetic
       alias_method :exclude?, :excludes?
       alias_method :inside?,  :includes?
       alias_method :outside?, :excludes?
+
+      def *(other)
+        raise ArgumentError, "expected a Vector, got #{other.class}" unless other.is_a?(Vector)
+
+        # Translate all vertices except the closing point (it gets re-added by initialize)
+        translated = @boundary[0...-1].map { |pt| other.destination_from(pt) }
+        self.class.new(boundary: translated)
+      end
+
+      alias_method :translate, :*
+
+      private
+
+      def compute_centroid
+        centroid_lat = 0.0
+        centroid_lng = 0.0
+        area = 0.0
+
+        0.upto(@boundary.length - 2) do |i|
+          cross = @boundary[i].lng * @boundary[i + 1].lat - @boundary[i + 1].lng * @boundary[i].lat
+          area += 0.5 * cross
+          centroid_lng += (@boundary[i].lng + @boundary[i + 1].lng) * cross
+          centroid_lat += (@boundary[i].lat + @boundary[i + 1].lat) * cross
+        end
+
+        if area.abs < 1e-12
+          # Degenerate polygon (collinear or self-intersecting) — fall back to mean
+          centroid_lat = @boundary[0...-1].sum(&:lat) / (@boundary.length - 1).to_f
+          centroid_lng = @boundary[0...-1].sum(&:lng) / (@boundary.length - 1).to_f
+        else
+          centroid_lng /= (6.0 * area)
+          centroid_lat /= (6.0 * area)
+        end
+
+        @centroid = Coordinate::LLA.new(lat: centroid_lat, lng: centroid_lng, alt: 0.0)
+      end
+
+      def validate_no_self_intersection!
+        segs = @boundary.each_cons(2).map { |a, b| Segment.new(a, b) }
+
+        segs.each_with_index do |seg_i, i|
+          segs.each_with_index do |seg_j, j|
+            # Skip same edge and adjacent edges (they share a vertex)
+            next if j <= i + 1
+            # Skip first-last pair (they share the closing vertex)
+            next if i == 0 && j == segs.length - 1
+
+            if seg_i.intersects?(seg_j)
+              raise ArgumentError, "edge #{i} intersects edge #{j} — polygon boundary must not self-intersect"
+            end
+          end
+        end
+      end
     end
   end
 end