compat_geom2d 0.1.0

data/lib/geom2d/bounding_box.rb

@@ -0,0 +1,84 @@
+# -*- frozen_string_literal: true -*-
+#
+#--
+# geom2d - 2D Geometric Objects and Algorithms
+# Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+#
+# This software may be modified and distributed under the terms
+# of the MIT license.  See the LICENSE file for details.
+#++
+
+module Geom2D
+
+  # Represents an axis aligned bounding box.
+  #
+  # An empty bounding box contains just the point at origin.
+  class BoundingBox
+
+    # The minimum x-coordinate.
+    attr_reader :min_x
+
+    # The minimum y-coordinate.
+    attr_reader :min_y
+
+    # The maximum x-coordinate.
+    attr_reader :max_x
+
+    # The maximum y-coordinate.
+    attr_reader :max_y
+
+    # Creates a new BoundingBox.
+    def initialize(min_x = 0, min_y = 0, max_x = 0, max_y = 0)
+      @min_x = min_x
+      @min_y = min_y
+      @max_x = max_x
+      @max_y = max_y
+    end
+
+    # Updates this bounding box to also contain the given bounding box or point.
+    def add!(other)
+      case other
+      when BoundingBox
+        @min_x = [min_x, other.min_x].min
+        @min_y = [min_y, other.min_y].min
+        @max_x = [max_x, other.max_x].max
+        @max_y = [max_y, other.max_y].max
+      when Point
+        @min_x = [min_x, other.x].min
+        @min_y = [min_y, other.y].min
+        @max_x = [max_x, other.x].max
+        @max_y = [max_y, other.y].max
+      else
+        raise ArgumentError, "Can only use another BoundingBox or Point"
+      end
+      self
+    end
+
+    # Returns the width of the bounding box.
+    def width
+      @max_x - @min_x
+    end
+
+    # Returns the height of the bounding box.
+    def height
+      @max_y - @min_y
+    end
+
+    # Returns a bounding box containing this bounding box and the argument.
+    def add(other)
+      dup.add!(other)
+    end
+    alias + add
+
+    # Returns the bounding box as an array of the form [min_x, min_y, max_x, max_y].
+    def to_a
+      [@min_x, @min_y, @max_x, @max_y]
+    end
+
+    def inspect #:nodoc:
+      "BBox[#{min_x}, #{min_y}, #{max_x}, #{max_y}]"
+    end
+
+  end
+
+end

data/lib/geom2d/point.rb

@@ -0,0 +1,145 @@
+# -*- frozen_string_literal: true -*-
+#
+#--
+# geom2d - 2D Geometric Objects and Algorithms
+# Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+#
+# This software may be modified and distributed under the terms
+# of the MIT license.  See the LICENSE file for details.
+#++
+
+require 'geom2d'
+
+module Geom2D
+
+  # Represents a point.
+  class Point
+
+    include Utils
+
+    # The x-coordinate.
+    attr_reader :x
+
+    # The y-coordinate.
+    attr_reader :y
+
+    # Creates a new Point from the given coordinates.
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+
+    # Returns the point's bounding box (i.e. a bounding box containing only the point itself).
+    def bbox
+      BoundingBox.new(x, y, x, y)
+    end
+
+    # Returns the distance from this point to the given point.
+    def distance(point)
+      Math.hypot(point.x - x, point.y - y)
+    end
+
+    # Returns self.
+    def +@
+      self
+    end
+
+    # Returns the point mirrored in the origin.
+    def -@
+      Point.new(-x, -y)
+    end
+
+    # Depending on the type of the argument, either adds a number to each coordinate or adds two
+    # points.
+    def +(other)
+      case other
+      when Point
+        Point.new(x + other.x, y + other.y)
+      when Numeric
+        Point.new(x + other, y + other)
+      when Array
+        self + Geom2D::Point(other)
+      else
+        raise ArgumentError, "Invalid argument class, must be Numeric or Point"
+      end
+    end
+
+    # Depending on the type of the argument, either subtracts a number from each coordinate or
+    # subtracts the other point from this one.
+    def -(other)
+      case other
+      when Point
+        Point.new(x - other.x, y - other.y)
+      when Numeric
+        Point.new(x - other, y - other)
+      when Array
+        self - Geom2D::Point(other)
+      else
+        raise ArgumentError, "Invalid argument class, must be Numeric or Point"
+      end
+    end
+
+    # Depending on the type of the argument, either multiplies this point with the other point (dot
+    # product) or multiplies each coordinate with the given number.
+    def *(other)
+      case other
+      when Point
+        x * other.x + y * other.y
+      when Numeric
+        Point.new(x * other, y * other)
+      when Array
+        self * Geom2D::Point(other)
+      else
+        raise ArgumentError, "Invalid argument class, must be Numeric or Point"
+      end
+    end
+
+    # Multiplies this point with the other point using the dot product.
+    def dot(other)
+      self * other
+    end
+
+    # Performs the wedge product of this point with the other point.
+    def wedge(other)
+      other = Geom2D::Point(other)
+      x * other.y - other.x * y
+    end
+
+    # Divides each coordinate by the given number.
+    def /(other)
+      case other
+      when Numeric
+        Point.new(x / other.to_f, y / other.to_f)
+      else
+        raise ArgumentError, "Invalid argument class, must be Numeric"
+      end
+    end
+
+    # Compares this point to the other point, using floating point equality.
+    #
+    # See Utils#float_equal.
+    def ==(other)
+      case other
+      when Point
+        float_equal(x, other.x) && float_equal(y, other.y)
+      when Array
+        self == Geom2D::Point(other)
+      else
+        false
+      end
+    end
+
+    # Allows destructuring of a point into an array.
+    def to_ary
+      [x, y]
+    end
+    alias to_a to_ary
+
+    def inspect #:nodoc:
+      "(#{x}, #{y})"
+    end
+    alias to_s inspect
+
+  end
+
+end

