triangular 0.0.2 → 0.1.1

data/lib/triangular/solid.rb

@@ -1,90 +1,88 @@
+# frozen_string_literal: true
+
 module Triangular
   class Solid
-    
     attr_accessor :name, :facets, :units
-    
+
     def initialize(name, *args)
       @name = name
       @facets = args
       @units = units
     end
-    
+
     def to_s
-      output = "solid #{@name || ""}\n"
+      output = "solid #{@name || ''}\n"
       @facets.each do |facet|
-        output << "facet normal #{facet.normal.x.to_f} #{facet.normal.y.to_f} #{facet.normal.z.to_f}\n"
-        output << "outer loop\n"
+        output += "facet normal #{facet.normal.x.to_f} #{facet.normal.y.to_f} #{facet.normal.z.to_f}\n"
+        output += "outer loop\n"
         facet.vertices.each do |vertex|
-          output <<"vertex #{vertex.x.to_f} #{vertex.y.to_f} #{vertex.z.to_f}\n"
+          output += "vertex #{vertex.x.to_f} #{vertex.y.to_f} #{vertex.z.to_f}\n"
         end
-        output << "endloop\n"
-        output << "endfacet\n"
+        output += "endloop\n"
+        output += "endfacet\n"
       end
-      output << "endsolid #{@name || ""}\n"
-      
+      output += "endsolid #{@name || ''}\n"
+
       output
     end
-    
-    def get_bounds
+
+    def bounds
       largest_x = @facets[0].vertices[0].x
       largest_y = @facets[0].vertices[0].y
       largest_z = @facets[0].vertices[0].z
-      
+
       smallest_x = @facets[0].vertices[0].x
       smallest_y = @facets[0].vertices[0].y
       smallest_z = @facets[0].vertices[0].z
-      
+
       @facets.each do |facet|
         facet.vertices.each do |vertex|
           largest_x = vertex.x if vertex.x > largest_x
           largest_y = vertex.y if vertex.y > largest_y
           largest_z = vertex.z if vertex.z > largest_z
-          
+
           smallest_x = vertex.x if vertex.x < smallest_x
           smallest_y = vertex.y if vertex.y < smallest_y
           smallest_z = vertex.z if vertex.z < smallest_z
         end
       end
-      
+
       [Point.new(smallest_x, smallest_y, smallest_z), Point.new(largest_x, largest_y, largest_z)]
     end
-    
+
     def align_to_origin!
-      bounds = self.get_bounds
-      self.translate!(-bounds[0].x, -bounds[0].y, -bounds[0].z)
+      translate!(-bounds[0].x, -bounds[0].y, -bounds[0].z)
     end
-    
+
     def center!
-      bounds = self.get_bounds
-      
       x_translation = ((bounds[1].x - bounds[0].x).abs / 2) + -bounds[1].x
       y_translation = ((bounds[1].y - bounds[0].y).abs / 2) + -bounds[1].y
       z_translation = ((bounds[1].z - bounds[0].z).abs / 2) + -bounds[1].z
-      
-      self.translate!(x_translation, y_translation, z_translation)
+
+      translate!(x_translation, y_translation, z_translation)
     end
-    
+
     def slice_at_z(z_plane)
-      lines = @facets.map {|facet| facet.intersection_at_z(z_plane) }
+      lines = @facets.map { |facet| facet.intersection_at_z(z_plane) }
       lines.compact!
-      
+
       Polyline.new(lines)
     end
-    
+
     def translate!(x, y, z)
       @facets.each do |facet|
         facet.translate!(x, y, z)
       end
     end
-    
+
     def self.parse(string)
-      partial_pattern = /\s* solid\s+ (?<name> [a-zA-Z0-9\-\_\.]+)?/x
+      partial_pattern = /\s* solid\s+ (?<name> [a-zA-Z0-9\-_.]+)?/x
       match_data = string.match(partial_pattern)
-      
-      solid = self.new(match_data[:name])
-      
-      solid.facets = Facet.parse(string.gsub(partial_pattern, ""))
-      
+
+      solid = new(match_data[:name])
+
+      solid.facets = Facet.parse(string.gsub(partial_pattern, ''))
+
       solid
     end
   end

data/lib/triangular/units.rb

@@ -1,30 +1,34 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module Triangular
+  class UnknownUnitError < RuntimeError; end
+
   class Units
-    
     UNITS = {
-      :inches      => {:name => 'inches', :svg_name => 'in', :stroke_width => 0.005},
-      :centimeters => {:name => 'centimeters', :svg_name => 'cm', :stroke_width => 0.01},
-      :millimeters => {:name => 'millimeters', :svg_name => 'mm', :stroke_width => 0.1},
-      :none        => {:name => 'none', :svg_name => '', :stroke_width => 0.1}
-    }
-    
+      inches: { name: 'inches', svg_name: 'in', stroke_width: 0.005 },
+      centimeters: { name: 'centimeters', svg_name: 'cm', stroke_width: 0.01 },
+      millimeters: { name: 'millimeters', svg_name: 'mm', stroke_width: 0.1 },
+      none: { name: 'none', svg_name: '', stroke_width: 0.1 }
+    }.freeze
+
     def self.get_property(unit, name)
