laser-cutter 0.5.3 → 1.0.0

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

@@ -0,0 +1,131 @@
+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 0.007in)") { |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

@@ -0,0 +1,51 @@
+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

@@ -13,6 +13,7 @@ module Laser
           units: 'in',
           page_layout: 'portrait',
           metadata: true
+          #kerf: 0.007  # smallest kerf for thin material, usually it's more than that.
       }
 
       UNIT_SPECIFIC_DEFAULTS = {
@@ -30,7 +31,7 @@ module Laser
 
       SIZE_REGEXP = /[\d\.]+x[\d\.]+x[\d\.]+\/[\d\.]+(\/[\d\.]+)?/
 
-      FLOATS = %w(width height depth thickness notch margin padding stroke)
+      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)
 
@@ -50,7 +51,7 @@ module Laser
           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 if self['thickness'] && self['notch'].nil?
+        self['notch'] = (self['thickness'] * 3.0).round(5) if self['thickness'] && self['notch'].nil?
       end
 
       def validate!

data/lib/laser-cutter/geometry.rb

@@ -1,7 +1,6 @@
 module Laser
   module Cutter
     module Geometry
-      MINIMUM_NOTCHES_PER_SIDE = 3
     end
   end
 end
@@ -10,5 +9,3 @@ require 'laser-cutter/geometry/tuple'
 require 'laser-cutter/geometry/dimensions'
 require 'laser-cutter/geometry/point'
 require 'laser-cutter/geometry/shape'
-require 'laser-cutter/geometry/edge'
-require 'laser-cutter/geometry/path_generator'

data/lib/laser-cutter/geometry/dimensions.rb

@@ -4,15 +4,15 @@ module Laser
       class Dimensions < Tuple
 
         def w
-          coords[0]
+          coords.[](0)
         end
 
         def h
-          coords[1]
+          coords.[](1)
         end
 
         def d
-          coords[2]
+          coords.[](2)
         end
 
         def separator

data/lib/laser-cutter/geometry/point.rb

@@ -5,52 +5,6 @@ module Laser
         def self.[] *array
           Point.new *array
         end
-
-        def customize_args(args)
-          if args.first.is_a?(Point)
-            return args.first.to_a
-          end
-          args
-        end
-
-        def x= value
-          coords[0] = value
-        end
-
-        def x
-          coords[0]
-        end
-
-        def y= value
-          coords[1] = value
-        end
-
-        def y
-          coords[1]
-        end
-
-        def separator
-          ','
-        end
-
-        def hash_keys
-          [:x, :y]
-        end
-
-        def move_by w, h
-          Point.new(x + w, y + h)
-        end
-
-        def <=>(other)
-          self.x == other.x ? self.y <=> other.y : self.x <=> other.x
-        end
-
-        def < (other)
-          self.x == other.x ? self.y < other.y : self.x < other.x
-        end
-        def > (other)
-          self.x == other.x ? self.y > other.y : self.x > other.x
-        end
       end
     end
   end

data/lib/laser-cutter/geometry/shape/line.rb

@@ -2,6 +2,11 @@ module Laser
   module Cutter
     module Geometry
       class Line < Shape
+
+        def self.[] *array
+          self.new *array
+        end
+
         attr_accessor :p1, :p2
 
         def initialize(point1, point2 = nil)
@@ -17,6 +22,30 @@ module Laser
           raise 'Both points are required for line definition' unless (p1 && p2)
         end
 
+        def overlaps?(another)
+          xs, ys = sorted_coords(another)
+          return false unless xs.all?{|x| x == xs[0] } || ys.all?{|y| y == ys[0] }
+          return false if xs.first[1] < xs.last[0] || xs.first[0] > xs.last[1]
+          return false if ys.first[1] < ys.last[0] || ys.first[0] > ys.last[1]
+          true
+        end
+
+        def sorted_coords(another)
+          xs = [[p1.x, p2.x].sort, [another.p1.x, another.p2.x].sort]
+          ys = [[p1.y, p2.y].sort, [another.p1.y, another.p2.y].sort]
+          return xs, ys
+        end
+
+        def xor(another)
+          return nil unless overlaps?(another)
+          xs, ys = sorted_coords(another)
+          xs.flatten!.sort!
+          ys.flatten!.sort!
+
+          [ Line.new(Point[xs[0], ys[0]], Point[xs[1], ys[1]]),
+            Line.new(Point[xs[2], ys[2]], Point[xs[3], ys[3]])]
+        end
+
         def relocate!
           dx = p2.x - p1.x
           dy = p2.y - p1.y
@@ -48,7 +77,17 @@ module Laser
         end
 
         def <=>(other)
