ruby-geometry 0.0.2

data/lib/comparison_with_precision.rb

@@ -0,0 +1,11 @@
+class Float
+  def ===(other)
+    (self - other).abs <= Float::EPSILON * 2
+  end
+end
+
+class Fixnum
+  def ===(other)
+    self == other
+  end
+end

data/lib/geometry.rb

@@ -0,0 +1,16 @@
+require 'point'
+require 'segment'
+require 'vector'
+require 'polygon'
+require 'line'
+
+module Geometry
+  include Math
+  extend Math
+  
+  def distance(point1, point2)
+    hypot point1.x - point2.x, point1.y - point2.y
+  end
+
+  module_function :distance
+end

data/lib/line.rb

@@ -0,0 +1,81 @@
+module Geometry
+  class Line < Struct.new(:point1, :point2)
+    def self.new_by_arrays(point1_coordinates, point2_coordinates)
+      self.new(Point.new_by_array(point1_coordinates), 
+               Point.new_by_array(point2_coordinates))
+    end
+
+    def slope
+      dy = Float(point2.y - point1.y)
+      dx = Float(point2.x - point1.x)
+
+      return 0.0 if dy == 0
+
+      dy / dx
+    end
+
+    def y_intercept
+      return nil if vertical?
+
+      # compute change in y between point1 and the origin
+      dy = point1.x * slope
+      point1.y - dy
+    end
+
+    def x_intercept
+      return nil if horizontal?
+
+      # compute change in x between point1 and the origin
+      dx = point1.y / slope
+      point1.x - dx
+    end
+
+    def parallel_to?(other)
+      # Special handling for when one slope is inf and the other is -inf:
+      return true if slope.infinite? and other.slope.infinite?
+
+      slope == other.slope
+    end
+    
+    def vertical?
+      if slope.infinite?
+        return true
+      else
+        return false
+      end
+    end
+
+    def horizontal?
+      slope == 0
+    end
+
+    def intersect_x(other)
+      if vertical? and other.vertical?
+        if x_intercept == other.x_intercept
+          return x_intercept
+        else
+          return nil
+        end
+      end
+
+      return nil if horizontal? and other.horizontal?
+
+      return x_intercept if vertical?
+      return other.x_intercept if other.vertical?
+
+      d_intercept = other.y_intercept - y_intercept
+      d_slope = slope - other.slope
+
+      # if d_intercept and d_slope are both 0, the result is NaN, which indicates
+      # the lines are identical
+      d_intercept / d_slope
+    end
+
+    def angle_to(other)
+      # return absolute difference between angles to horizontal of self and other
+      sa = Math::atan(slope)
+      oa = Math::atan(other.slope)
+      (sa-oa).abs
+    end
+  end
+end

data/lib/point.rb

@@ -0,0 +1,11 @@
+module Geometry
+  class Point < Struct.new(:x, :y)
+    def self.new_by_array(array)      
+      self.new(array[0], array[1])
+    end
+
+    def ==(another_point)
+      x === another_point.x && y === another_point.y
+    end
+  end
+end

data/lib/polygon.rb

@@ -0,0 +1,13 @@
+module Geometry
+  class Polygon < Struct.new(:vertices)
+    def edges
+      edges = []
+
+      1.upto(vertices.length - 1) do |vertex_index|
+        edges << Segment.new(vertices[vertex_index - 1], vertices[vertex_index])
+      end
+
+      edges << Segment.new(vertices.last, vertices.first)
+    end
+  end
+end

data/lib/segment.rb

