gmath3D 0.2.5 → 1.0.0

data/test/test_tri_mesh.rb

@@ -1,186 +1,186 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'helper'
-
-include GMath3D
-
-MiniTest::Unit.autorun
-
-class TriMeshTestCase < MiniTest::Unit::TestCase
-  def get_box_mesh
-    box = Box.new(Vector3.new(-1,-1,-1), Vector3.new(2,3,4))
-    return TriMesh.from_box(box)
-  end
-
-  def get_plane_mesh
-    rect = Rectangle.new(Vector3.new(-1,-1,-1), Vector3.new(2,0,0), Vector3.new(0,4,0) )
-    return TriMesh.from_rectangle(rect)
-  end
-
-  def test_initalize
-    plane_mesh = get_plane_mesh()
-    assert_equal( 2, plane_mesh.tri_indices.size)
-    assert_equal( 4, plane_mesh.vertices.size)
-
-    box_mesh = get_box_mesh()
-    assert_equal( 12, box_mesh.tri_indices.size)
-    assert_equal( 8, box_mesh.vertices.size)
-
-    assert_raises ArgumentError do
-      invalidResult = TriMesh.new(nil)
-    end
-    assert_raises ArgumentError do
-      invalidResult = TriMesh.new(Vector3.new(), 4.0)
-    end
-  end
-
-  def test_equal
-    plane_mesh = get_plane_mesh()
-    assert( plane_mesh != nil )
-    assert( plane_mesh != "String" )
-
-    shallow = plane_mesh
-    assert( shallow == plane_mesh )
-    assert( shallow.equal?(plane_mesh) )
-
-    new_mesh = get_plane_mesh()
-    assert( shallow == new_mesh )
-    assert( !shallow.equal?(new_mesh) )
-  end
-
-  def test_clone
-    plane_mesh = get_plane_mesh()
-    shallow = plane_mesh
-
-    shallow.vertices[0].x = 12
-    shallow.vertices[2] = Vector3.new(-3,2,5)
-    shallow.tri_indices[0] = [3,2,1]
-    shallow.tri_indices[1][2] = 2
-
-    assert_equal( 12, shallow.vertices[0].x )
-    assert_equal( 12, plane_mesh.vertices[0].x )
-    assert_equal( Vector3.new(-3,2,5), shallow.vertices[2] )
-    assert_equal( Vector3.new(-3,2,5), plane_mesh.vertices[2] )
-    assert_equal( [3,2,1], shallow.tri_indices[0] )
-    assert_equal( [3,2,1], plane_mesh.tri_indices[0] )
-    assert_equal( 2, shallow.tri_indices[1][2] )
-    assert_equal( 2, plane_mesh.tri_indices[1][2] )
-
-    deep = plane_mesh.clone
-    assert( deep == plane_mesh )
-    assert( !deep.equal?(plane_mesh) )
-
-    deep.vertices[0].x = -1
-    deep.vertices[2] = Vector3.new(4,2,1)
-    deep.tri_indices[0] = [4,2,2]
-    deep.tri_indices[1][2] = 5
-
-    assert_equal( -1, deep.vertices[0].x )
-    assert_equal( 12, plane_mesh.vertices[0].x )
-    assert_equal( Vector3.new(4,2,1), deep.vertices[2] )
-    assert_equal( Vector3.new(-3,2,5), plane_mesh.vertices[2] )
-    assert_equal( [4,2,2], deep.tri_indices[0] )
-    assert_equal( [3,2,1], plane_mesh.tri_indices[0] )
-    assert_equal( 5, deep.tri_indices[1][2] )
-    assert_equal( 2, plane_mesh.tri_indices[1][2] )
-  end
-
-  def test_to_s
-    assert_equal( "TriMesh[triangle_count:12, vertex_count:8]", get_box_mesh().to_s)
-  end
-
-  def test_box
-    box_mesh = get_box_mesh
-    plane_mesh = get_plane_mesh
-    assert_equal( Vector3.new(-1,-1,-1), box_mesh.box.min_point )
-    assert_equal( Vector3.new( 2, 3, 4), box_mesh.box.max_point )
-    assert_equal( Vector3.new(-1,-1,-1), plane_mesh.box.min_point )
-    assert_equal( Vector3.new( 1, 3,-1), plane_mesh.box.max_point )
-  end
-
-  def test_triangles
-    vertices = [Vector3.new(0,0,0),Vector3.new(2,0,0),Vector3.new(2,2,0),Vector3.new(0,2,0)]
-    tri_indices = [[0,1,3],[1,2,3]]
-    tri_mesh = TriMesh.new(vertices, tri_indices)
-    triangles = tri_mesh.triangles
-    assert_equal(2, triangles.size)
-    assert_equal(Vector3.new(0,0,0), triangles[0].vertices[0])
-    assert_equal(Vector3.new(2,0,0), triangles[0].vertices[1])
-    assert_equal(Vector3.new(0,2,0), triangles[0].vertices[2])
-    assert_equal(Vector3.new(2,0,0), triangles[1].vertices[0])
-    assert_equal(Vector3.new(2,2,0), triangles[1].vertices[1])
-    assert_equal(Vector3.new(0,2,0), triangles[1].vertices[2])
-
-    triangle = tri_mesh.triangle(1)
-    assert_equal(Vector3.new(2,0,0), triangle.vertices[0])
-    assert_equal(Vector3.new(2,2,0), triangle.vertices[1])
-    assert_equal(Vector3.new(0,2,0), triangle.vertices[2])
-
-    triangle = tri_mesh.triangle(3)
-    assert_equal(nil, triangle)
-  end
-
-  def test_from_triangles
-    tris = Array.new(8)
-    tris[0] = Triangle.new( Vector3.new(0,0,0), Vector3.new(1,0,0), Vector3.new(0,1,1) )
-    tris[1] = Triangle.new( Vector3.new(1,0,0), Vector3.new(1,1,1), Vector3.new(0,1,1) )
-    tris[2] = Triangle.new( Vector3.new(1,0,0), Vector3.new(2,0,0), Vector3.new(1,1,1) )
-    tris[3] = Triangle.new( Vector3.new(2,0,0), Vector3.new(2,1,1), Vector3.new(1,1,1) )
-    tris[4] = Triangle.new( Vector3.new(0,1,1), Vector3.new(1,1,1), Vector3.new(0,2,2) )
-    tris[5] = Triangle.new( Vector3.new(1,1,1), Vector3.new(1,2,2), Vector3.new(0,2,2) )
-    tris[6] = Triangle.new( Vector3.new(1,1,1), Vector3.new(2,1,1), Vector3.new(1,2,2) )
-    tris[7] = Triangle.new( Vector3.new(2,1,1), Vector3.new(2,2,2), Vector3.new(1,2,2) )
-    trimesh_from_tris = TriMesh::from_triangles(tris)
-    assert_equal( 9, trimesh_from_tris.vertices.size)
-    assert_equal( 8, trimesh_from_tris.tri_indices.size)
-  end
-
-  def test_from_convex_polyline
-    vertices = Array.new(6)
-    vertices[0] = Vector3.new(1,0,0)
-    vertices[1] = Vector3.new(2,0,0)
-    vertices[2] = Vector3.new(3,1,0)
-    vertices[3] = Vector3.new(2,2,0)
-    vertices[4] = Vector3.new(1,2,0)
-    vertices[5] = Vector3.new(0,1,0)
-    polyline_closed = Polyline.new( vertices, false ) # closed Polyline
-    polyline_open   = Polyline.new( vertices, true  ) # open Polyline
-    trimesh_from_convex_polyline1 = TriMesh.from_convex_polyline( polyline_closed )
-    trimesh_from_convex_polyline2 = TriMesh.from_convex_polyline( polyline_open )
-
-    assert_equal(4, trimesh_from_convex_polyline1.area)
-    assert_equal(4, trimesh_from_convex_polyline2.area)
-  end
-
-  def test_from_extruded_polyline
-    vertices = Array.new(6)
-    vertices[0] = Vector3.new(1,0,0)
-    vertices[1] = Vector3.new(2,0,0)
-    vertices[2] = Vector3.new(3,1,0)
-    vertices[3] = Vector3.new(2,2,0)
-    vertices[4] = Vector3.new(1,2,0)
-    vertices[5] = Vector3.new(0,1,0)
-    polyline_closed = Polyline.new( vertices, false ) # closed Polyline
-    polyline_open   = Polyline.new( vertices, true  ) # open Polyline
-    extrude_direction = Vector3.new(0,0,2)
-    trimesh_from_extruded_polyline1 = TriMesh.from_extrude_polyline( polyline_closed , extrude_direction )
-    trimesh_from_extruded_polyline2 = TriMesh.from_extrude_polyline( polyline_open   , extrude_direction )
-
-    assert_in_delta(4+8*(Math.sqrt(2)), trimesh_from_extruded_polyline1.area, 1e-10)
-    assert_in_delta(4+6*(Math.sqrt(2)), trimesh_from_extruded_polyline2.area, 1e-10)
-  end
-
-  def test_area
-    box_mesh = get_box_mesh()
-    assert_equal(94, box_mesh.area)
-  end
-
-  def test_normals_for_each_vertices
-    box = Box.new(Vector3.new(-1,-1,-1), Vector3.new(1,1,1))
-    box_mesh  = TriMesh.from_box(box)
-    result = box_mesh.normals_for_each_vertices
-    assert_equal( box_mesh.vertices.size, result.size )
-    box_mesh.vertices.each do |vertex|
-      assert_equal(vertex.normalize, result[vertex])
-    end
-  end
-end
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class TriMeshTestCase < MiniTest::Unit::TestCase
+  def get_box_mesh
+    box = Box.new(Vector3.new(-1,-1,-1), Vector3.new(2,3,4))
+    return TriMesh.from_box(box)
+  end
+
+  def get_plane_mesh
+    rect = Rectangle.new(Vector3.new(-1,-1,-1), Vector3.new(2,0,0), Vector3.new(0,4,0) )
+    return TriMesh.from_rectangle(rect)
+  end
+
+  def test_initalize
+    plane_mesh = get_plane_mesh()
+    assert_equal( 2, plane_mesh.tri_indices.size)
+    assert_equal( 4, plane_mesh.vertices.size)
+
+    box_mesh = get_box_mesh()
+    assert_equal( 12, box_mesh.tri_indices.size)
+    assert_equal( 8, box_mesh.vertices.size)
+
+    assert_raises ArgumentError do
+      invalidResult = TriMesh.new(nil)
+    end
+    assert_raises ArgumentError do
+      invalidResult = TriMesh.new(Vector3.new(), 4.0)
+    end
+  end
+
+  def test_equal
+    plane_mesh = get_plane_mesh()
+    assert( plane_mesh != nil )
+    assert( plane_mesh != "String" )
+
+    shallow = plane_mesh
+    assert( shallow == plane_mesh )
+    assert( shallow.equal?(plane_mesh) )
+
+    new_mesh = get_plane_mesh()
+    assert( shallow == new_mesh )
+    assert( !shallow.equal?(new_mesh) )
+  end
+
+  def test_clone
+    plane_mesh = get_plane_mesh()
+    shallow = plane_mesh
+
+    shallow.vertices[0].x = 12
+    shallow.vertices[2] = Vector3.new(-3,2,5)
+    shallow.tri_indices[0] = [3,2,1]
+    shallow.tri_indices[1][2] = 2
+
+    assert_equal( 12, shallow.vertices[0].x )
+    assert_equal( 12, plane_mesh.vertices[0].x )
+    assert_equal( Vector3.new(-3,2,5), shallow.vertices[2] )
+    assert_equal( Vector3.new(-3,2,5), plane_mesh.vertices[2] )
+    assert_equal( [3,2,1], shallow.tri_indices[0] )
+    assert_equal( [3,2,1], plane_mesh.tri_indices[0] )
+    assert_equal( 2, shallow.tri_indices[1][2] )
+    assert_equal( 2, plane_mesh.tri_indices[1][2] )
+
+    deep = plane_mesh.clone
+    assert( deep == plane_mesh )
+    assert( !deep.equal?(plane_mesh) )
+
+    deep.vertices[0].x = -1
+    deep.vertices[2] = Vector3.new(4,2,1)
+    deep.tri_indices[0] = [4,2,2]
+    deep.tri_indices[1][2] = 5
+
+    assert_equal( -1, deep.vertices[0].x )
+    assert_equal( 12, plane_mesh.vertices[0].x )
+    assert_equal( Vector3.new(4,2,1), deep.vertices[2] )
+    assert_equal( Vector3.new(-3,2,5), plane_mesh.vertices[2] )
+    assert_equal( [4,2,2], deep.tri_indices[0] )
+    assert_equal( [3,2,1], plane_mesh.tri_indices[0] )
+    assert_equal( 5, deep.tri_indices[1][2] )
+    assert_equal( 2, plane_mesh.tri_indices[1][2] )
+  end
+
+  def test_to_s
+    assert_equal( "TriMesh[triangle_count:12, vertex_count:8]", get_box_mesh().to_s)
+  end
+
+  def test_box
+    box_mesh = get_box_mesh
+    plane_mesh = get_plane_mesh
+    assert_equal( Vector3.new(-1,-1,-1), box_mesh.box.min_point )
+    assert_equal( Vector3.new( 2, 3, 4), box_mesh.box.max_point )
+    assert_equal( Vector3.new(-1,-1,-1), plane_mesh.box.min_point )
+    assert_equal( Vector3.new( 1, 3,-1), plane_mesh.box.max_point )
+  end
+
+  def test_triangles
+    vertices = [Vector3.new(0,0,0),Vector3.new(2,0,0),Vector3.new(2,2,0),Vector3.new(0,2,0)]
+    tri_indices = [[0,1,3],[1,2,3]]
+    tri_mesh = TriMesh.new(vertices, tri_indices)
+    triangles = tri_mesh.triangles
+    assert_equal(2, triangles.size)
+    assert_equal(Vector3.new(0,0,0), triangles[0].vertices[0])
+    assert_equal(Vector3.new(2,0,0), triangles[0].vertices[1])
+    assert_equal(Vector3.new(0,2,0), triangles[0].vertices[2])
+    assert_equal(Vector3.new(2,0,0), triangles[1].vertices[0])
+    assert_equal(Vector3.new(2,2,0), triangles[1].vertices[1])
+    assert_equal(Vector3.new(0,2,0), triangles[1].vertices[2])
+
+    triangle = tri_mesh.triangle(1)
+    assert_equal(Vector3.new(2,0,0), triangle.vertices[0])
+    assert_equal(Vector3.new(2,2,0), triangle.vertices[1])
+    assert_equal(Vector3.new(0,2,0), triangle.vertices[2])
+
+    triangle = tri_mesh.triangle(3)
+    assert_equal(nil, triangle)
+  end
+
+  def test_from_triangles
+    tris = Array.new(8)
+    tris[0] = Triangle.new( Vector3.new(0,0,0), Vector3.new(1,0,0), Vector3.new(0,1,1) )
+    tris[1] = Triangle.new( Vector3.new(1,0,0), Vector3.new(1,1,1), Vector3.new(0,1,1) )
+    tris[2] = Triangle.new( Vector3.new(1,0,0), Vector3.new(2,0,0), Vector3.new(1,1,1) )
+    tris[3] = Triangle.new( Vector3.new(2,0,0), Vector3.new(2,1,1), Vector3.new(1,1,1) )
+    tris[4] = Triangle.new( Vector3.new(0,1,1), Vector3.new(1,1,1), Vector3.new(0,2,2) )
+    tris[5] = Triangle.new( Vector3.new(1,1,1), Vector3.new(1,2,2), Vector3.new(0,2,2) )
+    tris[6] = Triangle.new( Vector3.new(1,1,1), Vector3.new(2,1,1), Vector3.new(1,2,2) )
+    tris[7] = Triangle.new( Vector3.new(2,1,1), Vector3.new(2,2,2), Vector3.new(1,2,2) )
+    trimesh_from_tris = TriMesh::from_triangles(tris)
+    assert_equal( 9, trimesh_from_tris.vertices.size)
+    assert_equal( 8, trimesh_from_tris.tri_indices.size)
+  end
+
+  def test_from_convex_polyline
+    vertices = Array.new(6)
+    vertices[0] = Vector3.new(1,0,0)
+    vertices[1] = Vector3.new(2,0,0)
+    vertices[2] = Vector3.new(3,1,0)
+    vertices[3] = Vector3.new(2,2,0)
+    vertices[4] = Vector3.new(1,2,0)
+    vertices[5] = Vector3.new(0,1,0)
+    polyline_closed = Polyline.new( vertices, false ) # closed Polyline
+    polyline_open   = Polyline.new( vertices, true  ) # open Polyline
+    trimesh_from_convex_polyline1 = TriMesh.from_convex_polyline( polyline_closed )
+    trimesh_from_convex_polyline2 = TriMesh.from_convex_polyline( polyline_open )
+
+    assert_equal(4, trimesh_from_convex_polyline1.area)
+    assert_equal(4, trimesh_from_convex_polyline2.area)
+  end
+
+  def test_from_extruded_polyline
+    vertices = Array.new(6)
+    vertices[0] = Vector3.new(1,0,0)
+    vertices[1] = Vector3.new(2,0,0)
+    vertices[2] = Vector3.new(3,1,0)
+    vertices[3] = Vector3.new(2,2,0)
+    vertices[4] = Vector3.new(1,2,0)
+    vertices[5] = Vector3.new(0,1,0)
+    polyline_closed = Polyline.new( vertices, false ) # closed Polyline
+    polyline_open   = Polyline.new( vertices, true  ) # open Polyline
+    extrude_direction = Vector3.new(0,0,2)
+    trimesh_from_extruded_polyline1 = TriMesh.from_extrude_polyline( polyline_closed , extrude_direction )
+    trimesh_from_extruded_polyline2 = TriMesh.from_extrude_polyline( polyline_open   , extrude_direction )
+
+    assert_in_delta(4+8*(Math.sqrt(2)), trimesh_from_extruded_polyline1.area, 1e-10)
+    assert_in_delta(4+6*(Math.sqrt(2)), trimesh_from_extruded_polyline2.area, 1e-10)
+  end
+
+  def test_area
+    box_mesh = get_box_mesh()
+    assert_equal(94, box_mesh.area)
+  end
+
+  def test_normals_for_each_vertices
+    box = Box.new(Vector3.new(-1,-1,-1), Vector3.new(1,1,1))
+    box_mesh  = TriMesh.from_box(box)
+    result = box_mesh.normals_for_each_vertices
+    assert_equal( box_mesh.vertices.size, result.size )
+    box_mesh.vertices.each do |vertex|
+      assert_equal(vertex.normalize, result[vertex])
+    end
+  end
+end

