ruby3mf 0.2.5 → 0.2.6

data/lib/ruby3mf/log3mf.rb

@@ -1,135 +1,135 @@
-require 'singleton'
-require 'yaml'
-
-# Example usage:
-
-# Log3mf.context "box.3mf" do |l|
-#   --do some stuff here
-
-#   l.context "[Content-Types].xml" do |l|
-#     -- try to parse file. if fail...
-#     l.log(:fatal_error, "couldn't parse XML") <<<--- THIS WILL GENERATE FATAL ERROR EXCEPTION
-#   end
-
-#   l.context "examing Relations" do |l|
-#     l.log(:error, "a non-fatal error")
-#     l.log(:warning, "a warning")
-#     l.log(:info, "it is warm today")
-#   end
-# end
-#
-# Log3mf.to_json
-
-
-class Log3mf
-  include Singleton
-  include Interpolation
-
-  LOG_LEVELS = [:fatal_error, :error, :warning, :info, :debug]
-
-  SPEC_LINKS = {
-    core: 'http://3mf.io/wp-content/uploads/2016/03/3MFcoreSpec_1.1.pdf',
-    material: 'http://3mf.io/wp-content/uploads/2015/04/3MFmaterialsSpec_1.0.1.pdf',
-    production: 'http://3mf.io/wp-content/uploads/2016/07/3MFproductionSpec.pdf',
-    slice: 'http://3mf.io/wp-content/uploads/2016/07/3MFsliceSpec.pdf',
-    #opc: 'http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-376,%20Fourth%20Edition,%20Part%202%20-%20Open%20Packaging%20Conventions.zip'
-    opc: 'http://3mf.io/wp-content/uploads/2016/03/3MFcoreSpec_1.1.pdf'
-  }.freeze
-
-  # Allows us to throw FatalErrors if we ever get errors of severity :fatal_error
-  class FatalError < RuntimeError
-  end
-
-  def initialize
-    @log_list = []
-    @context_stack = []
-    @ledger = []
-    errormap_path = File.join(File.dirname(__FILE__), "errors.yml")
-    @errormap = YAML.load_file(errormap_path)
-  end
-
-  def reset_log
-    @log_list = []
-    @context_stack = []
-  end
-
-  def self.reset_log
-    Log3mf.instance.reset_log
-  end
-
-  def context (context_description, &block)
-    @context_stack.push(context_description)
-    retval = block.call(Log3mf.instance)
-    @context_stack.pop
-    retval
-  end
-
-  def self.context(context_description, &block)
-    Log3mf.instance.context(context_description, &block)
-  end
-
-  def method_missing(name, *args, &block)
-    if LOG_LEVELS.include? name.to_sym
-      if [:fatal_error, :error, :debug].include? name.to_sym
-        linenumber = caller_locations[0].to_s.split('/')[-1].split(':')[-2].to_s
-        filename = caller_locations[0].to_s.split('/')[-1].split(':')[0].to_s
-        options = {linenumber: linenumber, filename: filename}
-        # Mike: do not call error or fatal_error without an entry in errors.yml
-        raise "{fatal_}error called WITHOUT using error symbol from: #{filename}:#{linenumber}" if ( !(args[0].is_a? Symbol) && (name.to_sym != :debug) )
-
-        puts "***** Log3mf.#{name} called from #{filename}:#{linenumber} *****" if $DEBUG
-
-        options = options.merge(args[1]) if args[1]
-        log(name.to_sym, args[0], options)
-      else
-        log(name.to_sym, *args)
-      end
-    else
-      super
-    end
-  end
-
-  def log(severity, message, options = {})
-    error = @errormap.fetch(message.to_s) { {"msg" => message.to_s, "page" => nil} }
-    options[:page] = error["page"] unless options[:page]
-    options[:spec] = error["spec"] unless options[:spec]
-    entry = {id: message,
-             context: "#{@context_stack.join("/")}",
-             severity: severity,
-             message: interpolate(error["msg"], options)}
-    entry[:spec_ref] = spec_link(options[:spec], options[:page]) if (options && options[:page])
-    entry[:caller] = "#{options[:filename]}:#{options[:linenumber]}" if (options && options[:filename] && options[:linenumber])
-    @log_list << entry
-    raise FatalError if severity == :fatal_error
-  end
-
-  def count_entries(*levels)
-    entries(*levels).count
-  end
-
-  def self.count_entries(*l)
-    Log3mf.instance.count_entries(*l)
-  end
-
-  def entries(*levels)
-    return @log_list if levels.size == 0
-    @log_list.select { |i| levels.include? i[:severity] }
-  end
-
-  def self.entries(*l)
-    Log3mf.instance.entries(*l)
-  end
-
-  def spec_link(spec, page)
-    spec = :core unless spec
-    "#{SPEC_LINKS[spec]}#page=#{page}"
-  end
-
-  def to_json
-    @log_list.to_json
-  end
-
-  def self.to_json
-    Log3mf.instance.to_json
-  end
-end
+require 'singleton'
+require 'yaml'
+
+# Example usage:
+
+# Log3mf.context "box.3mf" do |l|
+#   --do some stuff here
+
+#   l.context "[Content-Types].xml" do |l|
+#     -- try to parse file. if fail...
+#     l.log(:fatal_error, "couldn't parse XML") <<<--- THIS WILL GENERATE FATAL ERROR EXCEPTION
+#   end
+
+#   l.context "examing Relations" do |l|
+#     l.log(:error, "a non-fatal error")
+#     l.log(:warning, "a warning")
+#     l.log(:info, "it is warm today")
+#   end
+# end
+#
+# Log3mf.to_json
+
+
+class Log3mf
+  include Singleton
+  include Interpolation
+
+  LOG_LEVELS = [:fatal_error, :error, :warning, :info, :debug]
+
+  SPEC_LINKS = {
+    core: 'http://3mf.io/wp-content/uploads/2016/03/3MFcoreSpec_1.1.pdf',
+    material: 'http://3mf.io/wp-content/uploads/2015/04/3MFmaterialsSpec_1.0.1.pdf',
+    production: 'http://3mf.io/wp-content/uploads/2016/07/3MFproductionSpec.pdf',
+    slice: 'http://3mf.io/wp-content/uploads/2016/07/3MFsliceSpec.pdf',
+    #opc: 'http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-376,%20Fourth%20Edition,%20Part%202%20-%20Open%20Packaging%20Conventions.zip'
+    opc: 'http://3mf.io/wp-content/uploads/2016/03/3MFcoreSpec_1.1.pdf'
+  }.freeze
+
+  # Allows us to throw FatalErrors if we ever get errors of severity :fatal_error
+  class FatalError < RuntimeError
+  end
+
+  def initialize
+    @log_list = []
+    @context_stack = []
+    @ledger = []
+    errormap_path = File.join(File.dirname(__FILE__), "errors.yml")
+    @errormap = YAML.load_file(errormap_path)
+  end
+
+  def reset_log
+    @log_list = []
+    @context_stack = []
+  end
+
+  def self.reset_log
+    Log3mf.instance.reset_log
+  end
+
+  def context (context_description, &block)
+    @context_stack.push(context_description)
+    retval = block.call(Log3mf.instance)
+    @context_stack.pop
+    retval
+  end
+
+  def self.context(context_description, &block)
+    Log3mf.instance.context(context_description, &block)
+  end
+
+  def method_missing(name, *args, &block)
+    if LOG_LEVELS.include? name.to_sym
+      if [:fatal_error, :error, :debug].include? name.to_sym
+        linenumber = caller_locations[0].to_s.split('/')[-1].split(':')[-2].to_s
+        filename = caller_locations[0].to_s.split('/')[-1].split(':')[0].to_s
+        options = {linenumber: linenumber, filename: filename}
+        # Mike: do not call error or fatal_error without an entry in errors.yml
+        raise "{fatal_}error called WITHOUT using error symbol from: #{filename}:#{linenumber}" if ( !(args[0].is_a? Symbol) && (name.to_sym != :debug) )
+
+        puts "***** Log3mf.#{name} called from #{filename}:#{linenumber} *****" if $DEBUG
+
+        options = options.merge(args[1]) if args[1]
+        log(name.to_sym, args[0], options)
+      else
+        log(name.to_sym, *args)
+      end
+    else
+      super
+    end
+  end
+
+  def log(severity, message, options = {})
+    error = @errormap.fetch(message.to_s) { {"msg" => message.to_s, "page" => nil} }
+    options[:page] = error["page"] unless options[:page]
+    options[:spec] = error["spec"] unless options[:spec]
+    entry = {id: message,
+             context: "#{@context_stack.join("/")}",
+             severity: severity,
+             message: interpolate(error["msg"], options)}
+    entry[:spec_ref] = spec_link(options[:spec], options[:page]) if (options && options[:page])
+    entry[:caller] = "#{options[:filename]}:#{options[:linenumber]}" if (options && options[:filename] && options[:linenumber])
+    @log_list << entry
+    raise FatalError if severity == :fatal_error
+  end
+
+  def count_entries(*levels)
+    entries(*levels).count
+  end
+
+  def self.count_entries(*l)
+    Log3mf.instance.count_entries(*l)
+  end
+
+  def entries(*levels)
+    return @log_list if levels.size == 0
+    @log_list.select { |i| levels.include? i[:severity] }
+  end
+
+  def self.entries(*l)
+    Log3mf.instance.entries(*l)
+  end
+
+  def spec_link(spec, page)
+    spec = :core unless spec
+    "#{SPEC_LINKS[spec]}#page=#{page}"
+  end
+
+  def to_json
+    @log_list.to_json
+  end
+
+  def self.to_json
+    Log3mf.instance.to_json
+  end
+end