-      raise "Unknown unit: #{unit}" unless UNITS.has_key?(unit)
+      raise UnknownUnitError, "Unknown unit: #{unit}" unless UNITS.key?(unit)
+
       UNITS[unit][name]
     end
-    
+
     def self.name(unit)
-      self.get_property(unit, :name)
+      get_property(unit, :name)
     end
-    
+
     def self.svg_name(unit)
-      self.get_property(unit, :svg_name)
+      get_property(unit, :svg_name)
     end
-    
+
     def self.stroke_width(unit)
-      self.get_property(unit, :stroke_width)
+      get_property(unit, :stroke_width)
     end
   end
 end

data/lib/triangular/vector.rb

@@ -1,4 +1,11 @@
+# frozen_string_literal: true
+
 module Triangular
-  class Vector < Point    
+  class Vector < Point
+    def angle_to(other_vector)
+      dot_product = @x * other_vector.x + @y * other_vector.y + @z * other_vector.z
+      radians = Math.acos(dot_product)
+      radians * (180.0 / Math::PI)
+    end
   end
 end

data/lib/triangular/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Triangular
-  VERSION = "0.0.2"
+  VERSION = '0.1.1'
 end

data/lib/triangular/vertex.rb

@@ -1,45 +1,46 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module Triangular
   class Vertex
     extend Forwardable
-    
+
     def_delegator :@point, :x, :x
     def_delegator :@point, :y, :y
     def_delegator :@point, :z, :z
     def_delegator :@point, :translate!, :translate!
-    
+
     attr_accessor :point
-    
+
     def initialize(*args)
       if args.length == 1 && args.first.is_a?(Point)
         @point = args.first
       elsif args.length == 3
-        @point = Point.new(args[0], args[1], args[2])      
+        @point = Point.new(args[0], args[1], args[2])
       else
-        raise "You must either supply the XYZ coordinates or a Point object to create a Vertex"
+        raise 'You must either supply the XYZ coordinates or a Point object to create a Vertex'
       end
     end
-    
+
     def to_s
-      "vertex #{@point.to_s}"
+      "vertex #{@point}"
     end
-    
+
     def ==(other)
       return false unless other.is_a?(Vertex)
-      self.x == other.x && self.y == other.y && self.z == other.z
+
+      x == other.x && y == other.y && z == other.z
     end
-    
+
     def self.parse(string)
-      string.strip!
-      match_data = string.match(self.pattern)
-      
-      self.new(Point.parse(match_data[:point]))
+      match_data = string.strip.match(pattern)
+
+      new(Point.parse(match_data[:point]))
     end
-    
+
     def self.pattern
       /vertex\s+ (?<point>#{Point.pattern})/x
     end
-    
   end
 end

data/lib/triangular.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'triangular/point'
 require 'triangular/vertex'
 require 'triangular/vector'
@@ -6,12 +8,13 @@ require 'triangular/polyline'
 require 'triangular/facet'
 require 'triangular/units'
 require 'triangular/solid'
+require 'triangular/ray'
 
 module Triangular
   def self.parse(string)
     Solid.parse(string)
   end
-  
+
   def self.parse_file(path)
     File.open(path) do |file|
       Solid.parse(file.read)

data/spec/benchmark/benchmark_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.configure do |config|
+  config.after(:suite) do
+    benchmarks = {}
+
+    benchmarks['Triangular.parse_file'] = Benchmark.measure do
+      Triangular.parse_file(File.expand_path("#{File.dirname(__FILE__)}/../fixtures/y-axis-spacer.stl"))
+    end
+
+    puts "\n\n\n"
+    puts '--------------------------------------------------------------------------------'
+    puts '-  Benchmark Results:                                                          -'
+    puts '--------------------------------------------------------------------------------'
+    puts "\n"
+
+    benchmarks.each do |test_name, result|
+      puts test_name.ljust(34) + ": #{result}"
+    end
+  end
+end

data/spec/profile/profile_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.configure do |config|
+  config.after(:suite) do
+    profile = RubyProf.profile do
+      Triangular.parse_file(File.expand_path("#{File.dirname(__FILE__)}/../fixtures/y-axis-spacer.stl"))
+    end
+
+    puts "\n\n\n"
+    puts '--------------------------------------------------------------------------------'
+    puts '-  Profile Results:                                                            -'
+    puts '--------------------------------------------------------------------------------'
+    puts "\n"
+
+    printer = RubyProf::FlatPrinter.new(profile)
+    printer.print($stdout, min_percent: 2)
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,18 @@
-require "bundler/setup"
-require "triangular"
+# frozen_string_literal: true
 
-include Triangular
+require 'simplecov'
+SimpleCov.start
+
+require 'bundler/setup'
+require 'triangular'
+require 'benchmark'
+require 'ruby-prof'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/triangular/facet_spec.rb

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