geodetic 0.3.2 → 0.4.0

data/docs/reference/segment.md

@@ -0,0 +1,181 @@
+# Segment Reference
+
+`Geodetic::Segment` represents a directed line segment between two points on the Earth's surface. It is the fundamental geometric primitive underlying `Path` segments, `Polygon` edges, and closest-approach calculations.
+
+A Segment has a `start_point` and an `end_point`, both stored as `Coordinate::LLA`. Properties like `length`, `bearing`, and `midpoint` are computed lazily and cached.
+
+---
+
+## Great Circle Arcs
+
+On a sphere, any two points that are not antipodal (diametrically opposite) define a great circle, and that great circle produces two arcs between them: the **minor arc** (the shorter path) and the **major arc** (the longer way around the globe).
+
+Segment always uses the **minor arc**. All operations — `length`, `bearing`, `interpolate`, `project`, `contains?` — follow the shortest path between the two endpoints via Vincenty geodesic calculations.
+
+For **antipodal points** (exactly opposite sides of the Earth, roughly 20,000 km apart), the great circle is degenerate: there are infinitely many paths of equal length and the bearing is undefined.
+
+In practice, real-world segments rarely approach even a quarter of the Earth's circumference (~10,000 km), so the minor arc assumption holds for virtually all use cases.
+
+---
+
+## Constructor
+
+```ruby
+a = Geodetic::Coordinate::LLA.new(lat: 40.7484, lng: -73.9857, alt: 0)
+b = Geodetic::Coordinate::LLA.new(lat: 40.7580, lng: -73.9855, alt: 0)
+
+seg = Geodetic::Segment.new(a, b)
+```
+
+Accepts any coordinate type that responds to `to_lla`. Endpoints are converted to LLA on construction.
+
+---
+
+## Attributes
+
+| Attribute     | Type | Description |
+|---------------|------|-------------|
+| `start_point` | LLA  | The starting point of the segment |
+| `end_point`   | LLA  | The ending point of the segment |
+
+---
+
+## Properties
+
+All properties are lazily computed and cached after first access.
+
+| Method         | Returns  | Description |
+|----------------|----------|-------------|
+| `length`       | Distance | Great-circle distance between endpoints |
+| `distance`     | Distance | Alias for `length` |
+| `length_meters`| Float    | Length in meters (convenience accessor) |
+| `bearing`      | Bearing  | Forward azimuth from start to end |
+| `midpoint`     | LLA      | Point at the halfway mark |
+
+```ruby
+seg.length           # => #<Geodetic::Distance 1067.45 m>
+seg.distance         # => #<Geodetic::Distance 1067.45 m> (alias)
+seg.length_meters    # => 1067.45
+seg.bearing          # => #<Geodetic::Bearing 1.0°>
+seg.midpoint         # => LLA at the midpoint
+```
+
+---
+
+## Geometry
+
+### `reverse`
+
+Returns a new Segment with start and end points swapped.
+
+```ruby
+rev = seg.reverse
+rev.start_point == seg.end_point  # => true
+```
+
+### `interpolate(fraction)`
+
+Returns the LLA coordinate at a given fraction (0.0 to 1.0) along the segment.
+
+```ruby
+seg.interpolate(0.0)   # => start_point
+seg.interpolate(0.5)   # => midpoint
+seg.interpolate(1.0)   # => end_point
+seg.interpolate(0.25)  # => quarter-way along
+```
+
+---
+
+## Projection
+
+### `project(point)`
+
+Projects a point onto the segment, returning the closest point on the segment and the distance in meters.
+
+```ruby
+foot, distance_m = seg.project(target_point)
+```
+
+- If the perpendicular foot falls within the segment, returns the foot and the perpendicular distance.
+- If the foot falls before the start, returns `start_point`.
+- If the foot falls past the end, returns `end_point`.
+- Handles zero-length segments and target-at-endpoint edge cases.
+
+This is the core geometric operation used by `Path#closest_coordinate_to`, `Path#closest_points_to`, and `Path#at_distance`.
+
+---
+
+## Membership
+
+| Method | Description |
+|--------|-------------|
+| `includes?(point)` | True if the point is a vertex (start or end point) |
+| `contains?(point, tolerance: 10.0)` | True if the point lies on the segment within tolerance (meters) |
+| `excludes?(point, tolerance: 10.0)` | Opposite of `contains?` |
+
+`includes?` checks vertices only. `contains?` checks whether a point lies anywhere along the line between the two endpoints using a bearing comparison with a tolerance derived from the segment length.
+
+```ruby
+seg.includes?(seg.start_point)     # => true
+seg.includes?(seg.midpoint)        # => false
+
+seg.contains?(seg.midpoint)        # => true
+seg.contains?(far_away_point)      # => false
+```
+
+---
+
+## Intersection
+
+### `intersects?(other_segment)`
+
+Tests whether two segments cross each other using cross-product orientation tests on a flat lat/lng approximation. Handles both proper intersections and collinear overlap.
+
+```ruby
+seg1 = Geodetic::Segment.new(a, b)
+seg2 = Geodetic::Segment.new(c, d)
+
+seg1.intersects?(seg2)  # => true/false
+```
+
+Used internally by `Path#intersects?` and `Path#to_polygon` for self-intersection validation.
+
+---
+
+## Conversion
+
+| Method   | Returns | Description |
+|----------|---------|-------------|
+| `to_path`| Path    | A two-point Path from start to end |
+| `to_a`   | Array   | `[start_point, end_point]` |
+
+```ruby
+seg.to_path   # => #<Geodetic::Path size=2 ...>
+seg.to_a      # => [start_point, end_point]
+```
+
+---
+
+## Equality and Display
+
+```ruby
+seg1 == seg2   # true if same start and end points
+
+seg.to_s       # => "Segment(40.748400, ... -> 40.758000, ...)"
+seg.inspect    # => "#<Geodetic::Segment start=... end=... length=1067.45 m>"
+```
+
+Two segments are equal if they have the same start and end points. Direction matters: `Segment.new(a, b) != Segment.new(b, a)`.
+
+---
+
+## Relationship to Path and Polygon
+
+`Path#segments` returns an array of Segment objects:
+
+```ruby
+route = Path.new(coordinates: [a, b, c, d])
+route.segments  # => [Segment(a→b), Segment(b→c), Segment(c→d)]
+```
+
+Polygon edges are implicit segments formed by consecutive boundary points. Segment's `project`, `intersects?`, and `contains?` methods power the geometric operations in both Path and Polygon.

