laser-cutter 0.5.3 → 1.0.0

data/lib/laser-cutter/version.rb

@@ -1,5 +1,5 @@
 module Laser
   module Cutter
-    VERSION = "0.5.3"
+    VERSION = "1.0.0"
   end
 end

data/spec/aggregator_spec.rb

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

@@ -20,9 +20,13 @@ module Laser
       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(320)
+          expect(box1.notches.size).to eql(368)
         end
 
         it 'should properly calculate enclosure' do

data/spec/dimensions_spec.rb

@@ -1,5 +1,4 @@
 require_relative 'spec_helper'
-
 module Laser
   module Cutter
     module Geometry

data/spec/edge_spec.rb

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

data/spec/line_spec.rb

@@ -6,7 +6,7 @@ module Laser
       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(:center) { Point.new((7 + 1) / 2, (11 + 1) / 2) }
         let(:line) { Line.new(p1, p2) }
 
         context '#center' do
@@ -16,11 +16,11 @@ module Laser
         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))}
+          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))
+            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)
@@ -41,38 +41,61 @@ module Laser
         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]) }
+          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(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 = [l4, l3, l1, l2]
             list.sort!
-            expect(list).to eql([l1,l3,l2,l4])
+            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])
+            expect(list).to eql([l1, l3, l2, l4])
           end
+        end
+        context 'overlaps and such' do
+          let(:l1) { Line.new(Point[0, 0], Point[10, 0]) }
+          let(:l2) { Line.new(Point[7, 0], Point[15, 0]) }
+          let(:l3) { Line.new(Point[20, 0], Point[25, 0]) }
+          let(:l4) { Line.new(Point[0, 1], Point[0, 3]) }
+          let(:l5) { Line.new(Point[0, -1], Point[0, 2]) }
+
 
-          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])
+          context '#overlaps?' do
+            it 'should detect overlap' do
+              expect(l1.overlaps?(l2)).to be_truthy
+              expect(l1.overlaps?(l3)).to be_falsey
+              expect(l2.overlaps?(l3)).to be_falsey
+              expect(l1.overlaps?(l4)).to be_falsey
+              expect(l2.overlaps?(l4)).to be_falsey
+              expect(l4.overlaps?(l5)).to be_truthy
+            end
           end
 
+          context '#xor' do
+            let(:xor) { [ Line.new(Point[0, 0], Point[7, 0]),  Line.new(Point[10, 0], Point[15, 0])]}
+            it 'should subtract lines' do
+              expect(l1.xor(l2)).to eql(xor)
+              expect(l1.overlaps?(l3)).to be_falsey
+              expect(l2.overlaps?(l3)).to be_falsey
+              expect(l1.overlaps?(l4)).to be_falsey
+              expect(l2.overlaps?(l4)).to be_falsey
+              expect(l4.overlaps?(l5)).to be_truthy
+            end
+          end
         end
-
       end
     end
   end

data/spec/path_generator_spec.rb

@@ -2,19 +2,23 @@ require_relative 'spec_helper'
 
 module Laser
   module Cutter
-    module Geometry
+    module Notching
       describe PathGenerator do
         let(:notch) { 2 }
         let(:thickness) { 1 }
         let(:center_out) { true }
-        let(:fill_edge) { true }
-        let(:outside) { Line.new(from: [0, 0], to: [10, 0]) }
-        let(:inside) { Line.new(from: [1, 1], to: [9, 1]) }
-        let(:edge) { Edge.new(outside, inside, notch) }
-        let(:generator) { PathGenerator.new(notch_width: notch,
-                                            thickness: thickness,
-                                            center_out: center_out,
-                                            fill_edge: fill_edge) }
+        let(:corners) { true }
+
+        let(:options) { {notch_width: notch,
+                         thickness: thickness,
+                         center_out: center_out,
+                         corners: corners} }
+
+        let(:outside) { Geometry::Line.new(from: [0, 0], to: [10, 0]) }
+        let(:inside)  { Geometry::Line.new(from: [1, 1], to: [9,  1]) }
+        let(:edge) { Edge.new(outside, inside, options) }
+        let(:generator) { PathGenerator.new(edge) }
+
         context 'edge' do
           it 'should properly calculate notch size' do
             expect(edge.notch_width).to be_within(0.001).of(1.6)
