laser-cutter 0.2.0

data/lib/laser-cutter/configuration.rb

@@ -0,0 +1,56 @@
+require 'hashie/mash'
+require 'prawn/measurement_extensions'
+
+
+module Laser
+  module Cutter
+    class Configuration < Hashie::Mash
+      DEFAULTS = {
+          units: 'mm',
+          page_size: 'LETTER',
+          page_layout: 'portrait'
+      }
+
+      UNIT_SPECIFIC_DEFAULTS = {
+          'mm' => {
+              margin: 5,
+              padding: 5,
+              stroke: 0.0254,
+          },
+          'in' => {
+              margin: 0.125,
+              padding: 0.1,
+              stroke: 0.001,
+          }
+      }
+
+      SIZE_REGEXP = /[\d\.]+x[\d\.]+x[\d\.]+\/[\d\.]+\/[\d\.]+/
+
+      FLOATS   = %w(width height depth thickness notch margin padding stroke)
+      REQUIRED = %w(width height depth thickness notch file)
+
+      def initialize(options = {})
+        options.delete_if{|k,v| v.nil?}
+        self.merge!(DEFAULTS)
+        self.merge!(options)
+        if self['size'] && self['size'] =~ SIZE_REGEXP
+          dim, self['thickness'], self['notch'] = self['size'].split('/')
+          self['width'],self['height'],self['depth'] = dim.split('x')
+          delete('size')
+        end
+        FLOATS.each do |k|
+          self[k] = self[k].to_f if (self[k] && self[k].is_a?(String))
+        end
+        self.merge!(UNIT_SPECIFIC_DEFAULTS[self['units']].merge(self))
+      end
+
+      def validate!
+        missing = []
+        REQUIRED.each do |k|
+          missing << k if self[k].nil?
+        end
+        raise "#{missing.join(', ')} #{missing.size > 1 ? 'are' : 'is'} required, but missing." unless missing.empty?
+      end
+    end
+  end
+end

data/lib/laser-cutter/geometry.rb

@@ -0,0 +1,14 @@
+module Laser
+  module Cutter
+    module Geometry
+      MINIMUM_NOTCHES_PER_SIDE = 3
+    end
+  end
+end
+
+require 'laser-cutter/geometry/tuple'
+require 'laser-cutter/geometry/dimensions'
+require 'laser-cutter/geometry/point'
+require 'laser-cutter/geometry/shape'
+require 'laser-cutter/geometry/edge'
+require 'laser-cutter/geometry/path_generator'

data/lib/laser-cutter/geometry/dimensions.rb

@@ -0,0 +1,30 @@
+module Laser
+  module Cutter
+    module Geometry
+      class Dimensions < Tuple
+
+        def w
+          coords[0]
+        end
+
+        def h
+          coords[1]
+        end
+
+        def d
+          coords[2]
+        end
+
+        def separator
+          'x'
+        end
+
+        def hash_keys
+          [:w, :h, :d]
+        end
+
+      end
+    end
+  end
+
+end

data/lib/laser-cutter/geometry/edge.rb

@@ -0,0 +1,33 @@
+module Laser
+  module Cutter
+    module Geometry
+      # This class represents a single edge of one side: both inside
+      # and outside edge of the material.  It's also responsible
+      # for calculating the "perfect" notch width.
+      class Edge < Struct.new(:outside, :inside, :notch_width)
+        attr_accessor :notch_count
+
+        def initialize(*args)
+          super(*args)
+          adjust_notch(self.inside)
+        end
+
+        def adjust_notch(line)
+          d = (line.length / notch_width).to_f.ceil
+          pairs = d / 2
+          d = pairs * 2 + 1
+          d = MINIMUM_NOTCHES_PER_SIDE if d < MINIMUM_NOTCHES_PER_SIDE
+          self.notch_width = line.length / (1.0 * d)
+          self.notch_count = d
+        end
+
+        # face_setting determines if we want that face to have center notch
+        # facing out (for a hole, etc).  This works well when we have odd number
+        # of notches, but
+        def add_across_line?(face_setting)
+          notch_count % 4 == 1 ? face_setting : !face_setting
+        end
+      end
+    end
+  end
+end

data/lib/laser-cutter/geometry/notched_path.rb

