gifenc 0.1.0 → 0.2.0

data/lib/geometry.rb

@@ -2,8 +2,472 @@ module Gifenc
   # This module encapsulates all the necessary geometric functionality, and
   # more generally, all mathematical methods that may be useful for several
   # tasks of the library, such as drawing, resampling, etc.
+  #
+  # Every method that takes a point as argument may be supplied by providing
+  # either a `Point` or a `[Float, Float]` array representing its coordinates,
+  # regardless of whether the documentation has one or the other in the method's
+  # specification.
   module Geometry
 
+    # Represents a point in the plane. It's essentially a wrapper for an Float
+    # array with 2 elements (the coordinates) and many geometric methods that
+    # aid working with them. It is used indistinctly for both points and vectors,
+    # and will be denoted as such throughout the code, depending on which
+    # interpretation is more relevant.
+    class Point
+
+      # The X coordinate of the point.
+      # @return [Integer] X coordinate.
+      attr_accessor :x
+
+      # The Y coordinate of the point.
+      # @return [Integer] Y coordinate.
+      attr_accessor :y
+
+      # Convert polar coordinates to rectangular (Cartesian) coordinates.
+      # @param mod [Float] The point's module (euclidean norm).
+      # @param arg [Float] The point's argument (angle with respect to the
+      #   positive X axis).
+      # @return [Array<Float>] The corresponding Cartesian coordinates.
+      def self.polar2rect(mod, arg)
+        [mod * Math.cos(arg), mod * Math.sin(arg)]
+      end
+
+      # Convert rectangular (Cartesian) coordinates to polar coordinates.
+      # @param x [Float] The point's X coordinate.
+      # @param y [Float] The point's Y coordinate.
+      # @return [Array<Float>] The corresponding polar coordinates.
+      def self.rect2polar(x, y)
+        [(x ** 2  + y ** 2) ** 0.5, Math.atan2(y, x)]
+      end
+
+      # Parse a point from an arbitrary argument. It accepts either:
+      # * A point object, in which case it returns itself.
+      # * An array, in which case it creates a new point whose coordinates are
+      #   the values of the array.
+      # @param point [Point,Array<Integer>] The parameter to parse the point from.
+      # @param sys [Symbol] The coordinate system to use for parsing the
+      #   coordinates. It may be `:cartesian` or `:polar`.
+      # @return [Point] The parsed point object.
+      # @raise [Exception::GeometryError] When a point couldn't be parsed from the supplied
+      #   argument.
+      def self.parse(point, sys = :cartesian)
+        if point.is_a?(Point)
+          point
+        elsif point.is_a?(Array)
+          point = polar2rect(*point) if sys == :polar
+          new(*point)
+        else
+          raise Exception::GeometryError, "Couldn't parse point from argument."
+        end
+      end
+
+      # Create a new point given its coordinates. The coordinates are assumed to
+      # be the Cartesian coordinates with respect to the same axes as the desired
+      # image, and they need not be integers (though they'll be casted as such
+      # when actually drawing them).
+      # @param x [Float] The X coordinate of the point.
+      # @param y [Float] The Y coordinate of the point.
+      def initialize(x, y)
+        @x = x.to_f
+        @y = y.to_f
+      end
+
+      # Add another point to this one.
+      # @param p [Point] The other point.
+      # @return [Point] The new point.
+      def +(p)
+        p = Point.parse(p)
+        Point.new(@x + p.x, @y + p.y)
+      end
+
+      # Make all coordinates positive. This is equivalent to reflecting the
+      # point about the coordinate axes until it is in the first quadrant.
+      # @return (see #+)
+      def +@
+        Point.new(@x.abs, @y.abs)
+      end
+
+      # Subtract another point to this one.
+      # @param (see #+)
+      # @return (see #+)
+      def -(p)
+        p = Point.parse(p)
+        Point.new(@x - p.x, @y - p.y)
+      end
+
+      # Take the opposite point with respect to the origin. This is equivalent
+      # to performing half a rotation about the origin.
+      # @return (see #-)
+      def -@
+        Point.new(-@x, -@y)
+      end
+
+      # Scale a point or compute the dot product of two points.
+      # * If `arg` is Numeric, the point will be scaled by that factor. The
+      #   return value will then be a new Point.
+      # * If `arg` is a Point, the scalar product of the two points will be
+      #   computed. The return value will then be a Float.
+      # @param arg [Numeric,Point] The factor to scale the point.
+      # @return [Point,Float] The scaled point or the scalar product.
+      def *(arg)
+        if Numeric === arg
+          Point.new(@x * arg, @y * arg)
+        else
+          p = Point.parse(arg)
+          @x * p.x + @y * p.y
+        end
+      end
+
+      # Scale the point by the inverse of a factor.
+      # @param (see #*)
+      # @return (see #+)
+      def /(s)
+        Point.new(@x / s, @y / s)
+      end
+
+      # Project the point onto the given vector. The supplied vector need not be
+      # unitary, as it will be normalized automatically.
+      # @param (see #+)
+      # @return [Point] The new projected point.
+      def |(p)
+        u = Point.parse(p).normalize
+        u * (self * u)
+      end
+
+      # Reflect the point with respect to the given one.
+      # @param (see #+)
+      # @return [Point] The new reflected point.
+      def ^(p)
+        self + (Point.parse(p) - self) * 2
+      end
+
+      # Compute the midpoint between this point and the given one.
+      # @param (see #+)
+      # @return [Point] The midpoint.
+      def &(p)
+        (self + Point.parse(p)) / 2
+      end
+
+      # Return the standard (Cartesian) coordinates of the point. This consists
+      # on the X and Y values.
+      # @return [Array<Float>] Cartesian coordinates of the point.
+      def coords_cartesian
+        [@x, @y]
+      end
+
+      alias_method :coords, :coords_cartesian
+
+      # Return the polar coordinates of the point. This consists on the module
+      # (euclidean norm) and argument (angle between -PI and PI).
+      # @return [Array<Float>] Polar coordinates of the point.
+      def coords_polar
+        [mod, arg]
+      end
+
+      alias_method :polar, :coords_polar
+
+      # Compute the left-hand (CCW) normal vector.
+      # @return [Point] The left-hand normal vector.
+      # @see #normal_right
+      def normal_left
+        Point.new(@y, -@x)
+      end
+
+      # Compute the right-hand (CW) normal vector.
+      # @return [Point] The right-hand normal vector.
+      # @see #normal_left
+      def normal_right
+        Point.new(-@y, @x)
+      end
+
+      alias_method :normal, :normal_right
+
+      # Compute the p-norm of the vector. It should be `p>0`.
+      # @param p [Float] The parameter of the norm.
+      # @return [Float] The p-norm of the vector.
+      # @see #norm_1
+      # @see #norm
+      # @see #norm_inf
+      def norm_p(p = 2)
+        (@x.abs ** p + @y.abs ** p) ** (1.0 / p)
+      end
+
+      # Shortcut to compute the 1-norm of the vector.
+      # @return [Float] The 1-norm of the vector.
+      # @see #norm_p
+      def norm_1
+        (@x.abs + @y.abs).to_f
+      end
+
+      # Shortcut to compute the euclidean norm of the vector.
+      # @return [Float] The euclidean norm of the vector.
+      # @see #norm_p
+      def norm
+        norm_p(2)
+      end
+
+      alias_method :norm_2, :norm
+      alias_method :mod, :norm
+
+      # Shortcut to compute the infinity (maximum) norm of the vector.
+      # @return [Float] The infinity norm of the vector.
+      # @see #norm_p
+      def norm_inf
+        [@x.abs, @y.abs].max.to_f
+      end
+
+      # Normalize the vector with respect to the p-norm. It should be `p>0`.
+      # @param (see #norm_p)
+      # @return [Point] The normalized vector.
+      # @see #normalize_1
+      # @see #normalize
+      # @see #normalize_inf
+      # @raise [Exception::GeometryError] If trying to normalize the null vector.
+      def normalize_p(p)
+        normalize_gen(norm_p(p))
+      end
+
+      # Shotcut to normalize the vector with respect to the 1-norm.
+      # @return (see #normalize_p)
+      # @see #normalize_p
+      # @raise [Exception::GeometryError] If trying to normalize the null vector.
+      def normalize_1
+        normalize_p(1)
+      end
+
+      # Shotcut to normalize the vector with respect to the euclidean norm.
+      # @return (see #normalize_p)
+      # @see #normalize_p
+      # @raise [Exception::GeometryError] If trying to normalize the null vector.
+      def normalize
+        normalize_p(2)
+      end
+
+      alias_method :normalize_2, :normalize
+
+      # Shotcut to normalize the vector with respect to the infinity norm.
+      # @return (see #normalize_p)
+      # @see #normalize_p
+      # @raise [Exception::GeometryError] If trying to normalize the null vector.
+      def normalize_inf
+        normalize_gen(norm_inf)
+      end
+
+      # Compute the Euclidean distance between two points.
+      # @param (see #+)
+      # @return
+      def distance(p)
+        (self - Point.parse(p)).norm
+      end
+
+      # Project the point onto a line. The line might be supplied by providing
+      # either of the following 3 options:
+      # * Two different points from the line.
+      # * A point and a direction vector (not necessarily normalized).
+      # * A point and an angle.
+      # At least one point is therefore always required.
+      # @param p1 [Point] A point on the line.
+      # @param p2 [Point] Another point on the line.
+      # @param direction [Point] The direction vector of the line.
+      # @param angle [Float] The angle of the line, in radians.
+      # @return [Point] The projected point on the line.
+      # @raise [Exception::GeometryError] If the line couldn't be determined
+      #   from the supplied arguments.
+      def project(p1: nil, p2: nil, direction: nil, angle: nil)
+        raise Exception::GeometryError, "Couldn't determine line,\
+          at least one point must be supplied." if !p1 && !p2
+        point = Point.parse(p1 || p2)
+        direction = Geometry.direction(p1: p1, p2: p2, angle: angle) unless direction
+        point - ((point - self) | direction)
+      end
+
+      # Reflect the point with respect to a line. The line might be supplied by
+      # providing either of the following 3 options:
+      # * Two different points from the line.
+      # * A point and a direction vector (not necessarily normalized).
+      # * A point and an angle.
+      # At least one point is therefore always required.
+      # @param t [Float] Proportion of reflection to perform. For example:
+      #   * `t = 1` will perform the full reflection.
+      #   * `t = 0` will land on the line.
+      #   * `t = -1` will not move the point.
+      # @param (see #project)
+      # @return [Point] The reflected point with respect to the line.
+      # @raise (see #project)
+      def reflect(t = 1, p1: nil, p2: nil, direction: nil, angle: nil)
+        proj = self.project(p1: p1, p2: p2, direction: direction, angle: angle)
+        self + (proj - self) * (t + 1)
+      end
+
+      # Return the angle (argument) of the point. It is expressed in radian,
+      # between -PI and PI.
+      # @return [Float] Angle of the point.
+      def arg
+        Math.atan2(@y, @x)
+      end
+
+      # Whether the point is null, i.e., close enough to the origin.
+      # @return [Boolean] Whether the point is (close enough to) the origin.
+      def zero?
+        norm < PRECISION
+      end
+
+      # Find the angle between this point and the given one. The angle will be
+      # in the interval [0, PI].
+      # @param (see #+)
+      # @return [Float] Angle between the points.
+      def angle(p)
+        p = Point.parse(p)
+        Math.acos((self * p) / (norm * p.norm))
+      end
+
+      # Find whether the given point is perpendicular to this one.
+      # @param (see #+)
+      # @return [Boolean] Whether the points are orthogonal.
+      def orthogonal?(p)
+        (self * Point.parse(p)).abs < PRECISION
+      end
+
+      alias_method :perpendicular?, :orthogonal?
+
+      # Find whether the given point / vector is parallel (proportional) to
+      # this one.
+      # @param (see #+)
+      # @return [Boolean] Whether the points are parallel.
+      def parallel?(p)
+        angle(p).abs < PRECISION
+      end
+
+      # Find whether the points are positively aligned. This means that their
+      # scalar product is positive, and implies that they form an acute angle,
+      # i.e., they go roughly in the same direction.
+      # @param (see #+)
+      # @return [Boolean] Whether the points are positively aligned.
+      def positive?(p)
+        self * p > 0
+      end
+
+      # Find whether the points are negatively aligned. This means that their
+      # scalar product is negative, and implies that they form an obtuse angle,
+      # i.e., they go roughly in the opposite direction.
+      # @param (see #+)
+      # @return [Boolean] Whether the points are negatively aligned.
+      def negative?(p)
+        self * p < 0
+      end
+
+      # Rotate the point by a certain angle about a given center.
+      # @param angle [Float] The angle to rotate the point, in radians.
+      # @param center [Point] The point to rotate about.
+      # @return (see #+)
+      def rotate(angle, center = ORIGIN)
+        center = Point.parse(center)
+        x_old = @x - center.x
+        y_old = @y - center.y
+        sin = Math.sin(angle)
+        cos = Math.cos(angle)
+        x = x_old * cos - y_old * sin
+        y = x_old * sin + y_old * cos
+        Point.new(x + center.x, y + center.y)
+      end
+
+      # Shortcut to rotate the point 90 degrees counterclockwise about a given
+      #   center.
+      # @param center [Point] The point to rotate about.
+      # @return (see #+)
+      def rotate_left(center = ORIGIN)
+        rotate(-Math::PI / 2, center)
+      end
+
+      # Shortcut to rotate the point 90 degrees clockwise about a given center.
+      # @param (see #rotate_left)
+      # @return (see #+)
+      def rotate_right(center = ORIGIN)
+        rotate(Math::PI / 2, center)
+      end
+
+      # Shortcut to rotate the point 180 degrees about a given center.
+      # @param (see #rotate_left)
+      # @return (see #+)
+      def rotate_180(center = ORIGIN)
+        rotate(Math::PI, center)
+      end
+
+      alias_method :translate, :+
+      alias_method :scale, :*
+
+      # Convert to integer point by rounding the coordinates.
+      # @return (see #+)
+      # @see #to_i
+      # @see #floor
+      # @see #ceil
+      def round
+        Point.new(@x.round, @y.round)
+      end
+
+      # Convert to integer point by taking the integer part of the coordinates.
+      # @return (see #+)
+      # @see #floor
+      # @see #ceil
+      # @see #round
+      def to_i
+        Point.new(@x.to_i, @y.to_i)
+      end
+
+      alias_method :truncate, :to_i
+
+      # Convert to integer point by taking the floor part of the coordinates.
+      # @return (see #+)
+      # @see #to_i
+      # @see #ceil
+      # @see #round
+      def floor
+        Point.new(@x.floor, @y.floor)
+      end
+
+      # Convert to integer point by taking the ceiling part of the coordinates.
+      # @return (see #+)
+      # @see #to_i
+      # @see #floor
+      # @see #round
+      def ceil
+        Point.new(@x.ceil, @y.ceil)
+      end
+
+      # Format the point's coordinates in the usual form.
+      # @return [String] The formatted point.
+      def to_s
+        "(#{@x}, #{@y})"
+      end
+
+      private
+
+      # Normalize the vector with respect to an arbitrary norm.
+      def normalize_gen(norm)
+        raise Exception::GeometryError, "Cannot normalize null vector." if zero?
+        Point.new(@x / norm, @y / norm)
+      end
+
+    end # Class Point
+
+    # Precision of the floating point math. Anything below this threshold will
+    # be considered 0.
+    # @return [Float] Floating point math precision.
+    PRECISION = 1E-7
+
+    # The point representing the origin of coordinates.
+    # @return [Point] Origin of coordinates.
+    ORIGIN = Point.new(0, 0)
+
+    # The point representing the first vector of the canonical base.
+    # @return [Point] First canonical vector.
+    E1 = Point.new(1, 0)
+
+    # The point representing the second vector of the canonical base.
+    # @return [Point] Second canonical vector.
+    E2 = Point.new(0, 1)
+
     # Finds the endpoint of a line given the startpoint and something else.
     # Namely, either of the following:
     # * The displacement vector (`vector`).
