sevgi-geometry 0.95.0 → 1.0.0

data/lib/sevgi/geometry/operation/box.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Sevgi
+  module Geometry
+    module Operation
+      # Returns the smallest axis-aligned rectangle enclosing all elements.
+      #
+      # Each element contributes its existing {Sevgi::Geometry::Element#box},
+      # including zero-size boxes whose positions may still extend the result.
+      # @param elements [Array<Sevgi::Geometry::Element>] elements to enclose
+      # @return [Sevgi::Geometry::Rect] aggregate bounding rectangle
+      # @raise [Sevgi::ArgumentError] when no elements are given
+      # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when an argument is not a geometry element
+      # @example Enclose several geometry values
+      #   a = Sevgi::Geometry::Rect[10, 5, position: [2, 3]]
+      #   b = Sevgi::Geometry::Line.([-4, 8], [20, 12])
+      #   Sevgi::Geometry::Operation.box(a, b) # => Rect spanning both elements
+      def box(*elements)
+        validate_box_elements(elements)
+        boxes = elements.map(&:box)
+
+        Rect.from_corners(minimum_corner(boxes), maximum_corner(boxes))
+      end
+
+      private
+
+      def maximum_corner(boxes)
+        [
+          boxes.map { it.position.x + it.width }.max,
+          boxes.map { it.position.y + it.height }.max
+        ]
+      end
+
+      def minimum_corner(boxes)
+        [
+          boxes.map { it.position.x }.min,
+          boxes.map { it.position.y }.min
+        ]
+      end
+
+      def validate_box_elements(elements)
+        ArgumentError.("At least one geometric element required") if elements.empty?
+
+        elements.each do |element|
+          OperationInapplicableError.("Not a Geometric Element: #{element}") unless element.is_a?(Element)
+        end
+      end
+    end
+  end
+end

data/lib/sevgi/geometry/operation/sweep.rb

@@ -4,17 +4,18 @@ module Sevgi
   module Geometry
     module Operation
       # Sweep operation implementation.
+      # @api private
       module Sweep
         extend self
 
         # Default maximum number of sweep iterations.
         LIMIT = 1_000
 
-        # Sweeps parallel lines across a lined element in both directions.
+        # Sweeps parallel lines across a geometry element in both directions.
         #
         # Generated lines are boundary-to-boundary interior spans. A single
-        # sweep position can produce multiple lines for closed concave elements; open paths produce no interior lines.
-        # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+        # sweep position can produce multiple lines for closed concave elements. Open paths produce no interior lines.
+        # @param element [Sevgi::Geometry::Element] element to intersect
         # @param initial [Sevgi::Geometry::Point, Array<Numeric>] point on the initial sweep line
         # @param angle [Numeric] clockwise sweep line angle in degrees
         # @param step [Numeric] signed distance between sweep lines
@@ -23,9 +24,10 @@ module Sevgi
         # @yieldparam lines [Array<Sevgi::Geometry::Line>] generated sweep lines
         # @yieldreturn [void]
         # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
-        # @raise [Sevgi::Geometry::Error] when initial cannot be coerced
+        # @raise [Sevgi::Geometry::Error] when initial, angle, step, or limit is invalid
         # @raise [Sevgi::Geometry::Operation::OperationError] when iteration reaches the limit
         def sweep(element, initial:, angle:, step:, limit: LIMIT, &block)
