laser-cutter 1.0.5 → 2.0.0

data/lib/laser/cutter/box.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    # Note: this class badly needs refactoring and tests.  Both are coming.
+
+    class Box
+      # Everything is in millimeters
+
+      attr_accessor :dim, :thickness, :notch_width, :kerf, :padding, :units, :inside_box, :front, :back, :top, :bottom, :left, :right, :faces, :bounds, :conf, :corner_face, :metadata, :notches
+
+      def initialize(config = {})
+        self.dim = Geometry::Dimensions.new(config['width'], config['height'], config['depth'])
+        self.thickness = config['thickness']
+
+        self.notch_width = config['notch'] || (1.0 * longest / 5.0)
+        self.kerf = config['kerf'] || 0.0
+        self.padding = config['padding']
+        self.units = config['units']
+        self.inside_box = config['inside_box']
+
+        self.notches = []
+
+        self.metadata = Geometry::Point[config['metadata_width'] || 0, config['metadata_height'] || 0]
+
+        create_faces! # generates dimensions for each side
+        self.faces = [top, front, bottom, back, left, right]
+
+        self.conf = {
+          valign:  [:out, :out, :out, :out, :in, :in],
+          halign:  [:in, :out, :in, :out, :in, :in],
+          corners: {
+            front: [:no, :yes, :no, :yes, :no, :no], # our default choice, but may not work
+            top:   [:yes, :no, :yes, :no, :no, :no] # 2nd choice, has to work if 1st doesn't
+          },
+        }
+      end
+
+      def enclosure
+        generate_notches if notches.empty?
+        p1 = notches.first.p1.to_a
+        p2 = notches.first.p2.to_a
+
+        notches.each do |notch|
+          n = notch.normalized
+          n.p1.to_a.each_with_index { |c, i| p1[i] = c if c < p1[i] }
+          n.p2.to_a.each_with_index { |c, i| p2[i] = c if c > p2[i] }
+        end
+
+        Geometry::Rect[Geometry::Point.new(p1), Geometry::Point.new(p2)]
+      end
+
+      def generate_notches
+        position_faces!
+        corner_face = pick_corners_face
+        self.notches = []
+        faces.each_with_index do |face, face_index|
+          bound = face_bounding_rect(face)
+          edges = []
+          bound.sides.each_with_index do |bounding_side, side_index|
+            include_corners = conf[:corners][corner_face][face_index] == :yes && side_index.odd?
+            key = side_index.odd? ? :valign : :halign
+            center_out = (conf[key][face_index] == :out)
+            edges << Notching::Edge.new(bounding_side,
+                                        face.sides[side_index],
+                                        { notch_width: notch_width,
+                                          thickness:   thickness,
+                                          kerf:        kerf,
+                                          center_out:  center_out,
+                                          corners:     include_corners })
+          end
+
+          if edges.any?(&:corners) && !edges.all?(&:first_notch_out?)
+            edges.each { |e| e.adjust_corners = true }
+          end
+
+          side_lines = edges.map do |edge|
+            Notching::PathGenerator.new(edge).generate
+          end
+
+          notches << Aggregator.new(side_lines.flatten).lines
+        end
+        notches.flatten!
+      end
+
+      def w; dim.w; end
+      def h; dim.h; end
+      def d; dim.d; end
+
+      def longest
+        [w, h, d].max
+      end
+
+      def to_s
+        "Box:\nH:#{dim.h} W:#{dim.w} D:#{dim.d}\nThickness:#{thickness}, Notch:#{notch_width}"
+      end
+
+      private
+
+      def face_bounding_rect(face)
+        b = face.clone
+        b.move_to(b.position.plus(-thickness, -thickness))
+        b.p2 = b.p2.plus(2 * thickness, 2 * thickness)
+        b.relocate!
+      end
+
+      # ___________________________________________________________________
+      #
+      #               +-----------------+
+      #               |                 |
+      #               | back:     W x H |
+      #               |                 |
+      #               +-----------------+
+      #               +-----------------+
+      #               | bottom:   W x D |
+      #               +-----------------+
+      #   +--------+  +-----------------+  +--------+
+      #   |        |  |                 |  |        |
+      #   | left   |  | front:    W x H |  | right  |
+      #   | D x H  |  |                 |  | D x H  |
+      #   +--------+  X-----------------+  +--------+
+      #               +-----------------+
+      #               | top   :   W x D |
+      #               +-----------------+
+      #
+      # 0,0
+      # ___________________________________________________________________
+
+      def position_faces!
+        offset_x = [padding + d + (3 * thickness), metadata.x + (2 * thickness) + padding].max
+        offset_y = [padding + d + (3 * thickness), metadata.y + (2 * thickness) + padding].max
+
+        # X Coordinate
+        left.x  = offset_x - d - (2 * thickness) - padding
+        right.x = offset_x + w + (2 * thickness) + padding
+
+        [bottom, front, top, back].each { |s| s.x = offset_x }
+
+        # Y Coordinate
+        top.y    = offset_y - d - (2 * thickness) - padding
+        bottom.y = offset_y + h + (2 * thickness) + padding
+        back.y   = bottom.y + d + (2 * thickness) + padding
+
+        [left, front, right].each { |s| s.y = offset_y }
+
+        faces.each(&:relocate!)
+      end
+
+      def create_faces!
+        zero = Geometry::Point.new(0, 0)
+        self.front = Geometry::Rect.create(zero, dim.w, dim.h, "front")
+        self.back = Geometry::Rect.create(zero, dim.w, dim.h, "back")
+
+        self.top = Geometry::Rect.create(zero, dim.w, dim.d, "top")
+        self.bottom = Geometry::Rect.create(zero, dim.w, dim.d, "bottom")
+
+        self.left = Geometry::Rect.create(zero, dim.d, dim.h, "left")
+        self.right = Geometry::Rect.create(zero, dim.d, dim.h, "right")
+      end
+
+      # Choose which face will be responsible for filling out the little square overlap
+      # in the corners. Only one of the 3 possible sides need to be picked.
+      def pick_corners_face
+        b = face_bounding_rect(front)
+        edges = []
+        front.sides[0..1].each_with_index do |face, index|
+          edges << Notching::Edge.new(b.sides[index], face, notch_width: notch_width, kerf: kerf )
+        end
+        edges.map(&:notch_count).all?{ |c| c % 4 == 3 } ? :top : :front
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/command.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      # What every command inherits: the ui helpers, and the flags they all share.
+      class Command < Dry::CLI::Command
+        include Dry::CLI::UI
+
+        # Cells in a progress bar.
+        BAR_WIDTH = 60
+
+        def self.inherited(subclass)
+          super
+          subclass.option :verbose, type: :boolean, default: false, aliases: ['-v'],
+                                    desc: 'Print the configuration, and the full backtrace on failure'
+        end
+
+        # Boxes are as wide as help is.
+        def ui
+          @ui ||= Dry::CLI::UI::Console.new(out: out, err: err, box_width: CLI.help_width)
+        end
+
+        # A green bar of BAR_WIDTH cells, or fewer when the terminal is narrower.
+        #
+        # @param label [String]
+        # @param total [Integer]
+        # @yieldparam bar [#advance]
+        def progress(label, total:, &)
+          Dry::CLI::UI::Console
+            .new(out: out, err: err, box_width: CLI.help_width, width: progress_width(label))
+            .progress(label, total: total, color: :green, &)
+        end
+
+        private
+
+        # dry-cli-ui sizes a bar as the terminal width less the label and the
+        # counters around it, so the bar is capped by capping that width.
+        def progress_width(label)
+          wanted = BAR_WIDTH + label.length + Dry::CLI::UI::Widgets::Progress::CHROME
+          err.respond_to?(:tty?) && err.tty? ? [wanted, TTY::Screen.width].min : wanted
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/completion.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      # Dry::CLI::Autocomplete::Command[] builds an anonymous subclass, which
+      # loses the description and the examples. This one states its own.
+      class Completion < Dry::CLI::Autocomplete::Command
+        @registry = CLI
+        @program_name = PROGRAM
+
+        desc 'Generates auto-complete for BASH or ZSH'
+
+        example [
+          "bash > /usr/local/etc/bash_completion.d/#{PROGRAM}",
+          "zsh  > \"${fpath[1]}/_#{PROGRAM}\""
+        ]
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/config_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      # A configuration saved as JSON. The path '-' stands for STDIN when
+      # reading, and for the command's own output when writing.
+      class ConfigFile
+        STDIO = '-'
+
+        # @param path [String]
+        def initialize(path)
+          @path = path
+        end
+
+        # @return [Hash{String => Object}]
+        # @raise [Error] when the file is missing, or is not JSON
+        def read
+          JSON.parse(@path == STDIO ? $stdin.read : File.read(@path))
+        rescue SystemCallError, JSON::ParserError => e
+          raise Error, "cannot read the configuration from #{@path}: #{e.message}"
+        end
+
+        # @param settings [Hash]
+        # @param out [IO] where '-' writes to
+        # @raise [Error] when the file cannot be written
+        def write(settings, out)
+          json = JSON.pretty_generate(settings)
+          @path == STDIO ? out.puts(json) : File.write(@path, "#{json}\n")
+        rescue SystemCallError => e
+          raise Error, "cannot write the configuration to #{@path}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/examples.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class Examples < Command
+        desc 'Show detailed usage examples'
+
+        TEXT = <<~EXAMPLES
+          1. A box in inches, with the kerf set to 0.008", opened once it is written:
+
+               laser-cutter generate -b 3x2x2/0.125 -k 0.008 -O -o box.pdf
+
+          2. A box in millimeters on a landscape A3 page, with a 0.5mm stroke:
+
+               laser-cutter generate -u mm -w 70 -H 20 -d 50 -t 4.3 -n 5 -i A3 -l landscape -s 0.5 -o box.pdf
+
+          3. The same box as an SVG:
+
+               laser-cutter generate -b 3x2x2/0.125 -f svg -o box.svg
+
+          4. Every page size, in millimeters:
+
+               laser-cutter page-sizes -u mm
+
+          5. A box whose settings are saved for later:
+
+               laser-cutter generate -b 1.1x2.5x1.5/0.125/0.125 -p 0.1 -o box.pdf -W box-settings.json
+
+          6. A box from settings saved earlier, from a file or from STDIN:
+
+               laser-cutter generate -o box.pdf -R box-settings.json
+               cat box-settings.json | laser-cutter generate -o box.pdf -R -
+        EXAMPLES
+
+        def call(**)
+          out.puts TEXT
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/generate.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class Generate < Command
+        desc 'Draw the panels of a box into a PDF or an SVG file'
+
+        BANNER = "Laser-Cutter (ruby gem) Version #{Laser::Cutter::VERSION}, © 2015-2026 Konstantin Gredeskoul".freeze
+
+        # Columns a box spends on its borders and padding.
+        BOX_CHROME = 6
+
+        # What the opening box reports, in this order.
+        DIMENSIONS = %i[width height depth thickness notch kerf].freeze
+
+        # Options that describe the run rather than the box, kept out of a saved configuration.
+        RUN_ONLY = %i[verbose read write open format args].freeze
+
+        option :box, aliases: ['-b'], desc: 'WxHxD/T[/N]: width, height, depth, thickness and optional notch, in one'
+        option :width, aliases: ['-w'], desc: 'Internal width of the box'
+        option :height, aliases: ['-H'], desc: 'Internal height of the box'
+        option :depth, aliases: ['-d'], desc: 'Internal depth of the box'
+        option :thickness, aliases: ['-t'], desc: 'Thickness of the material'
+        option :notch, aliases: ['-n'], desc: 'Notch length, a guide only (default: three times the thickness)'
+        option :kerf, aliases: ['-k'], desc: 'Kerf, the width of the cut (default: 0.0024in)'
+        option :units, default: 'in', values: %w[in mm], aliases: ['-u'], desc: 'Units every dimension is in'
+
+        option :file, aliases: ['-o'], desc: 'File to write (required)'
+        option :format, default: 'pdf', aliases: ['-f'], desc: 'Output format: pdf or svg, in either case'
+
+        option :margin, aliases: ['-m'], desc: 'Margin from the edge of the page'
+        option :padding, aliases: ['-p'], desc: 'Space between the panels'
+        option :stroke, aliases: ['-s'], desc: 'Stroke width of the lines'
+        option :page_size, aliases: ['-i'], desc: 'Page size, such as LETTER or A3 (default: fit the box; PDF only)'
+        option :page_layout, default: 'portrait', values: %w[portrait landscape], aliases: ['-l'], desc: 'Page layout (PDF only)'
+
+        option :metadata, type: :boolean, default: true, aliases: ['-M'], desc: 'Print the settings of the box on the page'
+        option :inside_box, type: :boolean, default: false, aliases: ['-B'],
+                            desc: 'Also draw the box without kerf, in red, to check the kerf'
+        option :open, type: :boolean, default: false, aliases: ['-O'], desc: 'Open the file once it is written'
+        option :write, aliases: ['-W'], desc: "Save the configuration to a file, or to STDOUT with '-'"
+        option :read, aliases: ['-R'], desc: "Read the configuration from a file, or from STDIN with '-'"
+
+        example [
+          '-b 3x2x2/0.125 -o box.pdf # a box in inches',
+          '-b 3x2x2/0.125 -f svg -o box.svg # as an SVG',
+          '-u mm -w 70 -H 20 -d 50 -t 4.3 -o box.pdf'
+        ]
+
+        def call(format:, verbose:, **options)
+          config = configuration(options)
+          ui.debug('Configuration:', JSON.pretty_generate(config.to_hash)) if verbose
+          config.validate!
+          renderer = Renderer.for(format, config)
+          ui.info(BANNER, dimensions(config), "Format: #{format.upcase}")
+          ConfigFile.new(options[:write]).write(config.to_hash, out) if options[:write]
+
+          progress("Drawing #{File.basename(config.file)}", total: renderer.total) do |bar|
+            renderer.render { bar.advance }
+          end
+
+          report(format, File.expand_path(config.file))
+          system('open', config.file) if options[:open]
+        end
+
+        private
+
+        # A box wraps in the middle of a word, which would break a path nobody
+        # could then copy, so this one widens to fit a path longer than it.
+        def report(format, path)
+          ui.success("Generated #{format.upcase} file:", path, width: [CLI.help_width, path.length + BOX_CHROME].max)
+        end
+
+        # What was read from a file, overridden by what the command line gave.
+        def configuration(options)
+          given = options.except(*RUN_ONLY).compact
+          saved = options[:read] ? ConfigFile.new(options[:read]).read : {}
+          settings = saved.transform_keys(&:to_sym).merge(given)
+          Configuration.new(settings.merge(debug: settings.delete(:inside_box)))
+        end
+
+        # One line per dimension, aligned, in the units of the box.
+        def dimensions(config)
+          DIMENSIONS.map { |name| "#{"#{name.capitalize}:".ljust(11)} #{config[name]} #{config.units}" }.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/help.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class Help < Command
+        desc 'Show help, for the program or for one command'
+
+        argument :command, required: false, desc: 'The command to explain'
+
+        example ['', 'generate']
+
+        # Asks dry-cli for the help it prints on --help, which exits by itself.
+        def call(command: nil, **)
+          Dry::CLI.new(CLI).call(arguments: [command, '--help'].compact, out: out, err: err)
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/page_sizes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class PageSizes < Command
+        desc 'List every page size, with its dimensions'
+
+        option :units, default: 'in', values: %w[in mm], aliases: ['-u'], desc: 'Units to print the dimensions in'
+
+        example ['', '--units mm']
+
+        def call(units:, **)
+          out.puts PageManager.new(units).all_page_sizes
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli/version.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    module CLI
+      class Version < Command
+        desc 'Print the version'
+
+        def call(**)
+          out.puts Laser::Cutter::VERSION
+        end
+      end
+    end
+  end
+end

data/lib/laser/cutter/cli.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    # Every command the executable answers to.
+    module CLI
+      extend Dry::CLI::Registry
+
+      PROGRAM = 'laser-cutter'
+
+      # Help and boxes are never wider than this, however wide the terminal is.
+      HELP_WIDTH = 90
+
+      # Columns assumed when there is no terminal, or it reports none.
+      DEFAULT_COLUMNS = 80
+
+      # @return [Integer] columns help wraps at, and a box takes: the terminal's less 6,
+      #   capped at HELP_WIDTH
+      def self.help_width(columns = IO.console&.winsize&.last)
+        columns = DEFAULT_COLUMNS unless columns&.positive?
+        [columns - 6, HELP_WIDTH].min
+      end
+
+      Dry::CLI::Help.configure do
+        title "laser-cutter #{Laser::Cutter::VERSION}"
+        description 'Draws the notched panels of a box, ready to cut on a laser cutter, as a PDF or an SVG.'
+        epilogue 'Documentation: https://github.com/kigster/laser-cutter'
+
+        width CLI.help_width
+        exit_code_without_arguments 0
+
+        styles do
+          heading :bold, :cyan, case: :UPPERCASE
+          usage :yellow
+          example :yellow
+          option :green
+          example_comment :bright_black
+        end
+      end
+
+      register 'generate', Generate, aliases: ['g']
+      register 'page-sizes', PageSizes
+      register 'examples', Examples
+      register 'help', Help
+      register 'version', Version, aliases: ['-V', '--version']
+      register 'completion', Completion
+    end
+  end
+end

data/lib/laser/cutter/configuration.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Laser
+  module Cutter
+    class Configuration < Hashie::Mash
+      include ::Hashie::Extensions::Mash::SymbolizeKeys
+
+      SIZE_REGEXP = %r{[\d.]+x[\d.]+x[\d.]+/[\d.]+(/[\d.]+)?}
+
+      FLOATS   = %i(width height depth thickness notch margin padding stroke kerf).freeze
+      NON_ZERO = %i(width height depth thickness stroke).freeze
+      REQUIRED = %i(width height depth thickness notch file).freeze
+
+      @mutex = Mutex.new
+
+      class << self
+        attr_accessor :mutex, :defaults
+
+        def compute_defaults!
+          mutex.synchronize do
+            if defined?(@defaults)
+              @defaults
+            else
+              @defaults = compute_metric_units!
+            end
+          end.dup
+        end
+
+        def compute_metric_units!
+          defaults = Hashie::Mash.new({
+                                        units:       :in,
+                                        page_layout: 'portrait',
+                                        metadata:    true,
+                                        in:          {
+                                          kerf:    0.0024, # smallest kerf for thin material, usually it's more than that.
+                                          margin:  0.125,
+                                          padding: 0.1,
+                                          stroke:  0.001,
+                                        }
+                                      })
+
+          defaults[:mm] = defaults[:in].map { |k, v| [k, UnitsConverter.in2mm(v)] }.to_h
+          defaults
+        end
+      end
+
+      compute_defaults!
+
+      def initialize(options = {})
+        ::Hashie::Extensions::SymbolizeKeys.symbolize_keys!(options)
+
+        options.delete_if { |_k, v| v.nil? }
+        if options[:units]
+          unit = options[:units].to_sym
+          unless self.class.defaults.key?(unit) || self.class.defaults.key?(unit.to_s)
+            options.delete(:units)
+          end
+        end
+
+        super(self.class.defaults.merge(options))
+
+        if box =~ SIZE_REGEXP
+          dim, self[:thickness], self[:notch]       = self[:box].split('/')
+          self[:width], self[:height], self[:depth] = dim.split('x')
+          delete(:box)
+        end
+        FLOATS.each do |k|
+          self[k] = self[k].to_f if self[k].is_a?(String)
+        end
+        merge!(self.class.defaults[self[:units].to_sym].merge(self))
+        self[:notch] = (self[:thickness] * 3.0).round(5) if self[:thickness] && self[:notch].nil?
+      end
+
+      def validate!
+        missing = []
+        REQUIRED.each { |k| missing << k if self[k].nil? }
+        raise MissingOption, "#{missing.join(', ')} #{missing.size > 1 ? 'are' : 'is'} required, but missing." unless missing.empty?
+
+        zeros = []
+        NON_ZERO.each { |k| zeros << k if self[k] == 0 }
+        raise ZeroValueNotAllowed, "#{zeros.join(', ')} #{zeros.size > 1 ? 'are' : 'is'} required, but is zero." unless zeros.empty?
+      end
+
+      def change_units(new_units)
+        new_units = new_units.to_sym
+        return if new_units == units.to_sym
+        return unless self.class.defaults.key?(new_units)
+
+        k = units.to_sym == :in ? UnitsConverter.in2mm(1.0) : UnitsConverter.mm2in(1.0)
+
+        FLOATS.each do |field|
+          next if send(field).nil?
+
+          send("#{field}=", (send(field) * k).round(5))
+        end
+
+        self.units = new_units
+      end
+    end
+  end
+end

data/lib/{laser-cutter → laser/cutter}/geometry/dimensions.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module Laser
   module Cutter
     module Geometry
       class Dimensions < Tuple
-
         def w
           coords.[](0)
         end
@@ -22,9 +23,7 @@ module Laser
         def hash_keys
           [:w, :h, :d]
         end
-
       end
     end
   end
-
 end