@@ -19,29 +483,44 @@ module Gifenc
     # @param length [Float] The length of the line. Must be provided if either
     #   the `direction` or the `angle` method is being used.
     # @return [Array<Integer>] The [X, Y] coordinates of the line's endpoint.
-    # @raise [Exception::CanvasError] If the supplied parameters don't suffice
+    # @raise [Exception::GeometryError] If the supplied parameters don't suffice
     #   to determine a line (e.g. provided the `angle` but not the `length`).
     def self.endpoint(
         point: nil, vector: nil, direction: nil, angle: nil, length: nil
       )
-      raise Exception::CanvasError, "The line start must be specified." if !point
+      raise Exception::GeometryError, "The line start must be specified." if !point
+      point = Point.parse(point)
       if vector
-        x1 = x0 + vector[0]
-        y1 = y0 + vector[1]
+        vector = Point.parse(vector)
+        x1 = point.x + vector.x
+        y1 = point.y + vector.y
       else
-        raise Exception::CanvasError, "Either the endpoint, the vector or the length must be provided." if !length
+        raise Exception::GeometryError, "Either the endpoint, the vector or the length must be provided." if !length
         if direction
-          mod = Math.sqrt(direction[0] ** 2 + direction[1] ** 2)
-          direction[0] /= mod
-          direction[1] /= mod
+          direction = Point.parse(direction).normalize
         else
