draught 0.1.0

data/lib/draught/path_cleaner.rb

@@ -0,0 +1,77 @@
+require_relative 'path'
+
+module Draught
+  class PathCleaner
+    def self.dedupe(path)
+      Path.new(new(path.points).dedupe)
+    end
+
+    def self.simplify(path)
+      Path.new(new(path.points).simplify)
+    end
+
+    attr_reader :input_points
+
+    def initialize(input_points)
+      @input_points = input_points
+    end
+
+    def dedupe
+      output_points = [input_points.first]
+      input_points.inject do |previous_point, point|
+        output_points << point if point != previous_point
+        point
+      end
+      output_points
+    end
+
+    def simplify
+      points = dedupe
+      pos = 0
+      while pos < (points.length - 2)
+        triple = points[pos, 3]
+        if intercepts?(*triple)
+          points.delete_at(pos + 1)
+        else
+          pos += 1
+        end
+      end
+      points
+    end
+
+    private
+
+    def intercepts?(previous_point, point, next_point)
+      intercepts_horizontal?(previous_point, point, next_point) ||
+        intercepts_vertical?(previous_point, point, next_point)
+    end
+
+    def intercepts_horizontal?(previous_point, point, next_point)
+      points = [previous_point, point, next_point]
+      intercepts_line?(points, :x)
+    end
+
+    def intercepts_vertical?(previous_point, point, next_point)
+      points = [previous_point, point, next_point]
+      intercepts_line?(points, :y)
+    end
+
+    def intercepts_line?(points, axis)
+      axis_aligned?(points, perpendicular_axis(axis)) && obviously_intermediate?(points, axis)
+    end
+
+    def perpendicular_axis(axis)
+      {:x => :y, :y => :x}.fetch(axis)
+    end
+
+    def axis_aligned?(points, axis)
+      points.map(&axis).uniq.length == 1
+    end
+
+    def obviously_intermediate?(points, axis)
+      p1, p2, p3 = points.map(&axis)
+      operator = p1 < p3 ? :< : :>
+      p1.send(operator, p2) && p2.send(operator, p3)
+    end
+  end
+end

data/lib/draught/pathlike.rb

@@ -0,0 +1,57 @@
+module Draught
+  module Pathlike
+    def points
+      raise NotImplementedError, "Pathlike objects must return an array of their points"
+    end
+
+    def translate(vector)
+      raise NotImplementedError, "Pathlike objects must implement translation by Vector"
+    end
+
+    def transform(transformation)
+      raise NotImplementedError, "Pathlike objects must implement transformation by Affine transform or point-taking lambda"
+    end
+
+    def [](index_start_or_range, length = nil)
+      raise NotImplementedError, "Pathlike objects must implement [] access on their points, returning a new instance"
+    end
+
+    def number_of_points
+      points.length
+    end
+
+    def first
+      points.first
+    end
+
+    def last
+      points.last
+    end
+
+    def empty?
+      points.empty?
+    end
+
+    def ==(other)
+      return false if number_of_points != other.number_of_points
+      points.zip(other.points).all? { |a, b| a == b }
+    end
+
+    def approximates?(other, delta)
+      return false if number_of_points != other.number_of_points
+      points.zip(other.points).all? { |a, b| a.approximates?(b, delta) }
+    end
+
+    def paths
+      []
+    end
+
+    def containers
+      []
+    end
+
+    def box_type
+      [:path]
+    end
+  end
+end

data/lib/draught/point.rb

@@ -0,0 +1,53 @@
+require_relative './vector'
+require_relative './pointlike'
+require 'matrix'
+
+module Draught
+  class Point
+    def self.from_matrix(matrix)
+      x, y = matrix.to_a.flatten
+      Point.new(x, y)
+    end
+
+    include Pointlike
+
+    attr_reader :x, :y
+
+    def initialize(x, y)
+      @x, @y = x, y
+    end
+
+    def point_type
+      :point
+    end
+
+    def ==(other)
+      other.point_type == point_type &&
+        other.x == x && other.y == y
+    end
+
+    def approximates?(other, delta)
+      other.point_type == point_type &&
+        ((other.x - x).abs <= delta) &&
+        ((other.y - y).abs <= delta)
+    end
+
+    def translate(vector)
+      transform(vector.to_transform)
+    end
+
+    def translation_to(point)
+      Vector.translation_between(self, point)
+    end
+
+    def to_matrix
+      @matrix ||= Matrix[[x],[y],[1]].freeze
+    end
+
+    def transform(transformation)
+      transformation.call(self)
+    end
+
+    ZERO = new(0, 0)
+  end
+end

