laser-cutter 0.5.3 → 1.0.0

data/lib/laser-cutter/notching.rb

@@ -0,0 +1,10 @@
+module Laser
+  module Cutter
+    module Notching
+    end
+  end
+end
+
+require_relative 'notching/base'
+require_relative 'notching/edge'
+require_relative 'notching/path_generator'

data/lib/laser-cutter/notching/base.rb

@@ -0,0 +1,13 @@
+module Laser::Cutter::Notching
+  class Base
+    attr_accessor :edge
+
+    def initialize(edge)
+      @edge = edge
+    end
+
+    def notches
+      raise 'Abstract method'
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Laser
+  module Cutter
+    module Notching
+      MINIMUM_NOTCHES_PER_SIDE = 3
+      # 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
+
+        attr_accessor :outside, :inside
+        attr_accessor :notch_width
+        attr_accessor :thickness, :kerf
+        attr_accessor :center_out, :corners, :adjust_corners
+        attr_accessor :notch_count, :v1, :v2
+
+
+        def initialize(outside, inside, options = {})
+          self.outside = outside.clone
+          self.inside = inside.clone
+
+          # two vectors representing directions going from beginning of each inside line to the outside
+          self.v1 = [inside.p1.x - outside.p1.x, inside.p1.y - outside.p1.y].map{|e| -(e / e.abs).to_f }
+          self.v2 = [inside.p2.x - outside.p2.x, inside.p2.y - outside.p2.y].map{|e| -(e / e.abs).to_f }
+
+          self.v1 = Vector.[](*self.v1)
+          self.v2 = Vector.[](*self.v2)
+
+          self.center_out = options[:center_out] || false
+          self.thickness = options[:thickness]
+          self.corners = options[:corners]
+          self.kerf = options[:kerf] || 0
+          self.notch_width = options[:notch_width]
+          self.adjust_corners = options[:adjust_corners]
+
+          adjust_for_kerf!
+          calculate_notch_width!
+        end
+
+        def adjust_for_kerf!
+          if kerf?
+            k = kerf / 2.0
+            p1 = inside.p1.plus(v1 * k)
+            p2 = inside.p2.plus(v2 * k)
+            self.inside = Geometry::Line.new(p1, p2)
+
+            p1 = outside.p1.plus(v1 * k)
+            p2 = outside.p2.plus(v2 * k)
+            self.outside = Geometry::Line.new(p1, p2)
+
+            inside.relocate!
+            outside.relocate!
+            # note – we have not increased the length of the sides to compensate
+            # for kerf – we simply shifted both lines. We'll compenensate for this
+            # in notch width calculations later, and also corner box inclusion.
+          end
+        end
+
+        def kerf?
+          self.kerf > 0.0
+        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
+
+        # True if the first notch should be a tab (sticking out), or false if it's a hole.
+        def first_notch_out?
+          add_across_line?(center_out)
+        end
+        private
+
+        def calculate_notch_width!
+          length = kerf? ? self.inside.length - kerf : self.inside.length
+          count = (length / notch_width).to_f.ceil + 1
+          count = (count / 2 * 2) + 1 # make count always an odd number
+          count = [MINIMUM_NOTCHES_PER_SIDE, count].max
+          self.notch_width = 1.0 * length / count
+          self.notch_count = count
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+
+module Laser
+  module Cutter
+    module Notching
+      class Shift < Struct.new(:delta, :direction, :dim_index)
+        def next_point_after point
+          p = point.clone
+          shift = []
+          shift[dim_index] = delta * direction
+          shift[(dim_index + 1) % 2] = 0
+          p.plus *shift
+        end
+      end
+
+      # Alternating iterator
+      class InfiniteIterator < Struct.new(:array)
+        attr_accessor :array, :next_index, :calls
+
+        def initialize(array)
+          self.array = array
+          self.calls = 0
+          self.next_index = 0
+        end
+
+        def next
+          item = self.array[next_index].clone
+          self.next_index += 1
+          self.next_index %= array.size
+          self.calls += 1
+          item = yield item, self.calls if block_given?
+          item
+        end
+      end
+
+      class PathGenerator
+
+        extend Forwardable
+        %i(center_out thickness corners kerf kerf? notch_width first_notch_out? adjust_corners corners).each do |method_name|
+          def_delegator :@edge, method_name, method_name
+        end
+
+        attr_accessor :edge
+
+        # This class generates lines that zigzag between two lines: the outside line, and the
+        # inside line of a single edge. Edge class encapsulates both of them with additional
+        # properties.
+        def initialize(edge)
+          @edge = edge
+        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 generate
+          shifts = define_shifts
+          vertices = []
+          lines = []
+
+          if corners
+            lines << corner_box_sides
+          end
+
+          point = starting_point
+
+          vertices << point
+          adjust_for_kerf(vertices,-1) if adjust_corners && !first_notch_out?
+          shifts.each do |shift|
+            point = shift.next_point_after point
+            vertices << point
+          end
+          adjust_for_kerf(vertices, 1) if adjust_corners && !first_notch_out?
+          lines << create_lines(vertices)
+          lines.flatten
+        end
+
+        def adjust_for_kerf(vertices, direction)
+          if kerf?
+            point = vertices.pop
+            point = corners ? point.plus(2 * direction * shift_vector(1)) : point
+            vertices << point
+          end
+        end
+
+        def corner_box_sides
+          boxes = []
+          extra_lines = []
+          sides = []
+
+          # These two boxes occupy the corners of the 3D box. They do not match
+          # in width to our notches because they are usually merged with them.
+          # It's just an aesthetic choice I guess.
+          boxes << Geometry::Rect[edge.inside.p1.clone, edge.outside.p1.clone]
+          boxes << Geometry::Rect[edge.inside.p2.clone, edge.outside.p2.clone]
+
+          if kerf?
+            if adjust_corners
+              if first_notch_out?
+                k = 2
+                direction = -1
+                dim_index = 1
+                extra_lines << add_corners_when_out(dim_index, direction, k)
+              else
+                k = -2
+                direction = 1
+                dim_index = 0
+                extra_lines << add_boxes_when_in(dim_index, direction, k)
+              end
+            end
+          end
+          sides = boxes.flatten.map(&:relocate!).map(&:sides)
+          sides << extra_lines if !extra_lines.empty?
+          sides.flatten
+        end
+
+        def add_boxes_when_in(dim_index, direction, k)
+          v1 = k * direction * shift_vector(1, dim_index)
+          v2 = k * direction * shift_vector(2, dim_index)
+          p1 = edge.inside.p1.plus(v1)
+          coords = []
+          coords[d_index_along] = edge.inside.p1[d_index_along]
+          coords[d_index_across] = edge.outside.p1[d_index_across]
+          p2 = Geometry::Point[*coords]
+          r1 = Geometry::Rect[p1, p2]
+
+          p1 = edge.inside.p2.plus(v2)
+          coords = []
+          coords[d_index_along] = edge.inside.p2[d_index_along]
+          coords[d_index_across] = edge.outside.p2[d_index_across]
+          p2 = Geometry::Point[*coords]
+          r2 = Geometry::Rect[p1, p2]
+          lines = [r1, r2].map(&:sides).flatten
+          lines << Geometry::Line[edge.inside.p1.plus(v1), edge.inside.p1.clone]
+          lines << Geometry::Line[edge.inside.p2.plus(v2), edge.inside.p2.clone]
+          lines
+        end
+
+        def add_corners_when_out(dim_index, direction, k)
+          v1 = direction * k * shift_vector(1, dim_index)
+          v2 = direction * k * shift_vector(2, dim_index)
+          p1 = edge.inside.p1.plus(v1)
+          coords = []
+          coords[d_index_along] = edge.outside.p1[d_index_along]
+          coords[d_index_across] = edge.inside.p1[d_index_across]
+          p2 = Geometry::Point[*coords]
+          r1 = Geometry::Rect[p1, p2]
+
+          p1 = edge.inside.p2.plus(v2)
+          coords = []
+          coords[d_index_along] = edge.outside.p2[d_index_along]
+          coords[d_index_across] = edge.inside.p2[d_index_across]
+          p2 = Geometry::Point[*coords]
+          r2 = Geometry::Rect[p1, p2]
+          lines = [r1, r2].map(&:sides).flatten
+          lines << Geometry::Line[edge.inside.p1.plus(v1), edge.inside.p1.clone]
+          lines << Geometry::Line[edge.inside.p2.plus(v2), edge.inside.p2.clone]
+          lines
+        end
+
+        def shift_vector(index, dim_shift = 0)
+          shift = []
+          shift[(d_index_across + dim_shift) % 2] = 0
+          shift[(d_index_along + dim_shift) % 2] = kerf / 2.0 * edge.send("v#{index}".to_sym).[]((d_index_along + dim_shift) % 2)
+          Vector.[](*shift)
+        end
+
+
+        def starting_point
+          edge.inside.p1.clone # start
+        end
+
+        # 0 = X, 1 = Y
+        def d_index_along
+          (edge.inside.p1.x == edge.inside.p2.x) ? 1 : 0
+        end
+
+        def d_index_across
+          (d_index_along + 1) % 2
+        end
+
+        def direction_along
+          (edge.inside.p1.coords.[](d_index_along) < edge.inside.p2.coords.[](d_index_along)) ? 1 : -1
+        end
+
+        def direction_across
+          (edge.inside.p1.coords.[](d_index_across) < edge.outside.p1.coords.[](d_index_across)) ? 1 : -1
+        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.
+        # @param [Object] shift
+        def define_shifts
+          along_iter = create_iterator_along
+          across_iter = create_iterator_across
+
+          shifts = []
+          inner = true # false when we are drawing outer notch, true when inner
+
+          if first_notch_out?
+            shifts << across_iter.next
+            inner = !inner
+          end
+
+          (1..edge.notch_count).to_a.each do |notch_number|
+            shifts << along_iter.next do |shift, index|
+              if inner && (notch_number > 1 && notch_number < edge.notch_count)
+                shift.delta -= kerf
+              elsif !inner
+                shift.delta += kerf
+              end
+              inner = !inner
+              shift
+            end
+            shifts << across_iter.next unless notch_number == edge.notch_count
+          end
+
+          shifts << across_iter.next if first_notch_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 create_iterator_along
+          InfiniteIterator.new([Shift.new(notch_width, direction_along, d_index_along)])
+        end
+
+        def create_iterator_across
+          InfiniteIterator.new([Shift.new(thickness, direction_across, d_index_across),
+                                Shift.new(thickness, -direction_across, d_index_across)])
+        end
+
+        def create_lines(vertices)
+          lines = []
+          vertices.each_with_index do |v, i|
+            if v != vertices.last
+              lines << Geometry::Line.new(v, vertices[i+1])
+            end
+          end
+          lines.flatten
+        end
+      end
+    end
+  end
+end