-          raise Exception::CanvasError, "The angle must be specified if no direction is provided." if !angle
-          direction = [Math.cos(angle), Math.sin(angle)]
+          raise Exception::GeometryError, "The angle must be specified if no direction is provided." if !angle
+          direction = Point.new(Math.cos(angle), Math.sin(angle))
         end
-        x1 = (point[0] + length * direction[0]).to_i
-        y1 = (point[1] + length * direction[1]).to_i
+        x1 = (point.x + length * direction.x).to_i
+        y1 = (point.y + length * direction.y).to_i
       end
-      [x1, y1]
+      Point.new(x1, y1)
+    end
+
+    # Find the unit direction vector of a line given either the endpoints or
+    # the angle.
+    # @param p1 [Point] One point of the line.
+    # @param p2 [Point] Another point of the line.
+    # @param angle [Float] The angle in radians.
+    # @return [Point] The unit direction vector.
+    # @raise [Exception::GeometryError] If not enough information is supplied
+    #   (either the endpoints or the angle is required).
+    def self.direction(p1: nil, p2: nil, angle: nil)
+      return Point.parse([1, angle], :polar) if angle
+      raise Exception::GeometryError, "Couldn't parse direction, endpoints or|
+        angle must be supplied." if !p1 || !p2
+      (Point.parse(p1) - Point.parse(p2)).normalize
     end
 
     # Finds the bounding box of a set of points, i.e., the minimal rectangle
