laser-cutter 1.0.3 → 2.0.0

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

@@ -1,40 +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
-
       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
@@ -66,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
@@ -77,17 +48,16 @@ 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
 
         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.
@@ -95,19 +65,17 @@ module Laser
           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
+          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)
@@ -162,18 +130,17 @@ module Laser
         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
@@ -181,11 +148,11 @@ 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
@@ -206,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
@@ -238,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

data/lib/laser/cutter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "json"
+require "matrix"
+
+require "hashie/mash"
+require "hashie/extensions/symbolize_keys"
+require "hashie/extensions/mash/symbolize_keys"
+require "pdf/core/page_geometry"
+require "prawn"
+require "prawn/measurement_extensions"
+require "dry/cli"
+require "dry/cli/help"
+require "dry/cli/ui"
+require "dry/cli/autocomplete/command"
+require "tty-screen"
+require "zeitwerk"
+
+module Laser
+  module Cutter
+    class Error < StandardError; end
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem_extension(Laser)
+loader.inflector.inflect("cli" => "CLI")
+loader.setup
+loader.eager_load

data/lib/laser-cutter.rb

@@ -1,15 +1,3 @@
-require 'laser-cutter/version'
-require 'laser-cutter/configuration'
-require 'laser-cutter/geometry'
-require 'laser-cutter/box'
-require 'laser-cutter/renderer'
-require 'laser-cutter/page_manager'
-require 'laser-cutter/notching'
-require 'laser-cutter/aggregator'
-require 'prawn'
-require 'prawn/measurement_extensions'
+# frozen_string_literal: true
 
-module Laser
-  module Cutter
-  end
-end
+require_relative "laser/cutter"

data/lib/laser_cutter.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "laser/cutter"