data/lib/laser-cutter/renderer/base.rb

@@ -6,7 +6,7 @@ module Laser
       # page_manager contains access to units and page sizes
       class Base
         BLACK = "000000"
-        BLUE = "4090E0"
+        BLUE = "0070E0"
 
         attr_accessor :config, :subject, :enclosure, :page_manager
 

data/lib/laser-cutter/renderer/box_renderer.rb

@@ -24,8 +24,8 @@ module Laser
           renderer = self
           pdf.instance_eval do
             self.line_width = renderer.config.stroke.send(renderer.config.units.to_sym)
-            stroke_color BLACK
-            renderer.box.notches.each do |notch|
+            stroke_color renderer.config[:color] || BLACK
+            renderer.box.generate_notches.each do |notch|
               LineRenderer.new(renderer.config, notch).render(self)
             end
           end

data/lib/laser-cutter/renderer/layout_renderer.rb

@@ -11,23 +11,34 @@ module Laser
 
         def render
           renderer = self
+          renderers = []
 
-          margin = config.margin.to_f.send(config.units.to_sym)
-          meta_renderer = MetaRenderer.new(config)
           box_renderer = BoxRenderer.new(config)
-          box_renderer.ensure_space_for(meta_renderer.enclosure) if config.metadata
+          renderers << box_renderer
+
+          if config.metadata
+            meta_renderer = MetaRenderer.new(config)
+            renderers << meta_renderer
+            box_renderer.ensure_space_for(meta_renderer.enclosure)
+          end
 
