laser-cutter 1.0.5 → 2.0.0

data/lib/{laser-cutter → laser/cutter}/notching/path_generator.rb

@@ -1,51 +1,11 @@
-require 'forwardable'
+# frozen_string_literal: true
+
 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
-
-      # One of the key "tricks" that this algorithm applies, is that it converts everything into
-      # pure set of lines in the end. It then tries to find all intersections of the lines so that
-      # we can remove duplicates.  So any segment of any line that is covered by 2 lines or more is removed,
-      # cleared completely for an empty space.  This turns out to be very useful indeed, because we can
-      # paint with wide brush strokes to get the carcass, and then fine tune it by adding or removing line
-      # segments.  Some of the lines below are added to actually remove the lines that might have otherwise
-      # been there.
-      #
-      # This comes especially handy when drawing corner boxes, which are deliberately made not to match the notch
-      # width, but to match thickness of the material.  The corner notces for these sides will therefore have
-      # length equal to the thickness + regular notch length.
       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
@@ -77,7 +37,7 @@ module Laser
           point = starting_point
 
           vertices << point
-          adjust_for_kerf(vertices,-1) if adjust_corners && !first_notch_out?
+          adjust_for_kerf(vertices, -1) if adjust_corners && !first_notch_out?
           shifts.each do |shift|
             point = shift.next_point_after point
             vertices << point
@@ -88,45 +48,99 @@ module Laser
         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
+          return unless kerf?
+
+          point = vertices.pop
+          point = point.plus(2 * direction * shift_vector(1)) if corners
+          vertices << point
         end
 
-        # 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. Their
-        # size is equal to the thickness of the material (adjusted for kerf)
-        # It's just an aesthetic choice I guess.
         def corner_box_sides
           boxes = []
           extra_lines = []
 
+          # 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]
 
-          extra_lines << add_corners if adjust_corners && kerf?
+          if kerf? && 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
           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)
