draught 0.1.0

data/lib/draught/bounding_box.rb

@@ -0,0 +1,76 @@
+require_relative 'boxlike'
+require_relative 'point'
+
+module Draught
+  class BoundingBox
+    include Boxlike
+
+    attr_reader :paths
+
+    def initialize(*paths)
+      @paths = paths
+    end
+
+    def width
+      x_max - x_min
+    end
+
+    def height
+      y_max - y_min
+    end
+
+    def lower_left
+      @lower_left ||= Point.new(x_min, y_min)
+    end
+
+    def translate(point)
+      self.class.new(*paths.map { |path| path.translate(point) })
+    end
+
+    def transform(transformer)
+      self.class.new(*paths.map { |path| path.transform(transformer) })
+    end
+
+    def zero_origin
+      move_to(Point::ZERO)
+    end
+
+    def ==(other)
+      paths == other.paths
+    end
+
+    def containers
+      []
+    end
+
+    def box_type
+      [:container]
+    end
+
+    private
+
+    def x_max
+      @x_max ||= upper_rights.map(&:x).max
+    end
+
+    def x_min
+      @x_min ||= lower_lefts.map(&:x).min
+    end
+
+    def y_max
+      @y_max ||= upper_rights.map(&:y).max
+    end
+
+    def y_min
+      @y_min ||= lower_lefts.map(&:y).min
+    end
+
+    def lower_lefts
+      @lower_lefts ||= paths.map(&:lower_left)
+    end
+
+    def upper_rights
+      @upper_rights ||= paths.map(&:upper_right)
+    end
+  end
+end

data/lib/draught/boxlike.rb

@@ -0,0 +1,148 @@
+require_relative 'point'
+require_relative 'vector'
+
+module Draught
+  module Boxlike
+    POSITION_METHODS = [:lower_left, :lower_centre, :lower_right, :centre_right, :upper_right, :upper_centre, :upper_left, :centre_left, :centre]
+
+    def lower_left
+      raise NotImplementedError, "includers of Boxlike must implement #lower_left"
+    end
+
+    def width
+      raise NotImplementedError, "includers of Boxlike must implement #width"
+    end
+
+    def height
+      raise NotImplementedError, "includers of Boxlike must implement #height"
+    end
+
+    def box_type
+      raise NotImplementedError, "includers of Boxlike must implement #box_type"
+    end
+
+    def lower_right
+      @lower_right ||= lower_left.translate(Draught::Vector.new(width, 0))
+    end
+
+    def upper_right
+      @upper_right ||= lower_left.translate(Draught::Vector.new(width, height))
+    end
+
+    def upper_left
+      @upper_left ||= lower_left.translate(Draught::Vector.new(0, height))
+    end
+
+    def centre_left
+      @centre_left ||= lower_left.translate(Draught::Vector.new(0, height/2.0))
+    end
+
+    def lower_centre
+      @lower_centre ||= lower_left.translate(Draught::Vector.new(width/2.0, 0))
+    end
+
+    def centre_right
+      @centre_right ||= lower_right.translate(Draught::Vector.new(0, height / 2.0))
+    end
+
+    def upper_centre
+      @upper_centre ||= upper_left.translate(Draught::Vector.new(width/2.0, 0))
+    end
+
+    def centre
+      @centre ||= lower_left.translate(Draught::Vector.new(width/2.0, height/2.0))
+    end
+
+    def corners
+      [lower_left, lower_right, upper_right, upper_left]
+    end
+
+    def left_edge
+      @left_edge ||= lower_left.x
+    end
+
+    def right_edge
+      @right_edge ||= upper_right.x
+    end
+
+    def top_edge
+      @top_edge ||= upper_right.y
+    end
+
+    def bottom_edge
+      @bottom_edge ||= lower_left.y
+    end
+
+    def move_to(point, opts = {})
+      reference_position_method = opts.fetch(:position, :lower_left)
+      if invalid_position_method?(reference_position_method)
+        raise ArgumentError, ":position option must be a valid position (one of #{POSITION_METHODS.map(&:inspect).join(', ')}), rather than #{opts[:position].inspect}" 
+      end
+
+      reference_point = send(reference_position_method)
+      translation = Draught::Vector.translation_between(reference_point, point)
+      return self if translation == Draught::Vector::NULL
+      translate(translation)
+    end
+
+    def translate(point)
+      raise NotImplementedError
+    end
+
+    def transform(transformer)
+      raise NotImplementedError
+    end
+
+    def paths
+      raise NotImplementedError
+    end
+
+    def containers
+      raise NotImplementedError
+    end
+
+    def overlaps?(other_box)
+      !disjoint?(other_box)
+    end
+
+    def disjoint?(other_box)
+      horizontal_disjoint?(other_box) || vertical_disjoint?(other_box)
+    end
+
+    def include_point?(point)
+      horizontal_extent.include?(point.x) && vertical_extent.include?(point.y)
+    end
+
+    def min_gap
+      0
+    end
+
+    private
+
+    def horizontal_disjoint?(other_box)
+      other_box.left_edge == right_edge || other_box.right_edge == left_edge ||
+        other_box.left_edge > right_edge || other_box.right_edge < left_edge
+    end
+
+    def vertical_disjoint?(other_box)
+      other_box.bottom_edge == top_edge || other_box.top_edge == bottom_edge ||
+        other_box.top_edge < bottom_edge || other_box.bottom_edge > top_edge
+    end
+
+    def horizontal_extent
+      @horizontal_extent ||= lower_left.x..upper_right.x
+    end
+
+    def vertical_extent
+      @vertical_extent ||= lower_left.y..upper_right.y
+    end
+
+    def invalid_position_method?(method_name)
+      !valid_position_method?(method_name)
+    end
+
+    def valid_position_method?(method_name)
+      POSITION_METHODS.include?(method_name)
+    end
+  end
+end