+          if config.debug
+            unkerfed_config = Laser::Cutter::Configuration.new(config.to_hash)
+            unkerfed_config.merge!(kerf: 0.0, color: 'DD2211')
+            unkerfed_box_renderer = BoxRenderer.new(unkerfed_config)
+            unkerfed_box_renderer.ensure_space_for(meta_renderer.enclosure) if meta_renderer
+            renderers << unkerfed_box_renderer
+          end
+
+          margin = config.margin.to_f.send(config.units.to_sym)
           page_size = config.page_size || calculate_image_boundary(box_renderer, margin)
 
           pdf = Prawn::Document.new(:margin => margin,
                                     :page_size => page_size,
-                                    :page_layout => config.page_layout.to_sym)
+                                    :page_layout => self.config.page_layout.to_sym)
 
           pdf.instance_eval do
-            if renderer.config.metadata
-              meta_renderer.render(self)
-            end
-            box_renderer.render(self)
+            renderers.each {|r|  r.render(self) }
             render_file(renderer.config.file)
           end
 

data/lib/laser-cutter/renderer/meta_renderer.rb

@@ -1,7 +1,8 @@
 # encoding: utf-8
-require 'json'
 class Laser::Cutter::Renderer::MetaRenderer < Laser::Cutter::Renderer::Base
 
