laser-cutter 0.5.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 869598bd65fbb14370dcce5b969a19748f246ce2
-  data.tar.gz: 4ce9cc14002201a598b5df25f1ae1a474b4269f6
+  metadata.gz: 1e42b32bc2ee9759bffa630c87390941e92400e0
+  data.tar.gz: 2c69316654ae0a33f13871be5b401a973db83b76
 SHA512:
-  metadata.gz: c3b2164cedb8d7af10dfc1beb1482d902f5ce56ae916d32f35cdc289d42d87943567a0d8729f3e793d2844a40c99b27428b5a942b3ddb0b57e4055cc3a7e0266
-  data.tar.gz: 9983e63d47f490f0354159f0ba96ddb086d30c2dc44b62e76f0541529bd1b546693b01100366ac7b0f68c44359b6431c873a4b4ec7fa5a0821dfddc2965edc85
+  metadata.gz: 5e8a25fc98e3e9d4ca9a57a543fe67978cff1981b9e57744406a5d2a5056f3960672b1902d7af27521a4edc889dea077c8c399f10da130f7751f1324bb784173
+  data.tar.gz: cda884dcc0c1328250f3e9dd0542870e4f856d406abd493d1bdd32573460ebc03026a1f88dde37d456bbcdb5fe791a1f6be1f4f4604e56ba1dfd43da33ac608b

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
-  - 1.9.3
+  - 2.1.3
 script: "CODECLIMATE_REPO_TOKEN=6520104decf84e2f6c2c169d30d67976bfcdaa48cd89b4ec34f6e637f2a0ae02 bundle exec rspec"
 notifications:
   email:

data/README.md

@@ -50,29 +50,33 @@ Or install it yourself as:
 ## Usage
 
 ```bash
+
 Usage: laser-cutter [options] -o filename.pdf
-   eg: laser-cutter -s 1x1.5x2/0.125/0.125 -O -o box.pdf
+   eg: laser-cutter -z 1x1.5x2/0.125 -O -o box.pdf
 
 Specific Options:
     -w, --width WIDTH                Internal width of the box
     -h, --height HEIGHT              Internal height of the box
     -d, --depth DEPTH                Internal depth of the box
     -t, --thickness THICKNESS        Thickness of the box material
-    -n, --notch NOTCH                Preferred notch length (used only as a guide)
+    -n, --notch NOTCH                Optional notch length (aka "tab width"), guide only
+    -k, --kerf KERF                  Kerf - cut width (default is 0.007in)
 
     -m, --margin MARGIN              Margins from the edge of the document
     -p, --padding PADDING            Space between the boxes on the page
-    -k, --stroke WIDTH               Numeric stroke width of the line
-    -z, --page_size LETTER           Page size, see --list-all-page-sizes for more info.
-    -y, --page_layout portrait       Page layout, other option is 'landscape'
+    -s, --stroke WIDTH               Numeric stroke width of the line
+    -i, --page_size LETTER           Document page size, default is autofit the box.
+    -l, --page_layout portrait       Page layout, other option is 'landscape'
 
     -O, --open                       Open generated file with system viewer before exiting
-    -W, --write FILE                 Save provided configuration to a file, use '-' for STDOUT
-    -R, --read FILE                  Read configuration from a file, or use '-' for STDIN
+    -W, --write CONFIG_FILE          Save provided configuration to a file, use '-' for STDOUT
+    -R, --read CONFIG_FILE           Read configuration from a file, or use '-' for STDIN
 
-    -l, --list-all-page-sizes        Print all available page sizes with dimensions and exit
+    -L, --list-all-page-sizes        Print all available page sizes with dimensions and exit
     -M, --no-metadata                Do not print box metadata on the PDF
     -v, --[no-]verbose               Run verbosely
+    -B, --inside-box                 Draw the inside boxes (helpful to verify kerfing)
+    -D, --debug                      Show full exception stack trace on error
 
         --examples                   Show detailed usage examples
         --help                       Show this message
@@ -80,37 +84,37 @@ Specific Options:
 
 Common Options:
     -o, --file FILE                  Required output filename of the PDF
-    -s, --size WxHxD/T/N             Combined internal dimensions: W = width, H = height,
-                                     D = depth, T = thickness, N = notch length
+    -z, --size WxHxD/T[/N]           Combined internal dimensions: W = width, H = height,
+                                     D = depth, T = thickness, and optional N = notch length
 
     -u, --units UNITS                Either 'in' for inches (default) or 'mm'
 ```
 
 ### Examples
 