+          shift[(d_index_along + dim_shift) % 2] = kerf / 2.0 * edge.send(:"v#{index}").[]((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
+          edge.inside.p1.x == edge.inside.p2.x ? 1 : 0
         end
 
         def d_index_across
@@ -134,46 +148,14 @@ module Laser
         end
 
         def direction_along
-          (edge.inside.p1.coords.[](d_index_along) < edge.inside.p2.coords.[](d_index_along)) ? 1 : -1
+          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
+          edge.inside.p1.coords.[](d_index_across) < edge.outside.p1.coords.[](d_index_across) ? 1 : -1
         end
 
         private
-        # Helper method to calculate dimensions of our corners.
-        def add_corners
-          k, direction, dim_index, edge_along, edge_across = if first_notch_out?
-            [2, -1, 1, :inside, :outside]
-          else
-            [-2, 1, 0, :outside, :inside]
-          end
-          v1 = direction * k * shift_vector(1, dim_index)
-          v2 = direction * k * shift_vector(2, dim_index)
-
-          r1 = define_corner_rect(:p1, v1, edge_along, edge_across)
-          r2 = define_corner_rect(:p2, v2, edge_along, edge_across)
-
-          lines = [r1, r2].map(&:sides).flatten
-
-          # Our clever algorithm removes automatically duplicate lines. These lines
-          # below are added to actually clear out this space and remove the existing
-          # lines that are already there.
-          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 define_corner_rect(point, delta, edge_along, edge_across)
-          p1 = edge.inside.send(point).plus(delta)
-          coords = []
-          coords[d_index_along] = edge.send(edge_along).send(point)[d_index_along]
-          coords[d_index_across] = edge.send(edge_across).send(point)[d_index_across]
-          p2 = Geometry::Point[*coords]
-          Geometry::Rect[p1, p2]
-        end
-
 
         # This method has the bulk of the logic: we create the list of path deltas
         # to be applied when we walk the edge next.
@@ -191,8 +173,8 @@ module Laser
           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)
+            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
@@ -223,7 +205,7 @@ module Laser
           lines = []
           vertices.each_with_index do |v, i|
             if v != vertices.last
-              lines << Geometry::Line.new(v, vertices[i+1])
+              lines << Geometry::Line.new(v, vertices[i + 1])
             end
           end
           lines.flatten

data/lib/laser/cutter/notching/shift.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module Notching
+      Shift = Struct.new(:delta, :direction, :dim_index) do
+        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
+    end
+  end
+end

data/lib/laser/cutter/page_manager.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    class PageManager
+      SIZES = PDF::Core::PageGeometry::SIZES.clone.freeze
+
+      attr_reader :units
+
+      # @param units [String, Symbol] 'in' or 'mm'; the configuration's default is a Symbol
+      def initialize(units)
+        @units = units.to_s
+      end
+
+      def all_page_sizes
+        output = +""
+        page_size_values.each do |k|
+          output << sprintf("\t%10s:\t%6.1f x %6.1f\n", *k)
+        end
+        output
+      end
+
+      # if from_units is nil, we expect it to be in dots per inch (default
+      # measurements for Prawn
+      def value_from_units(value, from_units = nil)
+        multiplier = if from_units.nil?
+                       if units.eql?('in')
+                         1.0 / 72.0 # PDF units per inch
+                       else
+                         25.4 * 1.0 / 72.0
+                       end
+                     elsif units.eql?(from_units)
+                       1.0
+                     elsif units.eql?('in') && from_units.eql?('mm')
+                       (1.0 / 25.4)
+                     else
+                       25.4
+                     end
+        value.to_f * multiplier
+      end
+
+      def page_size_values
+        h = Hashie::Mash.new(SIZES)
+        h.keys.sort.map do |k|
+          [k, value_from_units(h[k][0].to_f), value_from_units(h[k][1].to_f)]
+        end
+      end
+    end
+  end
+end

data/lib/{laser-cutter → laser/cutter}/renderer/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Renderer
@@ -21,10 +23,9 @@ module Laser
         end
 
         def units
-          config.units.to_sym || :mm
+          config.units.to_sym
         end
       end
     end
   end
 end
-

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module Renderer
+      class BoxRenderer < Base
+        alias_method :box, :subject
+
+        def initialize(config)
+          super
+          self.subject = Laser::Cutter::Box.new(config)
+        end
+
+        def ensure_space_for(rect)
+          coords = [rect.p2.x, rect.p2.y].map{ |a| page_manager.value_from_units(a) }
+          box.metadata = Geometry::Point.new(coords)
+        end
+
+        def enclosure
+          box.enclosure
+        end
+
+        # @return [Array<Geometry::Line>] every line to cut, computed once
+        def lines
+          @lines ||= box.generate_notches
+        end
+
+        # Draws the box, yielding after each line so a caller can count them.
+        def render(pdf = nil)
+          pdf.line_width = config.stroke.send(units)
+          pdf.stroke_color config[:color] || BLACK
+          lines.each do |line|
+            LineRenderer.new(config, line).render(pdf)
+            yield line if block_given?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module Renderer
+      # Writes the PDF: the box, its metadata block, and the unkerfed outline
+      # when asked for.
+      class LayoutRenderer < Base
+        UNKERFED_COLOR = 'DD2211'
+
+        def initialize(config)
+          self.config = config
+          super
+        end
+
+        # @return [Integer] how many lines {#render} draws, and yields
+        def total
+          box_renderers.sum { |renderer| renderer.lines.size }
+        end
+
+        # Writes the file, yielding after each line drawn.
+        def render(&)
+          margin = config.margin.to_f.send(units)
+          pdf = Prawn::Document.new(margin:      margin,
+                                    page_size:   config.page_size || calculate_image_boundary(box_renderers.first, margin),
+                                    page_layout: config.page_layout.to_sym)
+
+          box_renderers.first.render(pdf, &)
+          meta_renderer&.render(pdf)
+          box_renderers.drop(1).each { |renderer| renderer.render(pdf, &) }
+          pdf.render_file(config.file)
+        end
+
+        def calculate_image_boundary(box_renderer, margin)
+          box_renderer.enclosure.to_a[1].map do |c|
+            c.send(units) + (2 * margin)
+          end
+        end
+
+        private
+
+        def meta_renderer
+          @meta_renderer ||= MetaRenderer.new(config) if config.metadata
+        end
+
+        # The box, then the same box without kerf when config.debug is set.
+        def box_renderers
+          @box_renderers ||= begin
+            configs = [config]
+            configs << Configuration.new(config.to_hash).merge!(kerf: 0.0, color: UNKERFED_COLOR) if config.debug
+            configs.map do |box_config|
+              BoxRenderer.new(box_config).tap do |renderer|
+                renderer.ensure_space_for(meta_renderer.enclosure) if meta_renderer
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/renderer/line_renderer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module Renderer
+      class LineRenderer < Base
+        alias_method :line, :subject
+        def render(pdf = nil)
+          pdf.stroke {
+            pdf.line([line.p1.x, line.p1.y].map{ |p| p.send(units) },
+                     [line.p2.x, line.p2.y].map{ |p| p.send(units) })
+          }
+        end
+
+        def enclosure
+          line
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module Renderer
+      class MetaRenderer < Laser::Cutter::Renderer::Base
+        META_KEYS = %i(units width height depth thickness notch kerf stroke padding margin page_size page_layout).freeze
+
+        def initialize(config = {})
+          self.config = config
+          self.enclosure = Laser::Cutter::Geometry::Rect.create(Laser::Cutter::Geometry::Point[1, 1], 140, 150)
+        end
+
+        def render(pdf = nil)
+          banner = <<-EOF
+
+    Made with Laser Cutter Ruby Gem (v#{Laser::Cutter::VERSION})
+    Credits to Prawn for ruby PDF generation,
+    and BoxMaker for inspiration.
+
+    Online: http://makeabox.io/
+    Source: https://github.com/kigster/laser-cutter
+          EOF
+
+          meta_color = BLUE
+          meta_top_height = 55
+
+          metadata = config.to_hash
+          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].to_s }.join("\n")
+
+          rect = enclosure
+
+          pdf.instance_eval do
+            self.line_width = 0.2.mm
+            float do
+              bounding_box([rect.p1.x, rect.h + rect.p1.y], width: rect.w, height: rect.h) do
+                stroke_color meta_color
+                stroke_bounds
+
+                # Print banner
+                indent 10 do
+                  font('Helvetica', size: 6) do
+                    text banner, color: meta_color
+                  end
+                end
+
+                # print values of the config, in two parts – keys right aligned first, values left aligned second.
+                float do
+                  bounding_box([0, rect.h - meta_top_height],
+                               width:  rect.w,
+                               height: rect.h - meta_top_height) do
+                    float do
+                      bounding_box([0, rect.h - meta_top_height], width: 70, height: rect.h - meta_top_height) do
+                        indent 10 do
+                          font('Helvetica', size: 7) do
+                            text meta_fields, color: meta_color, align: :right
+                          end
+                        end
+                      end
+                    end
+                    float do
+                      bounding_box([60, rect.h - meta_top_height], width: 70, height: rect.h - meta_top_height) do
+                        indent 10 do
+                          font('Helvetica', size: 7) do
+                            text meta_values, color: meta_color
+                          end
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/{laser-cutter → laser/cutter}/renderer/rect_renderer.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Renderer
       class RectRenderer < Base
         alias_method :rect, :subject