@@ -55,10 +534,11 @@ module Gifenc
     #   `[X, Y]` are the coordinates of the upper left corner of the rectangle,
     #   and `[W, H]` are its width and height, respectively.
     def self.bbox(points, pad = 0)
-      x0 = points.min_by(&:first)[0] - pad
-      y0 = points.min_by(&:last)[1] - pad
-      x1 = points.max_by(&:first)[0] + pad
-      y1 = points.max_by(&:last)[1] + pad
+      points = points.map{ |p| Point.parse(p) }
+      x0 = points.min_by(&:x).x.round - pad
+      y0 = points.min_by(&:y).y.round - pad
+      x1 = points.max_by(&:x).x.round + pad
+      y1 = points.max_by(&:y).y.round + pad
       [x0, y0, x1 - x0 + 1, y1 - y0 + 1]
     end
 
@@ -71,7 +551,8 @@ module Gifenc
     #   the supplied points.
     # @return [Array<Array<Integer>>] The list of translated points.
     def self.translate(points, vector)
-      points.map{ |p| [p[0] + vector[0], p[1] + vector[1]] }
+      vector = Point.parse(vector)
+      points.map{ |p| Point.parse(p) + vector }
     end
 
     # Computes the coordinates of a list of points relative to a provided bbox.
@@ -92,6 +573,43 @@ module Gifenc
       translate(points, [-bbox[0], -bbox[1]])
     end
 
