laser-cutter 0.2.0

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

@@ -0,0 +1,59 @@
+module Laser
+  module Cutter
+    module Geometry
+      class Rect < Line
+
+        attr_accessor :sides, :vertices
+
+        def self.[] p1, p2
+          Rect.new(p1, p2)
+        end
+
+        def self.create(point, w, h, name = nil)
+          r = Rect.new(point, Point[point.x + w, point.y + h])
+          r.name = name
+          r
+        end
+
+        def self.from_line(line)
+          Rect.new(line.p1, line.p2)
+        end
+
+        def initialize(*args)
+          super(*args)
+          relocate!
+        end
+
+        def relocate!
+          super
+          self.vertices = []
+          vertices << p1
+          vertices << p1.move_by(w, 0)
+          vertices << p2
+          vertices << p1.move_by(0, h)
+          self.sides = []
+          vertices.each_with_index do |v, index|
+            sides << Line.new(v, vertices[(index + 1) % vertices.size])
+          end
+          self
+        end
+
+        def w
+          p2.x - p1.x
+        end
+
+        def h
+          p2.y - p1.y
+        end
+
+
+        def to_s
+          "#{sprintf "%3d", w}(w)x#{sprintf "%3d", h}(h) @ #{position.to_s}"
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,89 @@
+module Laser
+  module Cutter
+    module Geometry
+      class Tuple
+        attr_accessor :coords
+        PRECISION = 0.000001
+
+        def initialize(*args)
+          args = customize_args(args)
+          x = args.first
+          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
+          else
+            self.coords = args.clone
+          end
+
+          self.coords.map!(&:to_f)
+        end
+
+        def customize_args(args)
+          args
+        end
+
+        def separator
+          raise NotImplementedError
+          # 'x'
+        end
+
+        def hash_keys
+          raise NotImplementedError
+          # [:x, :y, :z] or [:h, :w, :d]
+        end
+
+        def to_a
+          self.coords
+        end
+
+        def to_s
+          "{#{coords.map { |a| sprintf("%.5f", a) }.join(separator)}}"
+        end
+
+        def valid?
+          raise "Have nil value: #{self.inspect}" if coords.any? { |c| c.nil? }
+          true
+        end
+
+        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
+              equal = false
+              break
+            end
+          end
+          equal
+        end
+
+        def clone
+          clone = super
+          clone.coords = self.coords.clone
+          clone
+        end
+
+        private
+
+        #
+        # convert from, eg "100,50" to [100.0, 50.0],
+        # and then to a new instance.
+        #
+        def parse_string string
+          self.coords = string.split(separator).map(&:to_f)
+        end
+
+        def parse_hash hash
+          self.coords = []
+          hash_keys.each { |k| self.coords << hash[k] }
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/laser-cutter/renderer.rb

@@ -0,0 +1,19 @@
+module Laser
+  module Cutter
+    module Renderer
+      class AbstractRenderer < Struct.new(:subject, :options)
+        def render pdf = nil
+          raise 'Abstract method'
+        end
+
+        def units
+          options.units.to_sym || :mm
+        end
+      end
+    end
+  end
+end
+
+require 'laser-cutter/renderer/line_renderer'
+require 'laser-cutter/renderer/rect_renderer'
+require 'laser-cutter/renderer/box_renderer'

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