data/test/test_triangle.rb

@@ -1,318 +1,318 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'helper'
-
-include GMath3D
-
-MiniTest::Unit.autorun
-
-class TriangleTestCase < MiniTest::Unit::TestCase
-  def setup
-    @triangle = Triangle.new( Vector3.new(1,2,2), Vector3.new(1,4,2), Vector3.new(-1,3,0))
-    @triangle_default = Triangle.new()
-  end
-
-  def test_initialize
-    assert_equal(Vector3.new(1,2,2), @triangle.vertices[0])
-    assert_equal(Vector3.new(1,4,2), @triangle.vertices[1])
-    assert_equal(Vector3.new(-1,3,0), @triangle.vertices[2])
-
-    assert_equal(Vector3.new(0,0,0), @triangle_default.vertices[0])
-    assert_equal(Vector3.new(1,0,0), @triangle_default.vertices[1])
-    assert_equal(Vector3.new(0,1,0), @triangle_default.vertices[2])
-  end
-
-  def test_equals
-    assert(@triangle != nil)
-    assert(@triangle != "string")
-
-    shallow_copied = @triangle
-    assert(@triangle.equal?(shallow_copied))
-    assert(@triangle == shallow_copied)
-
-    assert_equal(@triangle, Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.0)))
-    assert(@triangle == Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.0)))
-    assert(@triangle != Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.5)))
-  end
-
-  def test_clone
-    shallow_copied = @triangle
-    shallow_copied.vertices[2].x = 1
-    assert(@triangle == shallow_copied)
-    assert(@triangle.equal?(shallow_copied))
-    assert_equal(1, @triangle.vertices[2].x)
-    assert_equal(1, shallow_copied.vertices[2].x)
-
-    cloned =@triangle.clone
-    assert(@triangle == cloned)
-    assert(!@triangle.equal?(cloned))
-
-    cloned.vertices[2].x = -10
-    assert_equal(-10, cloned.vertices[2].x)
-    assert_equal(1, @triangle.vertices[2].x) # original never changed in editing cloned one.
-  end
-
-  def test_to_s
-    assert_equal("Triangle[[1, 2, 2], [1, 4, 2], [-1, 3, 0]]", @triangle.to_s)
-  end
-
-  def test_box
-    box1 = @triangle.box
-    box2 = @triangle_default.box
-    assert_equal(Vector3.new(-1,2,0), box1.min_point)
-    assert_equal(Vector3.new(1,4,2), box1.max_point)
-    assert_equal(Vector3.new(0,0,0) , box2.min_point)
-    assert_equal(Vector3.new(1,1,0) , box2.max_point)
-  end
-
-  def test_point
-    assert_equal(@triangle.vertices[0], @triangle.point( Array.new([1,0,0])))
-    assert_equal(@triangle.vertices[1], @triangle.point( Array.new([0,1,0])))
-    assert_equal(@triangle.vertices[2], @triangle.point( Array.new([0,0,1])))
-
-    #on edge
-    assert_equal(Vector3.new(1,3,2), @triangle.point( Array.new([0.5,0.5,0])))
-    assert_equal(Vector3.new(0,3.5,1), @triangle.point( Array.new([0,0.5,0.5])))
-    assert_equal(Vector3.new(0,2.5,1), @triangle.point( Array.new([0.5,0,0.5])))
-
-    #inside
-    assert_equal(Vector3.new(0, 3, 1), @triangle.point( Array.new([0.25,0.25,0.5])))
-    assert_equal(@triangle.center, @triangle.point( Array.new([1.0/3.0,1.0/3.0,1.0/3.0])))
-  end
-
-  def test_edges
-    edges = @triangle.edges
-    assert_equal(@triangle.vertices[0], edges[0].start_point)
-    assert_equal(@triangle.vertices[1], edges[0].end_point)
-    assert_equal(@triangle.vertices[1], edges[1].start_point)
-    assert_equal(@triangle.vertices[2], edges[1].end_point)
-    assert_equal(@triangle.vertices[2], edges[2].start_point)
-    assert_equal(@triangle.vertices[0], edges[2].end_point)
-  end
-
-  def test_area
-    assert_in_delta(Math::sqrt(8), @triangle.area, @triangle.tolerance)
-    assert_in_delta(0.5, @triangle_default.area, @triangle_default.tolerance)
-  end
-
-  def test_normal
-    assert_equal( Vector3.new(-1,0,1).normalize(), @triangle.normal )
-    assert_equal( Vector3.new(0,0,1) ,@triangle_default.normal )
-  end
-
-  def test_reverse
-    current_normal = @triangle.normal()
-    reversed_normal = @triangle.reverse().normal()
-    assert( current_normal.parallel?(reversed_normal) )
-    assert( !current_normal.same_direction?(reversed_normal) )
-  end
-
-  def test_center
-    center = @triangle.center
-    assert_in_delta( 0.333333333333333, center.x, @triangle.tolerance)
-    assert_in_delta( 3.0, center.y, @triangle.tolerance)
-    assert_in_delta( 1.333333333333333, center.z, @triangle.tolerance)
-
-    barycentric_coordinate = @triangle.barycentric_coordinate(center)
-    assert_in_delta( 1.0/3.0, barycentric_coordinate[0], @triangle.tolerance)
-    assert_in_delta( 1.0/3.0, barycentric_coordinate[1], @triangle.tolerance)
-    assert_in_delta( 1.0/3.0, barycentric_coordinate[2], @triangle.tolerance)
-  end
-
-  def test_barycentric_coordinate
-    # on vertex
-    coord = @triangle.barycentric_coordinate( @triangle.vertices[1])
-    assert_equal( 3, coord.size )
-    assert_in_delta( 0, coord[0], @triangle.tolerance)
-    assert_in_delta( 1, coord[1], @triangle.tolerance)
-    assert_in_delta( 0, coord[2], @triangle.tolerance)
-
-    # on edge
-    coord = @triangle.barycentric_coordinate( Vector3.new(1,3,2) )
-    assert_in_delta( 0.5, coord[0], @triangle.tolerance)
-    assert_in_delta( 0.5, coord[1], @triangle.tolerance)
-    assert_in_delta( 0, coord[2], @triangle.tolerance)
-
-    # inside case
-    coord = @triangle.barycentric_coordinate( Vector3.new(0,3,1) )
-    assert_in_delta( 1.0, coord[0] + coord[1] + coord[2], @triangle.tolerance)
-    assert_in_delta( 0.25, coord[0], @triangle.tolerance)
-    assert_in_delta( 0.25, coord[1], @triangle.tolerance)
-    assert_in_delta( 0.5, coord[2], @triangle.tolerance)
-
-    # outside case
-    coord = @triangle_default.barycentric_coordinate( Vector3.new(2,0,0) )
-    assert_in_delta( -1.0, coord[0], @triangle.tolerance)
-    assert_in_delta( 2.0, coord[1], @triangle.tolerance)
-    assert_in_delta( 0.0, coord[2], @triangle.tolerance)
-
-    # outside case
-    coord = @triangle.barycentric_coordinate( Vector3.new(3,3,4) )
-    assert_in_delta(  1.0, coord[0], @triangle.tolerance)
-    assert_in_delta(  1.0, coord[1], @triangle.tolerance)
-    assert_in_delta( -1.0, coord[2], @triangle.tolerance)
-
-    #invalid argument
-    assert_raises ArgumentError do
-      coord = @triangle.barycentric_coordinate( 3 )
-    end
-    assert_raises ArgumentError do
-      coord = @triangle.barycentric_coordinate( nil )
-    end
-  end
-
-  def test_contains
-    check_point = @triangle.center + @triangle.normal*3.0
-    assert( !@triangle.contains?( check_point) )
-    assert( @triangle.contains?( @triangle.center) )
-    assert( @triangle.contains?( Vector3.new( 1,3,2)))
-    assert( @triangle.contains?( Vector3.new(-1,3,0)))
-    assert( @triangle_default.contains?( Vector3.new( 0.5, 0.5, 0.0 ) ))
-    assert( !@triangle_default.contains?( Vector3.new( -1.0, 2.0, 0.0 )))
-    assert( !@triangle_default.contains?( Vector3.new( 1.0, 1.0, 0.0 )))
-  end
-
-  def test_distance_to_point
-    # on inside
-    check_point = @triangle.center + @triangle.normal*3.0
-    distance, point_on_triangle = @triangle.distance(check_point)
-    assert_in_delta(3.0, distance, @triangle.tolerance)
-    assert_equal(@triangle.center, point_on_triangle)
-
-    # on vertex
-    distance, point_on_triangle = @triangle_default.distance(Vector3.new(-1,-1,0.5))
-    assert_in_delta(Math::sqrt(2.25), distance, @triangle_default.tolerance)
-    assert_equal(@triangle_default.vertices[0], point_on_triangle)
-
-    # on edge
-    distance, point_on_triangle = @triangle.distance( Vector3.new(2,3,2))
-    assert_in_delta(1, distance, @triangle_default.tolerance)
-    assert_equal(Vector3.new(1,3,2), point_on_triangle)
-
-    # contains to inside
-    distance, point_on_triangle = @triangle_default.distance(@triangle_default.center)
-    assert_in_delta(0, distance, @triangle_default.tolerance)
-    assert_equal(@triangle_default.center, point_on_triangle)
-  end
-
-  def test_distance_to_line
-    # on inside
-    line = Line.new(Vector3.new(0,3,-1), Vector3.new(0,0,4))
-    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
-    assert_equal(0, distance)
-    assert_equal(Vector3.new(0,3,1), point_on_triangle)
-    assert_equal(Vector3.new(0,3,1), point_on_line)
-    assert_in_delta(0.5, param_on_line, line.tolerance)
-
-    # on edge
-    line = Line.new(Vector3.new(1,3,-1), Vector3.new(0,0,4))
-    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
-    assert_equal(0, distance)
-    assert_equal(Vector3.new(1,3,2), point_on_triangle)
-    assert_equal(Vector3.new(1,3,2), point_on_line)
-    assert_in_delta(0.75, param_on_line, line.tolerance)
-
-    # on vertex
-    line = Line.new(Vector3.new(-1,3,0), Vector3.new(1,1,2))
-    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
-    assert_equal(0, distance)
-    assert_equal(Vector3.new(-1,3,0), point_on_triangle)
-    assert_equal(Vector3.new(-1,3,0), point_on_line)
-    assert_in_delta(0.0, param_on_line, line.tolerance)
-
-    # closest point is out of triangle1
-    line = Line.new(Vector3.new(2,3,0), Vector3.new(0,0,4))
-    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
-    assert_equal(1, distance)
-    assert_equal(Vector3.new(1,3,2), point_on_triangle)
-    assert_equal(Vector3.new(2,3,2), point_on_line)
-    assert_in_delta(0.5, param_on_line, line.tolerance)
-
-    # closest point is out of triangle2
-    line = Line.new(Vector3.new(-2,3,-1), Vector3.new(0,0,1))
-    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
-    assert_equal(1, distance)
-    assert_equal(Vector3.new(-1,3,0), point_on_triangle)
-    assert_equal(Vector3.new(-2,3,0), point_on_line)
-    assert_in_delta(1, param_on_line, line.tolerance)
-
-    # parallel case
-    line = Line.new(Vector3.new(1,0,4), Vector3.new(0,6,0))
-    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
-    assert_equal(2, distance)
-    assert_equal(nil, point_on_triangle)
-    assert_equal(nil, point_on_line)
-    assert_equal(nil, param_on_line)
-  end
-
-  def test_distance_to_plane
-    # intersect case
-    plane = Plane.new(Vector3.new(0,0,1), Vector3.new(1,0,0))
-    distance, intersect_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
-    assert_equal( 0, distance )
-    point1 = Vector3.new(0,2.5,1)
-    point2 = Vector3.new(0,3.5,1)
-    assert( FiniteLine.new(point1, point2) == intersect_line || FiniteLine.new(point2, point1) == intersect_line)
-    assert_equal( nil, point_on_triangle )
-    assert_equal( nil, point_on_plane )
-
-    # contains edge
-    plane = Plane.new(Vector3.new(1,0,1), Vector3.new(-1,0,0))
-    distance, intersect_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
-    assert_equal( 0, distance )
-    point1 = Vector3.new(1,2,2)
-    point2 = Vector3.new(1,4,2)
-    assert( FiniteLine.new(point1, point2) == intersect_line || FiniteLine.new(point2, point1) == intersect_line)
-    assert_equal( nil, point_on_triangle )
-    assert_equal( nil, point_on_plane )
-
-    # contains vertex
-    plane = Plane.new(Vector3.new(-1,0,1), Vector3.new(1,0,0))
-    distance, intersect_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
-    assert_equal( 0, distance )
-    assert_equal( nil, intersect_line)
-    assert_equal( Vector3.new(-1,3,0), point_on_triangle )
-    assert_equal( Vector3.new(-1,3,0), point_on_plane )
-
-    # closeing point is outside of triangle
-    plane = Plane.new(Vector3.new(-2,0,0), Vector3.new(-1,0,0))
-    distance, intersect_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
-    assert_equal( 1, distance )
-    assert_equal( nil, intersect_line)
-    assert_equal( Vector3.new(-1,3,0), point_on_triangle )
-    assert_equal( Vector3.new(-2,3,0), point_on_plane )
-
-    # parallel to plane
-    plane = Plane.new(Vector3.new(0,0,4), Vector3.new(0,0,1))
-    distance, intersect_line, point_on_triangle, point_on_plane = @triangle_default.distance(plane)
-    assert_equal( 4, distance )
-    assert_equal( nil, intersect_line)
-    assert_equal( nil, point_on_triangle )
-    assert_equal( nil, point_on_plane )
-
-    # parallel to edge
-    plane = Plane.new(Vector3.new(3.5,0,3), Vector3.new(-1,0,0))
-    distance, closest_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
-    assert_equal( 2.5, distance )
-    point1 = Vector3.new(1,2,2)
-    point2 = Vector3.new(1,4,2)
-    assert( FiniteLine.new(point1, point2) == closest_line || FiniteLine.new(point2, point1) == closest_line)
-    assert_equal( nil, point_on_triangle )
-    assert_equal( nil, point_on_plane )
-  end
-
-  def test_angle
-    triangle1 = Triangle.new( Vector3.new(0,0,1), Vector3.new(Math.sqrt(3.0),0,1), Vector3.new(0,1,1))
-    triangle2 = Triangle.new( Vector3.new(1,0,0), Vector3.new(0,0,1), Vector3.new(1,1,1))
-
-    assert_equal(nil, triangle1.angle(-1))
-    assert_equal(nil, triangle1.angle(3))
-
-    assert_in_delta(90.0*Math::PI/180.0, triangle1.angle(0), triangle1.tolerance)
-    assert_in_delta(30.0*Math::PI/180.0, triangle1.angle(1), triangle1.tolerance)
-    assert_in_delta(60.0*Math::PI/180.0, triangle1.angle(2), triangle1.tolerance)
-
-    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(0), triangle1.tolerance)
-    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(1), triangle1.tolerance)
-    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(2), triangle1.tolerance)
-  end
-end
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class TriangleTestCase < MiniTest::Unit::TestCase
+  def setup
+    @triangle = Triangle.new( Vector3.new(1,2,2), Vector3.new(1,4,2), Vector3.new(-1,3,0))
+    @triangle_default = Triangle.new()
+  end
+
+  def test_initialize
+    assert_equal(Vector3.new(1,2,2), @triangle.vertices[0])
+    assert_equal(Vector3.new(1,4,2), @triangle.vertices[1])
+    assert_equal(Vector3.new(-1,3,0), @triangle.vertices[2])
+
+    assert_equal(Vector3.new(0,0,0), @triangle_default.vertices[0])
+    assert_equal(Vector3.new(1,0,0), @triangle_default.vertices[1])
+    assert_equal(Vector3.new(0,1,0), @triangle_default.vertices[2])
+  end
+
+  def test_equals
+    assert(@triangle != nil)
+    assert(@triangle != "string")
+
+    shallow_copied = @triangle
+    assert(@triangle.equal?(shallow_copied))
+    assert(@triangle == shallow_copied)
+
+    assert_equal(@triangle, Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.0)))
+    assert(@triangle == Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.0)))
+    assert(@triangle != Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.5)))
+  end
+
+  def test_clone
+    shallow_copied = @triangle
+    shallow_copied.vertices[2].x = 1
+    assert(@triangle == shallow_copied)
+    assert(@triangle.equal?(shallow_copied))
+    assert_equal(1, @triangle.vertices[2].x)
+    assert_equal(1, shallow_copied.vertices[2].x)
+
+    cloned =@triangle.clone
+    assert(@triangle == cloned)
+    assert(!@triangle.equal?(cloned))
+
+    cloned.vertices[2].x = -10
+    assert_equal(-10, cloned.vertices[2].x)
+    assert_equal(1, @triangle.vertices[2].x) # original never changed in editing cloned one.
+  end
+
+  def test_to_s
+    assert_equal("Triangle[[1, 2, 2], [1, 4, 2], [-1, 3, 0]]", @triangle.to_s)
+  end
+
+  def test_box
+    box1 = @triangle.box
+    box2 = @triangle_default.box
+    assert_equal(Vector3.new(-1,2,0), box1.min_point)
+    assert_equal(Vector3.new(1,4,2), box1.max_point)
+    assert_equal(Vector3.new(0,0,0) , box2.min_point)
+    assert_equal(Vector3.new(1,1,0) , box2.max_point)
+  end
+
+  def test_point
+    assert_equal(@triangle.vertices[0], @triangle.point( Array.new([1,0,0])))
+    assert_equal(@triangle.vertices[1], @triangle.point( Array.new([0,1,0])))
+    assert_equal(@triangle.vertices[2], @triangle.point( Array.new([0,0,1])))
+
+    #on edge
+    assert_equal(Vector3.new(1,3,2), @triangle.point( Array.new([0.5,0.5,0])))
+    assert_equal(Vector3.new(0,3.5,1), @triangle.point( Array.new([0,0.5,0.5])))
+    assert_equal(Vector3.new(0,2.5,1), @triangle.point( Array.new([0.5,0,0.5])))
+
+    #inside
+    assert_equal(Vector3.new(0, 3, 1), @triangle.point( Array.new([0.25,0.25,0.5])))
+    assert_equal(@triangle.center, @triangle.point( Array.new([1.0/3.0,1.0/3.0,1.0/3.0])))
+  end
+
+  def test_edges
+    edges = @triangle.edges
+    assert_equal(@triangle.vertices[0], edges[0].start_point)
+    assert_equal(@triangle.vertices[1], edges[0].end_point)
+    assert_equal(@triangle.vertices[1], edges[1].start_point)
+    assert_equal(@triangle.vertices[2], edges[1].end_point)
+    assert_equal(@triangle.vertices[2], edges[2].start_point)
+    assert_equal(@triangle.vertices[0], edges[2].end_point)
+  end
+
+  def test_area
+    assert_in_delta(Math::sqrt(8), @triangle.area, @triangle.tolerance)
+    assert_in_delta(0.5, @triangle_default.area, @triangle_default.tolerance)
+  end
+
+  def test_normal
+    assert_equal( Vector3.new(-1,0,1).normalize(), @triangle.normal )
+    assert_equal( Vector3.new(0,0,1) ,@triangle_default.normal )
+  end
+
+  def test_reverse
+    current_normal = @triangle.normal()
+    reversed_normal = @triangle.reverse().normal()
+    assert( current_normal.parallel?(reversed_normal) )
+    assert( !current_normal.same_direction?(reversed_normal) )
+  end
+
+  def test_center
+    center = @triangle.center
+    assert_in_delta( 0.333333333333333, center.x, @triangle.tolerance)
+    assert_in_delta( 3.0, center.y, @triangle.tolerance)
+    assert_in_delta( 1.333333333333333, center.z, @triangle.tolerance)
+
+    barycentric_coordinate = @triangle.barycentric_coordinate(center)
+    assert_in_delta( 1.0/3.0, barycentric_coordinate[0], @triangle.tolerance)
+    assert_in_delta( 1.0/3.0, barycentric_coordinate[1], @triangle.tolerance)
+    assert_in_delta( 1.0/3.0, barycentric_coordinate[2], @triangle.tolerance)
+  end
+
+  def test_barycentric_coordinate
+    # on vertex
+    coord = @triangle.barycentric_coordinate( @triangle.vertices[1])
+    assert_equal( 3, coord.size )
+    assert_in_delta( 0, coord[0], @triangle.tolerance)
+    assert_in_delta( 1, coord[1], @triangle.tolerance)
+    assert_in_delta( 0, coord[2], @triangle.tolerance)
+
+    # on edge
+    coord = @triangle.barycentric_coordinate( Vector3.new(1,3,2) )
+    assert_in_delta( 0.5, coord[0], @triangle.tolerance)
+    assert_in_delta( 0.5, coord[1], @triangle.tolerance)
+    assert_in_delta( 0, coord[2], @triangle.tolerance)
+
+    # inside case
+    coord = @triangle.barycentric_coordinate( Vector3.new(0,3,1) )
+    assert_in_delta( 1.0, coord[0] + coord[1] + coord[2], @triangle.tolerance)
+    assert_in_delta( 0.25, coord[0], @triangle.tolerance)
+    assert_in_delta( 0.25, coord[1], @triangle.tolerance)
+    assert_in_delta( 0.5, coord[2], @triangle.tolerance)
+
+    # outside case
+    coord = @triangle_default.barycentric_coordinate( Vector3.new(2,0,0) )
+    assert_in_delta( -1.0, coord[0], @triangle.tolerance)
+    assert_in_delta( 2.0, coord[1], @triangle.tolerance)
+    assert_in_delta( 0.0, coord[2], @triangle.tolerance)
+
+    # outside case
+    coord = @triangle.barycentric_coordinate( Vector3.new(3,3,4) )
+    assert_in_delta(  1.0, coord[0], @triangle.tolerance)
+    assert_in_delta(  1.0, coord[1], @triangle.tolerance)
+    assert_in_delta( -1.0, coord[2], @triangle.tolerance)
+
+    #invalid argument
+    assert_raises ArgumentError do
+      coord = @triangle.barycentric_coordinate( 3 )
+    end
+    assert_raises ArgumentError do
+      coord = @triangle.barycentric_coordinate( nil )
+    end
+  end
+
+  def test_contains
+    check_point = @triangle.center + @triangle.normal*3.0
+    assert( !@triangle.contains?( check_point) )
+    assert( @triangle.contains?( @triangle.center) )
+    assert( @triangle.contains?( Vector3.new( 1,3,2)))
+    assert( @triangle.contains?( Vector3.new(-1,3,0)))
+    assert( @triangle_default.contains?( Vector3.new( 0.5, 0.5, 0.0 ) ))
+    assert( !@triangle_default.contains?( Vector3.new( -1.0, 2.0, 0.0 )))
+    assert( !@triangle_default.contains?( Vector3.new( 1.0, 1.0, 0.0 )))
+  end
+
+  def test_distance_to_point
+    # on inside
+    check_point = @triangle.center + @triangle.normal*3.0
+    distance, point_on_triangle = @triangle.distance(check_point)
+    assert_in_delta(3.0, distance, @triangle.tolerance)
+    assert_equal(@triangle.center, point_on_triangle)
+
+    # on vertex
+    distance, point_on_triangle = @triangle_default.distance(Vector3.new(-1,-1,0.5))
+    assert_in_delta(Math::sqrt(2.25), distance, @triangle_default.tolerance)
+    assert_equal(@triangle_default.vertices[0], point_on_triangle)
+
+    # on edge
+    distance, point_on_triangle = @triangle.distance( Vector3.new(2,3,2))
+    assert_in_delta(1, distance, @triangle_default.tolerance)
+    assert_equal(Vector3.new(1,3,2), point_on_triangle)
+
+    # contains to inside
+    distance, point_on_triangle = @triangle_default.distance(@triangle_default.center)
+    assert_in_delta(0, distance, @triangle_default.tolerance)
+    assert_equal(@triangle_default.center, point_on_triangle)
+  end
+
+  def test_distance_to_line
+    # on inside
+    line = Line.new(Vector3.new(0,3,-1), Vector3.new(0,0,4))
+    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
+    assert_equal(0, distance)
+    assert_equal(Vector3.new(0,3,1), point_on_triangle)
+    assert_equal(Vector3.new(0,3,1), point_on_line)
+    assert_in_delta(0.5, param_on_line, line.tolerance)
+
+    # on edge
+    line = Line.new(Vector3.new(1,3,-1), Vector3.new(0,0,4))
+    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
+    assert_equal(0, distance)
+    assert_equal(Vector3.new(1,3,2), point_on_triangle)
+    assert_equal(Vector3.new(1,3,2), point_on_line)
+    assert_in_delta(0.75, param_on_line, line.tolerance)
+
+    # on vertex
+    line = Line.new(Vector3.new(-1,3,0), Vector3.new(1,1,2))
+    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
+    assert_equal(0, distance)
+    assert_equal(Vector3.new(-1,3,0), point_on_triangle)
+    assert_equal(Vector3.new(-1,3,0), point_on_line)
+    assert_in_delta(0.0, param_on_line, line.tolerance)
+
+    # closest point is out of triangle1
+    line = Line.new(Vector3.new(2,3,0), Vector3.new(0,0,4))
+    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
+    assert_equal(1, distance)
+    assert_equal(Vector3.new(1,3,2), point_on_triangle)
+    assert_equal(Vector3.new(2,3,2), point_on_line)
+    assert_in_delta(0.5, param_on_line, line.tolerance)
+
+    # closest point is out of triangle2
+    line = Line.new(Vector3.new(-2,3,-1), Vector3.new(0,0,1))
+    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
+    assert_equal(1, distance)
+    assert_equal(Vector3.new(-1,3,0), point_on_triangle)
+    assert_equal(Vector3.new(-2,3,0), point_on_line)
+    assert_in_delta(1, param_on_line, line.tolerance)
+
+    # parallel case
+    line = Line.new(Vector3.new(1,0,4), Vector3.new(0,6,0))
+    distance, point_on_triangle, point_on_line, param_on_line = @triangle.distance(line)
+    assert_equal(2, distance)
+    assert_equal(nil, point_on_triangle)
+    assert_equal(nil, point_on_line)
+    assert_equal(nil, param_on_line)
+  end
+
+  def test_distance_to_plane
+    # intersect case
+    plane = Plane.new(Vector3.new(0,0,1), Vector3.new(1,0,0))
+    distance, intersect_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
+    assert_equal( 0, distance )
+    point1 = Vector3.new(0,2.5,1)
+    point2 = Vector3.new(0,3.5,1)
+    assert( FiniteLine.new(point1, point2) == intersect_line || FiniteLine.new(point2, point1) == intersect_line)
+    assert_equal( nil, point_on_triangle )
+    assert_equal( nil, point_on_plane )
+
+    # contains edge
+    plane = Plane.new(Vector3.new(1,0,1), Vector3.new(-1,0,0))
+    distance, intersect_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
+    assert_equal( 0, distance )
+    point1 = Vector3.new(1,2,2)
+    point2 = Vector3.new(1,4,2)
+    assert( FiniteLine.new(point1, point2) == intersect_line || FiniteLine.new(point2, point1) == intersect_line)
+    assert_equal( nil, point_on_triangle )
+    assert_equal( nil, point_on_plane )
+
+    # contains vertex
+    plane = Plane.new(Vector3.new(-1,0,1), Vector3.new(1,0,0))
+    distance, intersect_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
+    assert_equal( 0, distance )
+    assert_equal( nil, intersect_line)
+    assert_equal( Vector3.new(-1,3,0), point_on_triangle )
+    assert_equal( Vector3.new(-1,3,0), point_on_plane )
+
+    # closeing point is outside of triangle
+    plane = Plane.new(Vector3.new(-2,0,0), Vector3.new(-1,0,0))
+    distance, intersect_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
+    assert_equal( 1, distance )
+    assert_equal( nil, intersect_line)
+    assert_equal( Vector3.new(-1,3,0), point_on_triangle )
+    assert_equal( Vector3.new(-2,3,0), point_on_plane )
+
+    # parallel to plane
+    plane = Plane.new(Vector3.new(0,0,4), Vector3.new(0,0,1))
+    distance, intersect_line, point_on_triangle, point_on_plane = @triangle_default.distance(plane)
+    assert_equal( 4, distance )
+    assert_equal( nil, intersect_line)
+    assert_equal( nil, point_on_triangle )
+    assert_equal( nil, point_on_plane )
+
+    # parallel to edge
+    plane = Plane.new(Vector3.new(3.5,0,3), Vector3.new(-1,0,0))
+    distance, closest_line, point_on_triangle, point_on_plane = @triangle.distance(plane)
+    assert_equal( 2.5, distance )
+    point1 = Vector3.new(1,2,2)
+    point2 = Vector3.new(1,4,2)
+    assert( FiniteLine.new(point1, point2) == closest_line || FiniteLine.new(point2, point1) == closest_line)
+    assert_equal( nil, point_on_triangle )
+    assert_equal( nil, point_on_plane )
+  end
+
+  def test_angle
+    triangle1 = Triangle.new( Vector3.new(0,0,1), Vector3.new(Math.sqrt(3.0),0,1), Vector3.new(0,1,1))
+    triangle2 = Triangle.new( Vector3.new(1,0,0), Vector3.new(0,0,1), Vector3.new(1,1,1))
+
+    assert_equal(nil, triangle1.angle(-1))
+    assert_equal(nil, triangle1.angle(3))
+
+    assert_in_delta(90.0*Math::PI/180.0, triangle1.angle(0), triangle1.tolerance)
+    assert_in_delta(30.0*Math::PI/180.0, triangle1.angle(1), triangle1.tolerance)
+    assert_in_delta(60.0*Math::PI/180.0, triangle1.angle(2), triangle1.tolerance)
+
+    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(0), triangle1.tolerance)
+    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(1), triangle1.tolerance)
+    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(2), triangle1.tolerance)
+  end
+end