triangular 0.0.2 → 0.1.1

data/README.rdoc

@@ -1,64 +0,0 @@
-= Triangular
-
-Triangular is an easy-to-use Ruby library for reading, writing and manipulating Stereolithography (STL) files.
-
-The main purpose of Triangular is to enable its users to quickly create new software for Rapid Prototyping and Personal Manufacturing applications. Triangular has many of the core functions needed in order to generate toolpaths for 3D printers and CNC Mills/Routers.
-
-Please note that Triangular requires Ruby 1.9+. Triangular is currently in the Alpha stage of development which means that the API can and will change, and that new features will be added often!
-
-=== A Quick Example
-  
-  require "rubygems"
-  require "triangular"
-
-  # Open and parse an STL file
-  solid = Triangular.parse_file("test.stl")
-  
-  # Set the units of measurement for the resulting solid to inches
-  solid.units = :inches
-
-  # Move the solid so that all of it's coordinates are in positive space (ie: greater than 0)
-  solid.align_to_origin!
-  
-  # Get the bounding box of the solid
-  bounds = solid.get_bounds
-
-  # Create a section plane ('slice') through the solid on the XY plane at a Z height of 0.7
-  slice = solid.slice_at_z(0.7)
-
-  # Open a file for SVG output
-  File.open("slice.svg", "w+") do |file|
-  
-    # Output the slice as an SVG document (correctly scaled according to the solid's units)
-    file.puts slice.to_svg(bounds[1].x, bounds[1].y, solid.units)
-  end
-
-=== Installation
-
-For ease of use the Triangular is packaged as a RubyGem. Providing you already have Ruby and RubyGems installing Triangular is as easy as entering the following command in a terminal:
-
-  gem install triangular
-  
-=== Performance
-
-At the moment Triangular has not been optimized at all. The parser is a relatively naive one that was designed to be easy to read rather than performant. Once the feature-set of Triangular has stabilized I will be doing a pass over it in order to make it fast enough for production use. Right now it could definitely be improved.
-
-For example here is some information about run-times when processing a 51Mb STL file:
-
-  solid = Triangular.parse("big_file.stl")
-  # 65 seconds
-  
-  solid.align_to_origin!
-  # 8 seconds
-  
-  solid.slice_at_z(1.0)
-  # 2 seconds
-
-=== Author & Credits
-
-Author:: {Aaron Gough}[mailto:aaron@aarongough.com]
-
-Special thanks go out to {Alkas Baybas}[https://github.com/abaybas] for lending me his massive brain!
-
-Copyright (c) 2011 {Aaron Gough}[http://thingsaaronmade.com/] ({thingsaaronmade.com}[http://thingsaaronmade.com/]), released under the MIT license
-

data/Rakefile

@@ -1,11 +0,0 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks
-
-require 'rspec/core/rake_task'
-
-desc "Run the specs for Triangular"
-RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = "-c"
-  t.fail_on_error = false
-  t.verbose = false
-end

data/spec/facet_spec.rb

@@ -1,233 +0,0 @@
-require 'spec_helper'
-
-describe Facet do
-  describe ".parse" do
-    context "with a correctly formatted facet" do
-      before do
-        @result = Facet.parse(<<-EOD)
-          facet normal 0.0 0.0 -1.0
-          outer loop
-          vertex 16.5 0.0 -0.75
-          vertex 0.0 -9.5 -0.75
-          vertex 0.0 0.0 -0.75
-          endloop
-          endfacet
-        EOD
-      end
-      
-      it "should return a facet object" do
-        @result.should be_a Facet
-      end
-      
-      it "should return a facet with 3 vertices" do
-        @result.vertices.length.should == 3
-      end
-      
-      it "should return a facet with vertices of type Vertex" do
-        @result.vertices.each do |vertex|
-          vertex.should be_a Vertex
-        end
-      end
-      
-      it "should return a facet with a normal of type Vector" do
-        @result.normal.should be_a Vector
-      end
-      
-      it "should correctly set the normal values" do
-        @result.normal.x.should == 0
-        @result.normal.y.should == 0
-        @result.normal.z.should == -1
-      end
-      
-      it "should correctly set the values for the first vertex" do
-        @result.vertices[0].x.should == 16.5
-        @result.vertices[0].y.should == 0
-        @result.vertices[0].z.should == -0.75
-      end
-      
-      it "should correctly set the values for the second vertex" do
-        @result.vertices[1].x.should == 0
-        @result.vertices[1].y.should == -9.5
-        @result.vertices[1].z.should == -0.75
-      end
-      
-      it "should correctly set the values for the third vertex" do
-        @result.vertices[2].x.should == 0
-        @result.vertices[2].y.should == 0
-        @result.vertices[2].z.should == -0.75
-      end
-    end
-    
-    context "when passed multiple facets" do
-      before do
-        @result = Facet.parse(<<-EOD)
-          facet normal 0.0 0.0 -1.0
-          outer loop
-          vertex 16.5 0.0 -0.75
-          vertex 0.0 -9.5 -0.75
-          vertex 0.0 0.0 -0.75
-          endloop
-          endfacet
-          facet normal 0.0 0.0 -1.0
-          outer loop
-          vertex 16.5 0.0 -0.75
-          vertex 0.0 -9.5 -0.75
-          vertex 0.0 0.0 -0.75
-          endloop
-          endfacet
-        EOD
-      end
-      
-      it "should return multiple facet objects" do
-        @result.should be_a Array
-        @result.each do |item|
-          item.should be_a Facet
-        end
-      end
-    end
-  end
-  
-  describe "#to_s" do
-    it "should return the string representation for a facet" do
-      facet = Facet.new
-      facet.normal = Vector.new(0, 0, 1)
-      facet.vertices << Point.new(1, 2, 3)
-      facet.vertices << Point.new(1, 2, 3)
-      facet.vertices << Point.new(1, 2, 3)
-      
-      expected_string  = "facet normal 0.0 0.0 1.0\n"
-      expected_string += "outer loop\n"
-      expected_string += facet.vertices[0].to_s + "\n"
-      expected_string += facet.vertices[1].to_s + "\n"
-      expected_string += facet.vertices[2].to_s + "\n"
-      expected_string += "endloop\n"
-      expected_string += "endfacet\n"
-      
-      facet.to_s.should == expected_string
-    end
-  end
-  
-  describe "#intersection_at_z" do
-    context "for a facet that intersects the target Z plane" do
-      before do
-        vertex1 = Vertex.new(0.0, 0.0, 0.0)
-        vertex2 = Vertex.new(0.0, 0.0, 6.0)
-        vertex3 = Vertex.new(6.0, 0.0, 6.0)
-        
-        @facet = Facet.new(nil, vertex1, vertex2, vertex3)
-      end
-      
-      context "when the target Z plane is 3.0" do
-        it "should return a line object" do
-          @facet.intersection_at_z(3.0).should be_a Line
-        end
-        
-        it "should return a line with the correct start value" do
-          @facet.intersection_at_z(3.0).start.x.should == 0.0
-          @facet.intersection_at_z(3.0).start.y.should == 0.0
-          @facet.intersection_at_z(3.0).start.z.should == 3.0
-        end
-        
-        it "should return a line with the correct end value" do
-          @facet.intersection_at_z(3.0).end.x.should == 3.0
-          @facet.intersection_at_z(3.0).end.y.should == 0.0
-          @facet.intersection_at_z(3.0).end.z.should == 3.0
-        end
-      end
-      
-      context "when the target Z plane is 6.0" do
-        it "should return a line object" do
-          @facet.intersection_at_z(6.0).should be_a Line
-        end
-        
-        it "should return a line with the correct start value" do
-          @facet.intersection_at_z(6.0).start.x.should == 0.0
-          @facet.intersection_at_z(6.0).start.y.should == 0.0
-          @facet.intersection_at_z(6.0).start.z.should == 6.0
-        end
-        
-        it "should return a line with the correct end value" do
-          @facet.intersection_at_z(6.0).end.x.should == 6.0
-          @facet.intersection_at_z(6.0).end.y.should == 0.0
-          @facet.intersection_at_z(6.0).end.z.should == 6.0
-        end
-      end
-    end
-    
-    context "with vertices in both positive and negative space" do
-      before do
-        @facet = Facet.parse(<<-EOD)
-          facet normal -0.0 1.0 -0.0
-          outer loop
-          vertex -1.0 1.0 1.0
-          vertex 1.0 1.0 -1.0
-          vertex -1.0 1.0 -1.0
-          endloop
-          endfacet
-        EOD
-      end
-      
-      it "should return a line with the correct start value" do
-        @facet.intersection_at_z(0.0).start.x.should == 0.0
-        @facet.intersection_at_z(0.0).start.y.should == 1.0
-        @facet.intersection_at_z(0.0).start.z.should == 0.0
-      end
-      
-      it "should return a line with the correct end value" do
-        @facet.intersection_at_z(0.0).end.x.should == -1.0
-        @facet.intersection_at_z(0.0).end.y.should == 1.0
-        @facet.intersection_at_z(0.0).end.z.should == 0.0
-      end
-    end
-    
-    context "for a facet that lies on the target Z plane" do
-      before do
-        vertex1 = Vertex.new(0.0, 0.0, 1.0)
-        vertex2 = Vertex.new(2.0, 0.0, 1.0)
-        vertex3 = Vertex.new(2.0, 2.0, 1.0)
-        
-        @facet = Facet.new(nil, vertex1, vertex2, vertex3)
-      end
-      
-      it "should return nil" do
-        @facet.intersection_at_z(1.0).should == nil
-      end
-    end
-    
-    context "for a facet that does not intersect the target Z plane" do
-      before do
-        vertex1 = Vertex.new(0.0, 0.0, 0.0)
-        vertex2 = Vertex.new(2.0, 0.0, 0.0)
-        vertex3 = Vertex.new(2.0, 2.0, 0.0)
-        
-        @facet = Facet.new(nil, vertex1, vertex2, vertex3)
-      end
-      
-      it "should return nil" do
-        @facet.intersection_at_z(1.0).should == nil
-      end
-    end
-  end
-  
-  describe "#translate!" do
-    before do
-      @facet = Facet.parse(<<-EOD)
-        facet normal 0.0 0.0 -1.0
-        outer loop
-        vertex -16.5 0.0 -0.75
-        vertex 0.0 -9.5 -0.75
-        vertex 0.0 0.0 -0.75
-        endloop
-        endfacet
-      EOD
-    end
-    
-    it "should call translate on each of it's Vertices" do
-      @facet.vertices[0].should_receive(:translate!).with(16.5, 9.5, 0.75)
-      @facet.vertices[1].should_receive(:translate!).with(16.5, 9.5, 0.75)
-      @facet.vertices[2].should_receive(:translate!).with(16.5, 9.5, 0.75)
-      
-      @facet.translate!(16.5, 9.5, 0.75)
-    end
-  end
-end

data/spec/line_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-
-describe Line do
-  describe "#intersects_z?" do 
-    context "for a line that intersects the target Z plane" do
-      context "with a positive Z vector" do
-        before do
-          @line = Line.new(Vertex.new(0.0, 0.0, 0.0), Vertex.new(0.0, 0.0, 6.0))
-        end
-        
-        it "should return true" do
-          @line.intersects_z?(3.0).should be_true
-        end
-      end
-      
-      context "with a negative Z vector" do
-        before do
-          @line = Line.new(Vertex.new(0.0, 0.0, 6.0), Vertex.new(0.0, 0.0, 0.0))
-        end
-        
-        it "should return true" do
-          @line.intersects_z?(3.0).should be_true
-        end
-      end
-    end
-    
-    context "for a line that does not intersect the target Z plane" do
-      before do
-        @line = Line.new(Vertex.new(0.0, 0.0, 4.0), Vertex.new(0.0, 0.0, 6.0))
-      end
-      
-      it "should return false" do
-        @line.intersects_z?(3.0).should be_false
-      end
-    end
-  end
-  
-  describe "#intersection_at_z" do
-    context "for a line that intersects the target Z plane" do
-      context "and spans both positive and negative space" do
-        context "with a positive Z vector" do
-          before do
-            @line = Line.new(Vertex.new(-1.0, 1.0, 1.0), Vertex.new(1.0, 1.0, -1.0))
-          end
-          
-          it "should return a Point representing the intersection" do
-            @line.intersection_at_z(0).x.should == 0.0
-            @line.intersection_at_z(0).y.should == 1.0
-            @line.intersection_at_z(0).z.should == 0.0
-          end
-        end
-        
-        context "with a negative Z vector" do
-          before do
-            @line = Line.new(Vertex.new(1.0, 1.0, 1.0), Vertex.new(-1.0, -1.0, -1.0))
-          end
-          
-          it "should return a Point representing the intersection" do
-            @line.intersection_at_z(0).x.should == 0
-            @line.intersection_at_z(0).y.should == 0
-            @line.intersection_at_z(0).z.should == 0
-          end
-        end
-      end
-    end
-      
-    context "for a line that lies on the target Z plane" do
-      before do
-        @line = Line.new(Vertex.new(0.0, 0.0, 3.0), Vertex.new(0.0, 6.0, 3.0))
-      end
-      
-      it "should raise an error" do
-        lambda{
-          @line.intersection_at_z(3.0)
-        }.should raise_error
-      end
-    end
-    
-    context "for a line that does not intersect the target Z plane" do
-      before do
-        @line = Line.new(Vertex.new(0.0, 0.0, 4.0), Vertex.new(0.0, 0.0, 6.0))
-      end
-      
-      it "should return nil" do
-        @line.intersection_at_z(3.0).should be_nil
-      end
-    end
-  end
-  
-  describe "==" do
-    it "should return true when the two lines are identical" do
-      (Line.new(Vertex.new(-1.0, -1.0, -1.0), Vertex.new(1.0, 1.0, 1.0)) == Line.new(Vertex.new(-1.0, -1.0, -1.0), Vertex.new(1.0, 1.0, 1.0))).should be_true
-    end
-    
-    it "should not return true when the lines are not identical" do
-      (Line.new(Vertex.new(-1.0, -1.0, -1.1), Vertex.new(1.0, 1.0, 1.0)) == Line.new(Vertex.new(-1.0, -1.0, -1.0), Vertex.new(1.0, 1.0, 1.0))).should be_false
-    end
-  end
-  
-  describe "#to_svg_path" do 
-    it "should return a string containing an SVG path" do
-      line = Line.new(Vertex.new(0.0, 0.0, 0.0), Vertex.new(1.0, 1.0, 1.0))
-      expected_output = '<path d="M 0.0 0.0 L 1.0 1.0" fill="none" stroke="black" stroke-width="0.005" />'
-      
-      line.to_svg_path(:inches).should == expected_output
-    end
-  end
-end

data/spec/point_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe Point do
-  describe ".parse" do
-    context "with a correctly formatted point" do
-      before do
-        @result = Point.parse("  16.5 0.0 -0.75 ")
-      end
-      
-      it "should return a point object" do
-        @result.should be_a Point
-      end
-      
-      it "should correctly set the X value" do
-        @result.x.should == 16.5
-      end
-      
-      it "should correctly set the Y value" do
-        @result.y.should == 0
-      end
-      
-      it "should correctly set the Z value" do
-        @result.z.should == -0.75
-      end
-    end
-    
-    context "with a point that contains exponential notation" do
-      before do
-        @result = Point.parse("  -5.23431439438796e-32 0.0 5.23431439438796e32 ")
-      end
-      
-      it "should correctly set the X value" do
-        @result.x.should == -5.23431439438796e-32
-      end
-      
-      it "should correctly set the Y value" do
-        @result.y.should == 0.0
-      end
-      
-      it "should correctly set the Z value" do
-        @result.z.should == 5.23431439438796e32
-      end
-    end
-  end
-  
-  describe "#to_s" do
-    it "should return the XYZ components separated by spaces" do
-      point = Point.new(1.0, 2.0, -3.1)
-      point.to_s.should == "1.0 2.0 -3.1"
-    end
-    
-    it "should convert integers into floats for output" do
-      point = Point.new(1, 2, 3)
-      point.to_s.should == "1.0 2.0 3.0"
-    end
-  end
-  
-  describe "#==" do
-    it "should return true when the points have identical values" do
-      (Point.new(1.0, 2.0, -3.1) == Point.new(1.0, 2.0, -3.1)).should be_true
-    end
-    
-    it "should return false when the points do not have identical values" do
-      (Point.new(1.0, 2.0, -3.1) == Point.new(1.0, 2.0, -3.2)).should be_false
-    end
-  end
-  
-  describe "#translate!" do
-    before do
-      @point = Point.new(1.0, 1.0, 1.0)
-    end
-    
-    it "should add the supplied value to X" do
-      @point.translate!(16.5, 9.5, 0.75)
-      @point.x.should == 17.5
-    end
-    
-    it "should add the supplied value to Y" do
-      @point.translate!(16.5, 9.5, 0.75)
-      @point.y.should == 10.5
-    end
-    
-    it "should add the supplied value to Z" do
-      @point.translate!(16.5, 9.5, 0.75)
-      @point.z.should == 1.75
-    end
-  end
-end

data/spec/polyline_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Polyline do
-  describe "#to_svg" do
-    it "should output an SVG document as a string" do
-      line = Line.new(Vertex.new(0.0, 0.0, 0.0), Vertex.new(1.0, 1.0, 1.0))
-      polyline = Polyline.new([line])
-      
-      expected_svg  = '<?xml version="1.0" standalone="no"?>' + "\n"
-      expected_svg += '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">' + "\n"
-      expected_svg += '<svg x="0" y="0" width="20in" height="30in" viewBox="0 0 20 30" xmlns="http://www.w3.org/2000/svg" version="1.1">' + "\n"
-      expected_svg += '  <g transform="translate(1in,2in)">' + "\n"
-      expected_svg += "    #{line.to_svg_path(:inches)}\n"
-      expected_svg += '  </g>' + "\n"
-      expected_svg += '</svg>'
-      
-      polyline.to_svg(20, 30, :inches, 1, 2).should == expected_svg
-    end
-  end
-end

data/spec/triangular_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Triangular do  
-  describe ".parse" do
-    it "should return a Solid" do
-      stl_string = File.open("#{File.dirname(__FILE__)}/fixtures/y-axis-spacer.stl").read
-      result = Triangular.parse(stl_string)
-      
-      result.should be_a Solid
-    end
-  end
-  
-  describe ".parse_file" do
-    it "should return a Solid" do
-      input = File.open(File.expand_path("#{File.dirname(__FILE__)}/fixtures/y-axis-spacer.stl")).read
-      result = Triangular.parse_file(File.expand_path("#{File.dirname(__FILE__)}/fixtures/y-axis-spacer.stl"))
-      result.should be_a Solid
-
-      result.to_s.should == input
-    end
-  end
-end

data/spec/units_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-describe Units do
-  describe ".name" do
-    it "should return 'inches' for :inches" do
-      Units.name(:inches).should == 'inches'
-    end
-    
-    it "should return 'centimeters' for :centimeters" do
-      Units.name(:centimeters).should == 'centimeters'
-    end
-    
-    it "should return 'millimeters' for :millimeters" do
-      Units.name(:millimeters).should == 'millimeters'
-    end
-    
-    it "should return 'none' for :none" do
-      Units.name(:none).should == 'none'
-    end
-    
-    it "should raise an exception if called with an unknown unit" do
-      lambda {
-        Units.name(:error)
-      }.should raise_error
-    end
-  end
-  
-  describe ".svg_name" do
-    it "should return 'in' for :inches" do
-      Units.svg_name(:inches).should == 'in'
-    end
-    
-    it "should return 'cm' for :centimeters" do
-      Units.svg_name(:centimeters).should == 'cm'
-    end
-    
-    it "should return 'mm' for :millimeters" do
-      Units.svg_name(:millimeters).should == 'mm'
-    end
-    
-    it "should return '' for :none" do
-      Units.svg_name(:none).should == ''
-    end
-    
-    it "should raise an exception if called with an unknown unit" do
-      lambda {
-        Units.svg_name(:error)
-      }.should raise_error
-    end
-  end
-  
-  describe ".stroke_width" do
-    it "should return 'in' for :inches" do
-      Units.stroke_width(:inches).should == 0.005
-    end
-    
-    it "should return 'cm' for :centimeters" do
-      Units.stroke_width(:centimeters).should == 0.01
-    end
-    
-    it "should return 'mm' for :millimeters" do
-      Units.stroke_width(:millimeters).should == 0.1
-    end
-    
-    it "should return '' for :none" do
-      Units.stroke_width(:none).should == 0.1
-    end
-    
-    it "should raise an exception if called with an unknown unit" do
-      lambda {
-        Units.stroke_width(:error)
-      }.should raise_error
-    end
-  end
-end

data/spec/vertex_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe Vertex do
-  describe ".parse" do
-    context "with a correctly formatted vertex" do
-      before do
-        @result = Vertex.parse("  vertex 16.5 0.0 -0.75\n")
-      end
-      
-      it "should return a vertex object" do
-        @result.should be_a Vertex
-      end
-      
-      it "should correctly set the X value" do
-        @result.x.should == 16.5
-      end
-      
-      it "should correctly set the Y value" do
-        @result.y.should == 0
-      end
-      
-      it "should correctly set the Z value" do
-        @result.z.should == -0.75
-      end
-    end
-  end
-  
-  describe "#to_s" do
-    it "should return the keyword 'vertex' followed by the XYZ coordinates" do
-      vertex = Vertex.new(1.0, 2.0, -3.0)
-      vertex.to_s.should == "vertex 1.0 2.0 -3.0"
-    end
-  end
-  
-  describe "#==" do
-    it "should return true when the vertices have identical values" do
-      (Vertex.new(1.0, 2.0, -3.1) == Vertex.new(1.0, 2.0, -3.1)).should be_true
-    end
-    
-    it "should return false when the vertices do not have identical values" do
-      (Vertex.new(1.0, 2.0, -3.1) == Vertex.new(1.0, 2.0, -3.2)).should be_false
-    end
-  end
-end