easy_geometry 0.1.0

data/lib/easy_geometry/d2/ray.rb

@@ -0,0 +1,111 @@
+module EasyGeometry
+  module D2
+    # A Ray is a semi-line in the space with a source point and a direction.
+    class Ray < LinearEntity
+
+      # Is other GeometryEntity contained in this Ray?
+      # 
+      # Parameters:
+      #   GeometryEntity
+      # 
+      # Returns:
+      #   true if `other` is on this Line.
+      #   false otherwise.
+      # 
+      def contains?(other)
+        other = Point.new(other[0], other[1]) if other.is_a?(Array)
+
+        if other.is_a?(Point)
+          if Point.is_collinear?(other, self.p1, self.p2)
+            # if we're in the direction of the ray, our
+            # direction vector dot the ray's direction vector
+            # should be non-negative
+            return (self.p2 - self.p1).dot(other - self.p1) >= 0
+          end
+        end
+
+        if other.is_a?(Ray)
+          if Point.is_collinear?(self.p1, self.p2, other.p1, other.p2)
+            return (self.p2 - self.p1).dot(other.p2 - other.p1) > 0
+          end
+        end
+
+        if other.is_a?(Segment)
+          return true if self.contains?(other.p1) && self.contains?(other.p2)
+        end
+
+        return false
+      end
+
+      # Finds the shortest distance between the ray and a point.
+      # 
+      # Raises
+      #   ======
+      #   TypeError is raised if `other` is not a Point
+      def distance(other)
+        raise TypeError, "Distance between Ray and #{ other.class } is not defined" unless other.is_a?(Point)
+
+        return 0 if self.contains?(other)
+
+        proj = Line.new(self.p1, self.p2).projection_point(other)
+        if self.contains?(proj)
+          return (other - proj).abs
+        end
+          
+        (other - self.source).abs
+      end
+
+      # Returns True if self and other are the same mathematical entities
+      def ==(other)
+        return false unless other.is_a?(Ray)
+        self.source == other.source && self.contains?(other.p2)
+      end
+
+      # The point from which the ray emanates.
+      def source
+        self.p1
+      end
+
+      # The x direction of the ray.
+      # 
+      # Returns:
+      #     Positive infinity if the ray points in the positive x direction,
+      #     negative infinity if the ray points in the negative x direction,
+      #     or 0 if the ray is vertical.
+      def xdirection
+        return @xdirection if defined?(@xdirection)
+
+        if self.p1.x < self.p2.x
+          @xdirection = BigDecimal('Infinity')
+        elsif self.p1.x == self.p2.x
+          @xdirection = 0
+        else
+          @xdirection = -BigDecimal('Infinity')
+        end
+
+        @xdirection
+      end
+
+      # The y direction of the ray.
+      # 
+      # Returns:
+      #     Positive infinity if the ray points in the positive y direction,
+      #     negative infinity if the ray points in the negative y direction,
+      #     or 0 if the ray is vertical.
+      def ydirection
+        return @ydirection if defined?(@ydirection)
+
+        if self.p1.y < self.p2.y
+          @ydirection = BigDecimal('Infinity')
+        elsif self.p1.y == self.p2.y
+          @ydirection = 0
+        else
+          @ydirection = -BigDecimal('Infinity')
+        end
+
+        @ydirection
+      end
+
+    end
+  end
+end

data/lib/easy_geometry/d2/segment.rb