-        def render pdf
+        def render(pdf)
           rect.sides.each do |side|
             LineRenderer.new(config, side).render(pdf)
           end

data/lib/laser/cutter/renderer/svg_renderer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'victor'
+
+module Laser
+  module Cutter
+    module Renderer
+      # Writes the box as an SVG sized in the configuration's own units. It
+      # fits the page to the box, and carries the metadata as a <desc>
+      # instead of drawing it.
+      class SvgRenderer < Base
+        def initialize(config)
+          super
+          self.subject = Laser::Cutter::Box.new(config)
+        end
+
+        # @return [Array<Geometry::Line>] every line to cut, computed once
+        def lines
+          @lines ||= subject.generate_notches
+        end
+
+        # @return [Integer] how many lines {#render} draws, and yields
+        def total
+          lines.size
+        end
+
+        # Writes the file, yielding after each line drawn.
+        def render
+          svg = Victor::SVG.new(width: "#{width}#{units}", height: "#{height}#{units}", viewBox: "0 0 #{width} #{height}")
+          svg.element(:desc, description) if config.metadata
+          lines.each do |line|
+            svg.line(**coordinates(line), stroke: "##{config[:color] || BLACK}", stroke_width: config.stroke)
+            yield line if block_given?
+          end
+          File.write(config.file, svg.render)
+        end
+
+        private
+
+        def margin
+          config.margin.to_f
+        end
+
+        def width
+          (subject.enclosure.p2.x + (2 * margin)).round(5)
+        end
+
+        def height
+          (subject.enclosure.p2.y + (2 * margin)).round(5)
+        end
+
+        # SVG counts y down from the top, the box geometry up from the bottom.
+        def coordinates(line)
+          { x1: (line.p1.x + margin).round(5), y1: (height - margin - line.p1.y).round(5),
+            x2: (line.p2.x + margin).round(5), y2: (height - margin - line.p2.y).round(5) }
+        end
+
+        def description
+          fields = MetaRenderer::META_KEYS.filter_map { |key| "#{key}: #{config[key]}" if config[key] }
+          "Made with laser-cutter v#{VERSION}. #{fields.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/renderer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module Renderer
+      # The renderer that writes each output format.
+      FORMATS = {
+        'pdf' => 'LayoutRenderer',
+        'svg' => 'SvgRenderer'
+      }.freeze
+
+      # @param format [String, Symbol] 'pdf' or 'svg', in either case
+      # @param config [Configuration]
+      # @return [LayoutRenderer, SvgRenderer]
+      # @raise [Error] for a format nothing here writes
+      def self.for(format, config)
+        name = FORMATS.fetch(format.to_s.downcase) do
+          raise Error, "unknown format #{format.inspect}, expected one of: #{FORMATS.keys.join(', ')}"
+        end
+        const_get(name).new(config)
+      end
+    end
+  end
+end

data/lib/laser/cutter/units_converter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    class UnitsConverter
+      def self.mm2in(value)
+        (0.039370079 * value).round(5)
+      end
+
+      def self.in2mm(value)
+        (25.4 * value).round(5)
+      end
+    end
+  end
+end

data/lib/laser/cutter/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    VERSION = "2.0.0"
+  end
+end

data/lib/laser/cutter/zero_value_not_allowed.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    class ZeroValueNotAllowed < MissingOption; end
+  end
+end