@@ -0,0 +1,46 @@
+module Laser
+  module Cutter
+    module Geometry
+      class NotchedPath
+        attr_accessor :lines, :vertices, :corner_boxes
+        def initialize(vertices = [])
+          @vertices = vertices
+          @lines = []
+          @corner_boxes = []
+        end
+
+        def << value
+          self.vertices << value
+        end
+
+        def [] value
+          self.vertices[value]
+        end
+
+        def size
+          self.vertices.size
+        end
+
+        def create_lines
+          self.lines = []
+          self.vertices.each_with_index do |v, i|
+            if v != vertices.last
+              self.lines << Line.new(v, vertices[i+1])
+            end
+          end
+          self.corner_boxes.each do |box|
+            box.relocate!
+            self.lines << box.sides
+          end
+
+          self.lines.flatten!
+          self.lines
+        end
+
+      end
+
+    end
+
+  end
+end
+

data/lib/laser-cutter/geometry/path_generator.rb

@@ -0,0 +1,132 @@
+require_relative 'notched_path'
+
+module Laser
+  module Cutter
+    module Geometry
+      class Shift < Struct.new(:delta, :direction, :dim_index)
+        POINTERS = {[1, 0]  => '   ->',
+                    [-1, 0] => '<-   ',
+                    [1, 1]  => '  V  ',
+                    [-1, 1] => '  ^  '}
+
+        def next(point1)
+          p = Point.new(point1.to_a)
+          p.coords[dim_index] += (delta * direction)
+          p
+        end
+        def to_s
+          "shift by:#{sprintf('%.2f', delta)}, #{POINTERS[[direction,dim_index]]}"
+        end
+      end
+
+      # Alternating iterator
+      class InfiniteIterator < Struct.new(:shift_array)
+        attr_accessor :current_index
+        def next
+          self.current_index = -1 if current_index.nil?
+          self.current_index += 1
+          self.current_index = current_index % shift_array.size
+          shift_array[current_index]
+        end
+      end
+
+      class PathGenerator
+        # Removes the items from the list that appear more than once
+        # Unlike uniq-ing which keeps all elements, just ensures that are not
+        # repeated, here we remove elements completely if they are seen more than once.
+        # This is used to remove lines
+        def self.deduplicate list
+          new_list = []
+          list.sort!
+          list.each_with_index do |e, i|
+            next if i < (list.size - 1) && e.eql?(list[i + 1])
+            next if i > 0 && e.eql?(list[i - 1])
+            new_list << e
+          end
+          new_list
+        end
+
+        attr_accessor :notch_width, :thickness
+        attr_accessor :center_out, :fill_corners
+
+        def initialize(options = {})
+          @notch_width = options[:notch_width]    # only desired, will be adapted for each line
+          @center_out = options[:center_out]      # when true, the notch in the middle of the edge is out, not in.
+          @thickness = options[:thickness]
+
+          # 2D array of booleans.  If true first or second end of the edge is
+          # created with a corner filled in.
+          @fill_corners = options[:fill_corners]
+        end
+
+        # Calculates a notched path that flows between the outer edge of the box
+        # (outside_line) and inner (inside_line).  Relative location of these lines
+        # also defines the direction and orientation of the box, and hence the notches.
+        #
+        # We always want to create a symmetric path that has a notch in the middle
+        # (for center_out = true) or dip in the middle (center_out = false)
+        def path(edge)
+          shifts = define_shifts(edge)
+
+          path = NotchedPath.new
+
+          if fill_corners
+            r1 = Geometry::Rect.new(edge.inside.p1, edge.outside.p1)
+            r2 = Geometry::Rect.new(edge.inside.p2, edge.outside.p2)
+            path.corner_boxes << r1
+            path.corner_boxes << r2
+          end
+
+          point = edge.inside.p1.clone
+          vertices = [point]
+          shifts.each do |shift|
+            point = shift.next(point)
+            vertices << point
+          end
+          path.vertices = vertices
+          path
+        end
+
+        private
+
+        # This method has the bulk of the logic: we create the list of path deltas
+        # to be applied when we walk the edge next.
+        def define_shifts(edge)
+          along_iterator, across_iterator = define_shift_iterators(edge)
+          shifts = []
+
+          shifts << across_iterator.next if edge.add_across_line?(center_out)
+
+          (1..edge.notch_count).to_a.each do |count|
+            shifts << along_iterator.next
+            shifts << across_iterator.next unless count == edge.notch_count
+          end
+
+          shifts << across_iterator.next if edge.add_across_line?(center_out)
+          shifts
+        end
+
+        # As we draw notches, shifts define the 'delta' – movement from one point
+        # to the next.  This method defines three types of movements we'll be doing:
+        # one alongside the edge, and two across (towards the box and outward from the box)
+        def define_shift_iterators(edge)
+          alongside_dimension = (edge.inside.p1.x == edge.inside.p2.x) ? 1 : 0
+          alongside_direction = (edge.inside.p1.coords[alongside_dimension] <
+              edge.inside.p2.coords[alongside_dimension]) ? 1 : -1
+
+          across_dimension = (alongside_dimension + 1) % 2
+          across_direction = (edge.inside.p1.coords[across_dimension] >
+              edge.outside.p1.coords[across_dimension]) ? -1 : 1
+
+          [
+           InfiniteIterator.new(
+               [Shift.new(edge.notch_width, alongside_direction, alongside_dimension)]),
+           InfiniteIterator.new(
+               [Shift.new(thickness, across_direction, across_dimension),
+                Shift.new(thickness, -across_direction, across_dimension)])
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/laser-cutter/geometry/point.rb

@@ -0,0 +1,57 @@
+module Laser
+  module Cutter
+    module Geometry
+      class Point < Tuple
+        def self.[] *array
+          Point.new *array
+        end
+
+        def customize_args(args)
+          if args.first.is_a?(Point)
+            return args.first.to_a
+          end
+          args
+        end
+
+        def x= value
+          coords[0] = value
+        end
+
+        def x
+          coords[0]
+        end
+
+        def y= value
+          coords[1] = value
+        end
+
+        def y
+          coords[1]
+        end
+
+        def separator
+          ','
+        end
+
+        def hash_keys
+          [:x, :y]
+        end
+
+        def move_by w, h
+          Point.new(x + w, y + h)
+        end
+
+        def <=>(other)
+          self.x == other.x ? self.y <=> other.y : self.x <=> other.x
+        end
+
+        def < (other)
+          self.x == other.x ? self.y < other.y : self.x < other.x
+        end
+        def > (other)
+          self.x == other.x ? self.y > other.y : self.x > other.x
+        end
+      end
+    end
+  end
+end

data/lib/laser-cutter/geometry/shape.rb

@@ -0,0 +1,36 @@
+module Laser
+  module Cutter
+    module Geometry
+      class Shape
+        attr_accessor :position, :name
+
+        def position
+          @position ||= Point.new(0, 0)
+        end
+
+        def x= value
+          position.x = value
+        end
+
+        def y= value
+          position.y = value
+        end
+
+        def move_to new_point
+          self.position = new_point
+          relocate!
+          self
+        end
+
+
+        # Implement in each shape to move to the new pointd
+        def relocate!
+          raise 'Abstract method'
+        end
+      end
+    end
+  end
+end
+
+require_relative 'shape/line'
+require_relative 'shape/rect'

data/lib/laser-cutter/geometry/shape/line.rb

@@ -0,0 +1,66 @@
+module Laser
+  module Cutter
+    module Geometry
+      class Line < Shape
+        attr_accessor :p1, :p2
+
+        def initialize(point1, point2 = nil)
+          if point1.is_a?(Hash)
+            options = point1
+            self.p1 = Point.new(options[:from])
+            self.p2 = Point.new(options[:to])
+          else
+            self.p1 = point1.clone
+            self.p2 = point2.clone
+          end
+          self.position = p1.clone
+          raise 'Both points are required for line definition' unless (p1 && p2)
+        end
+
+        def relocate!
+          dx = p2.x - p1.x
+          dy = p2.y - p1.y
+
+          self.p1 = position.clone
+          self.p2 = Point[p1.x + dx, p1.y + dy]
+          self
+        end
+
+        def center
+          Point.new((p2.x + p1.x) / 2, (p2.y + p1.y) / 2)
+        end
+
+        def length
+          Math.sqrt((p2.x - p1.x)**2 + (p2.y - p1.y)**2)
+        end
+
+        def to_s
+          "#{self.class.name.gsub(/.*::/,'').downcase} #{p1}=>#{p2}"
+        end
+
+        def eql?(other)
+          (other.p1.eql?(p1) && other.p2.eql?(p2)) ||
+          (other.p2.eql?(p1) && other.p1.eql?(p2))
+        end
+
+        def normalized
+          p1 < p2 ? Line.new(p1, p2) : Line.new(p2, p1)
+        end
+
+        def <=>(other)
+          self.normalized.to_s <=> other.normalized.to_s
+        end
+
+        def hash
+          [p1.to_a, p2.to_a].sort.hash
+        end
+
+        def clone
+          self.class.new(p1, p2)
+        end
+
+      end
+
+    end
+  end
+end