data/lib/geom2d/polygon.rb

@@ -0,0 +1,108 @@
+# -*- frozen_string_literal: true -*-
+#
+#--
+# geom2d - 2D Geometric Objects and Algorithms
+# Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+#
+# This software may be modified and distributed under the terms
+# of the MIT license.  See the LICENSE file for details.
+#++
+
+require 'geom2d'
+
+module Geom2D
+
+  # Represents a polygon.
+  class Polygon
+
+    # Creates a new Polygon object. The +vertices+ argument has to be an array of point-like
+    # objects.
+    def initialize(vertices = [])
+      @vertices = []
+      vertices.each {|value| @vertices << Geom2D::Point(value) }
+    end
+
+    # Returns one since a polygon object represents a single polygon.
+    def nr_of_contours
+      1
+    end
+
+    # Returns the number of vertices in the polygon.
+    def nr_of_vertices
+      @vertices.size
+    end
+
+    # Returns the i-th vertex of the polygon.
+    def [](i)
+      @vertices[i]
+    end
+
+    # Adds a new vertex to the end of the polygon.
+    def add(x, y = nil)
+      @vertices << Geom2D::Point(x, y)
+      self
+    end
+    alias << add
+
+    # Removes the last vertex of the polygon.
+    def pop
+      @vertices.pop
+    end
+
+    # Calls the given block once for each vertex of the polygon.
+    #
+    # If no block is given, an Enumerator is returned.
+    def each_vertex(&block)
+      return to_enum(__method__) unless block_given?
+      @vertices.each(&block)
+    end
+
+    # Calls the given block once for each segment in the polygon.
+    #
+    # If no block is given, an Enumerator is returned.
+    def each_segment
+      return to_enum(__method__) unless block_given?
+      return unless @vertices.size > 1
+
+      0.upto(@vertices.size - 2) do |i|
+        yield(Geom2D::Segment(@vertices[i], @vertices[i + 1]))
+      end
+      yield(Geom2D::Segment(@vertices[-1], @vertices[0]))
+    end
+
+    # Returns the BoundingBox of this polygon, or an empty BoundingBox if the polygon has no
+    # vertices.
+    def bbox
+      return BoundingBox.new if @vertices.empty?
+      result = @vertices.first.bbox
+      @vertices[1..-1].each {|v| result.add!(v) }
+      result
+    end
+
+    # Returns +true+ if the vertices of the polygon are ordered in a counterclockwise fashion.
+    def ccw?
+      return true if @vertices.empty?
+      area = @vertices[-1].wedge(@vertices[0])
+      1.upto(@vertices.size - 2) {|i| area += @vertices[i].wedge(@vertices[i + 1]) }
+      area >= 0
+    end
+
+    # Reverses the direction of the vertices (and therefore the segments).
+    def reverse!
+      @vertices.reverse!
+    end
+
+    # Returns an array with the vertices of the polygon.
+    def to_ary
+      @vertices.dup
+    end
+    alias to_a to_ary
+
+    def inspect #:nodoc:
+      "Polygon#{@vertices}"
+    end
+    alias to_s inspect
+
+  end
+
+end