data/lib/draught/container.rb

@@ -0,0 +1,39 @@
+require_relative 'boxlike'
+require 'forwardable'
+
+module Draught
+  class Container
+    extend Forwardable
+    include Boxlike
+
+    attr_reader :box, :min_gap
+
+    def_delegators :box, :lower_left, :width, :height, :containers
+
+    def initialize(box, opts = {})
+      @box = box
+      @min_gap = opts.fetch(:min_gap, 0)
+    end
+
+    def translate(point)
+      self.class.new(box.translate(point), {min_gap: min_gap})
+    end
+
+    def transform(transformer)
+      transformed_min_gap = Point.new(min_gap,0).transform(transformer).x
+      self.class.new(box.transform(transformer), {min_gap: transformed_min_gap})
+    end
+
+    def ==(other)
+      min_gap == other.min_gap && box == other.box
+    end
+
+    def box_type
+      [:container]
+    end
+
+    def paths
+      [box]
+    end
+  end
+end

data/lib/draught/corner.rb

@@ -0,0 +1,163 @@
+require_relative './path_builder'
+require_relative './vector'
+require_relative './line'
+require_relative './arc_builder'
+
+module Draught
+  class Corner
+    def self.join_rounded(args)
+      new(args).join
+    end
+
+    attr_reader :radius, :paths
+
+    def initialize(args)
+      @radius = args.fetch(:radius)
+      @paths = args.fetch(:paths)
+    end
+
+    def join
+      paths.inject { |incoming, outgoing|
+        Rounded.join(radius: radius, incoming: incoming, outgoing: outgoing)
+      }
+    end
+
+    class Rounded
+      def self.join(args)
+        new(args).joined
+      end
+
+      attr_reader :radius, :incoming, :outgoing
+
+      def initialize(args)
+        @radius = args.fetch(:radius)
+        @incoming = args.fetch(:incoming)
+        @outgoing = args.fetch(:outgoing)
+      end
+
+      def joined
+        PathBuilder.connect(
+          incoming_before_final_segment,
+          incoming_final_segment,
+          corner_arc_path,
+          outgoing_first_segment,
+          outgoing_after_first_segment
+        )
+      end
+
+      def incoming_before_final_segment
+        incoming[0..-2]
+      end
+
+      def incoming_final_segment
+        incoming_line.extend(by: -distance_to_tangent)
+      end
+
+      def incoming_line
+        Line.from_path(incoming[-2,2])
+      end
+
+      def outgoing_first_segment
+        outgoing_line.extend(by: -distance_to_tangent, at: :start)
+      end
+
+      def outgoing_line
+        Line.from_path(outgoing[0..1])
+      end
+
+      def outgoing_after_first_segment
+        outgoing[1..-1]
+      end
+
+      def distance_to_tangent
+        @distance_to_tangent ||= join_angles.tangent_distance(radius)
+      end
+
+      def join_angles
+        @join_angles ||= JoinAngles.new(incoming_line, outgoing_line)
+      end
+
+      def corner_arc_path
+        ArcBuilder.radians(angle: join_angles.arc_sweep, radius: radius, starting_angle: starting_angle).path
+      end
+
+      def starting_angle
+        incoming_line.radians - (Math::PI / 2)
+      end
+    end
+
+    class JoinAngles
+      attr_reader :incoming_line, :outgoing_line
+
+      def initialize(incoming_line, outgoing_line)
+        @incoming_line = incoming_line
+        @outgoing_line = outgoing_line
+      end
+
+      def arc_sweep
+        anticlockwise? ? abs_arc_sweep : abs_arc_sweep * -1
+      end
+
+      def tangent_distance(radius)
+        radius / Math.tan(abs_corner_angle / 2.0)
+      end
+
+      private
+
+      def abs_corner_angle
+        @abs_corner_angle ||= begin
+          half_corner_angle = Math.asin(corner_top_line.length/incoming_corner_line.length)
+          half_corner_angle * 2.0
+        end
+      end
+
+      def corner_top_line
+        @corner_top_line ||= begin
+          corner_top_line = Line.build({
+            start_point: incoming_corner_line.start_point, end_point: outgoing_corner_line.end_point
+          })
+          corner_top_line.extend(to: corner_top_line.length / 2.0)
+        end
+      end
+
+      def incoming_corner_line
+        @incoming_corner_line ||= zeroed_unit_line_segment(incoming_line, :last)
+      end
+
+      def outgoing_corner_line
+        @outgoing_corner_line ||= zeroed_unit_line_segment(outgoing_line, :first)
+      end
+
+      def zeroed_unit_line_segment(segment, zero_to_point)
+        unit_line_segment = segment.extend(to: 1)
+        unit_line_segment.translate(
+          Vector.translation_to_zero(unit_line_segment.public_send(zero_to_point))
+        )
+      end
+
+      def abs_arc_sweep
+        @abs_arc_sweep ||= Math::PI - abs_corner_angle
+      end
+
+      def anticlockwise?
+        !clockwise?
+      end
+
+      def clockwise?
+        if aligned_zeroed_lines[0].x > aligned_zeroed_lines[1].x
+          aligned_zeroed_lines[0].y < aligned_zeroed_lines[2].y
+        else
+          aligned_zeroed_lines[0].y > aligned_zeroed_lines[2].y
+        end
+      end
+
+      def aligned_zeroed_lines
+        @aligned_zeroed_lines ||= begin
+          joined_lines = PathBuilder.connect(incoming_line, outgoing_line)
+          zeroed_joined_lines = joined_lines.translate(Vector.translation_to_zero(joined_lines.first))
+          zeroed_joined_lines.transform(Transformations.rotate(incoming_line.radians * -1))
+        end
+      end
+    end
+  end
+end