@@ -0,0 +1,119 @@
+module EasyGeometry
+  module D2
+    # A segment in a 2-dimensional Euclidean space.
+    class Segment < LinearEntity
+
+      # Is the other GeometryEntity contained within this Segment?
+      # 
+      # Parameters:
+      #   GeometryEntity
+      # 
+      # Returns:
+      #   true if `other` is in this Segment.
+      #   false otherwise.
+      # 
+      def contains?(other)
+        other = Point.new(other[0], other[1]) if other.is_a?(Array)
+
+        if other.is_a?(Point)
+          if Point.is_collinear?(other, self.p1, self.p2)
+            # if it is collinear and is in the bounding box of the
+            # segment then it must be on the segment
+            vert = (1/self.slope).zero?
+            
+            if vert
+              return (self.p1.y - other.y) * (self.p2.y - other.y) <= 0
+            end
+            
+            return (self.p1.x - other.x) * (self.p2.x - other.x) <= 0
+          end
+        end
+
+        if other.is_a?(Segment)
+          return self.contains?(other.p1) && self.contains?(other.p2)
+        end
+
+        return false
+      end
+
+      # Returns True if self and other are the same mathematical entities
+      def ==(other)
+        return false unless other.is_a?(Segment)
+        [p1, p2].sort_by {|p| [p.x, p.y]} == [other.p1, other.p2].sort_by {|p| [p.x, p.y]}
+      end
+
+      def <=>(other)
+        return self.p2 <=> other.p2 if self.p1 == other.p1 
+        self.p1 <=> other.p1
+      end
+
+      # Finds the shortest distance between a line segment and a point.
+      # 
+      # Parameters:
+      #   Point
+      # 
+      # Returns:
+      #   Number
+      # 
+      # Raises
+      #   ======
+      #   TypeError is raised if `other` is not a Point
+      def distance(other)
+        other = Point.new(other[0], other[1]) if other.is_a?(Array)
+        raise TypeError, "Distance between Segment and #{ other.class } is not defined" unless other.is_a?(Point)
+
+        vp1 = other - self.p1
+        vp2 = other - self.p2
+
+        dot_prod_sign_1 = self.direction.to_point.dot(vp1) >= 0
+        dot_prod_sign_2 = self.direction.to_point.dot(vp2) <= 0
+
+        if dot_prod_sign_1 && dot_prod_sign_2
+          return Line.new(self.p1, self.p2).distance(other)
+        end
+
+        if dot_prod_sign_1 && !dot_prod_sign_2
+          return vp2.abs
+        end
+
+        if !dot_prod_sign_1 && dot_prod_sign_2
+          return vp1.abs
+        end
+      end
+
+      # The length of the line segment.
+      def length
+        @length ||= p1.distance(p2)
+      end
+
+      # The midpoint of the line segment.
+      def midpoint
+        @midpoint ||= p1.midpoint(p2)
+      end
+
+      # The perpendicular bisector of this segment.
+      # If no point is specified or the point specified is not on the
+      # bisector then the bisector is returned as a Line. 
+      # Otherwise a Segment is returned that joins the point specified and the
+      # intersection of the bisector and the segment.
+      # 
+      # Parameters:
+      #   Point
+      # 
+      # Returns:
+      #   Line or Segment
+      # 
+      def perpendicular_bisector(point=nil)
+        l = self.perpendicular_line(self.midpoint)
+        
+        if !point.nil?
+          point = Point.new(point[0], point[1]) if point.is_a?(Array)        
+          raise TypeError, "This method is not defined for #{ point.class }" unless point.is_a?(Point)
+          return Segment.new(point, self.midpoint) if l.contains?(point)
+        end
+
+        return l
+      end
+    end
+  end
+end

data/lib/easy_geometry/d2/triangle.rb