+    # Compute the convex hull of a set of points. The convex hull is the smallest
+    # convex set containing the supplied points. This method will return the
+    # points located in the boundary of said hull in CCW order. The interior of
+    # the polygon they delimit is thus the convex hull.
+    #
+    # The *reduced* version will only include the extreme points of the boundary,
+    # i.e. the vertices, as opposed to all of them. The algorithm employed in
+    # both cases is the most basic one, known as the *Jarvis march*.
+    # @param points [Array<Point>] The list of points.
+    # @param reduced [Boolean] Whether to only return the vertices of the hull.
+    # @return [Array<Point>] The points composing the boundary of the convex hull.
+    def self.convex_hull(points, reduced = false)
+      points = points.uniq.map{ |p| Point.parse(p) }
+      return points if points.size < 3
+      hull_1 = points.min_by{ |p| [p.x, p.y] }
+      hull_2 = nil
+      hull_old = nil
+      hull = []
+      until hull_1 == hull.first
+        hull << hull_1
+        hull_2 = (points[0 ... 3] - [hull_1, hull_old]).first
+        points.each{ |p|
+          next if p == hull_1 || p == hull_2 || p == hull_old
+          index = cw(hull_1, p, hull_2)
+          next if index > PRECISION
+          if index.abs < PRECISION
+            d_new = hull_1.distance(p)
+            d_old = hull_1.distance(hull_2)
+          end
+          hull_2 = p if index < -PRECISION || (reduced ? d_new > d_old : d_new < d_old)
+        }
+        hull_old = hull_1
+        hull_1 = hull_2
+      end
+      hull
+    end
+
     # Checks if a list of points is entirely contained in the specified bounding
     # box.
     # @param (see #transform)