+          step = validate_arguments(step, limit)
           equation = Tuple[Point, initial].equation(angle)
 
           [
@@ -36,11 +38,11 @@ module Sevgi
           end
         end
 
-        # Sweeps parallel lines across a lined element and requires at least one result.
+        # Sweeps parallel lines across a geometry element and requires at least one result.
         #
         # Generated lines are boundary-to-boundary interior spans. A single
-        # sweep position can produce multiple lines for closed concave elements; open paths produce no interior lines.
-        # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+        # sweep position can produce multiple lines for closed concave elements. Open paths produce no interior lines.
+        # @param element [Sevgi::Geometry::Element] element to intersect
         # @param initial [Sevgi::Geometry::Point, Array<Numeric>] point on the initial sweep line
         # @param angle [Numeric] clockwise sweep line angle in degrees
         # @param step [Numeric] signed distance between sweep lines
@@ -49,7 +51,7 @@ module Sevgi
         # @yieldparam lines [Array<Sevgi::Geometry::Line>] generated sweep lines
         # @yieldreturn [void]
         # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
-        # @raise [Sevgi::Geometry::Error] when initial cannot be coerced
+        # @raise [Sevgi::Geometry::Error] when initial, angle, step, or limit is invalid
         # @raise [Sevgi::Geometry::Operation::OperationError] when no lines are found or iteration reaches the limit
         def sweep!(element, initial:, angle:, step:, limit: LIMIT, &block)
           sweep(element, initial:, angle:, step:, limit:) do |lines|
@@ -64,14 +66,16 @@ module Sevgi
         # Sweeps parallel lines in one signed direction from an equation.
         #
         # Generated lines are boundary-to-boundary interior spans. A single
-        # sweep position can produce multiple lines for closed concave elements; open paths produce no interior lines.
-        # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+        # sweep position can produce multiple lines for closed concave elements. Open paths produce no interior lines.
+        # @param element [Sevgi::Geometry::Element] element to intersect
         # @param equation [Sevgi::Geometry::Equation] initial sweep equation
         # @param step [Numeric] signed distance between sweep lines
         # @param limit [Integer] maximum iterations
         # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
+        # @raise [Sevgi::Geometry::Error] when step or limit is invalid
         # @raise [Sevgi::Geometry::Operation::OperationError] when iteration reaches the limit
         def unisweep(element, equation, step, limit: LIMIT)
+          step = validate_arguments(step, limit)
           lines = []
 
           limit.times do
@@ -86,36 +90,46 @@ module Sevgi
           OperationError.("Loop limit reached: #{limit}")
         end
 
+        private :unisweep
+
         # Reports whether the sweep handler can operate on an element.
         # @api private
         # @param element [Object] candidate element
         # @return [Boolean]
         def applicable?(element)
-          element.respond_to?(:intersection)
+          element.respond_to?(:intersection) && element.respond_to?(:inside?) && element.respond_to?(:on?)
         end
 
         private
 
+        def validate_arguments(step, limit)
+          step = Real[:step, step]
+          Error.("Sweep step must be nonzero") if step.zero?
+          unless limit.is_a?(::Integer) && limit.positive?
+            Error.("Sweep limit must be a positive Integer: #{limit.inspect}")
+          end
+
+          step
+        end
+
         def interior_lines(element, equation, points)
-          return [] if element.class.respond_to?(:open?) && element.class.open?
+          return [] unless element.closed?
 
           if points.size == 2
+            return [] unless element.inside?(Point.midpoint(*points))
+
             line = simple_line(points)
 
             return line ? [line] : []
           end
 
           sorted_points(equation, points).each_cons(2).filter_map do |starting, ending|
-            next unless element.inside?(midpoint(starting, ending))
+            next unless element.inside?(Point.midpoint(starting, ending))
 
             simple_line([starting, ending])
           end
         end
 
-        def midpoint(starting, ending)
-          Point[(starting.x + ending.x) / 2.0, (starting.y + ending.y) / 2.0]
-        end
-
         def simple_line(points)
           line = Line.(*points)
 
@@ -129,7 +143,7 @@ module Sevgi
         end
       end
 
-      register(Sweep, :sweep, :sweep!, :unisweep)
+      register(Sweep, :sweep, :sweep!)
 
       private_constant :Sweep
     end

data/lib/sevgi/geometry/operation.rb

@@ -2,7 +2,13 @@
 
 module Sevgi
   module Geometry
-    # Dispatches geometry operations to operation handler modules.
+    # Stateless operations that relate or derive geometry values.
+    #
+    # `alignment` returns a translation offset, while `align` applies that
+    # offset to a copy. Center alignment works on both axes. Edge alignments
+    # change only the named axis and preserve the other coordinate. `sweep`
+    # derives boundary-to-boundary spans from a closed geometry element, and
+    # `sweep!` additionally requires at least one span.
     module Operation
       extend self
 
@@ -15,25 +21,37 @@ module Sevgi
       # @!parse
       #   class << self
       #     # Returns an element translated to align with another element.
+      #     # Center alignment changes both axes. Edge alignments change only the named axis.
       #     # @param element [Sevgi::Geometry::Element] element to move
       #     # @param other [Sevgi::Geometry::Element] reference element
       #     # @param alignment [Symbol] one of :center, :left, :right, :top, or :bottom
       #     # @return [Sevgi::Geometry::Element] translated element
       #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when an argument is not a geometry element
       #     # @raise [Sevgi::ArgumentError] when alignment is unknown
+      #     # @example Center one rectangle inside another
+      #     #   inner = Sevgi::Geometry::Rect[4, 2]
+      #     #   outer = Sevgi::Geometry::Rect[20, 10, position: [5, 5]]
+      #     #   Sevgi::Geometry::Operation.align(inner, outer).position.deconstruct # => [13.0, 9.0]
       #     def align(element, other, alignment = :center); end
       #
       #     # Returns the offset needed to align one element with another.
+      #     # Center alignment includes both axes. Edge alignments return zero on the other axis.
       #     # @param element [Sevgi::Geometry::Element] element to move
       #     # @param other [Sevgi::Geometry::Element] reference element
       #     # @param alignment [Symbol] one of :center, :left, :right, :top, or :bottom
       #     # @return [Sevgi::Geometry::Point] translation offset
       #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when an argument is not a geometry element
       #     # @raise [Sevgi::ArgumentError] when alignment is unknown
+      #     # @example Calculate an offset without moving the element
+      #     #   inner = Sevgi::Geometry::Rect[4, 2]
+      #     #   outer = Sevgi::Geometry::Rect[20, 10, position: [5, 5]]
+      #     #   Sevgi::Geometry::Operation.alignment(inner, outer, :bottom).approx.deconstruct # => [0.0, 13.0]
       #     def alignment(element, other, alignment = :center); end
       #
-      #     # Sweeps parallel lines across a lined element in both directions.
-      #     # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+      #     # Sweeps parallel lines across a geometry element in both directions.
+      #     # `angle` is the direction of the returned lines. `step` is their signed perpendicular spacing.
+      #     # Open paths yield no interior spans.
+      #     # @param element [Sevgi::Geometry::Element] element to intersect
       #     # @param initial [Sevgi::Geometry::Point, Array<Numeric>] point on the initial sweep line
       #     # @param angle [Numeric] clockwise sweep line angle in degrees
       #     # @param step [Numeric] signed distance between sweep lines
@@ -43,12 +61,18 @@ module Sevgi
       #     # @yieldreturn [void]
       #     # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
       #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when element is not sweepable
-      #     # @raise [Sevgi::Geometry::Error] when initial cannot be coerced
+      #     # @raise [Sevgi::Geometry::Error] when initial, angle, step, or limit is invalid
       #     # @raise [Sevgi::Geometry::Operation::OperationError] when iteration reaches the limit
+      #     # @example Generate horizontal spans through a rectangle
+      #     #   rect = Sevgi::Geometry::Rect[10, 6]
+      #     #   lines = Sevgi::Geometry::Operation.sweep(rect, initial: [0, 0], angle: 0, step: 2)
+      #     #   lines.size                # => 4
+      #     #   lines.map(&:length).uniq # => [10.0]
       #     def sweep(element, initial:, angle:, step:, limit: Sweep::LIMIT); end
       #
-      #     # Sweeps parallel lines across a lined element and requires at least one result.
-      #     # @param element [Sevgi::Geometry::Element::Lined] element to intersect
+      #     # Sweeps parallel lines across a geometry element and requires at least one result.
+      #     # It has the same geometry as {sweep}, but raises when the result is empty.
+      #     # @param element [Sevgi::Geometry::Element] element to intersect
       #     # @param initial [Sevgi::Geometry::Point, Array<Numeric>] point on the initial sweep line
       #     # @param angle [Numeric] clockwise sweep line angle in degrees
       #     # @param step [Numeric] signed distance between sweep lines
@@ -58,19 +82,9 @@ module Sevgi
       #     # @yieldreturn [void]
       #     # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
       #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when element is not sweepable
-      #     # @raise [Sevgi::Geometry::Error] when initial cannot be coerced
+      #     # @raise [Sevgi::Geometry::Error] when initial, angle, step, or limit is invalid
       #     # @raise [Sevgi::Geometry::Operation::OperationError] when no lines are found or iteration reaches the limit
       #     def sweep!(element, initial:, angle:, step:, limit: Sweep::LIMIT); end
-      #
-      #     # Sweeps parallel lines in one signed direction from an equation.
-      #     # @param element [Sevgi::Geometry::Element::Lined] element to intersect
-      #     # @param equation [Sevgi::Geometry::Equation] initial sweep equation
-      #     # @param step [Numeric] signed distance between sweep lines
-      #     # @param limit [Integer] maximum iterations
-      #     # @return [Array<Sevgi::Geometry::Line>] generated sweep lines
-      #     # @raise [Sevgi::Geometry::Operation::OperationInapplicableError] when element is not sweepable
-      #     # @raise [Sevgi::Geometry::Operation::OperationError] when iteration reaches the limit
-      #     def unisweep(element, equation, step, limit: Sweep::LIMIT); end
       #   end
       # Registers one or more public operation methods.
       # @api private
@@ -87,7 +101,7 @@ module Sevgi
         define_singleton_method(operation) do |element, *args, **kwargs, &block|
           OperationInapplicableError.("Not a Geometric Element: #{element}") unless element.is_a?(Element)
           unless handler.applicable?(element)
-            OperationInapplicableError.("Unapplicable operation for #{element}: #{handler}")
+            OperationInapplicableError.("Operation not applicable to #{element}: #{handler}")
           end
 
           handler.public_send(operation, element, *args, **kwargs, &block)
@@ -98,4 +112,5 @@ module Sevgi
 end
 
 require_relative "operation/align"
+require_relative "operation/box"
 require_relative "operation/sweep"

data/lib/sevgi/geometry/point.rb

@@ -2,7 +2,8 @@
 
 module Sevgi
   module Geometry
-    # Affine transforms shared by immutable geometry tuples.
+    # Implementation owner and registry for public affine transformations on Point and lined elements.
+    # @api private
     module Affinity
       # Reflects a point across the selected axes.
       #
@@ -11,45 +12,141 @@ module Sevgi
       # @param x [Boolean] reflect across the x-axis
       # @param y [Boolean] reflect across the y-axis
       # @return [Sevgi::Geometry::Point]
-      def reflect(x: true, y: true) = with(x: (y ? -1 : 1) * self.x(), y: (x ? -1 : 1) * self.y())
+      # @raise [Sevgi::Geometry::Error] when a flag is not Boolean
+      def reflect(x: true, y: true)
+        Error.("Reflection x flag must be Boolean") unless x.equal?(true) || x.equal?(false)
+        Error.("Reflection y flag must be Boolean") unless y.equal?(true) || y.equal?(false)
+
+        with(x: (y ? -1 : 1) * self.x(), y: (x ? -1 : 1) * self.y())
+      end
 
       # Rotates a point around the origin using screen-space degrees.
       # @param a [Numeric] clockwise angle in degrees
       # @return [Sevgi::Geometry::Point]
-      def rotate(a) = with(x: (x * F.cos(a)) - (y * F.sin(a)), y: (x * F.sin(a)) + (y * F.cos(a)))
+      # @raise [Sevgi::Geometry::Error] when angle is not a finite real number
+      def rotate(a)
+        a = Real[:angle, a]
+        with(x: (x * F.cos(a)) - (y * F.sin(a)), y: (x * F.sin(a)) + (y * F.cos(a)))
+      end
 
       # Scales a point from the origin.
       # @param sx [Numeric] x scale factor
       # @param sy [Numeric, Sevgi::Undefined] y scale factor, defaulting to sx
       # @return [Sevgi::Geometry::Point]
-      def scale(sx, sy = Undefined) = with(x: sx * x, y: Undefined.default(sy, sx) * y)
+      # @raise [Sevgi::Geometry::Error] when a scale is not a finite real number
+      def scale(sx, sy = Undefined)
+        sx = Real[:sx, sx]
+        sy = Real[:sy, Undefined.default(sy, sx)]
+        with(x: sx * x, y: sy * y)
+      end
 
       # Skews a point from the origin.
       # @param ax [Numeric] x-axis skew angle in degrees
       # @param ay [Numeric, Sevgi::Undefined] y-axis skew angle in degrees, defaulting to ax
       # @return [Sevgi::Geometry::Point]
-      def skew(ax, ay = Undefined) = with(x: x + (y * F.tan(ax)), y: y + (x * F.tan(Undefined.default(ay, ax))))
+      # @raise [Sevgi::Geometry::Error] when an angle is not a finite real number
+      def skew(ax, ay = Undefined)
+        ax = Real[:ax, ax]
+        ay = Real[:ay, Undefined.default(ay, ax)]
+        with(x: x + (y * F.tan(ax)), y: y + (x * F.tan(ay)))
+      end
 
       # Skews a point along x.
       # @param a [Numeric] skew angle in degrees
       # @return [Sevgi::Geometry::Point]
-      def skew_x(a) = with(x: x + (y * F.tan(a)))
+      # @raise [Sevgi::Geometry::Error] when angle is not a finite real number
+      def skew_x(a) = with(x: x + (y * F.tan(Real[:angle, a])))
 
       # Skews a point along y.
       # @param a [Numeric] skew angle in degrees
       # @return [Sevgi::Geometry::Point]
-      def skew_y(a) = with(y: y + (x * F.tan(a)))
+      # @raise [Sevgi::Geometry::Error] when angle is not a finite real number
+      def skew_y(a) = with(y: y + (x * F.tan(Real[:angle, a])))
 
       # Translates a point.
       # @param dx [Numeric] x offset
       # @param dy [Numeric, Sevgi::Undefined] y offset, defaulting to dx
       # @return [Sevgi::Geometry::Point]
-      def translate(dx, dy = Undefined) = with(x: x + dx, y: y + Undefined.default(dy, dx))
+      # @raise [Sevgi::Geometry::Error] when an offset is not a finite real number
+      def translate(dx, dy = Undefined)
+        dx = Real[:dx, dx]
+        dy = Real[:dy, Undefined.default(dy, dx)]
+        with(x: x + dx, y: y + dy)
+      end
     end
 
     # Immutable point in SVG/screen coordinates.
     #
-    # Use `Point[x, y]` to create a point from two coordinates.
+    # Use `Point[x, y]` to create a point from two coordinates. Public geometry
+    # methods that expect a point also accept `[x, y]`. Explicit Point values are
+    # most useful when a result will be transformed, compared, or reused.
+    # @example Measure and rotate a point in screen coordinates
+    #   point = Sevgi::Geometry::Point[3, 4]
+    #   Sevgi::Geometry::Point.length(Sevgi::Geometry::Origin, point) # => 5.0
+    #   point.rotate(90).approx.deconstruct # => [-4.0, 3.0]
+    # @example Compare positions in screen coordinates
+    #   upper = Sevgi::Geometry::Point[4, 2]
+    #   lower = Sevgi::Geometry::Point[4, 8]
+    #   upper.above?(lower) # => true
+    #   upper.left?([6, 2]) # => true
+    # @see Sevgi::Geometry::Segment
+    # @!parse
+    #   class Point
+    #     # Creates a point from two coordinates.
+    #     # @param x [Numeric] x coordinate
+    #     # @param y [Numeric] y coordinate
+    #     # @return [Sevgi::Geometry::Point]
+    #     # @raise [Sevgi::Geometry::Error] when a coordinate is not a finite Numeric
+    #     # @example Create a point with mathematical notation
+    #     #   Sevgi::Geometry::Point[3, 5]
+    #     def self.[](x, y); end
+    #
+    #     # Returns a point reflected across the selected axes.
+    #     # @param x [Boolean] reflect across the x-axis
+    #     # @param y [Boolean] reflect across the y-axis
+    #     # @return [Sevgi::Geometry::Point]
+    #     # @raise [Sevgi::Geometry::Error] when a flag is not Boolean
+    #     def reflect(x: true, y: true); end
+    #
+    #     # Returns a point rotated around the origin.
+    #     # @param a [Numeric] clockwise angle in degrees
+    #     # @return [Sevgi::Geometry::Point]
+    #     # @raise [Sevgi::Geometry::Error] when angle is not a finite real number
+    #     def rotate(a); end
+    #
+    #     # Returns a point scaled from the origin.
+    #     # @param sx [Numeric] x scale factor
+    #     # @param sy [Numeric, Sevgi::Undefined] y scale factor, defaulting to sx
+    #     # @return [Sevgi::Geometry::Point]
+    #     # @raise [Sevgi::Geometry::Error] when a scale is not a finite real number
+    #     def scale(sx, sy = Undefined); end
+    #
+    #     # Returns a point skewed from the origin.
+    #     # @param ax [Numeric] x-axis skew angle in degrees
+    #     # @param ay [Numeric, Sevgi::Undefined] y-axis skew angle in degrees, defaulting to ax
+    #     # @return [Sevgi::Geometry::Point]
+    #     # @raise [Sevgi::Geometry::Error] when an angle is not a finite real number
+    #     def skew(ax, ay = Undefined); end
+    #
+    #     # Returns a point skewed along x.
+    #     # @param a [Numeric] skew angle in degrees
+    #     # @return [Sevgi::Geometry::Point]
+    #     # @raise [Sevgi::Geometry::Error] when angle is not a finite real number
+    #     def skew_x(a); end
+    #
+    #     # Returns a point skewed along y.
+    #     # @param a [Numeric] skew angle in degrees
+    #     # @return [Sevgi::Geometry::Point]
+    #     # @raise [Sevgi::Geometry::Error] when angle is not a finite real number
+    #     def skew_y(a); end
+    #
+    #     # Returns a translated point.
+    #     # @param dx [Numeric] x offset
+    #     # @param dy [Numeric, Sevgi::Undefined] y offset, defaulting to dx
+    #     # @return [Sevgi::Geometry::Point]
+    #     # @raise [Sevgi::Geometry::Error] when an offset is not a finite real number
+    #     def translate(dx, dy = Undefined); end
+    #   end
     Point = Data.define(:x, :y) do
       include Comparable
       include Affinity
@@ -87,7 +184,17 @@ module Sevgi
       # @raise [Sevgi::Geometry::Error] when either point cannot be coerced
       def self.length(starting, ending)
         starting, ending = Tuples[Point, starting, ending]
-        ::Math.sqrt(((starting.y - ending.y) ** 2) + ((starting.x - ending.x) ** 2))
+        ::Math.hypot(starting.x - ending.x, starting.y - ending.y)
+      end
+
+      # Returns the midpoint between two points.
+      # @param starting [Sevgi::Geometry::Point, Array<Numeric>] first point
+      # @param ending [Sevgi::Geometry::Point, Array<Numeric>] second point
+      # @return [Sevgi::Geometry::Point] midpoint
+      # @raise [Sevgi::Geometry::Error] when either point cannot be coerced
+      def self.midpoint(starting, ending)
+        starting, ending = Tuples[Point, starting, ending]
+        self[(starting.x / 2.0) + (ending.x / 2.0), (starting.y / 2.0) + (ending.y / 2.0)]
       end
 
       # Returns the origin point.
@@ -104,10 +211,13 @@ module Sevgi
       def initialize(x:, y:) = super(x: Real[:x, x], y: Real[:y, y])
 
       # Compares points by x, then y.
-      # @param other [Sevgi::Geometry::Point, Array<Numeric>] point to compare
-      # @return [Integer, nil]
-      # @raise [Sevgi::Geometry::Error] when other cannot be coerced
-      def <=>(other) = deconstruct <=> Tuple[Point, other].deconstruct
+      # @param other [Object] point or two-item coordinate array to compare
+      # @return [Integer, nil] comparison result, or nil when other is not a valid point value
+      def <=>(other)
+        deconstruct <=> Tuple[Point, other].deconstruct
+      rescue Error
+        nil
+      end
 
       # Reports whether this point is at or above another point in screen coordinates.
       # @param other [Sevgi::Geometry::Point, Array<Numeric>] point to compare
@@ -165,6 +275,8 @@ module Sevgi
       alias_method :==, :eql?
     end
 
+    private_constant :Affinity
+
     # Origin point in SVG/screen coordinates.
     Origin = Point.origin
   end