data/examples/02_all_coordinate_systems.rb

@@ -253,13 +253,13 @@ def demo_coordinate_systems
   puts "   Lat/Lng error is from MGRS 1-meter grid precision truncation."
   puts
 
-  # ========== Rectangle Area ==========
-  puts "RECTANGLE AREA"
+  # ========== BoundingBox Area ==========
+  puts "BOUNDING BOX AREA"
   puts "-" * 50
 
   nw = LLA.new(lat: 47.65, lng: -122.40)
   se = LLA.new(lat: 47.60, lng: -122.30)
-  rect = Areas::Rectangle.new(nw: nw, se: se)
+  rect = Areas::BoundingBox.new(nw: nw, se: se)
   puts "   NW: (#{rect.nw.lat}, #{rect.nw.lng})"
   puts "   SE: (#{rect.se.lat}, #{rect.se.lng})"
   puts "   NE: (#{rect.ne.lat}, #{rect.ne.lng})"
@@ -268,10 +268,10 @@ def demo_coordinate_systems
   puts "   Space Needle inside? #{rect.includes?(lla_coord)}"
   puts "   London inside? #{rect.includes?(london_lla)}"
 
-  # Rectangle from non-LLA coordinates
+  # BoundingBox from non-LLA coordinates
   nw_wm = WebMerc.from_lla(nw)
   se_wm = WebMerc.from_lla(se)
-  rect_wm = Areas::Rectangle.new(nw: nw_wm, se: se_wm)
+  rect_wm = Areas::BoundingBox.new(nw: nw_wm, se: se_wm)
   puts "   From WebMercator: NW=(#{rect_wm.nw.lat.round(4)}, #{rect_wm.nw.lng.round(4)})"
   puts
 
@@ -292,7 +292,7 @@ def demo_coordinate_systems
   puts "Geohash-36 (GH36)"
   puts "Geoid Height Support"
   puts
