laser-cutter 1.0.3 → 2.0.0

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/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/base.rb

@@ -1,13 +0,0 @@
-module Laser::Cutter::Notching
-  class Base
-    attr_accessor :edge
-
-    def initialize(edge)
-      @edge = edge
-    end
-
-    def notches
-      raise 'Abstract method'
-    end
-  end
-end

data/lib/laser-cutter/notching.rb

@@ -1,10 +0,0 @@
-module Laser
-  module Cutter
-    module Notching
-    end
-  end
-end
-
-require_relative 'notching/base'
-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

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

@@ -1,77 +0,0 @@
-# encoding: utf-8
-class Laser::Cutter::Renderer::MetaRenderer < Laser::Cutter::Renderer::Base
-
-  META_KEYS = %w(units width height depth thickness notch kerf stroke padding margin page_size page_layout)
-
-  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] }.join("\n")
-
-    rect = self.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

data/lib/laser-cutter/renderer.rb

@@ -1,14 +0,0 @@
-module Laser
-  module Cutter
-    module Renderer
-
-    end
-  end
-end
-
-require 'laser-cutter/renderer/base'
-require 'laser-cutter/renderer/line_renderer'
-require 'laser-cutter/renderer/rect_renderer'
-require 'laser-cutter/renderer/box_renderer'
-require 'laser-cutter/renderer/meta_renderer'
-require 'laser-cutter/renderer/layout_renderer'

data/lib/laser-cutter/version.rb

@@ -1,5 +0,0 @@
-module Laser
-  module Cutter
-    VERSION = "1.0.3"
-  end
-end

data/spec/aggregator_spec.rb

@@ -1,65 +0,0 @@
-require_relative 'spec_helper'
-
-module Laser
-  module Cutter
-    describe Aggregator do
-      let(:p1) { Geometry::Point[0,  0] }
-      let(:p2) { Geometry::Point[2,  0] }
-      let(:p3) { Geometry::Point[5,  0] }
-      let(:p4) { Geometry::Point[10, 0] }
-      let(:p5) { Geometry::Point[0, 12] }
-
-      let(:l1) { Geometry::Line.new(p1, p3) }
-      let(:l2) { Geometry::Line.new(p2, p4) }
-      let(:l3) { Geometry::Line.new(p2, p5) }
-      let(:l4) { Geometry::Line.new(p1, p2) }
-      let(:l5) { Geometry::Line.new(p3, p4) }
-
-      let(:lines) { [ l1, l2 ]}
-
-      let(:aggregator) { Aggregator.new(lines) }
-
-      context '#initialize' do
-        it 'should initialize with passed in parameters' do
-          expect(aggregator.lines.size).to eql(2)
-        end
-      end
-
-      context '#dedup' do
-        let(:a) { [1,5,3,1,2,2,2,2 ] }
-        let(:unique_lines) { [ l1, l2, l3, l4, l5 ]}
-        it 'should remove dups from a simple array' do
-          expect(Aggregator.new(a).dedup!.lines).to eql([3,5])
-        end
-        context 'short array' do
-          let(:lines) { [ l1, l2, l1, l1 ]}
-          let(:result) { [ l2 ]}
-          it 'should remove dupes from lines array' do
-            expect(Aggregator.new(lines).dedup!.lines.map(&:to_s)).to eql(result.map(&:to_s))
-          end
-        end
-        context 'long array' do
-          let(:lines) { [ l4, l1, l2, l3, l4, l3, l4, l5 ]}
-          let(:result) { [ l1, l2, l5 ]}
-          it 'should remove dupes from lines array' do
-            expect(Aggregator.new(lines).dedup!.lines.map(&:to_s)).to eql(result.map(&:to_s))
-          end
-        end
-      end
-
-      context '#deoverlap' do
-        let(:lines) { [ l1, l2, l3 ]}
-
-        let(:deoverlapped) { [ l4, l5, l3 ].sort }
-        it 'should remove lines that overlap' do
-          expect(aggregator.lines.size).to eql(3)
-          aggregator.deoverlap!
-          expect(aggregator.lines.size).to eql(3)
-          expect(aggregator.lines.map(&:to_s)).to eql(deoverlapped.map(&:to_s))
-        end
-      end
-
-    end
-  end
-end
-p

data/spec/box_spec.rb

@@ -1,40 +0,0 @@
-require_relative 'spec_helper'
-
-module Laser
-  module Cutter
-    describe Box do
-      let(:config) { {'width' => 50, 'height' => 60, 'depth' => 70, 'margin' => 5, 'padding' => 3, 'units' => 'mm'} }
-      let(:box1) { Box.new(config.merge('thickness' => 6, 'notch' => 10)) }
-      let(:box2) { Box.new(config.merge('thickness' => 6, )) }
-
-      context '#initialize' do
-        it 'should initialize with passed in parameters' do
-          expect(box1.w).to eq(50.0)
-          expect(box1.thickness).to eq(6.0)
-          expect(box1.notch_width).to eq(10.0)
-        end
-
-        it 'should initialize with default notch' do
-          expect(box2.notch_width).to eq(70.0 / 5.0)
-        end
-      end
-
-      context '#notches' do
-        before do
-          box1.generate_notches
-          box2.generate_notches
-        end
-        it 'should generate notches' do
-          expect(box1.notches).to_not be_nil
-          expect(box1.notches.size).to eql(368)
-        end
-
-        it 'should properly calculate enclosure' do
-          expect(box1.enclosure.to_a.flatten.map(&:round)).to eql([0,0, 232, 317])
-          expect(box2.enclosure.to_a.flatten.map(&:round)).to eql([0,0, 232, 317])
-        end
-      end
-
-    end
-  end
-end