data/lib/geom2d/polygon_set.rb

@@ -0,0 +1,67 @@
+# -*- frozen_string_literal: true -*-
+#
+#--
+# geom2d - 2D Geometric Objects and Algorithms
+# Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+#
+# This software may be modified and distributed under the terms
+# of the MIT license.  See the LICENSE file for details.
+#++
+
+require 'geom2d/polygon'
+
+module Geom2D
+
+  # Represents a set of polygons.
+  class PolygonSet
+
+    # The array of polygons.
+    attr_reader :polygons
+
+    # Creates a new PolygonSet with the given polygons.
+    def initialize(polygons = [])
+      @polygons = polygons
+    end
+
+    # Adds a polygon to this set.
+    def add(polygon)
+      @polygons << polygon
+      self
+    end
+    alias << add
+
+    # Creates a new polygon set by combining the polygons from this set and the other one.
+    def join(other)
+      PolygonSet.new(@polygons + other.polygons)
+    end
+    alias + join
+
+    # Calls the given block once for each segment of each polygon in the set.
+    #
+    # If no block is given, an Enumerator is returned.
+    def each_segment(&block)
+      return to_enum(__method__) unless block_given?
+      @polygons.each {|polygon| polygon.each_segment(&block) }
+    end
+
+    # Returns the number of polygons in this set.
+    def nr_of_contours
+      @polygons.size
+    end
+
+    # Returns the BoundingBox of all polygons in the set, or +nil+ if it contains no polygon.
+    def bbox
+      return BoundingBox.new if @polygons.empty?
+      result = @polygons.first.bbox
+      @polygons[1..-1].each {|v| result.add!(v.bbox) }
+      result
+    end
+
+    def inspect #:nodoc:
+      "PolygonSet#{@polygons}"
+    end
+    alias to_s inspect
+
+  end
+
+end

data/lib/geom2d/segment.rb