-Create a box defined in inches, and open PDF in preview right after:
+Create a box defined in inches, with kerf (cut width) set to 0.008", and open PDF in preview right after:
 
 ```bash
-    laser-cutter -s 3x2x2/0.125/0.5 -O -o box.pdf
+    laser-cutter -z 3x2x2/0.125 -k 0.008 -O -o box.pdf
 ```       
 
 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:
 
 ```bash
-    laser-cutter -u mm -w70 -h20 -d50 -t4.3 -n5 -zA3 -y landscape -k0.5 -v -O -o box.pdf
+    laser-cutter -u mm -w70 -h20 -d50 -t4.3 -n5 -iA3 -l landscape -s0.5 -v -O -o box.pdf
 ```   
 
 List all possible page sizes in metric system:
 
 ```bash
-    laser-cutter -l -u mm
+    laser-cutter -L -u mm
 ```                 
 
 Create a box with provided dimensions, and save the config to a file for later use:
 
 ```bash
-    laser-cutter -s 1.1x2.5x1.5/0.125/0.125 -p 0.1 -O -o box.pdf -W box-settings.json
+    laser-cutter -z 1.1x2.5x1.5/0.125/0.125 -p 0.1 -O -o box.pdf -W box-settings.json
 ```    
 
 Read settings from a previously saved file:
@@ -171,7 +175,7 @@ And laser-cutter:
 
 ```bash
 gem install laser-cutter
-laser-cutter -s 1x1.5x2/0.125/0.125 -O -o box.pdf
+laser-cutter -z 1x1.5x2/0.125/0.125 -O -o box.pdf
 ```
 
 ![LaserCutter Comparison](doc/comparison.jpg).

data/bin/laser-cutter

@@ -1,162 +1,8 @@
 #!/usr/bin/env ruby
-require 'laser-cutter'
-require 'optparse'
-require 'colored'
-require 'json'
-require 'hashie/mash'
+require File.expand_path('../../lib/laser-cutter', __FILE__)
+require File.expand_path('../../lib/laser-cutter/cli/opt_parser', __FILE__)
 