@@ -0,0 +1,375 @@
+module EasyGeometry
+  module D2
+    # A polygon with three vertices and three sides.
+    class Triangle < Polygon
+      attr_reader :vertices
+
+      EQUITY_TOLERANCE = 0.0000000000001
+
+      def initialize(*args)
+        @vertices = preprocessing_args(args)
+        remove_consecutive_duplicates
+        remove_collinear_points
+      end
+
+      # Is another triangle similar to this one.
+      # 
+      # Parameters:
+      #   Triangle
+      # 
+      # Returns:
+      #   bool
+      # 
+      def is_similar?(other)
+        return false unless other.is_a?(Triangle)
+
+        s1_1, s1_2, s1_3 = self.sides.map {|side| side.length}
+        s2 = other.sides.map {|side| side.length}
+
+        are_similar?(s1_1, s1_2, s1_3, *s2) ||
+        are_similar?(s1_1, s1_3, s1_2, *s2) ||
+        are_similar?(s1_2, s1_1, s1_3, *s2) ||
+        are_similar?(s1_2, s1_3, s1_1, *s2) ||
+        are_similar?(s1_3, s1_1, s1_2, *s2) ||
+        are_similar?(s1_3, s1_2, s1_1, *s2)
+      end
+
+      # Are all the sides the same length?
+      # Precision - 10e-13
+      # 
+      # Returns:
+      #   bool
+      # 
+      def is_equilateral?
+        lengths = self.sides.map { |side| side.length }
+        lengths = lengths.map { |l| l - lengths.first }
+        return lengths.reject { |l| l.abs < EQUITY_TOLERANCE }.length == 0
+      end
+
+      # Are two or more of the sides the same length?
+      # 
+      # Returns:
+      #   bool
+      # 
+      def is_isosceles?
+        has_dups(self.sides.map { |side| side.length })
+      end
+
+      # Are all the sides of the triangle of different lengths?
+      # 
+      # Returns:
+      #   bool
+      # 
+      def is_scalene?
+        !has_dups(self.sides.map { |side| side.length })
+      end
+
+      # Is the triangle right-angled.
+      # 
+      # Returns:
+      #   bool
+      #
+      def is_right?
+        s = self.sides
+
+        s[0].perpendicular_to?(s[1]) ||
+        s[1].perpendicular_to?(s[2]) ||
+        s[0].perpendicular_to?(s[2])
+      end
+
+      # The altitudes of the triangle.
+      # 
+      # An altitude of a triangle is a segment through a vertex,
+      # perpendicular to the opposite side, with length being the
+      # height of the vertex measured from the line containing the side.
+      # 
+      # Returns:
+      #   Hash (The hash consists of keys which are vertices and values
+      #     which are Segments.)
+      #
+      def altitudes
+        return @altitudes if defined?(@altitudes)
+
+        @altitudes = { 
+          self.vertices[0] =>  self.sides[1].perpendicular_segment(self.vertices[0]),
+          self.vertices[1] =>  self.sides[2].perpendicular_segment(self.vertices[1]),
+          self.vertices[2] =>  self.sides[0].perpendicular_segment(self.vertices[2])
+        }
+
+        @altitudes
+      end
+
+      # The orthocenter of the triangle.
+      # 
+      # The orthocenter is the intersection of the altitudes of a triangle.
+      # It may lie inside, outside or on the triangle.
+      # 
+      # Returns:
+      #   Point
+      # 
+      def orthocenter
+        return @orthocenter if defined?(@orthocenter)
+
+        a = self.altitudes
+        a1 = a[self.vertices[0]]; a2 = a[self.vertices[1]]
+        
+        l1 = Line.new(a1.p1, a1.p2)
+        l2 = Line.new(a2.p1, a2.p2)
+
+        @orthocenter = l1.intersection(l2)[0]
+        @orthocenter
+      end
+
+      # The circumcenter of the triangle
+      # 
+      # The circumcenter is the center of the circumcircle.
+      # 
+      # Returns:
+      #   Point or nil
+      # 
+      def circumcenter
+        return @circumcenter if defined?(@circumcenter)
+
+        a, b, c = self.sides.map { |side| side.perpendicular_bisector }
+        
+        @circumcenter = a.intersection(b)[0]
+        @circumcenter
+      end
+
+      # The radius of the circumcircle of the triangle.
+      # 
+      # Returns:
+      #   int
+      # 
+      def circumradius
+        @circumradius ||= self.vertices[0].distance(self.circumcenter)
+      end
+
+      # The circle which passes through the three vertices of the triangle.
+      # 
+      # Returns:
+      #   Circle
+      # 
+      def circumcircle
+        # Circle.new(self.circumcenter, self.circumradius)
+      end
+
+      # The angle bisectors of the triangle.
+      # 
+      # An angle bisector of a triangle is a straight line through a vertex
+      # which cuts the corresponding angle in half.
+      # 
+      # Returns:
+      #   Hash (each key is a vertex (Point) and each value is the corresponding
+      #     bisector (Segment).)
+      #
+      def bisectors
+        s = self.sides.map { |side| Line.new(side.p1, side.p2) }
+        c = self.incenter
+
+        inter1 = Line.new(self.vertices[0], c).intersection(s[1]).first
+        inter2 = Line.new(self.vertices[1], c).intersection(s[2]).first
+        inter3 = Line.new(self.vertices[2], c).intersection(s[0]).first
+
+        {
+          self.vertices[0] => Segment.new(self.vertices[0], inter1), 
+          self.vertices[1] => Segment.new(self.vertices[1], inter2),
+          self.vertices[2] => Segment.new(self.vertices[2], inter3),
+        }
+      end
+
+      # The center of the incircle.
+      # 
+      # The incircle is the circle which lies inside the triangle and touches
+      # all three sides.
+      # 
+      # Returns:
+      #   Point
+      # 
+      def incenter
+        return @incenter if defined?(@incenter)
+
+        s = self.sides
+        l = [1, 2, 0].map { |i| s[i].length }
+        p = l.sum
+
+        x_arr = self.vertices.map { |v| v.x / p }
+        y_arr = self.vertices.map { |v| v.y / p }
+
+        x = l[0] * x_arr[0] + l[1] * x_arr[1] + l[2] * x_arr[2]
+        y = l[0] * y_arr[0] + l[1] * y_arr[1] + l[2] * y_arr[2]
+
+        @incenter = Point.new(x, y)
+        @incenter
+      end
+
+      # The radius of the incircle.
+      # 
+      # Returns:
+      #   int
+      #
+      def inradius
+        @inradius ||= 2 * self.area / self.perimeter
+      end
+
+      # The incircle of the triangle.
+      # 
+      # The incircle is the circle which lies inside the triangle and touches
+      # all three sides.
+      # 
+      # Returns:
+      #   Circle
+      #
+      def incircle
+        # Circle.new(self.incenter, self.inradius)
+      end
+
+      # The radius of excircles of a triangle.
+      # 
+      # An excircle of the triangle is a circle lying outside the triangle,
+      # tangent to one of its sides and tangent to the extensions of the
+      # other two.
+      # 
+      # Returns:
+      #   Hash
+      #
+      def exradii
+        return @exradii if defined?(@exradii)
+        a = self.sides[0].length
+        b = self.sides[1].length
+        c = self.sides[2].length
+        s = (a + b + c) / 2
+        area = self.area
+
+        @exradii = {
+          self.sides[0] => area / (s - a),
+          self.sides[1] => area / (s - b),
+          self.sides[2] => area / (s - c)
+        }
+        @exradii
+      end
+
+      # The medians of the triangle.
+      # 
+      # A median of a triangle is a straight line through a vertex and the
+      # midpoint of the opposite side, and divides the triangle into two
+      # equal areas.
+      # 
+      # Returns:
+      #   Hash (each key is a vertex (Point) and each value is the median (Segment)
+      #     at that point.)
+      #
+      def medians
+        @medians ||= {
+          self.vertices[0] => Segment.new(self.vertices[0], self.sides[1].midpoint),
+          self.vertices[1] => Segment.new(self.vertices[1], self.sides[2].midpoint),
+          self.vertices[2] => Segment.new(self.vertices[2], self.sides[0].midpoint)
+        }
+      end
+
+      # The medial triangle of the triangle.
+      # The triangle which is formed from the midpoints of the three sides.
+      # 
+      # Returns:
+      #   Triangle
+      # 
+      def medial
+        @medial ||= Triangle.new(
+          self.sides[0].midpoint, 
+          self.sides[1].midpoint, 
+          self.sides[2].midpoint
+        )
+      end
+
+      # The nine-point circle of the triangle.
+      # 
+      # Nine-point circle is the circumcircle of the medial triangle, which
+      # passes through the feet of altitudes and the middle points of segments
+      # connecting the vertices and the orthocenter.
+      # 
+      # Returns:
+      #   Circle
+      # 
+      def nine_point_circle
+        # Circle.new(*self.medial.vertices)
+      end
+
+      # The Euler line of the triangle.
+      # The line which passes through circumcenter, centroid and orthocenter.
+      # 
+      # Returns:
+      #   Line (or Point for equilateral triangles in which case all
+      #     centers coincide)
+      # 
+      def eulerline
+        return self.orthocenter if self.is_equilateral?
+        Line.new(self.orthocenter, self.circumcenter)
+      end
+
+      private
+
+      def has_dups(arr)
+        (0...arr.length).each do |i|
+          return true if (arr[i] - arr[i - 1]).abs  < EQUITY_TOLERANCE
+        end
+
+        return false
+      end
+
+      def are_similar?(u1, u2, u3, v1, v2, v3)
+        e1 = u1 / v1
+        e2 = u2 / v2
+        e3 = u3 / v3
+
+        e1 == e2 && e2 == e3
+      end
+
+       # preprocessing_args - convert coordinates to points if necessary.
+       def preprocessing_args(args)
+        args.map do |v|
+          if v.is_a?(Array) && v.length == 2
+            Point.new(*v)
+          elsif v.is_a?(Point)
+            v
+          else
+            raise TypeError, "Arguments should be arrays with coordinates or Points."
+          end
+        end
+      end
+
+      def remove_consecutive_duplicates
+        nodup = []        
+        @vertices.each do |p|
+          next if !nodup.empty? && p == nodup[-1]
+          nodup << p
+        end
+
+        if nodup.length > 1 && nodup[-1] == nodup[0]
+          nodup.pop # last point was same as first
+        end
+
+        @vertices = nodup
+        validate
+      end
+
+      def remove_collinear_points
+        i = 0
+        while i < vertices.length
+          a, b, c = vertices[i], vertices[i - 1], vertices[i - 2]
+          if Point.is_collinear?(a, b, c)
+            vertices.delete_at(i - 1)
+            vertices.delete_at(i - 2) if a == c
+          else
+            i += 1
+          end
+        end
+
+        validate
+      end
+
+      def validate
+        raise ArgumentError, 'Triangle instantiates with three points' if vertices.length != 3
+      end
+    end
+  end
+end