-          self.normalized.to_s <=> other.normalized.to_s
+          n1 = self.normalized
+          n2 = other.normalized
+          n1.p1.eql?(n2.p1) ? n1.p2 <=> n2.p2 : n1.p1 <=> n2.p1
+        end
+
+        def < (other)
+          self.p1 == other.p1 ? self.p2 < other.p2 : self.p1 < other.p1
+        end
+
+        def > (other)
+          self.p1 == other.p1 ? self.p2 > other.p2 : self.p1 > other.p1
         end
 
         def hash

data/lib/laser-cutter/geometry/shape/rect.rb

@@ -28,9 +28,9 @@ module Laser
           super
           self.vertices = []
           vertices << p1
-          vertices << p1.move_by(w, 0)
+          vertices << p1.plus(w, 0)
           vertices << p2
-          vertices << p1.move_by(0, h)
+          vertices << p1.plus(0, h)
           self.sides = []
           vertices.each_with_index do |v, index|
             sides << Line.new(v, vertices[(index + 1) % vertices.size])

data/lib/laser-cutter/geometry/tuple.rb

@@ -1,3 +1,4 @@
+require 'matrix'
 module Laser
   module Cutter
     module Geometry
@@ -6,60 +7,107 @@ module Laser
         PRECISION = 0.000001
 
         def initialize(*args)
-          args = customize_args(args)
           x = args.first
-          if x.is_a?(String)
+          coordinates = if x.is_a?(String)
             parse_string(x)
           elsif x.is_a?(Hash)
             parse_hash(x)
           elsif x.is_a?(Array)
-            self.coords = x.clone
+            x.clone
+          elsif x.is_a?(Tuple) or x.is_a?(Vector)
+            x.to_a
           else
-            self.coords = args.clone
+            args.clone
           end
-
-          self.coords.map!(&:to_f)
+          coordinates.map!(&:to_f)
+          self.coords = Vector.[](*coordinates)
         end
 
-        def customize_args(args)
-          args
+        def + x, y = nil
+          shift = if x.is_a?(Vector)
+                    x
+                  elsif x.is_a?(Tuple)
+                    x.coords
+                  elsif y
+                    Vector.[](x,y)
+                  end
+          self.class.new(self.coords + shift)
         end
 
-        def separator
-          raise NotImplementedError
-          # 'x'
-        end
 
-        def hash_keys
-          raise NotImplementedError
-          # [:x, :y, :z] or [:h, :w, :d]
-        end
+        alias_method :plus, :+
 
         def to_a
-          self.coords.clone
+          self.coords.to_a
         end
 
         def to_s
-          "{#{coords.map { |a| sprintf("%.5f", a) }.join(separator)}}"
+          "{#{coords.to_a.map { |a| sprintf("%.5f", a) }.join(separator)}}"
         end
 
         def valid?
-          raise "Have nil value: #{self.inspect}" if coords.any? { |c| c.nil? }
+          raise "Have nil value: #{self.inspect}" if coords.to_a.any? { |c| c.nil? }
           true
         end
 
+        def x= value
+          self.coords = Vector.[](value, coords.[](1))
+        end
+
+        def y= value
+          self.coords = Vector.[](coords.[](0), value)
+        end
+
+        def x
+          coords.[](0)
+        end
+
+        def y
+          coords.[](1)
+        end
+
+        def separator
+          ','
+        end
+
+        def [] value
+          coords.[](value)
+        end
+
+
+        # Override in subclasses, eg:
+        # def separator
+        #   ';'
+        # end
+        #
+        # def hash_keys
+        #   [:x, :y, :z] or [:h, :w, :d]
+        # end
+        def hash_keys
+          [:x, :y]
+        end
+
+        # Identity, cloning and sorting/ordering
         def eql?(other)
           return false unless other.respond_to?(:coords)
           equal = true
           self.coords.each_with_index do |c, i|
-            if (c - other.coords[i])**2 > PRECISION
+            if (c - other.coords.to_a[i])**2 > PRECISION
               equal = false
               break
             end
           end
           equal
         end
-
+        def <=>(other)
+          self.x == other.x ? self.y <=> other.y : self.x <=> other.x
+        end
+        def < (other)
+          self.x == other.x ? self.y < other.y : self.x < other.x
+        end
+        def > (other)
+          self.x == other.x ? self.y > other.y : self.x > other.x
+        end
         def clone
           clone = super
           clone.coords = self.coords.clone
@@ -69,16 +117,14 @@ module Laser
         private
 
         #
-        # convert from, eg "100,50" to [100.0, 50.0],
-        # and then to a new instance.
-        #
+        # Convert from, eg "100,50" to [100.0, 50.0],
         def parse_string string
-          self.coords = string.split(separator).map(&:to_f)
+          string.split(separator).map(&:to_f)
         end
 
+        # Return array of coordinates
         def parse_hash hash
-          self.coords = []
-          hash_keys.each { |k| self.coords << hash[k] }
+          hash_keys.map{ |k,v| hash[k] }
         end
 
       end