+  META_KEYS = %w(units width height depth thickness notch kerf stroke padding margin page_size page_layout)
+
   def initialize(config = {})
     self.config = config
     self.enclosure = Laser::Cutter::Geometry::Rect.create(Laser::Cutter::Geometry::Point[1, 1], 140, 150)
@@ -19,11 +20,14 @@ class Laser::Cutter::Renderer::MetaRenderer < Laser::Cutter::Renderer::Base
     EOF
 
     meta_color = BLUE
-    meta_top_height = 50
+    meta_top_height = 55
 
     metadata = config.to_hash
-    metadata.delete_if { |k| %w(verbose metadata open file).include?(k) }
     metadata['page_size'] ||= 'custom'
+    metadata.delete('page_layout') if metadata['page_size'].eql?('custom')
+
+    meta_fields = META_KEYS.find_all{|k| metadata[k]}.join(": \n") + ": \n"
+    meta_values = META_KEYS.find_all{|k| metadata[k]}.map{|k| metadata[k] }.join("\n")
 
     rect = self.enclosure
 
@@ -41,13 +45,8 @@ class Laser::Cutter::Renderer::MetaRenderer < Laser::Cutter::Renderer::Base
             end
           end
 
-          # print values of the config, in two parts – keys right aligned first,
-          # values left aligned second.
+          # print values of the config, in two parts – keys right aligned first, values left aligned second.
           float do
-            # parse out meta keys and then values
-            meta_fields = JSON.pretty_generate(metadata).gsub(/[\{\}",]/, '').gsub(/:.*\n/x, "\n")
-            meta_values = JSON.pretty_generate(metadata).gsub(/[\{\}",]/, '').gsub(/\n?.*:/x, "\n:")
-
             bounding_box([0, rect.h - meta_top_height],
                          :width => rect.w,
                          :height => rect.h - meta_top_height) do