data/lib/draught/cubic_bezier.rb

@@ -0,0 +1,62 @@
+require_relative './pointlike'
+
+module Draught
+  class CubicBezier
+    include Pointlike
+
+    attr_reader :end_point, :control_point_1, :control_point_2
+
+    def initialize(args = {})
+      @end_point = args.fetch(:end_point)
+      @control_point_1 = args.fetch(:control_point_1)
+      @control_point_2 = args.fetch(:control_point_2)
+    end
+
+    def x
+      end_point.x
+    end
+
+    def y
+      end_point.y
+    end
+
+    def ==(other)
+      other.point_type == point_type &&
+        comparison_array(other).all? { |a, b| a == b }
+    end
+
+    def point_type
+      :cubic_bezier
+    end
+
+    def approximates?(other, delta)
+      other.point_type == point_type &&
+        comparison_array(other).all? { |a, b|
+          a.approximates?(b, delta)
+        }
+    end
+
+    def translate(vector)
+      transform(vector.to_transform)
+    end
+
+    def transform(transformer)
+      new_args = Hash[args_hash.map { |k, point|
+        [k, point.transform(transformer)]
+      }]
+      self.class.new(new_args)
+    end
+
+    private
+
+    def args_hash
+      {end_point: end_point, control_point_1: control_point_1, control_point_2: control_point_2}
+    end
+
+    def comparison_array(other)
+      args_hash.map { |arg, point|
+        [other.send(arg), point]
+      }
+    end
+  end
+end