@@ -0,0 +1,202 @@
+# -*- frozen_string_literal: true -*-
+#
+#--
+# geom2d - 2D Geometric Objects and Algorithms
+# Copyright (C) 2018 Thomas Leitner <t_leitner@gmx.at>
+#
+# This software may be modified and distributed under the terms
+# of the MIT license.  See the LICENSE file for details.
+#++
+
+require 'geom2d'
+
+module Geom2D
+
+  # Represents a line segment.
+  class Segment
+
+    include Utils
+
+    # The start point of the segment.
+    attr_reader :start_point
+
+    # The end point of the segment.
+    attr_reader :end_point
+
+    # Creates a new Segment from the start to the end point. The arguments are converted to proper
+    # Geom2D::Point objects if needed.
+    def initialize(start_point, end_point)
+      @start_point = Geom2D::Point(start_point)
+      @end_point = Geom2D::Point(end_point)
+    end
+
+    # Returns +true+ if the segment is degenerate, i.e. if it consists only of a point.
+    def degenerate?
+      @start_point == @end_point
+    end
+
+    # Returns +true+ if the segment is vertical.
+    def vertical?
+      float_equal(start_point.x, end_point.x)
+    end
+
+    # Returns +true+ if the segment is horizontal.
+    def horizontal?
+      float_equal(start_point.y, end_point.y)
+    end
+
+    # Returns the left-most bottom-most point of the segment (either the start or the end point).
+    def min
+      if start_point.x < end_point.x ||
+          (float_equal(start_point.x, end_point.x) && start_point.y < end_point.y)
+        start_point
+      else
+        end_point
+      end
+    end
+
+    # Returns the right-most top-most point of the segment (either the start or the end point).
+    def max
+      if start_point.x > end_point.x ||
+          (float_equal(start_point.x, end_point.x) && start_point.y > end_point.y)
+        start_point
+      else
+        end_point
+      end
+    end
+
+    # Returns the length of the segment.
+    def length
+      start_point.distance(end_point)
+    end
+
+    # Returns the direction vector of the segment as Geom2D::Point object.
+    def direction
+      end_point - start_point
+    end
+
+    # Returns the slope of the segment.
+    #
+    # If the segment is vertical, Float::INFINITY is returned.
+    def slope
+      if float_equal(start_point.x, end_point.x)
+        Float::INFINITY
+      else
+        (end_point.y - start_point.y).to_f / (end_point.x - start_point.x)
+      end
+    end
+
+    # Returns the y-intercept, i.e. the point on the y-axis where the segment does/would intercept
+    # it.
+    def y_intercept
+      slope = self.slope
+      if slope == Float::INFINITY
+        nil
+      else
+        -start_point.x * slope + start_point.y
+      end
+    end
+
+    # Reverses the start and end point.
+    def reverse!
+      @start_point, @end_point = @end_point, @start_point
+    end
+
+    # Returns the intersection of this segment with the given one:
+    #
+    # +nil+:: No intersections
+    # Geom2D::Point:: Exactly one point
+    # Geom2D::Segment:: The segment overlapping both other segments.
+    def intersect(segment)
+      p0 = start_point
+      p1 = segment.start_point
+      d0 = direction
+      d1 = segment.direction
+      e = p1 - p0
+
+      cross = d0.wedge(d1).to_f # cross product of direction vectors
+
+      if cross.abs > Utils.precision # segments are not parallel
+        s = e.wedge(d1) / cross
+        return nil if s < 0 || s > 1
+        t = e.wedge(d0) / cross
+        return nil if t < 0 || t > 1
+
+        result = p0 + [s * d0.x, s * d0.y]
+        result = start_point if result == start_point
+        result = end_point if result == end_point
+        result = segment.start_point if result == segment.start_point
+        result = segment.end_point if result == segment.end_point
+        return result
+      end
+
+      return nil if e.wedge(d0).abs > Utils.precision # non-intersecting parallel segment lines
+
+      e0 = end_point
+      e1 = segment.end_point
+
+      # sort segment points by x-value
+      p0, e0 = e0, p0 if float_compare(p0.x, e0.x) > 0
+      p1, e1 = e1, p1 if float_compare(p1.x, e1.x) > 0
+      if float_compare(p0.x, p1.x) > 0
+        _p0, p1, e0, e1 = p1, p0, e1, e0
+      end
+
+      # p0 before or equal to p1
+      if float_compare(e0.x, p1.x) < 0     # e0 before p1
+        nil                                # no common point
+      elsif float_compare(e1.x, e0.x) <= 0 # e1 before or equal to e0
+        self.class.new(p1, e1)             # p1-e1 inside p0-e0
+      elsif float_compare(p1.x, e0.x) == 0 # common endpoint p1=e0
+        p1
+      else
+        self.class.new(p1, e0)             # s1 overlaps end of s0
+      end
+    end
+
+    # Returns self.
+    def +@
+      self
+    end
+
+    # Returns the segment mirrored in the origin.
+    def -@
+      Segment.new(-start_point, -end_point)
+    end
+
+    # Adds the given vector (given as array or Geom2D::Point) to the segment, i.e. performs a
+    # translation.
+    def +(other)
+      case other
+      when Point, Array
+        Segment.new(start_point + other, end_point + other)
+      else
+        raise ArgumentError, "Invalid argument class, must be Point"
+      end
+    end
+
+    # Subtracts the given vector (given as array or Geom2D::Point) from the segment, i.e. performs a
+    # translation.
+    def -(other)
+      case other
+      when Point, Array
+        Segment.new(start_point - other, end_point - other)
+      else
+        raise ArgumentError, "Invalid argument class, must be Point"
+      end
+    end
+
+    # Compares this segment to the other, returning true if the end points match.
+    def ==(other)
+      return false unless other.kind_of?(Segment)
+      start_point == other.start_point && end_point == other.end_point
+    end
+
+    def inspect #:nodoc:
+      "Segment[#{start_point}-#{end_point}]"
+    end
+    alias to_s inspect
+
+  end
+
+end