@@ -101,18 +619,76 @@ module Gifenc
     # @raise [Exception::CanvasError] If the points are not contained in the
     #   bounding box and `silent` has not been set.
     def self.bound_check(points, bbox, silent = false)
+      bbox = [0, 0, bbox.width, bbox.height] if bbox.is_a?(Image)
+      points.map!{ |p| Point.parse(p) }
       outer_points = points.select{ |p|
-        !p[0].between?(bbox[0], bbox[0] + bbox[2]) ||
-        !p[1].between?(bbox[1], bbox[1] + bbox[3])
+        !p.x.between?(bbox[0], bbox[0] + bbox[2] - 1) ||
+        !p.y.between?(bbox[1], bbox[1] + bbox[3] - 1)
       }
       if outer_points.size > 0
         return false if silent
-        points_str = outer_points.take(3).map{ |p| "(#{p[0]}, #{p[1]})" }
+        points_str = outer_points.take(3).map{ |p| "(#{p.x}, #{p.y})" }
                                  .join(', ') + '...'
         raise Exception::CanvasError, "Out of bounds pixels found: #{points_str}"
       end
       true
     end
 
-  end
-end
+    # Compute a linear combination of points given the weights. The two supplied
+    # arrays should have the same length.
+    # @param points [Array<Point>] The points to combine.
+    # @param weights [Array<Float>] The weights to utilize for each point.
+    # @return [Point] The resulting linear combination.
+    # @raise [Exception::GeometryError] If the arrays' sizes differ.
+    def self.comb_linear(points, weights)
+      if points.size != weights.size
+        raise Exception::GeometryError, "Point and weight counts differ."
+      end
+      return ORIGIN if points.size == 0
+
+      points.map!{ |p| Point.parse(p) }
+      res = points[0] * weights[0]
+      points[1..-1].each_with_index{ |p, i|
+        res += p * weights[i + 1]
+      }
+      res
+    end
+
+    # Compute a convex combination of points given the weights. This is simply
+    # a linear combination, but the weights are normalized so they sum to 1.
+    # If they're positive, the resulting point will always be contained within
+    # the convex hull of the supplied points, hence the name. The two provided
+    # arrays should have the same length.
+    # @param (see #comb_linear)
+    # @return [Point] The resulting convex combination.
+    # @raise [Exception::GeometryError] If the arrays's sizes differ, or if the
+    #   weights sum to 0.
+    def self.comb_convex(points, weights)
+      return ORIGIN if points.size == 0
+      weight = weights.sum
+      raise Exception::GeometryError, "Cannot find convex combination, weights sum to 0." if weight.abs < PRECISION
+      comb_linear(points, weights.map{ |w| w.to_f / weight })
+    end
+
+    # Find the center of mass (barycenter) of a list of points. This will always
+    # be contained within the convex hull of the supplied points.
+    # @param points [Array<Point>] The list of points.
+    # @return [Point] 
+    def self.center(points)
+      raise Exception::GeometryError, "Cannot find center of empty list of points." if points.size == 0
+      points.map!{ |p| Point.parse(p) }
+      points.sum(ORIGIN) / points.size
+    end
+
+    private
+
+    # Index that indicates the clockwise order of 3 points:
+    # < 0 --> CCW
+    # = 0 --> Aligned
+    # > 0 --> CW
+    def self.cw(p, q, r)
+      (r.y - p.y) * (q.x - p.x) - (q.y - p.y) * (r.x - p.x)
+    end
+
+  end # Module Geometry
+end # Module Gifenc