@@ -29,19 +33,20 @@ module Laser
         end
 
         context 'alternating iterator' do
-          let(:iterator) { InfiniteIterator.new([:a, :b, :c]) }
+          let(:a) { "hello" }
+          let(:b) { "again" }
+          let(:iterator) { InfiniteIterator.new([a,b]) }
           it 'returns things in alternating order' do
-            expect(iterator.next).to eq(:a)
-            expect(iterator.next).to eq(:b)
-            expect(iterator.next).to eq(:c)
-            expect(iterator.next).to eq(:a)
+            expect(iterator.next).to eq(a)
+            expect(iterator.next).to eq(b)
+            expect(iterator.next).to eq(a)
           end
         end
 
         context 'shift definition' do
 
           it 'correctly defines shifts' do
-            shifts = generator.send(:define_shifts, edge)
+            shifts = generator.send(:define_shifts)
             expect(edge.outside.length).to eql(10.0)
             expect(edge.inside.length).to eql(8.0)
             expect(edge.notch_width).to be_within(0.001).of(1.6)
@@ -53,41 +58,30 @@ module Laser
 
         context 'path generation' do
           # let(:outside) { Line.new(
-          #     from: inside.p1.move_by(-thickness, -thickness),
-          #     to: inside.p2.move_by(thickness, -thickness)) }
+          #     from: inside.p1.plus(-thickness, -thickness),
+          #     to: inside.p2.plus(thickness, -thickness)) }
 
           context 'center out' do
             it 'generates correct path vertices' do
-              inside.freeze
               expect(inside.p1).to_not eql(inside.p2)
-              path = generator.path(edge)
-              expect(path).to be_a_kind_of(NotchedPath)
-              expect(path.size).to be > 5
+              lines = generator.generate
+              expect(lines.size).to be > 5
 
-              expect(Line.new(path.vertices.first, inside.p1).length).to be_within(0.001).of(0)
-              expect(Line.new(path.vertices.last, inside.p2).length).to be_within(0.001).of(0)
+              expect(Geometry::Line.new(lines.first.p1, inside.p1).length).to be_within(0.001).of(0)
+              expect(Geometry::Line.new(lines.last.p2, inside.p2).length).to be_within(0.001).of(0)
 
               # Sanity Check
-              expect(Point.new(1, 1)).to eql(inside.p1)
-              expect(Point.new(9, 1)).to eql(inside.p2)
+              expect(Geometry::Point.new(1, 1)).to eql(inside.p1)
+              expect(Geometry::Point.new(9, 1)).to eql(inside.p2)
             end
 
             it 'generates correct lines' do
-              path = generator.path(edge)
-              lines = path.create_lines
-              expect(path.size).to eq(12)
-              expect(lines.size).to be > 1
+              lines = generator.generate
+              expect(lines.size).to eq(19)
             end
           end
         end
 
-        context 'remove dupes' do
-          let(:a) { [1,5,3,1,2,2,2,2 ] }
-          it 'should remove dups' do
-            expect(PathGenerator.deduplicate(a)).to eql([3,5])
-          end
-        end
-
       end
     end
   end

data/spec/point_spec.rb

@@ -42,12 +42,12 @@ module Laser
 
         context 'move by' do
           it 'should move properly' do
-            p = p1.move_by(10, -2)
+            p = p1.plus(10, -2)
             expect(p.x).to be_within(0.001).of(11)
             expect(p.y).to be_within(0.001).of(0)
           end
           it 'should move cloned version properly' do
-            p2 = p1.clone.move_by(10, -2)
+            p2 = p1.clone.plus(10, -2)
             expect(p2.x).to be_within(0.001).of(11)
             expect(p2.y).to be_within(0.001).of(0)
           end

data/spec/rect_spec.rb