-module Laser
-  module Cutter
-    class OptParse
-      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 -s 1x1.5x2/0.125 -O -o box.pdf
-        EOF
-
-        examples = <<-EOF
-
-Examples:
-  1. Create a box defined in inches, and open PDF in preview right after:
-
-       laser-cutter -s 3x2x2/0.125 -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 -zA3 -y landscape -k0.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 -s 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 (used as a guide)") { |value| options.notch = 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("-k", "--stroke WIDTH", "Numeric stroke width of the line") { |value| options.stroke = value }
-          opts.on("-z", "--page_size LETTER", "Page size, see --list-all-page-sizes for more info.") { |value| options.page_size = value }
-          opts.on("-y", "--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 FILE", "Save provided configuration to a file, use '-' for STDOUT") { |v| options.write_file = v }
-          opts.on("-R", "--read 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.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("-s", "--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
-          read_options_from_file(options)
-        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
-          write_options_to_file(config)
-        end
-
-        config
-      rescue OptionParser::InvalidOption, OptionParser::MissingArgument, Laser::Cutter::MissingOption => e
-        puts opt_parser.banner.blue
-        puts_error(e)
-        exit 1
-      end
-
-      def self.read_options_from_file(options)
-        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 self.write_options_to_file(options)
-        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 # class OptParse
-
-config = Laser::Cutter::OptParse.parse(ARGV)
+config = Laser::Cutter::CLI::OptParser.parse(ARGV)
 
 begin
   Laser::Cutter::Renderer::LayoutRenderer.new(config).render
@@ -164,7 +10,7 @@ begin
     `open #{config.file}`
   end
 rescue Exception => e
-  STDERR.puts "#{e.inspect}".red
+  STDERR.puts "Whoops, #{e.message}".red
   if config.verbose
     STDERR.puts e.backtrace.join("\n").red
   end

data/lib/laser-cutter.rb

@@ -4,6 +4,8 @@ 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'
 

data/lib/laser-cutter/aggregator.rb

@@ -0,0 +1,57 @@
+module Laser
+  module Cutter
+    class Aggregator
+      attr_accessor :lines
+
+      def initialize(array_of_lines = [])
+        self.lines = array_of_lines.sort
+      end
+
+      # This method finds lines that are identical (same p1/p2)
+      def dedup!
+        lines_to_delete = []
+        count = lines.size
+        for i in 0..(count - 1) do
+          for j in (i + 1)..(count - 1) do
+            l1 = lines[i]
+            l2 = lines[j]
+            if l1.eql?(l2)
+              lines_to_delete << l1
+              lines_to_delete << l2
+            end
+          end
+        end
+        self.lines = self.lines - lines_to_delete
+        self
+      end
+
+      # Find overlapping (intersecting) sections of lines and
+      # remove them.
+      def deoverlap!
+        lines_to_delete = []
+        lines_to_add = []
+        count = lines.size
+        for i in 0..(count - 1) do
+          for j in (i + 1)..(count - 1) do
+            l1 = lines[i]
+            l2 = lines[j]
+            if l1.overlaps?(l2)
+              lines_to_delete << l1
+              lines_to_delete << l2
+              lines_to_add << l1.xor(l2)
+            end
+          end
+        end
+
+        lines_to_delete.uniq!
+        lines_to_delete.flatten!
+        lines_to_add.uniq!
+        lines_to_add.flatten!
+
+        self.lines = (self.lines - lines_to_delete + lines_to_add).flatten
+        self.lines.sort!
+        self
+      end
+    end
+  end
+end

data/lib/laser-cutter/box.rb

@@ -5,8 +5,8 @@ module Laser
     class Box
       # Everything is in millimeters
 
-      attr_accessor :dim, :thickness, :notch_width
-      attr_accessor :padding, :units
+      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
@@ -17,10 +17,12 @@ module Laser
         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']
 
-        @notches = []
+        self.notches = []
 
         self.metadata = Geometry::Point[config['metadata_width'] || 0, config['metadata_height'] || 0]
 
@@ -39,6 +41,7 @@ module Laser
       end
 
       def enclosure
+        generate_notches if self.notches.empty?
         p1 = notches.first.p1.to_a
         p2 = notches.first.p2.to_a
 
@@ -51,32 +54,40 @@ module Laser
         Geometry::Rect[Geometry::Point.new(p1), Geometry::Point.new(p2)]
       end
 
-      # Returns an flattened array of lines representing notched lines
-      def notches
-        generate_notches! if @notches.empty?
-        @notches
-      end
-
-      def generate_notches!
+      def generate_notches
         position_faces!
-
         corner_face = pick_corners_face
-
-        @notches = []
+        self.notches = []
         faces.each_with_index do |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
-            path = Geometry::PathGenerator.new(:notch_width => notch_width,
-                                               :center_out => (self.conf[key][face_index] == :out) ,
-                                               :fill_corners => (self.conf[:corners][corner_face][face_index] == :yes && side_index.odd?),
-                                               :thickness => thickness
-            ).path(Geometry::Edge.new(bounding_side, face.sides[side_index], self.notch_width))
-            @notches << path.create_lines
+            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
-        end
 
-        @notches = Geometry::PathGenerator.deduplicate(@notches.flatten.sort)
+          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
+        self.notches.flatten!
       end
 
       def w; dim.w; end
@@ -95,8 +106,8 @@ module Laser
 
       def face_bounding_rect(face)
         b = face.clone
-        b.move_to(b.position.move_by(-thickness, -thickness))
-        b.p2 = b.p2.move_by(2 * thickness, 2 * thickness)
+        b.move_to(b.position.plus(-thickness, -thickness))
+        b.p2 = b.p2.plus(2 * thickness, 2 * thickness)
         b.relocate!
       end
 
@@ -154,11 +165,13 @@ module Laser
         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 << Geometry::Edge.new(b.sides[index], face, notch_width)
+          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