@@ -0,0 +1,105 @@
+module Geometry
+  class SegmentsDoNotIntersect < Exception; end
+  class SegmentsOverlap < Exception; end
+  
+  class Segment < Struct.new(:point1, :point2)
+    def self.new_by_arrays(point1_coordinates, point2_coordinates)
+      self.new(Point.new_by_array(point1_coordinates), 
+               Point.new_by_array(point2_coordinates))
+    end
+
+    def leftmost_endpoint
+      ((point1.x <=> point2.x) == -1) ? point1 : point2
+    end
+
+    def rightmost_endpoint
+      ((point1.x <=> point2.x) == 1) ? point1 : point2
+    end
+
+    def topmost_endpoint
+      ((point1.y <=> point2.y) == 1) ? point1 : point2
+    end
+
+    def bottommost_endpoint
+      ((point1.y <=> point2.y) == -1) ? point1 : point2
+    end
+ 
+    def contains_point?(point)      
+      Geometry.distance(point1, point2) ===
+        Geometry.distance(point1, point) + Geometry.distance(point, point2)
+    end
+
+    def parallel_to?(segment)
+      to_vector.collinear_with?(segment.to_vector)
+    end
+
+    def lies_on_one_line_with?(segment)
+      Segment.new(point1, segment.point1).parallel_to?(self) &&
+        Segment.new(point1, segment.point2).parallel_to?(self)
+    end
+
+    def intersects_with?(segment)
+      Segment.have_intersecting_bounds?(self, segment) &&
+        lies_on_line_intersecting?(segment) &&
+        segment.lies_on_line_intersecting?(self)
+    end
+    
+    def overlaps?(segment)
+      Segment.have_intersecting_bounds?(self, segment) &&
+        lies_on_one_line_with?(segment)
+    end
+    
+    def intersection_point_with(segment)
+      raise SegmentsDoNotIntersect unless intersects_with?(segment)
+      raise SegmentsOverlap if overlaps?(segment)
+      
+      numerator = (segment.point1.y - point1.y) * (segment.point1.x - segment.point2.x) -
+        (segment.point1.y - segment.point2.y) * (segment.point1.x - point1.x);
+      denominator = (point2.y - point1.y) * (segment.point1.x - segment.point2.x) - 
+        (segment.point1.y - segment.point2.y) * (point2.x - point1.x);
+
+      t = numerator.to_f / denominator;
+      
+      x = point1.x + t * (point2.x - point1.x)
+      y = point1.y + t * (point2.y - point1.y)            
+      
+      Point.new(x, y)
+    end
+
+    def length      
+      Geometry.distance(point1, point2)
+    end
+
+    def to_vector
+      Vector.new(point2.x - point1.x, point2.y - point1.y)
+    end        
+
+  protected
+
+    def self.have_intersecting_bounds?(segment1, segment2)
+      intersects_on_x_axis =
+        (segment1.leftmost_endpoint.x < segment2.rightmost_endpoint.x ||
+        segment1.leftmost_endpoint.x == segment2.rightmost_endpoint.x) &&
+        (segment2.leftmost_endpoint.x < segment1.rightmost_endpoint.x ||
+        segment2.leftmost_endpoint.x == segment1.rightmost_endpoint.x)
+    
+      intersects_on_y_axis =
+        (segment1.bottommost_endpoint.y < segment2.topmost_endpoint.y ||
+        segment1.bottommost_endpoint.y == segment2.topmost_endpoint.y) &&
+        (segment2.bottommost_endpoint.y < segment1.topmost_endpoint.y ||
+        segment2.bottommost_endpoint.y == segment1.topmost_endpoint.y)
+
+      intersects_on_x_axis && intersects_on_y_axis
+    end
+
+    def lies_on_line_intersecting?(segment)
+      vector_to_first_endpoint = Segment.new(self.point1, segment.point1).to_vector
+      vector_to_second_endpoint = Segment.new(self.point1, segment.point2).to_vector
+
+      #FIXME: '>=' and '<=' method of Fixnum and Float should be overriden too (take precision into account)
+      # there is a rare case, when this method is wrong due to precision
+      self.to_vector.cross_product(vector_to_first_endpoint) *
+        self.to_vector.cross_product(vector_to_second_endpoint) <= 0
+    end
+  end
+end

data/lib/vector.rb

@@ -0,0 +1,50 @@
+module Geometry
+  class Vector < Struct.new(:x, :y)
+    def ==(vector)
+      x === vector.x && y === vector.y
+    end        
+    
+    # Modulus of vector. Also known as length, size or norm
+    def modulus      
+      Math.hypot(x ,y)
+    end
+
+    # z-coordinate of cross product (also known as vector product or outer product)
+    # It is positive if other vector should be turned counter-clockwise in order to superpose them.
+    # It is negetive if other vector should be turned clockwise in order to superpose them.
+    # It is zero when vectors are collinear.
+    # Remark: x- and y- coordinates of plane vectors cross product are always zero
+    def cross_product(vector)
+      x * vector.y - y * vector.x
+    end
+
+    # Scalar product, also known as inner product or dot product
+    def scalar_product(vector)
+      x * vector.x + y * vector.y
+    end
+    
+    def collinear_with?(vector)
+      cross_product(vector) === 0
+    end
+
+    def +(vector)
+      Vector.new(x + vector.x, y + vector.y)
+    end
+
+    def -(vector)
+      self + (-1) * vector
+    end
+
+    def *(scalar)      
+      Vector.new(x * scalar, y * scalar)
+    end
+
+    def coerce(scalar)      
+      if scalar.is_a?(Numeric)
+        [self, scalar]
+      else
+        raise ArgumentError, "Vector: cannot coerce #{scalar.inspect}"
+      end             
+    end
+  end
+end

data/test/geometry/distance_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'geometry'
+
+class DistanceTest < Test::Unit::TestCase
+  include Geometry
+
+  def test_trivial_cases    
+    assert 1 === distance(Point.new(1, 1), Point.new(1, 2))
+
+    assert 1 === distance(Point.new(1, 1), Point.new(2, 1))
+
+    assert sqrt(2) === distance(Point.new(1, 1), Point.new(2, 2))
+  end    
+end