data/lib/draught/pointlike.rb

@@ -0,0 +1,35 @@
+module Draught
+  module Pointlike
+    def x
+      raise NotImplementedError, "including classes must return an x value"
+    end
+
+    def y
+      raise NotImplementedError, "including classes must return an y value"
+    end
+
+    def point_type
+      raise NotImplementedError, "including classes must return a Symbol with their point type"
+    end
+
+    def ==(other)
+      raise NotImplementedError, "including classes must implement equality checking. It's assumed other point_types are always unequal"
+    end
+
+    def approximates?(other, delta)
+      raise NotImplementedError, "including classes must implement approximate equality checking. It's assumed other point_types are always unequal"
+    end
+
+    def translate(vector)
+      raise NotImplementedError, "including classes must return a new instance translated by the vector arg"
+    end
+
+    def transform(transformer)
+      raise NotImplementedError, "including classes must return a new instance transformed by the Affine transform or lambda Point-based transform supplied"
+    end
+
+    def points
+      [self]
+    end
+  end
+end

data/lib/draught/renderer.rb

@@ -0,0 +1,93 @@
+require 'prawn'
+require_relative './curve'
+require_relative './cubic_bezier'
+
+module Draught
+  class Renderer
+    class PdfContext
+      include Prawn::View
+
+      attr_reader :width, :height
+
+      def initialize(width, height)
+        @width, @height = width, height
+      end
+
+      def document
+        @document ||= Prawn::Document.new(page_size: [width, height], margin: 0)
+      end
+
+      def draw_closed_path(path)
+        points = path.points.dup
+        close_and_stroke do
+          self.line_width = 0.003
+          move_to(*point_tuple(points.shift))
+          points.each do |pointlike|
+            draw_pointlike(pointlike)
+          end
+        end
+      end
+
+      def draw_pointlike(pointlike)
+        case pointlike
+        when Draught::Curve
+          pointlike.as_cubic_beziers.each do |cubic_bezier|
+            draw_pointlike(cubic_bezier)
+          end
+        when Draught::CubicBezier
+          curve_to(point_tuple(pointlike.end_point), {
+            bounds: [
+              point_tuple(pointlike.control_point_1),
+              point_tuple(pointlike.control_point_2)
+            ]
+          })
+        else
+          line_to(*point_tuple(pointlike))
+        end
+      end
+
+      def point_tuple(point)
+        [point.x, point.y]
+      end
+    end
+
+    def self.render_to_file(sheet, path)
+      new(sheet).render_to_file(path)
+    end
+
+    attr_reader :root_box
+
+    def initialize(root_box)
+      @root_box = root_box
+    end
+
+    def context
+      @context ||= PdfContext.new(root_box.width, root_box.height)
+    end
+
+    def render_to_file(path)
+      render && context.save_as(path)
+    end
+
+    def render
+      walk(root_box)
+    end
+
+    def render_container(container, context)
+    end
+
+    def render_path(path, context)
+      context.draw_closed_path(path)
+    end
+
+    private
+
+    def walk(box)
+      render_container(box, context) if box.box_type.include?(:container)
+      box.paths.each do |child|
+        render_path(child, context) if child.box_type.include?(:path)
+        walk(child)
+      end
+    end
+  end
+end

data/lib/draught/sheet.rb

@@ -0,0 +1,45 @@
+require_relative 'boxlike'
+require_relative 'point'
+
+module Draught
+  class Sheet
+    include Boxlike
+
+    attr_reader :containers, :lower_left, :width, :height
+
+    def initialize(opts = {})
+      @containers = opts.fetch(:containers)
+      @lower_left = opts.fetch(:lower_left, Point::ZERO)
+      @width = opts.fetch(:width)
+      @height = opts.fetch(:height)
+    end
+
+    def translate(point)
+      tr_lower_left = lower_left.translate(point)
+      tr_containers = containers.map { |container| container.translate(point) }
+      self.class.new(containers: tr_containers, lower_left: tr_lower_left, width: width, height: height)
+    end
+
+    def transform(transformer)
+      tr_lower_left = lower_left.transform(transformer)
+      tr_containers = containers.map { |container| container.transform(transformer) }
+      extent = Point.new(width, height).transform(transformer)
+      tr_width, tr_height = extent.x, extent.y
+      self.class.new({
+        containers: tr_containers, lower_left: tr_lower_left, width: tr_width, height: tr_height
+      })
+    end
+
+    def paths
+      containers
+    end
+
+    def box_type
+      [:container]
+    end
+
+    def ==(other)
+      lower_left == other.lower_left && width == other.width && height == other.height && containers == other.containers
+    end
+  end
+end