-  puts "Areas: Circle, Polygon, Rectangle"
+  puts "Areas: Circle, Polygon, BoundingBox"
   puts
   puts "All coordinate systems support complete bidirectional conversions!"
   puts "Total coordinate systems implemented: 13"

data/examples/06_path_operations.rb

@@ -59,10 +59,8 @@ puts
 
 puts "--- 3. Segment Analysis ---"
 
-route.segments.each_with_index do |(a, b), i|
-  dist    = a.distance_to(b)
-  bearing = a.bearing_to(b)
-  puts "  Segment #{i + 1}: #{dist.to_km} #{bearing.to_compass(points: 8)} (#{bearing.to_s(1)})"
+route.segments.each_with_index do |seg, i|
+  puts "  Segment #{i + 1}: #{seg.length.to_km} #{seg.bearing.to_compass(points: 8)} (#{seg.bearing.to_s(1)})"
 end
 
 puts <<~TOTAL

data/examples/07_segments_and_shapes.rb

@@ -0,0 +1,258 @@
+#!/usr/bin/env ruby
+
+# Demonstration of Segment and polygon subclasses (Triangle, Rectangle,
+# Pentagon, Hexagon, Octagon). Shows construction, properties, predicates,
+# containment testing, segment access, bounding boxes, and Feature integration.
+
+require_relative "../lib/geodetic"
+
+include Geodetic
+LLA = Coordinate::LLA
+
+# ── Notable locations around the National Mall, Washington DC ─────
+
+lincoln     = LLA.new(lat: 38.8893, lng: -77.0502, alt: 0)
+washington  = LLA.new(lat: 38.8895, lng: -77.0353, alt: 0)
+capitol     = LLA.new(lat: 38.8899, lng: -77.0091, alt: 0)
+white_house = LLA.new(lat: 38.8977, lng: -77.0365, alt: 0)
+jefferson   = LLA.new(lat: 38.8814, lng: -77.0365, alt: 0)
+pentagon    = LLA.new(lat: 38.8719, lng: -77.0563, alt: 0)
+
+puts "=== Segments and Shapes Demo ==="
+puts
+
+# ── 1. Segment Basics ────────────────────────────────────────────
+
+puts "--- 1. Segment ---"
+puts
+
+seg = Segment.new(lincoln, washington)
+
+puts <<~SEG
+  Lincoln Memorial -> Washington Monument
+  Length:   #{seg.length.to_s}  (#{seg.length_meters.round(1)} m)
+  Distance: #{seg.distance.to_s}  (alias for length)
+  Bearing:  #{seg.bearing.to_s}  (#{seg.bearing.to_compass})
+  Midpoint: #{seg.midpoint.to_s(4)}
+  Centroid: #{seg.centroid.to_s(4)}  (alias for midpoint)
+SEG
+puts
+
+# ── 2. Segment Operations ───────────────────────────────────────
+
+puts "--- 2. Segment Operations ---"
+puts
+
+quarter = seg.interpolate(0.25)
+puts "  Quarter-way point:  #{quarter.to_s(4)}"
+puts "  Reverse bearing:    #{seg.reverse.bearing.to_s}"
+puts
+
+foot, dist_m = seg.project(white_house)
+puts "  Project White House onto Lincoln-Washington segment:"
+puts "  Foot:     #{foot.to_s(4)}"
+puts "  Distance: #{dist_m.round(1)} m from segment"
+puts
+
+puts "  White House is a vertex?   #{seg.includes?(white_house)}"
+puts "  Lincoln is a vertex?       #{seg.includes?(lincoln)}"
+puts "  Midpoint on segment?       #{seg.contains?(seg.midpoint)}"
+puts "  White House on segment?    #{seg.contains?(white_house)}"
+puts
+
+# ── 3. Segment Intersection ─────────────────────────────────────
+
+puts "--- 3. Segment Intersection ---"
+puts
+
+mall_ns = Segment.new(white_house, jefferson)
+mall_ew = Segment.new(lincoln, capitol)
+
+puts "  N-S segment: White House -> Jefferson Memorial"
+puts "  E-W segment: Lincoln Memorial -> Capitol"
+puts "  Intersects?  #{mall_ew.intersects?(mall_ns)}"
+puts
+
+parallel = Segment.new(
+  LLA.new(lat: 38.892, lng: -77.050, alt: 0),
+  LLA.new(lat: 38.892, lng: -77.010, alt: 0)
+)
+puts "  Parallel segment (north of Mall):"
+puts "  Intersects E-W?  #{mall_ew.intersects?(parallel)}"
+puts
+
+# ── 4. Triangle ──────────────────────────────────────────────────
+
+puts "--- 4. Triangle ---"
+puts
+
+puts "  Isosceles (center + width + height):"
+tri = Areas::Triangle.new(center: washington, width: 400, height: 600, bearing: 0)
+puts "    Sides:       #{tri.sides}"
+puts "    Width:       #{tri.width} m"
+puts "    Height:      #{tri.height} m"
+puts "    Bearing:     #{tri.bearing}\u00B0"
+puts "    Equilateral? #{tri.equilateral?}"
+puts "    Isosceles?   #{tri.isosceles?}"
+puts "    Scalene?     #{tri.scalene?}"
+puts "    Side lengths: #{tri.side_lengths.map { |l| "#{l.round(1)} m" }.join(', ')}"
+puts "    Center inside?  #{tri.includes?(washington)}"
+puts
+
+puts "  Equilateral by side (500m):"
+eq_tri = Areas::Triangle.new(center: washington, side: 500, bearing: 30)
+puts "    Equilateral? #{eq_tri.equilateral?}"
+puts "    Side lengths: #{eq_tri.side_lengths.map { |l| "#{l.round(1)} m" }.join(', ')}"
+puts
+
+puts "  Equilateral by radius (300m):"
+r_tri = Areas::Triangle.new(center: washington, radius: 300, bearing: 0)
+puts "    Equilateral? #{r_tri.equilateral?}"
+puts "    Width:  #{r_tri.width.round(1)} m"
+puts "    Height: #{r_tri.height.round(1)} m"
+puts
+
+puts "  Arbitrary 3 vertices:"
+arb_tri = Areas::Triangle.new(vertices: [lincoln, washington, white_house])
+puts "    Scalene?     #{arb_tri.scalene?}"
+puts "    Side lengths: #{arb_tri.side_lengths.map { |l| "#{l.round(1)} m" }.join(', ')}"
+puts "    Washington inside? #{arb_tri.includes?(washington)}"
+puts
+
+# ── 5. Rectangle ────────────────────────────────────────────────
+
+puts "--- 5. Rectangle ---"
+puts
+
+puts "  From a Segment (Lincoln -> Washington) + width:"
+centerline = Segment.new(lincoln, washington)
+rect = Areas::Rectangle.new(segment: centerline, width: 200)
+
+puts "    Width:     #{rect.width} m"
+puts "    Height:    #{rect.height.round(1)} m"
+puts "    Bearing:   #{rect.bearing.round(1)}\u00B0"
+puts "    Center:    #{rect.center.to_s(4)}"
+puts "    Square?    #{rect.square?}"
+puts "    Sides:     #{rect.sides}"
+puts "    Corners:   #{rect.corners.size}"
+puts "    Centerline start: #{rect.centerline.start_point.to_s(4)}"
+puts "    Centerline end:   #{rect.centerline.end_point.to_s(4)}"
+puts
+
+puts "  From an array of two points + width:"
+rect2 = Areas::Rectangle.new(segment: [white_house, jefferson], width: 300)
+puts "    Width:   #{rect2.width} m"
+puts "    Height:  #{rect2.height.round(1)} m"
+puts "    Bearing: #{rect2.bearing.round(1)}\u00B0"
+puts "    Square?  #{rect2.square?}"
+puts
+
+puts "  Square rectangle (width = segment distance):"
+short_seg = Segment.new(lincoln, seg.interpolate(0.1))
+sq = Areas::Rectangle.new(segment: short_seg, width: short_seg.distance)
+puts "    Width:   #{sq.width.round(1)} m"
+puts "    Height:  #{sq.height.round(1)} m"
+puts "    Square?  #{sq.square?}"
+puts
+
+# ── 6. Pentagon, Hexagon, Octagon ────────────────────────────────
+
+puts "--- 6. Regular Polygons ---"
+puts
+
+[
+  ["Pentagon", Areas::Pentagon.new(center: washington, radius: 500, bearing: 0)],
+  ["Hexagon",  Areas::Hexagon.new(center: washington, radius: 500, bearing: 0)],
+  ["Octagon",  Areas::Octagon.new(center: washington, radius: 500, bearing: 0)]
+].each do |name, shape|
+  puts "  #{name}:"
+  puts "    Sides:    #{shape.sides}"
+  puts "    Radius:   #{shape.radius} m"
+  puts "    Vertices: #{shape.boundary.size - 1} (boundary has #{shape.boundary.size} points, closed)"
+  puts "    Centroid: #{shape.centroid.to_s(4)}"
+  puts "    Center inside?  #{shape.includes?(washington)}"
+  puts "    Pentagon inside? #{shape.includes?(pentagon)}"
+  puts
+end
+
+# ── 7. Polygon Segments ─────────────────────────────────────────
+
+puts "--- 7. Polygon Segments ---"
+puts
+
+puts "  Rectangle segments (edges/border):"
+rect.segments.each_with_index do |s, i|
+  puts "    Edge #{i + 1}: #{s.length_meters.round(1)} m, bearing #{s.bearing.to_s}"
+end
+puts "    Connected? #{rect.segments.each_cons(2).all? { |a, b| a.end_point == b.start_point }}"
+puts
+
+puts "  Triangle segments:"
+tri.segments.each_with_index do |s, i|
+  puts "    Side #{i + 1}: #{s.length_meters.round(1)} m"
+end
+puts
+
+# ── 8. Bounding Boxes ───────────────────────────────────────────
+
+puts "--- 8. Bounding Boxes ---"
+puts
+
+[
+  ["Triangle",  tri],
+  ["Rectangle", rect]
+].each do |name, shape|
+  bbox = shape.to_bounding_box
+  puts "  #{name}:"
+  puts "    NW: #{bbox.nw.to_s(4)}"
+  puts "    SE: #{bbox.se.to_s(4)}"
+
+  shape_center = shape.respond_to?(:center) ? shape.center : shape.centroid
+  puts "    Center inside bbox? #{bbox.includes?(shape_center)}"
+  puts
+end
+
+# ── 9. Containment ──────────────────────────────────────────────
+
+puts "--- 9. Containment Testing ---"
+puts
+
+hex = Areas::Hexagon.new(center: washington, radius: 500)
+
+test_points = {
+  "Washington Monument" => washington,
+  "Lincoln Memorial"    => lincoln,
+  "White House"         => white_house,
+  "Pentagon"            => pentagon
+}
+
+puts "  Hexagon (500m radius around Washington Monument):"
+test_points.each do |name, point|
+  dist = washington.distance_to(point)
+  puts "    #{name.ljust(22)} inside? #{hex.includes?(point).to_s.ljust(5)}  (#{dist.to_s} away)"
+end
+puts
+
+# ── 10. Feature Integration ─────────────────────────────────────
+
+puts "--- 10. Feature Integration ---"
+puts
+
+seg_feature = Feature.new(label: "National Mall Axis", geometry: centerline)
+tri_feature = Feature.new(label: "Warning Zone", geometry: tri, metadata: { type: "restricted" })
+rect_feature = Feature.new(label: "Search Area", geometry: rect, metadata: { priority: "high" })
+
+puts "  Segment feature: #{seg_feature}"
+puts "  Triangle feature: #{tri_feature}"
+puts "  Rectangle feature: #{rect_feature}"
+puts
+
+puts "  Distance from each feature to the Pentagon:"
+[seg_feature, tri_feature, rect_feature].each do |f|
+  dist = f.distance_to(pentagon)
+  bearing = f.bearing_to(pentagon)
+  puts "    #{f.label.ljust(20)} #{dist.to_s.rjust(12)}  bearing #{bearing.to_s} (#{bearing.to_compass})"
+end
+puts
+
+puts "=== Done ==="

data/examples/README.md

@@ -76,10 +76,28 @@ 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

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/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