triangular 0.0.1

data/examples/slice_example.rb

@@ -0,0 +1,9 @@
+require "bundler/setup"
+require "triangular"
+
+solid = Triangular.parse_file("#{File.dirname(__FILE__)}/example_files/y-axis-spacer.stl")
+polyline = solid.slice_at_z(-0.5)
+
+File.open(File.expand_path("~/Desktop/slice.svg"), "w+") do |file|
+  file.puts polyline.to_svg(10, 10)
+end

data/lib/triangular.rb

@@ -0,0 +1,19 @@
+require 'triangular/point'
+require 'triangular/vertex'
+require 'triangular/vector'
+require 'triangular/line'
+require 'triangular/polyline'
+require 'triangular/facet'
+require 'triangular/solid'
+
+module Triangular
+  def self.parse(string)
+    Solid.parse(string)
+  end
+  
+  def self.parse_file(path)
+    File.open(path) do |file|
+      Solid.parse(file.read)
+    end
+  end
+end

data/lib/triangular/facet.rb

@@ -0,0 +1,81 @@
+module Triangular
+  class Facet
+    
+    attr_accessor :normal, :vertices
+    
+    def initialize(normal = nil, *args)
+      @normal = normal
+      @vertices = args
+    end
+    
+    def to_s
+      output = "facet normal #{@normal.to_s}\n"
+      output += "outer loop\n"
+      @vertices.each do |vertex|
+        output += vertex.to_s + "\n"
+      end
+      output += "endloop\n"
+      output += "endfacet\n"
+      
+      output
+    end
+    
+    def lines
+      [
+        Line.new(@vertices[0], @vertices[1]),
+        Line.new(@vertices[1], @vertices[2]),
+        Line.new(@vertices[2], @vertices[0])
+      ]
+    end
+    
+    def intersection_at_z(z_plane)
+      return nil if @vertices.count{|vertex| vertex.z == z_plane} > 2
+      
+      intersection_points = []
+      lines.each do |line|
+        intersection_points << line.intersection_at_z(z_plane) unless line.start.z == z_plane && line.end.z == z_plane
+      end
+      
+      intersection_points.compact!
+      if intersection_points.empty?
+        nil
+      elsif intersection_points.count == 2       
+        Line.new(intersection_points[0], intersection_points[1])
+      end
+    end
+    
+    def self.parse(string)
+      facets = []
+      
+      string.scan(self.pattern) do |match_data|
+        facet = self.new
+        
+        facet.vertices << Vertex.parse(match_data[4])
+        facet.vertices << Vertex.parse(match_data[9])
+        facet.vertices << Vertex.parse(match_data[14])
+        
+        facet.normal = Vector.parse(match_data[0])
+        
+        facets << facet
+      end
+      
+      if facets.length == 1
+        facets.first
+      else
+        facets
+      end
+    end
+    
+    def self.pattern
+      /
+      \s* facet\snormal\s (?<normal> #{Point.pattern})\s
+      \s* outer\sloop\s
+      \s* (?<vertex1> #{Vertex.pattern})
+      \s* (?<vertex2> #{Vertex.pattern})
+      \s* (?<vertex3> #{Vertex.pattern})
+      \s* endloop\s
+      \s* endfacet\s
+      /x
+    end
+  end
+end

data/lib/triangular/line.rb

@@ -0,0 +1,38 @@
+module Triangular
+  class Line
+    
+    attr_accessor :start, :end
+    
+    def initialize(line_start, line_end)
+      @start = line_start
+      @end = line_end
+    end
+    
+    def ==(other)
+      return false unless other.is_a?(Line)
+      self.start == other.start && self.end == other.end
+    end
+    
+    def intersects_z?(z_plane)
+      if (@start.z >= z_plane && @end.z <= z_plane) || (@start.z <= z_plane && @end.z >= z_plane)
+        true
+      else
+        false
+      end
+    end
+    
+    def intersection_at_z(z_plane)
+      return nil if !self.intersects_z?(z_plane)
+      raise "Cannot calculate intersection for line that lies on the target Z plane" if @start.z == z_plane && @end.z == z_plane
+      
+      x_intersect = (@end.x - @start.x) / (@end.z - @start.z) * (z_plane - @start.z) + @start.x
+      y_intersect = (@end.y - @start.y) / (@end.z - @start.z) * (z_plane - @start.z) + @start.y
+      
+      Point.new(x_intersect, y_intersect, z_plane)
+    end
+    
+    def to_svg_path
+      "<path d=\"M #{@start.x} #{@start.y} L #{@end.x} #{@end.y}\" fill=\"none\" stroke=\"black\" stroke-width=\"1\" />"
+    end
+  end
+end

data/lib/triangular/point.rb

@@ -0,0 +1,33 @@
+module Triangular
+  class Point
+    
+    attr_accessor :x, :y, :z
+    
+    def initialize(x, y, z)
+      @x = x
+      @y = y
+      @z = z      
+    end
+    
+    def to_s
+      "#{@x.to_f} #{@y.to_f} #{@z.to_f}"
+    end
+    
+    def ==(other)
+      return false unless other.is_a?(Point)
+      self.x == other.x && self.y == other.y && self.z == other.z
+    end
+    
+    def self.parse(string)
+      string.strip!
+      match_data = string.match(self.pattern)
+      
+      self.new(match_data[:x].to_f, match_data[:y].to_f, match_data[:z].to_f)
+    end
+    
+    def self.pattern
+      /(?<x>-?\d+.\d+(e\-?\d+)?)\s(?<y>-?\d+.\d+(e\-?\d+)?)\s(?<z>-?\d+.\d+(e\-?\d+)?)/
+    end
+    
+  end
+end

data/lib/triangular/polyline.rb

@@ -0,0 +1,24 @@
+module Triangular
+  class Polyline
+   
+    attr_accessor :lines
+    
+    def initialize(lines)
+      @lines = lines
+    end
+    
+    def to_svg(x_offset = 20, y_offset = 20)
+      output  = '<?xml version="1.0" standalone="no"?>' + "\n"
+      output << '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">' + "\n"
+      output << '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">' + "\n"
+      output << "  <g transform=\"translate(#{x_offset},#{y_offset})\">\n"
+      
+      @lines.each do |line|
+        output << "    " + line.to_svg_path + "\n"
+      end
+      
+      output << '  </g>' + "\n"
+      output << '</svg>'
+    end
+  end
+end

data/lib/triangular/solid.rb

@@ -0,0 +1,45 @@
+module Triangular
+  class Solid
+    
+    attr_accessor :name, :facets
+    
+    def initialize(name, *args)
+      @name = name
+      @facets = args
+    end
+    
+    def to_s
+      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"
+        facet.vertices.each do |vertex|
+          output <<"vertex #{vertex.x.to_f} #{vertex.y.to_f} #{vertex.z.to_f}\n"
+        end
+        output << "endloop\n"
+        output << "endfacet\n"
+      end
+      output << "endsolid #{@name || ""}\n"
+      
+      output
+    end
+    
+    def slice_at_z(z_plane)
+      lines = @facets.map {|facet| facet.intersection_at_z(z_plane) }
+      lines.compact!
+      
+      Polyline.new(lines)
+    end
+    
+    def self.parse(string)
+      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
+    end
+  end
+end

data/lib/triangular/vector.rb

@@ -0,0 +1,4 @@
+module Triangular
+  class Vector < Point    
+  end
+end

data/lib/triangular/version.rb

@@ -0,0 +1,3 @@
+module Triangular
+  VERSION = "0.0.1"
+end

data/lib/triangular/vertex.rb

@@ -0,0 +1,44 @@
+require 'forwardable'
+
+module Triangular
+  class Vertex
+    extend Forwardable
+    
+    def_delegator :@point, :x, :x
+    def_delegator :@point, :y, :y
+    def_delegator :@point, :z, :z
+    
+    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])      
+      else
+        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}"
+    end
+    
+    def ==(other)
+      return false unless other.is_a?(Vertex)
+      self.x == other.x && self.y == other.y && self.z == other.z
+    end
+    
+    def self.parse(string)
+      string.strip!
+      match_data = string.match(self.pattern)
+      
+      self.new(Point.parse(match_data[:point]))
+    end
+    
+    def self.pattern
+      /vertex\s+ (?<point>#{Point.pattern})/x
+    end
+    
+  end
+end

data/spec/facet_spec.rb

@@ -0,0 +1,257 @@
+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 "for a facet that intersects the target Z plane at an angle" do
+      before do
+        vertex1 = Vertex.new(0.0, 0.0, 0.0)
+        vertex2 = Vertex.new(0.0, 6.0, 6.0)
+        vertex3 = Vertex.new(6.0, 6.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 == 3.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 == 3.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 == 6.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 == 6.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
+end