data/lib/draught/sheet_builder.rb

@@ -0,0 +1,144 @@
+require_relative 'sheet'
+require_relative 'point'
+
+module Draught
+  class SheetBuilder
+    attr_reader :max_height, :max_width, :outer_gap, :boxes
+
+    def self.sheet(args)
+      new(args).sheet
+    end
+
+    def initialize(opts = {})
+      @max_width = opts.fetch(:max_width)
+      @max_height = opts.fetch(:max_height)
+      @outer_gap = opts.fetch(:outer_gap, 0)
+      @boxes = opts.fetch(:boxes)
+    end
+
+    def sheet
+      containers = nested
+      Sheet.new({
+        lower_left: Point::ZERO,
+        containers: containers,
+        width: width(containers),
+        height: height(containers)
+      })
+    end
+
+    def ==(other)
+      comparison_args.inject(true) { |ok, meth_name|
+        send(meth_name) == other.send(meth_name) && ok
+      }
+    end
+
+    private
+
+    def comparison_args
+      [:max_width, :max_height, :outer_gap, :boxes]
+    end
+
+    def containers
+      @containers ||= nested
+    end
+
+    def nested
+      full = false
+      nested_boxes = []
+      boxes.cycle do |box|
+        break if full
+        placement_point = find_placement_point(box, nested_boxes)
+        if placement_point
+          nested_boxes << box.move_to(placement_point)
+        else
+          full = true
+        end
+      end
+      nested_boxes.map { |box| box.translate(origin_offset) }
+    end
+
+    def width(boxes)
+      edge_length(boxes, :left_edge, :right_edge)
+    end
+
+    def height(boxes)
+      edge_length(boxes, :bottom_edge, :top_edge)
+    end
+
+    def edge_length(boxes, min_method, max_method)
+      min = boxes.map(&min_method).min
+      max = boxes.map(&max_method).max
+      (max - min) + (2 * outer_gap)
+    end
+
+    def find_placement_point(box, placed_boxes)
+      return Point::ZERO if placeable_at_location?(box, Point::ZERO, placed_boxes)
+      placement_after_a_box(box, placed_boxes) || placement_above_a_box(box, placed_boxes)
+    end
+
+    def placement_after_a_box(box, placed_boxes)
+      placement_around_a_box(box, placed_boxes, :lower_right)
+    end
+
+    def placement_above_a_box(box, placed_boxes)
+      placement_around_a_box(box, placed_boxes, :upper_left)
+    end
+
+    def placement_around_a_box(box, placed_boxes, reference_point_method)
+      reference_box = placed_boxes.find { |placed_box|
+        point = offset(box, placed_box, reference_point_method)
+        placeable_at_location?(box, point, placed_boxes)
+      }
+      if reference_box
+        return offset(box, reference_box, reference_point_method)
+      end
+      false
+    end
+
+    def offset(box, reference_box, reference_point_method)
+      gap = [box.min_gap, reference_box.min_gap].max
+      offset_point(gap, reference_box, reference_point_method)
+    end
+
+    def offset_point(gap, box, reference_point_method)
+      offset = offset_translation(gap, reference_point_method)
+      box.send(reference_point_method).translate(offset)
+    end
+
+    def offset_translation(gap, reference_point_method)
+      case reference_point_method
+      when :lower_right
+        Vector.new(gap, 0)
+      when :upper_left
+        Vector.new(0, gap)
+      end
+    end
+
+    def placeable_at_location?(box, placement_point, placed_boxes)
+      box_to_place = box.move_to(placement_point)
+      no_overlaps?(box_to_place, placed_boxes) && fits?(box_to_place)
+    end
+
+    def no_overlaps?(box, placed_boxes)
+      placed_boxes.none? { |placed_box| box.overlaps?(placed_box) }
+    end
+
+    def fits?(box)
+      x = 0..usable_width
+      y = 0..usable_height
+      box.corners.all? { |point| x.include?(point.x) && y.include?(point.y) }
+    end
+
+    def usable_width
+      @usable_width ||= max_width - (2 * outer_gap)
+    end
+
+    def usable_height
+      @usable_height ||= max_height - (2 * outer_gap)
+    end
+
+    def origin_offset
+      Vector.new(outer_gap, outer_gap)
+    end
+  end
+end