data/spec/configuration_spec.rb

@@ -1,81 +0,0 @@
-require_relative 'spec_helper'
-
-module Laser
-  module Cutter
-    describe Configuration do
-      let(:config) { Laser::Cutter::Configuration.new(opts) }
-
-      context 'option parsing' do
-        let(:opts) { {"size" => "2x3x2/0.125/0.5", "inches" => true} }
-        it 'should be able to parse size options' do
-          expect(config.width).to eql(2.0)
-          expect(config.height).to eql(3.0)
-          expect(config.depth).to eql(2.0)
-          expect(config.thickness).to eql(0.125)
-          expect(config.notch).to eql(0.5)
-        end
-      end
-      context '#validate' do
-        context 'missing options' do
-          let(:opts) { {"height" => "23"} }
-          it 'should be able to validate missing options' do
-            expect(config.height).to eql(23.0)
-            expect { config.validate! }.to raise_error(Laser::Cutter::MissingOption)
-          end
-        end
-        context 'zero options' do
-          let(:opts) { {"size" => "2.0x0.0x2/0.125/0.5", 'file' => '/tmp/a'} }
-          it 'should be able to validate missing options' do
-            expect(config.height).to eql(0.0)
-            expect { config.validate! }.to raise_error(Laser::Cutter::ZeroValueNotAllowed)
-          end
-        end
-      end
-
-      context 'default values' do
-        let(:opts) { {"size" => "2.0x1.0x2/0.125", 'file' => '/tmp/a'} }
-        it 'should correctly default notch based on thickness' do
-          config.validate!
-          expect(config.thickness).to eql(0.125)
-          expect(config.notch).to eql(config.thickness * 3.0)
-        end
-      end
-
-      context 'when invalid units are provided' do
-        let(:opts) { {"size" => "2x3x2/0.125/0.5", "units" => 'xx'} }
-        it 'should default to inches' do
-          expect(config.units).to eql('in')
-        end
-      end
-
-      context 'when converting between units' do
-        context 'all config values' do
-          context "to mm" do
-            let(:opts) { {'size' => "2.0x3x2/0.125/0.5", 'padding' => '4.2', "units" => 'in'} }
-            it 'should be correct' do
-              expect(config.width).to eql(2.0)
-              config.change_units('in')
-              expect(config.width).to eql(2.0)
-              config.change_units('mm')
-              expect(config.width).to eql(50.8)
-              expect(config.padding).to eql(106.68)
-              expect(config.units).to eql('mm')
-            end
-          end
-          context 'to inches' do
-            let(:opts) { {'size' => "20.0x30.0x40.0/5/5", 'margin' => '10.0', "units" => 'mm'} }
-            it 'should be correct' do
-              expect(config.width).to eql(20.0)
-              config.change_units('mm')
-              expect(config.width).to eql(20.0)
-              config.change_units('in')
-              expect(config.width).to be_within(0.00001).of(0.787401575)
-              expect(config.margin).to be_within(0.00001).of(0.393700787)
-              expect(config.units).to eql('in')
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/edge_spec.rb

@@ -1,43 +0,0 @@
-require_relative 'spec_helper'
-
-module Laser
-  module Cutter
-
-    describe "Notching::Edge" do
-      context 'left vertical side' do
-        let(:notch_width) { 2 }
-        let(:inside)  { Geometry::Line.new(Geometry::Point[1, 1], Geometry::Point[1, 9])}
-        let(:outside) { Geometry::Line.new(Geometry::Point[0, 0], Geometry::Point[0, 10]) }
-        let(:edge) { Notching::Edge.new(inside, outside,
-                                        center_out: true,
-                                        fill_corners: true,
-                                        notch_width: notch_width,
-                                        kerf: 0.02,
-                                        thickness: 1) }
-
-        it 'should create a node correctly' do
-          expect(inside.length).to eql(8.0)
-          expect(outside.length).to eql(10.0)
-          expect(edge.center_out).to be_truthy
-          expect(edge.kerf).to be_within(0.0001).of(0.02)
-          expect(edge.thickness).to be_within(0.0001).of(1)
-          expect(edge.notch_width).to be_within(notch_width / 3.0).of(notch_width)
-        end
-
-        it 'should calculate notch width correctly' do
-          expect(inside.length).to eql(8.0)
-          expect(outside.length).to eql(10.0)
-          expect(edge.center_out).to be_truthy
-
-          expect(edge.kerf).to be_within(0.0001).of(0.02)
-          expect(edge.thickness).to be_within(0.0001).of(1)
-        end
-
-        it 'should correctly calculate v1 and v2' do
-          expect(edge.v1.to_a).to eql([1.0,1.0])
-          expect(edge.v2.to_a).to eql([1.0,-1.0])
-        end
-      end
-    end
-  end
-end