data/lib/ruby3mf/mesh_analyzer.rb

@@ -1,80 +1,80 @@
-class MeshAnalyzer
-
-  def self.validate_object(object, includes_material)
-    Log3mf.context "verifying object" do |l|
-      children = object.children.map { |child| child.name }
-      have_override = object.attributes["pid"] or object.attributes["pindex"]
-      l.error :object_with_components_and_pid if have_override && children.include?("components")
-    end
-
-    Log3mf.context "validating geometry" do |l|
-      list = EdgeList.new
-
-      # if a triangle has a pid, then the object needs a pid
-      has_triangle_pid = false
-
-      meshs = object.css('mesh')
-      meshs.each do |mesh|
-
-        num_vertices = mesh.css("vertex").count
-        triangles = mesh.css("triangle")
-        l.error :not_enough_triangles if triangles.count < 4
-
-        if triangles
-          triangles.each do |triangle|
-
-            v1 = triangle.attributes["v1"].to_s.to_i
-            v2 = triangle.attributes["v2"].to_s.to_i
-            v3 = triangle.attributes["v3"].to_s.to_i
-
-            l.error :invalid_vertex_index if [v1, v2, v3].select{|vertex| vertex >= num_vertices}.count > 0
-
-            unless includes_material
-              l.context "validating property overrides" do |l|
-                property_overrides = []
-                property_overrides << triangle.attributes['p1'].to_s.to_i if triangle.attributes['p1']
-                property_overrides << triangle.attributes['p2'].to_s.to_i if triangle.attributes['p2']
-                property_overrides << triangle.attributes['p3'].to_s.to_i if triangle.attributes['p3']
-
-                property_overrides.reject! { |prop| prop.nil? }
-                l.error :has_base_materials_gradient unless property_overrides.uniq.size <= 1
-              end
-            end
-
-            if v1 == v2 || v2 == v3 || v3 == v1
-              l.error :non_distinct_indices
-            end
-
-            list.add_edge(v1, v2)
-            list.add_edge(v2, v3)
-            list.add_edge(v3, v1)
-            unless has_triangle_pid
-              has_triangle_pid = triangle.attributes["pid"] != nil
-            end
-          end
-
-          if has_triangle_pid && !(object.attributes["pindex"] && object.attributes["pid"])
-            l.error :missing_object_pid
-          end
-
-          result = list.verify_edges
-          if result == :bad_orientation
-            l.error :resource_3dmodel_orientation
-          elsif result == :hole
-            l.error :resource_3dmodel_hole
-          elsif result == :nonmanifold
-            l.error :resource_3dmodel_nonmanifold
-          end
-
-        end
-      end
-    end
-  end
-
-  def self.validate(model_doc, includes_material)
-    model_doc.css('model/resources/object').select { |object| ['model', 'solidsupport', ''].include?(object.attributes['type'].to_s) }.each do |object|
-      validate_object(object, includes_material)
-    end
-  end
-
-end
+class MeshAnalyzer
+
+  def self.validate_object(object, includes_material)
+    Log3mf.context "verifying object" do |l|
+      children = object.children.map { |child| child.name }
+      have_override = object.attributes["pid"] or object.attributes["pindex"]
+      l.error :object_with_components_and_pid if have_override && children.include?("components")
+    end
+
+    Log3mf.context "validating geometry" do |l|
+      list = EdgeList.new
+
+      # if a triangle has a pid, then the object needs a pid
+      has_triangle_pid = false
+
+      meshs = object.css('mesh')
+      meshs.each do |mesh|
+
+        num_vertices = mesh.css("vertex").count
+        triangles = mesh.css("triangle")
+        l.error :not_enough_triangles if triangles.count < 4
+
+        if triangles
+          triangles.each do |triangle|
+
+            v1 = triangle.attributes["v1"].to_s.to_i
+            v2 = triangle.attributes["v2"].to_s.to_i
+            v3 = triangle.attributes["v3"].to_s.to_i
+
+            l.error :invalid_vertex_index if [v1, v2, v3].select{|vertex| vertex >= num_vertices}.count > 0
+
+            unless includes_material
+              l.context "validating property overrides" do |l|
+                property_overrides = []
+                property_overrides << triangle.attributes['p1'].to_s.to_i if triangle.attributes['p1']
+                property_overrides << triangle.attributes['p2'].to_s.to_i if triangle.attributes['p2']
+                property_overrides << triangle.attributes['p3'].to_s.to_i if triangle.attributes['p3']
+
+                property_overrides.reject! { |prop| prop.nil? }
+                l.error :has_base_materials_gradient unless property_overrides.uniq.size <= 1
+              end
+            end
+
+            if v1 == v2 || v2 == v3 || v3 == v1
+              l.error :non_distinct_indices
+            end
+
+            list.add_edge(v1, v2)
+            list.add_edge(v2, v3)
+            list.add_edge(v3, v1)
+            unless has_triangle_pid
+              has_triangle_pid = triangle.attributes["pid"] != nil
+            end
+          end
+
+          if has_triangle_pid && !(object.attributes["pindex"] && object.attributes["pid"])
+            l.error :missing_object_pid
+          end
+
+          result = list.verify_edges
+          if result == :bad_orientation
+            l.error :resource_3dmodel_orientation
+          elsif result == :hole
+            l.error :resource_3dmodel_hole
+          elsif result == :nonmanifold
+            l.error :resource_3dmodel_nonmanifold
+          end
+
+        end
+      end
+    end
+  end
+
+  def self.validate(model_doc, includes_material)
+    model_doc.css('model/resources/object').select { |object| ['model', 'solidsupport', ''].include?(object.attributes['type'].to_s) }.each do |object|
+      validate_object(object, includes_material)
+    end
+  end
+
+end