@@ -0,0 +1,69 @@
+require 'json'
+module Laser
+  module Cutter
+    module Renderer
+      class BoxRenderer < AbstractRenderer
+
+        def box
+          subject
+        end
+
+        def render pdf = nil
+          pdf = Prawn::Document.new(:margin => options.margin.send(options.units),
+                                    :page_size => options.page_size,
+                                    :page_layout => options.page_layout.to_sym)
+
+          header = <<-EOF
+
+          Produced with Laser Cutter Ruby Gem (v#{Laser::Cutter::VERSION})
+          Credits to Prawn (for ruby PDF generation),
+          and BoxMaker (for the inspiration).
+          © 2014 Konstantin Gredeskoul, MIT license.
+          https://github.com/kigster/laser-cutter
+          Generated at #{Time.new}.
+          EOF
+
+          renderer = self
+
+          pdf.instance_eval do
+            self.line_width = renderer.options.stroke.send(renderer.options.units.to_sym)
+            float do
+              bounding_box([0, 50], :width => 150, :height => 40) do
+                stroke_color '0080FF'
+                stroke_bounds
+
+                indent 10 do
+                  font('Courier', :size => 5) do
+                    text header, :color => "0080FF"
+                  end
+                end
+              end
+              bounding_box([480, 120], :width => 110, :height => 110) do
+                stroke_color '00DF20'
+                stroke_bounds
+                indent 10 do
+                  font('Courier', :size => 6) do
+                    out = JSON.pretty_generate(renderer.options.to_hash).gsub(/[\{\}",]/,'')
+                    text out, :color => "00DF20"
+                  end
+                end
+              end
+            end
+
+            stroke_color "000000"
+            renderer.box.notches.each do |notch|
+              LineRenderer.new(notch, renderer.options).render(self)
+            end
+
+            render_file(renderer.options.file)
+          end
+
+          if options.verbose
+            puts "file #{options.file} has been written."
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Laser
+  module Cutter
+    module Renderer
+      class LineRenderer < AbstractRenderer
+        def line
+          subject
+        end
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Laser
+  module Cutter
+    module Renderer
+      class RectRenderer < AbstractRenderer
+        def rect
+          subject
+        end
+
+        def render pdf
+          rect.sides.each do |side|
+            LineRenderer.new(side, options).render(pdf)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/laser-cutter/version.rb

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

data/spec/box_spec.rb

@@ -0,0 +1,31 @@
+require_relative 'spec_helper'
+
+module Laser
+  module Cutter
+    describe Box do
+      let(:config) { {'width' => 50, 'height' => 60, 'depth' => 70, 'margin' => 5, 'padding' => 3 } }
+      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
+        it 'should generate notches' do
+          expect(box1.notches).to_not be_nil
+          expect(box1.notches.size).to eql(320)
+        end
+      end
+
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,28 @@
+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
+        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(RuntimeError)
+        end
+      end
+
+    end
+  end
+end

data/spec/dimensions_spec.rb

@@ -0,0 +1,28 @@
+require_relative 'spec_helper'
+
+module Laser
+  module Cutter
+    module Geometry
+
+      describe Dimensions do
+        let(:dim1) { Dimensions.new(20, 10, 50) }
+
+        context 'creation' do
+          context 'from string' do
+            let(:dim2) { Dimensions.new "20x10x50" }
+            it 'should instantiate correctly from a string' do
+              expect(dim2).to_not be_nil
+              expect(dim2).to eql(dim1)
+            end
+          end
+
+          context 'from hash' do
+            it 'should instantiate correctly from a hash' do
+              expect(Dimensions.new(h: 10, w: 20, d: 50)).to eql(dim1)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/line_spec.rb

@@ -0,0 +1,79 @@
+require_relative 'spec_helper'
+
+module Laser
+  module Cutter
+    module Geometry
+      describe Line do
+        let(:p1) { Point.new(1, 1) }
+        let(:p2) { Point.new(7, 11) }
+        let(:center) { Point.new( (7 + 1) / 2, (11 + 1) / 2) }
+        let(:line) { Line.new(p1, p2) }
+
+        context '#center' do
+          it 'should calculate' do
+            expect(line.center).to eql(center)
+          end
+        end
+
+        context '#initialize' do
+          let(:line2) { Line.new(from: [1,1], to: [7,11])}
+          let(:line3) { Line.new(from: Point.new(1,1), to: Point.new(7,11))}
+          it 'should create' do
+            expect(line2.p1).to eql(Point.new(1,1))
+            expect(line2.p2).to eql(Point.new(7,11))
+          end
+          it 'should properly equal identical line' do
+            expect(line).to eql(line2)
+            expect(line).to eql(line3)
+          end
+
+        end
+
+        context '#length' do
+          let(:line1) { Line.new(Point.new(0, 0), Point.new(0, 10)) }
+          let(:line2) { Line.new(Point.new(0, 0), Point.new(-10, 0)) }
+          let(:line3) { Line.new(Point.new(0, 0), Point.new(3, 4)) }
+          it 'should calculate' do
+            expect(line1.length).to be_within(0.001).of(10)
+            expect(line2.length).to be_within(0.001).of(10)
+            expect(line3.length).to be_within(0.001).of(5)
+          end
+        end
+
+        context 'ordering and equality' do
+          let(:l1) { Line.new(Point[0,0], Point[10,10]) }
+          let(:l2) { Line.new(Point[0,1], Point[10,10]) }
+          let(:l3) { Line.new(Point[0,0], Point[11,10]) }
+          let(:l4) { Line.new(Point[20,20], Point[1,1]) }
+          let(:l5) { Line.new(Point[11,10], Point[0,0]) }
+          it 'should detect equality' do
+            expect(l1).to eql(Line.new(l1.p1, l1.p2))
+            expect(l1).to_not eql(Line.new(l1.p1, Point[2,4]))
+            expect(l5).to eql(l3)
+            expect(l5.hash).to eql(l3.hash)
+          end
+
+          it 'should properly compare' do
+            list = [l4,l3,l1,l2]
+            list.sort!
+            expect(list).to eql([l1,l3,l2,l4])
+          end
+
+          it 'should properly uniq' do
+            list = [l4, l1, l4, l2, l3, l3, l2, l1]
+            list.sort!.uniq!
+            expect(list).to eql([l1,l3,l2,l4])
+          end
+
+          it 'should properly deduplicate' do
+            list = [l1, l4, l2, l3, l5, l3, l1, l3, l3, l2]
+            new_list = PathGenerator.deduplicate(list)
+            expect(new_list).to eql([l4])
+          end
+
+        end
+
+      end
+    end
+  end
+end