@@ -28,7 +28,7 @@ module Laser
             expect(rect1.sides.first.p1).to eql(p1)
             expect(rect1.sides[0].p1.to_s).to eql("{1.00000,3.00000}")
             expect(rect1.sides[1].p1.to_s).to eql("{11.00000,3.00000}")
-            expect(rect1.sides[2].p1).to eql(p1.move_by(10, 20))
+            expect(rect1.sides[2].p1).to eql(p1.plus(10, 20))
           end
           it 'can be moved' do
             expect(rect1.sides[0].p1.to_s).to eql("{1.00000,3.00000}")

data/spec/renderer_spec.rb

@@ -9,17 +9,26 @@ module Laser
           let(:file) { File.expand_path("../../laser-cutter-pdf-test.#{$$}.pdf", __FILE__) }
 
           def render_file filename
+            real_file = ENV['RSPEC_SAVE_PDF'] ? true : false
             config.validate!
-            expect(!File.exists?(filename))
+            expect(!File.exists?(filename)) if real_file
             renderer.render
-            expect(File.exist?(filename))
-            expect(File.size(filename) > 0)
+            expect(File.exist?(filename)) if real_file
+            expect(File.size(filename) > 0) if real_file
           rescue Exception => e
             STDERR.puts e.backtrace.join("\n")
             fail e.message
           ensure
-            File.delete(filename) rescue nil
-            expect(!File.exists?(filename))
+            if real_file
+              File.delete(filename) rescue nil
+              expect(!File.exists?(filename))
+            end
+          end
+
+          before do
+            unless ENV['RSPEC_SAVE_PDF']
+              expect_any_instance_of(Prawn::Document).to receive(:render_file).once
+            end
           end
 
           context 'metric' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: laser-cutter
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Konstantin Gredeskoul
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-05 00:00:00.000000000 Z
+date: 2014-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prawn
@@ -146,18 +146,22 @@ files:
 - doc/comparison.jpg
 - laser-cutter.gemspec
 - lib/laser-cutter.rb
+- lib/laser-cutter/aggregator.rb
 - lib/laser-cutter/box.rb
+- lib/laser-cutter/cli/opt_parser.rb
+- lib/laser-cutter/cli/serializer.rb
 - lib/laser-cutter/configuration.rb
 - lib/laser-cutter/geometry.rb
 - lib/laser-cutter/geometry/dimensions.rb
-- lib/laser-cutter/geometry/edge.rb
-- lib/laser-cutter/geometry/notched_path.rb
-- lib/laser-cutter/geometry/path_generator.rb
 - lib/laser-cutter/geometry/point.rb
 - lib/laser-cutter/geometry/shape.rb
 - lib/laser-cutter/geometry/shape/line.rb
 - lib/laser-cutter/geometry/shape/rect.rb
 - lib/laser-cutter/geometry/tuple.rb
+- lib/laser-cutter/notching.rb
+- lib/laser-cutter/notching/base.rb
+- lib/laser-cutter/notching/edge.rb
+- lib/laser-cutter/notching/path_generator.rb
 - lib/laser-cutter/page_manager.rb
 - lib/laser-cutter/renderer.rb
 - lib/laser-cutter/renderer/base.rb
@@ -167,9 +171,11 @@ files:
 - lib/laser-cutter/renderer/meta_renderer.rb
 - lib/laser-cutter/renderer/rect_renderer.rb
 - lib/laser-cutter/version.rb
+- spec/aggregator_spec.rb
 - spec/box_spec.rb
 - spec/configuration_spec.rb
 - spec/dimensions_spec.rb
+- spec/edge_spec.rb
 - spec/line_spec.rb
 - spec/page_manager_spec.rb
 - spec/path_generator_spec.rb
@@ -203,9 +209,11 @@ specification_version: 4
 summary: Creates notched box outlines for laser-cut boxes which are geometrically
   symmetric and pleasing to the eye.
 test_files:
+- spec/aggregator_spec.rb
 - spec/box_spec.rb
 - spec/configuration_spec.rb
 - spec/dimensions_spec.rb
+- spec/edge_spec.rb
 - spec/line_spec.rb
 - spec/page_manager_spec.rb
 - spec/path_generator_spec.rb