data/lib/ruby3mf/mesh_normal_analyzer.rb

@@ -1,219 +1,219 @@
-class MeshNormalAnalyzer
-
-  def initialize(mesh)
-    @vertices = []
-    @intersections = []
-
-    vertices_node = mesh.css("vertices")
-    vertices_node.children.each do |vertex_node|
-      if vertex_node.attributes.count > 0
-        x = vertex_node.attributes['x'].to_s.to_f
-        y = vertex_node.attributes['y'].to_s.to_f
-        z = vertex_node.attributes['z'].to_s.to_f
-        @vertices << [x, y, z]
-      end
-    end
-
-    @triangles = []
-    triangles_node = mesh.css("triangles")
-    triangles_node.children.each do |triangle_node|
-      if triangle_node.attributes.count > 0
-        v1 = triangle_node.attributes['v1'].to_s.to_i
-        v2 = triangle_node.attributes['v2'].to_s.to_i
-        v3 = triangle_node.attributes['v3'].to_s.to_i
-        @triangles << [v1, v2, v3]
-      end
-    end
-  end
-
-  def found_inward_triangle
-    # Trace a ray toward the center of the vertex points.  This will hopefully
-    # maximize our chances of hitting the object's trianges on the first try.
-    center = point_cloud_center(@vertices)
-
-    @point = [0.0, 0.0, 0.0]
-    @direction = vector_to(@point, center)
-
-    # Make sure that we have a reasonably sized direction.
-    # Might end up with a zero length vector if the center is also
-    # at the origin.
-    if magnitude(@direction) < 0.1
-      @direction = [0.57, 0.57, 0.57]
-    end
-
-    # make the direction a unit vector just to make the
-    # debug info easier to understand
-    @direction = normalize(@direction)
-
-    attempts = 0
-    begin
-      # Get all of the intersections from the ray and put them in order of distance.
-      # The triangle we hit that's farthest from the start of the ray should always be
-      # a triangle that points away from us (otherwise we would hit a triangle even
-      # further away, assuming the mesh is closed).
-      #
-      # One special case is when the set of triangles we hit at that distance is greater
-      # than one.  In that case we might have hit a "corner" of the model and so we don't
-      # know which of the two (or more) points away from us.  In that case, cast a random
-      # ray from the center of the object and try again.
-
-      @triangles.each do |tri|
-        v1 = @vertices[tri[0]]
-        v2 = @vertices[tri[1]]
-        v3 = @vertices[tri[2]]
-
-        process_triangle(@point, @direction, [v1, v2, v3])
-      end
-
-      if @intersections.count > 0
-        # Sort the intersections so we can find the hits that are furthest away.
-        @intersections.sort! {|left, right| left[0] <=> right[0]}
-
-        max_distance = @intersections.last[0]
-        furthest_hits = @intersections.select{|hit| (hit[0]-max_distance).abs < 0.0001}
-
-        # Print out the hits
-        # furthest_hits.each {|hit| puts hit[1].to_s}
-
-        found_good_hit = furthest_hits.count == 1
-      end
-
-      if found_good_hit
-        outside_triangle = furthest_hits.last[2]
-      else
-        @intersections = []
-        attempts = attempts + 1
-
-        target = [Random.rand(10)/10.0, Random.rand(10)/10.0, Random.rand(10)/10.0]
-        @point = center
-        @direction = normalize(vector_to(@point, target))
-      end
-    end until found_good_hit || attempts >= 10
-
-    # return true if we hit a triangle with an inward pointing normal
-    # (according to counter-clockwise normal orientation)
-    found_good_hit && !compare_normals(outside_triangle, @direction)
-  end
-
-  def compare_normals(triangle, hit_direction)
-    oriented_normal = cross_product(
-        vector_to(triangle[0], triangle[1]),
-        vector_to(triangle[1], triangle[2]))
-
-    angle = angle_between(oriented_normal, hit_direction)
-
-    angle < Math::PI / 2.0
-  end
-
-  def process_triangle(point, direction, triangle)
-    found_intersection, t = intersect(point, direction, triangle)
-
-    if t > 0
-      intersection = []
-      intersection[0] = point[0] + t * direction[0]
-      intersection[1] = point[1] + t * direction[1]
-      intersection[2] = point[2] + t * direction[2]
-
-      @intersections << [t, intersection, triangle]
-    end
-  end
-
-  def intersect(point, direction, triangle)
-    v0 = triangle[0]
-    v1 = triangle[1]
-    v2 = triangle[2]
-
-    return [false, 0] if v0.nil? || v1.nil? || v2.nil?
-
-    e1 = vector_to(v0, v1)
-    e2 = vector_to(v0, v2)
-
-    h = cross_product(direction, e2)
-    a = dot_product(e1, h)
-
-    if a.abs < 0.00001
-      return false, 0
-    end
-
-    f = 1.0/a
-    s = vector_to(v0, point)
-    u = f * dot_product(s, h)
-
-    if u < 0.0 || u > 1.0
-      return false, 0
-    end
-
-    q = cross_product(s, e1)
-    v = f * dot_product(direction, q)
-
-    if v < 0.0 || u + v > 1.0
-      return false, 0
-    end
-
-    t = f * dot_product(e2, q)
-    [t > 0, t]
-  end
-end
-
-# Various utility functions
-
-def cross_product(a, b)
-  result = [0, 0, 0]
-  result[0] = a[1]*b[2] - a[2]*b[1]
-  result[1] = a[2]*b[0] - a[0]*b[2]
-  result[2] = a[0]*b[1] - a[1]*b[0]
-
-  result
-end
-
-def dot_product(a, b)
-  a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
-end
-
-def vector_to(a, b)
-  [b[0] - a[0], b[1] - a[1], b[2] - a[2]]
-end
-
-def magnitude(a)
-  Math.sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2])
-end
-
-def equal(a, b)
-  (a[0] - b[0]).abs < 0.0001 && (a[1] - b[1]).abs < 0.0001 && (a[2] - b[2]).abs < 0.0001
-end
-
-def angle_between(a, b)
-  cos_theta = dot_product(a, b) / (magnitude(a) * magnitude(b))
-  Math.acos(cos_theta)
-end
-
-def normalize(a)
-  length = magnitude(a)
-  [a[0]/length, a[1]/length, a[2]/length]
-end
-
-def point_cloud_center(vertices)
-  if vertices.count < 1
-    return [0, 0, 0]
-  end
-
-  vertex = vertices[0]
-  min_x = max_x = vertex[0]
-  min_y = max_y = vertex[1]
-  min_z = max_z = vertex[2]
-
-  vertices.each do |vertex|
-    x = vertex[0]
-    y = vertex[1]
-    z = vertex[2]
-
-    min_x = x if x < min_x
-    max_x = x if x > max_x
-    min_y = y if y < min_y
-    max_y = y if y > max_y
-    min_z = z if z < min_z
-    max_z = z if z > max_z
-  end
-
-  [(min_x + max_x) / 2.0, (min_y + max_y) / 2.0, (min_z + max_z) / 2.0]
+class MeshNormalAnalyzer
+
+  def initialize(mesh)
+    @vertices = []
+    @intersections = []
+
+    vertices_node = mesh.css("vertices")
+    vertices_node.children.each do |vertex_node|
+      if vertex_node.attributes.count > 0
+        x = vertex_node.attributes['x'].to_s.to_f
+        y = vertex_node.attributes['y'].to_s.to_f
+        z = vertex_node.attributes['z'].to_s.to_f
+        @vertices << [x, y, z]
+      end
+    end
+
+    @triangles = []
+    triangles_node = mesh.css("triangles")
+    triangles_node.children.each do |triangle_node|
+      if triangle_node.attributes.count > 0
+        v1 = triangle_node.attributes['v1'].to_s.to_i
+        v2 = triangle_node.attributes['v2'].to_s.to_i
+        v3 = triangle_node.attributes['v3'].to_s.to_i
+        @triangles << [v1, v2, v3]
+      end
+    end
+  end
+
+  def found_inward_triangle
+    # Trace a ray toward the center of the vertex points.  This will hopefully
+    # maximize our chances of hitting the object's trianges on the first try.
+    center = point_cloud_center(@vertices)
+
+    @point = [0.0, 0.0, 0.0]
+    @direction = vector_to(@point, center)
+
+    # Make sure that we have a reasonably sized direction.
+    # Might end up with a zero length vector if the center is also
+    # at the origin.
+    if magnitude(@direction) < 0.1
+      @direction = [0.57, 0.57, 0.57]
+    end
+
+    # make the direction a unit vector just to make the
+    # debug info easier to understand
+    @direction = normalize(@direction)
+
+    attempts = 0
+    begin
+      # Get all of the intersections from the ray and put them in order of distance.
+      # The triangle we hit that's farthest from the start of the ray should always be
+      # a triangle that points away from us (otherwise we would hit a triangle even
+      # further away, assuming the mesh is closed).
+      #
+      # One special case is when the set of triangles we hit at that distance is greater
+      # than one.  In that case we might have hit a "corner" of the model and so we don't
+      # know which of the two (or more) points away from us.  In that case, cast a random
+      # ray from the center of the object and try again.
+
+      @triangles.each do |tri|
+        v1 = @vertices[tri[0]]
+        v2 = @vertices[tri[1]]
+        v3 = @vertices[tri[2]]
+
+        process_triangle(@point, @direction, [v1, v2, v3])
+      end
+
+      if @intersections.count > 0
+        # Sort the intersections so we can find the hits that are furthest away.
+        @intersections.sort! {|left, right| left[0] <=> right[0]}
+
+        max_distance = @intersections.last[0]
+        furthest_hits = @intersections.select{|hit| (hit[0]-max_distance).abs < 0.0001}
+
+        # Print out the hits
+        # furthest_hits.each {|hit| puts hit[1].to_s}
+
+        found_good_hit = furthest_hits.count == 1
+      end
+
+      if found_good_hit
+        outside_triangle = furthest_hits.last[2]
+      else
+        @intersections = []
+        attempts = attempts + 1
+
+        target = [Random.rand(10)/10.0, Random.rand(10)/10.0, Random.rand(10)/10.0]
+        @point = center
+        @direction = normalize(vector_to(@point, target))
+      end
+    end until found_good_hit || attempts >= 10
+
+    # return true if we hit a triangle with an inward pointing normal
+    # (according to counter-clockwise normal orientation)
+    found_good_hit && !compare_normals(outside_triangle, @direction)
+  end
+
+  def compare_normals(triangle, hit_direction)
+    oriented_normal = cross_product(
+        vector_to(triangle[0], triangle[1]),
+        vector_to(triangle[1], triangle[2]))
+
+    angle = angle_between(oriented_normal, hit_direction)
+
+    angle < Math::PI / 2.0
+  end
+
+  def process_triangle(point, direction, triangle)
+    found_intersection, t = intersect(point, direction, triangle)
+
+    if t > 0
+      intersection = []
+      intersection[0] = point[0] + t * direction[0]
+      intersection[1] = point[1] + t * direction[1]
+      intersection[2] = point[2] + t * direction[2]
+
+      @intersections << [t, intersection, triangle]
+    end
+  end
+
+  def intersect(point, direction, triangle)
+    v0 = triangle[0]
+    v1 = triangle[1]
+    v2 = triangle[2]
+
+    return [false, 0] if v0.nil? || v1.nil? || v2.nil?
+
+    e1 = vector_to(v0, v1)
+    e2 = vector_to(v0, v2)
+
+    h = cross_product(direction, e2)
+    a = dot_product(e1, h)
+
+    if a.abs < 0.00001
+      return false, 0
+    end
+
+    f = 1.0/a
+    s = vector_to(v0, point)
+    u = f * dot_product(s, h)
+
+    if u < 0.0 || u > 1.0
+      return false, 0
+    end
+
+    q = cross_product(s, e1)
+    v = f * dot_product(direction, q)
+
+    if v < 0.0 || u + v > 1.0
+      return false, 0
+    end
+
+    t = f * dot_product(e2, q)
+    [t > 0, t]
+  end
+end
+
+# Various utility functions
+
+def cross_product(a, b)
+  result = [0, 0, 0]
+  result[0] = a[1]*b[2] - a[2]*b[1]
+  result[1] = a[2]*b[0] - a[0]*b[2]
+  result[2] = a[0]*b[1] - a[1]*b[0]
+
+  result
+end
+
+def dot_product(a, b)
+  a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
+end
+
+def vector_to(a, b)
+  [b[0] - a[0], b[1] - a[1], b[2] - a[2]]
+end
+
+def magnitude(a)
+  Math.sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2])
+end
+
+def equal(a, b)
+  (a[0] - b[0]).abs < 0.0001 && (a[1] - b[1]).abs < 0.0001 && (a[2] - b[2]).abs < 0.0001
+end
+
+def angle_between(a, b)
+  cos_theta = dot_product(a, b) / (magnitude(a) * magnitude(b))
+  Math.acos(cos_theta)
+end
+
+def normalize(a)
+  length = magnitude(a)
+  [a[0]/length, a[1]/length, a[2]/length]
+end
+
+def point_cloud_center(vertices)
+  if vertices.count < 1
+    return [0, 0, 0]
+  end
+
+  vertex = vertices[0]
+  min_x = max_x = vertex[0]
+  min_y = max_y = vertex[1]
+  min_z = max_z = vertex[2]
+
+  vertices.each do |vertex|
+    x = vertex[0]
+    y = vertex[1]
+    z = vertex[2]
+
+    min_x = x if x < min_x
+    max_x = x if x > max_x
+    min_y = y if y < min_y
+    max_y = y if y > max_y
+    min_z = z if z < min_z
+    max_z = z if z > max_z
+  end
+
+  [(min_x + max_x) / 2.0, (min_y + max_y) / 2.0, (min_z + max_z) / 2.0]
 end