data/test/line/angle_to_test.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'geometry'
+
+class AngleToTest < Test::Unit::TestCase
+  include Geometry
+
+  def test_angle_to_self
+    line = Line.new_by_arrays([0, 0], [1, 1])
+    assert_equal 0, line.angle_to(line)
+  end
+
+  def test_angle_to_perpendicular
+    line = Line.new_by_arrays([0, 0], [1, 1])
+    perp = Line.new_by_arrays([0, 0], [1, -1])
+    assert_equal Math::PI/2, line.angle_to(perp)
+    assert_equal Math::PI/2, perp.angle_to(line)
+  end
+
+  def test_angle_to_acute
+    line = Line.new_by_arrays([0, 0], [1, 1])
+    acute = Line.new_by_arrays([0, 0], [0, 1])
+    assert_equal Math::PI/4, line.angle_to(acute)
+    assert_equal Math::PI/4, acute.angle_to(line)
+  end
+end

data/test/line/horizontal_test.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'geometry'
+
+class HorizontalTest < Test::Unit::TestCase
+  include Geometry
+
+  def test_horizontal
+    x, y = 0, 0
+    l1 = Line.new_by_arrays([x, y], [x+1, y])
+    assert l1.horizontal?
+  end
+
+  def test_not_horizontal
+    x, y = 0, 0
+    l1 = Line.new_by_arrays([x, y], [x+1, y+1])
+    assert ! l1.horizontal?
+  end
+end

data/test/line/initialize_test.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+require 'geometry'
+
+class InitializeTest < Test::Unit::TestCase
+  include Geometry
+
+  def test_initialize_by_points
+    line = Line.new(Point.new(1, 2), Point.new(3, 4))
+
+    assert_equal Point.new(1, 2), line.point1
+    assert_equal Point.new(3, 4), line.point2
+  end
+
+  def test_initialize_by_points_coordinates_arrays
+    line = Line.new_by_arrays([1, 2], [3, 4])
+
+    assert_equal Point.new(1, 2), line.point1
+    assert_equal Point.new(3, 4), line.point2
+  end
+end

data/test/line/intersect_x_test.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+require 'geometry'
+
+class IntersectXTest < Test::Unit::TestCase
+  include Geometry
+
+  def test_vertical_non_overlapping
+    l1 = Line.new_by_arrays([0, 0], [0, 1])
+    l2 = Line.new_by_arrays([1, 0], [1, 1])
+    assert l1.intersect_x(l2).nil?
+  end
+
+  def test_vertical_overlapping
+    x = 0
+    l1 = Line.new_by_arrays([x, 0], [x, 1])
+    l2 = Line.new_by_arrays([x, 0], [x, 1])
+    assert_equal x, l1.intersect_x(l2)
+    assert_equal x, l2.intersect_x(l1)
+  end
+
+  def test_horizontal_non_overlapping
+    l1 = Line.new_by_arrays([0, 0], [1, 0])
+    l2 = Line.new_by_arrays([0, 1], [1, 1])
+    p l1.intersect_x(l2)
+    assert l1.intersect_x(l2).nil?
+  end
+
+  def test_horizontal_overlapping
+    y = 0
+    l1 = Line.new_by_arrays([0, y], [1, y])
+    l2 = Line.new_by_arrays([0, y], [1, y])
+    assert l1.intersect_x(l2).nil?
+  end
+
+  def test_perpendicular
+    [-1, 0, 1].each do |xo|
+      [-1, 0, 1].each do |yo|
+        l1 = Line.new_by_arrays([xo, yo], [xo+0, yo+1])
+        l2 = Line.new_by_arrays([xo, yo], [xo+1, yo+0])
+        assert_equal xo, l1.intersect_x(l2)
+        assert_equal xo, l2.intersect_x(l1)
+      end
+    end
+  end
+end

data/test/line/parallel_to_test.rb

@@ -0,0 +1,45 @@
+require 'test/unit'
+require 'geometry'
+
+class ParallelToTest < Test::Unit::TestCase
+  include Geometry
+
+  def test_identical
+    num_tests = 100
+    (1..num_tests).each do
+      point1 = [rand-0.5, rand-0.5]
+      point2 = [rand-0.5, rand-0.5]
+      line = Line.new_by_arrays(point1, point2)
+      assert line.parallel_to? line
+    end
+  end
+
+  def test_verticals
+    up = Line.new_by_arrays([0, 0], [0, 1])
+    down = Line.new_by_arrays([0, 0], [0, -1])
+    assert up.parallel_to? down
+    assert down.parallel_to? up
+  end
+
+  def test_horizontals
+    left = Line.new_by_arrays([0, 0], [-1, 0])
+    right = Line.new_by_arrays([0, 0], [1, 0])
+    assert left.parallel_to? right
+    assert right.parallel_to? left
+  end
+
+  def test_shifted
+    shift = 1
+    l1 = Line.new_by_arrays([0, 0], [1, 1])
+    l2 = Line.new_by_arrays([0+shift, 0], [1+shift, 1])
+    assert l1.parallel_to? l2
+    assert l2.parallel_to? l1
+  end
+
+  def test_not_parallel
+    l1 = Line.new_by_arrays([0, 0], [1, 1])
+    l2 = Line.new_by_arrays([0, 0], [1, -1])
+    assert ! l1.parallel_to?(l2)
+    assert ! l1.parallel_to?(l2)
+  end
+end