laser-cutter 1.0.5 → 2.0.0

data/lib/laser-cutter/box.rb

@@ -1,183 +0,0 @@
-require 'forwardable'
-module Laser
-  module Cutter
-    class Box
-      # Everything is in millimeters
-      extend Forwardable
-      def_delegators :@dim, :w, :h, :d
-
-      attr_accessor :dim, :thickness, :notch_width, :kerf
-      attr_accessor :padding, :units, :inside_box
-
-      attr_accessor :front, :back, :top, :bottom, :left, :right
-      attr_accessor :faces, :bounds, :conf, :corner_face
-      attr_accessor :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 * self.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: {
-            top: [:yes, :no, :yes, :no, :no, :no], # 2nd choice, has to work if 1st doesn't
-            front: [:no, :yes, :no, :yes, :no, :no], # our default choice, but may not work
-          },
-        }
-        self
-      end
-
-      def generate_notches
-        position_faces!
-        self.corner_face = pick_corners_face
-        self.notches     = []
-        faces.each_with_index do |face, face_index|
-          create_face_edges(face, face_index)
-        end
-        self.notches.flatten!
-      end
-
-      def enclosure
-        generate_notches if self.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 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 create_face_edges(face, face_index)
-        bound      = face_bounding_rect(face)
-
-        side_lines = []
-        edges      = []
-        bound.sides.each_with_index do |bounding_side, side_index|
-          include_corners = (self.conf[:corners][corner_face][face_index] == :yes && side_index.odd?)
-          key             = side_index.odd? ? :valign : :halign
-          center_out      = (self.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? {|e| e.corners} && !edges.all? {|e| e.first_notch_out?}
-          edges.each {|e| e.adjust_corners = true}
-        end
-
-        edges.each do |edge|
-          side_lines << Notching::PathGenerator.new(edge).generate
-        end
-
-        aggregator = Aggregator.new(side_lines.flatten)
-        aggregator.dedup!.deoverlap!.dedup!
-        self.notches << aggregator.lines
-      end
-
-      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/opt_parser.rb

@@ -1,131 +0,0 @@
-require 'optparse'
-require 'colored'
-require 'json'
-require 'hashie/mash'
-require 'laser-cutter'
-require_relative 'serializer'
-
-module Laser
-  module Cutter
-    module CLI
-      class OptParser
-        def self.puts_error(e)
-          STDERR.puts "Whoops, #{e}".red
-          STDERR.puts "Try --help or --examples for more info...".yellow
-        end
-
-        def self.parse(args)
-          banner_text = <<-EOF
-#{('Laser-Cutter v'+ Laser::Cutter::VERSION).bold}
-
-Usage: laser-cutter [options] -o filename.pdf
-   eg: laser-cutter -z 1x1.5x2/0.125 -O -o box.pdf
-          EOF
-
-          examples = <<-EOF
-
-Examples:
-  1. Create a box defined in inches, set kerf to 0.008" and open PDF in preview right after:
-
-       laser-cutter -z 3x2x2/0.125 -k 0.008 -O -o box.pdf
-
-  2. Create a box defined in millimeters, print verbose info, and set
-     page size to A3, and layout to landscape, and stroke width to 1/2mm:
-
-       laser-cutter -u mm -w70 -h20 -d50 -t4.3 -n5 -iA3 -l landscape -s0.5 -v -O -o box.pdf
-
-  3. List all possible page sizes in metric systems:
-
-       laser-cutter -L -u mm
-
-  4. Create a box with provided dimensions, and save the config to a file
-     for later use:
-
-       laser-cutter -z 1.1x2.5x1.5/0.125/0.125 -p 0.1 -O -o box.pdf -W box-settings.json
-
-  5. Read settings from a previously saved file:
-
-       laser-cutter -O -o box.pdf -R box-settings.json
-       cat box-settings.json | laser-cutter -O -o box.pdf -R -
-
-          EOF
-          options = Hashie::Mash.new
-          options.verbose = false
-          options.units = 'in'
-
-          opt_parser = OptionParser.new do |opts|
-            opts.banner = banner_text.blue
-            opts.separator "Specific Options:"
-            opts.on("-w", "--width WIDTH", "Internal width of the box") { |value| options.width = value }
-            opts.on("-h", "--height HEIGHT", "Internal height of the box") { |value| options.height = value }
-            opts.on("-d", "--depth DEPTH", "Internal depth of the box") { |value| options.depth= value }
-            opts.on("-t", "--thickness THICKNESS", "Thickness of the box material") { |value| options.thickness = value }
-            opts.on("-n", "--notch NOTCH", "Optional notch length (aka \"tab width\"), guide only") { |value| options.notch = value }
-            opts.on("-k", "--kerf KERF", "Kerf - cut width (default is #{Laser::Cutter::Configuration::UNIT_SPECIFIC_DEFAULTS['in'][:kerf]}in)") { |value| options.kerf = value }
-            opts.separator ""
-            opts.on("-m", "--margin MARGIN", "Margins from the edge of the document") { |value| options.margin = value }
-            opts.on("-p", "--padding PADDING", "Space between the boxes on the page") { |value| options.padding = value }
-            opts.on("-s", "--stroke WIDTH", "Numeric stroke width of the line") { |value| options.stroke = value }
-            opts.on("-i", "--page_size LETTER", "Document page size, default is autofit the box.") { |value| options.page_size = value }
-            opts.on("-l", "--page_layout portrait", "Page layout, other option is 'landscape' ") { |value| options.page_layout = value }
-            opts.separator ""
-            opts.on("-O", "--open", "Open generated file with system viewer before exiting") { |v| options.open = v }
-            opts.on("-W", "--write CONFIG_FILE", "Save provided configuration to a file, use '-' for STDOUT") { |v| options.write_file = v }
-            opts.on("-R", "--read CONFIG_FILE", "Read configuration from a file, or use '-' for STDIN") { |v| options.read_file = v }
-            opts.separator ""
-            opts.on("-L", "--list-all-page-sizes", "Print all available page sizes with dimensions and exit") { |v| options.list_all_page_sizes = true }
-            opts.on("-M", "--no-metadata", "Do not print box metadata on the PDF") { |value| options.metadata = value }
-            opts.on("-v", "--[no-]verbose", "Run verbosely") { |v| options.verbose = v }
-            opts.on("-B", "--inside-box", "Draw the inside boxes (helpful to verify kerfing)") { |v| options.inside_box = v }
-            opts.on("-D", "--debug", "Show full exception stack trace on error") { |v| options.debug = v }
-            opts.separator ""
-            opts.on("--examples", "Show detailed usage examples") { puts opts; puts examples.yellow; exit }
-            opts.on("--help", "Show this message") { puts opts; exit }
-            opts.on("--version", "Show version") { puts Laser::Cutter::VERSION; exit }
-            opts.separator ""
-            opts.separator "Common Options:"
-            opts.on_tail("-o", "--file FILE", "Required output filename of the PDF") { |value| options.file = value }
-            opts.on_tail("-z", "--size WxHxD/T[/N]",
-                         "Combined internal dimensions: W = width, H = height,\n#{" " * 37}D = depth, T = thickness, and optional N = notch length\n\n") do |size|
-              options.size = size
-            end
-            opts.on_tail("-u", "--units UNITS", "Either 'in' for inches (default) or 'mm'") { |value| options.units = value }
-          end
-
-          opt_parser.parse!(args)
-
-          if options.read_file
-            # these options are kept from the command line
-            override_with = %w(debug verbose read_file)
-            keep = options.reject{ |k,v| !override_with.include?(k)}
-            Serializer.new(options).deserialize
-            options.merge!(keep)
-          end
-
-          config = Laser::Cutter::Configuration.new(options.to_hash)
-          if config.list_all_page_sizes
-            puts PageManager.new(config.units).all_page_sizes
-            exit 0
-          end
-
-          if options.verbose
-            puts "Starting with the following configuration:"
-            puts JSON.pretty_generate(config.to_hash).green
-          end
-
-          config.validate!
-
-          if config.write_file
-            Serializer.new(config).serialize
-          end
-
-          config
-        rescue OptionParser::InvalidOption, OptionParser::MissingArgument, Laser::Cutter::MissingOption => e
-          puts opt_parser.banner.blue
-          puts_error(e)
-          exit 1
-        end
-      end
-    end
-  end
-end

data/lib/laser-cutter/cli/serializer.rb

@@ -1,51 +0,0 @@
-require 'json'
-require 'laser-cutter'
-
-module Laser
-  module Cutter
-    module CLI
-      class Serializer
-        attr_accessor :options
-        def initialize(options = {})
-          self.options = options
-        end
-
-        def deserialize
-          string = if options.read_file.eql?('-')
-                     $stdin.read
-                   elsif File.exist?(options.read_file)
-                     File.read(options.read_file)
-                   end
-          if string
-            options.replace(JSON.load(string))
-          end
-        rescue Exception => e
-          STDERR.puts "Error reading options from file #{options.read_file}, #{e.message}".red
-          if options.verbose
-            STDERR.puts e.backtrace.join("\n").red
-          end
-          exit 1
-        end
-
-        def serialize
-          output = if options.write_file.eql?('-')
-                     $stdout
-                   elsif options.write_file
-                     File.open(options.write_file, 'w')
-                   else
-                     nil
-                   end
-          output.puts(JSON.pretty_generate(options))
-          output.close if output != $stdout
-        rescue Exception => e
-          STDERR.puts "Error writing options to file #{options.write_file}, #{e.message}".red
-          if options.verbose
-            STDERR.puts e.backtrace.join("\n").red
-          end
-          exit 1
-        end
-      end
-    end
-  end
-end
-

data/lib/laser-cutter/configuration.rb

@@ -1,83 +0,0 @@
-require 'hashie/mash'
-require 'prawn/measurement_extensions'
-require 'pdf/core/page_geometry'
-
-module Laser
-  module Cutter
-    class MissingOption < RuntimeError; end
-    class ZeroValueNotAllowed < MissingOption; end
-
-    class UnitsConverter
-      def self.mm2in value
-        0.039370079 * value
-      end
-      def self.in2mm value
-        25.4 * value
-      end
-    end
-
-    class Configuration < Hashie::Mash
-      DEFAULTS = {
-          units: 'in',
-          page_layout: 'portrait',
-          metadata: true
-      }
-
-      UNIT_SPECIFIC_DEFAULTS = {
-          'in' => {
-              kerf: 0.0024, # smallest kerf for thin material, usually it's more than that.
-              margin: 0.125,
-              padding: 0.1,
-              stroke: 0.001,
-          }
-      }
-
-      UNIT_SPECIFIC_DEFAULTS['mm'] = UNIT_SPECIFIC_DEFAULTS['in'].map{|k, v| [k, UnitsConverter.in2mm(v)] }.to_h
-
-      SIZE_REGEXP = /[\d\.]+x[\d\.]+x[\d\.]+\/[\d\.]+(\/[\d\.]+)?/
-
-      FLOATS   = %w(width height depth thickness notch margin padding stroke kerf)
-      NON_ZERO = %w(width height depth thickness stroke)
-      REQUIRED = %w(width height depth thickness notch file)
-
-      def initialize(options = {})
-        options.delete_if { |k, v| v.nil? }
-        if options['units'] && !UNIT_SPECIFIC_DEFAULTS.keys.include?(options['units'])
-          options.delete('units')
-        end
-        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))
-        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.new("#{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.new("#{zeros.join(', ')} #{zeros.size > 1 ? 'are' : 'is'} required, but is zero.") unless zeros.empty?
-      end
-
-      def change_units(new_units)
-        return if (self.units.eql?(new_units) || !UNIT_SPECIFIC_DEFAULTS.keys.include?(new_units))
-        k = (self.units == 'in') ? UnitsConverter.in2mm(1.0) : UnitsConverter.mm2in(1.0)
-        FLOATS.each do |field|
-          next if self.send(field.to_sym).nil?
-          self.send("#{field}=".to_sym, (self.send(field.to_sym) * k).round(5))
-        end
-        self.units = new_units
-      end
-    end
-  end
-end

data/lib/laser-cutter/face.rb

@@ -1,18 +0,0 @@
-require 'forwardable'
-module Laser
-  module Cutter
-    # Note: this class badly needs refactoring and tests.  Both are coming.
-
-
-    class Face
-      attr_accessor :edges, :rect
-      extend Forwardable
-      def_delegators :@rect, *((Geometry::Rect.new(Geometry::Point.new(0,0), Geometry::Point.new(1,1))).methods - Object.methods)
-      def initialize(rect, edges = [])
-        self.rect  = rect
-        self.edges = edges
-      end
-    end
-
-  end
-end

data/lib/laser-cutter/geometry.rb

@@ -1,11 +0,0 @@
-module Laser
-  module Cutter
-    module Geometry
-    end
-  end
-end
-
-require 'laser-cutter/geometry/tuple'
-require 'laser-cutter/geometry/dimensions'
-require 'laser-cutter/geometry/point'
-require 'laser-cutter/geometry/shape'

data/lib/laser-cutter/notching.rb

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

data/lib/laser-cutter/page_manager.rb

@@ -1,43 +0,0 @@
-require 'hashie/mash'
-require 'prawn/measurement_extensions'
-require 'pdf/core/page_geometry'
-
-class Laser::Cutter::PageManager < Struct.new(:units)
-  SIZES = PDF::Core::PageGeometry::SIZES.clone.freeze
-
-  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 self.units.eql?(from_units)
-                   1.0
-                 elsif self.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 = SIZES
-    array = []
-    h.keys.sort.each do |k|
-      array << [k, value_from_units(h[k][0].to_f), value_from_units(h[k][1].to_f)]
-    end
-    array
-  end
-end

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

@@ -1,36 +0,0 @@
-# encoding: utf-8
-require 'json'
-module Laser
-  module Cutter
-    module Renderer
-      class BoxRenderer < Base
-        alias_method :box, :subject
-
-        def initialize(config)
-          super(config)
-          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
-
-        def render pdf = nil
-          renderer = self
-          pdf.instance_eval do
-            self.line_width = renderer.config.stroke.send(renderer.config.units.to_sym)
-            stroke_color renderer.config[:color] || BLACK
-            renderer.box.generate_notches.each do |notch|
-              LineRenderer.new(renderer.config, notch).render(self)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-# encoding: utf-8
-require 'json'
-module Laser
-  module Cutter
-    module Renderer
-      class LayoutRenderer < Base
-        def initialize(config)
-          self.config = config
-          super(config)
-        end
-
-        def render
-          renderer = self
-          renderers = []
-
-          box_renderer = BoxRenderer.new(config)
-          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 => self.config.page_layout.to_sym)
-
-          pdf.instance_eval do
-            renderers.each {|r|  r.render(self) }
-            render_file(renderer.config.file)
-          end
-
-          if config.verbose
-            puts "PDF saved to #{config.file}."
-          end
-        end
-
-        def calculate_image_boundary(box_renderer, margin)
-          box_renderer.enclosure.to_a[1].map do |c|
-            c.send(config.units.to_sym) + 2 * margin
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-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
-          self.line
-        end
-      end
-    end
-  end
-end