gmath3D 0.1.1

data/test/test_finite_line.rb

@@ -0,0 +1,245 @@
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class FiniteLineTestCase < MiniTest::Unit::TestCase
+  def test_initialize
+    start_point_tmp = Vector3.new(1.0,  0.0, 2.0)
+    end_point_tmp   = Vector3.new(1.0, -3.5, 1.0)
+    line = FiniteLine.new(start_point_tmp, end_point_tmp)
+    
+    assert_equal(start_point_tmp ,line.start_point)
+    assert_equal(end_point_tmp   ,line.end_point  )
+    
+    lineDefault = FiniteLine.new()
+    assert_equal(Vector3.new(0,0,0), lineDefault.start_point)
+    assert_equal(Vector3.new(1,0,0), lineDefault.end_point  )
+  end
+  
+  def test_direction
+    start_point_tmp = Vector3.new(1.0,  0.0, 2.0)
+    end_point_tmp   = Vector3.new(1.0, -3.5, 1.0)
+    line = FiniteLine.new(start_point_tmp, end_point_tmp)
+    assert_in_delta( 0.0, line.direction.x, line.tolerance)
+    assert_in_delta(-3.5, line.direction.y, line.tolerance)
+    assert_in_delta(-1.0, line.direction.z, line.tolerance)
+  end
+
+  def test_param
+    start_point_tmp = Vector3.new(1.0, 1.0,  2.0)
+    end_point_tmp   = Vector3.new(2.0, 3.0, -4.0)
+    line = FiniteLine.new(start_point_tmp, end_point_tmp)
+    assert_equal( Vector3.new(1.0, 1.0,  2.0), line.point(0.0))
+    assert_equal( Vector3.new(1.5, 2.0, -1.0), line.point(0.5))
+    assert_equal( Vector3.new(2.0, 3.0, -4.0), line.point(1))
+
+    # if param is smaller than 0 or bigger than 1 then return nil
+    assert_equal( nil, line.point(-1.0))
+    assert_equal( nil, line.point(1.2))
+  end
+  
+  def test_length
+    start_point_tmp = Vector3.new(0.0, 0.0, 2.0)
+    end_point_tmp   = Vector3.new(2.0, 2.0, 2.0)
+    line = FiniteLine.new(start_point_tmp, end_point_tmp)
+    
+    assert_in_delta(Math::sqrt(8), line.length, line.tolerance)
+  end
+  
+  def test_distance_to_point
+    start_point_tmp = Vector3.new(0.0, 0.0, 2.0)
+    end_point_tmp   = Vector3.new(2.0, 2.0, 2.0)
+    line = FiniteLine.new(start_point_tmp, end_point_tmp)
+    
+    targetPoint = Vector3.new(1.0, 1.0, -4.0)
+    distance, pointOnLine, parameter = line.distance(targetPoint)
+    assert_in_delta(6.0, distance, targetPoint.tolerance)
+    assert_equal( Vector3.new(1.0, 1.0, 2.0), pointOnLine)
+    assert_in_delta(0.5, parameter, targetPoint.tolerance)
+    
+    targetPoint2 = Vector3.new(3.0, 3.0, 2.0)
+    distance, pointOnLine, parameter = line.distance(targetPoint2)
+    assert_in_delta(Math::sqrt(2), distance, targetPoint.tolerance)
+    assert_equal( end_point_tmp, pointOnLine)
+    assert_in_delta(1.0, parameter, targetPoint.tolerance)
+    
+    targetPoint3 = Vector3.new(0.0, -1.0, 3.0)
+    distance, pointOnLine, parameter = line.distance(targetPoint3)
+    assert_in_delta(Math::sqrt(2), distance, targetPoint.tolerance)
+    assert_equal( start_point_tmp, pointOnLine)
+    assert_in_delta(0.0, parameter, targetPoint.tolerance)
+
+    target_point4 = Vector3.new( 2,3,3)
+    line = FiniteLine.new( Vector3.new(1,2,3), Vector3.new(1,4,3))
+    distance, point_on_line, parameter = line.distance( target_point4 )
+    assert_in_delta( 1, distance, line.tolerance )
+    assert_equal( Vector3.new(1,3,3), point_on_line )
+    assert_in_delta( 0.5, parameter, line.tolerance ) 
+  end
+
+  def test_distance_to_line
+    start_point_tmp = Vector3.new(0.0, 0.0, 2.0)
+    end_point_tmp   = Vector3.new(2.0, 2.0, 2.0)
+    finite_line = FiniteLine.new(start_point_tmp, end_point_tmp)
+
+    #intersect case
+    infinite_line = Line.new(Vector3.new(0.0, 2.0, 3.0), Vector3.new(2.0, -2.0, -2.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(infinite_line)
+    assert_in_delta(0.0, distance, infinite_line.tolerance)
+    assert_equal( Vector3.new(1,1,2), point1)
+    assert_equal( Vector3.new(1,1,2), point2)
+    assert_in_delta(0.5, parameter1, infinite_line.tolerance)
+    assert_in_delta(0.5, parameter2, infinite_line.tolerance)
+
+    #not intersect case
+    infinite_line = Line.new(Vector3.new(0.0, 2.0, 4.0), Vector3.new(2.0, -2.0, 0.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(infinite_line)
+    assert_in_delta(2.0, distance, infinite_line.tolerance)
+    assert_equal( Vector3.new(1,1,2), point1)
+    assert_equal( Vector3.new(1,1,4), point2)
+    assert_in_delta(0.5, parameter1, infinite_line.tolerance)
+    assert_in_delta(0.5, parameter2, infinite_line.tolerance)
+
+    #not intersect case2
+    infinite_line = Line.new(Vector3.new(-2.0, 2.0, 4.0), Vector3.new(0.0, -2.0, 0.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(infinite_line)
+    assert_in_delta(Math::sqrt(8), distance, infinite_line.tolerance)
+    assert_equal( Vector3.new(0,0,2), point1)
+    assert_equal( Vector3.new(-2,0,4), point2)
+    assert_in_delta(0.0, parameter1, infinite_line.tolerance)
+    assert_in_delta(1.0, parameter2, infinite_line.tolerance)
+
+    #not intersect case3
+    infinite_line = Line.new(Vector3.new(12.0, 12.0, 2.0), Vector3.new(0, 5.0, 0.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(infinite_line)
+    assert_in_delta(10, distance, infinite_line.tolerance)
+    assert_equal( Vector3.new(2,2,2), point1)
+    assert_equal( Vector3.new(12,2,2), point2)
+    assert_in_delta(1.0, parameter1, infinite_line.tolerance)
+    assert_in_delta(-2.0, parameter2, infinite_line.tolerance)
+
+    #parallel case
+    infinite_line = Line.new(Vector3.new(0, -2.0, 6.0), Vector3.new(-1.0, -1.0, 0.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(infinite_line)
+    assert_in_delta(Math::sqrt(18), distance, infinite_line.tolerance)
+    assert_equal( nil, point1)
+    assert_equal( nil, point2)
+    assert_equal( nil, parameter1)
+    assert_equal( nil, parameter2)
+
+    #including case
+    infinite_line = Line.new(Vector3.new(-2, -2.0, 2.0), Vector3.new(1.0, 1.0, 0.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(infinite_line)
+    assert_in_delta(0, distance, infinite_line.tolerance)
+    assert_equal( nil, point1)
+    assert_equal( nil, point2)
+    assert_equal( nil, parameter1)
+    assert_equal( nil, parameter2)
+  end
+
+  def test_distance_to_finite_line
+    finite_line = FiniteLine.new(Vector3.new(0.0, 0.0, 2.0), Vector3.new(2.0,2.0,2.0))
+
+    #intersect case
+    target_finite_line = FiniteLine.new(Vector3.new(2.0, 0.0, 2.0), Vector3.new(0.0, 2.0,2.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(0.0, distance, target_finite_line.tolerance)
+    assert_equal( Vector3.new(1,1,2), point1)
+    assert_equal( Vector3.new(1,1,2), point2)
+    assert_in_delta(0.5, parameter1, target_finite_line.tolerance)
+    assert_in_delta(0.5, parameter2, target_finite_line.tolerance)
+    
+    #not intersect case1
+    target_finite_line = FiniteLine.new(Vector3.new(2.0, 0.0, 4.0), Vector3.new(0.0, 2.0, 4.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(2.0, distance, target_finite_line.tolerance)
+    assert_equal( Vector3.new(1,1,2), point1)
+    assert_equal( Vector3.new(1,1,4), point2)
+    assert_in_delta(0.5, parameter1, target_finite_line.tolerance)
+    assert_in_delta(0.5, parameter2, target_finite_line.tolerance)
+    
+    #not intersect case2
+    target_finite_line = FiniteLine.new(Vector3.new(3.0, 2.0, 2.0), Vector3.new(5.0, 0.0, 2.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(1.0, distance, target_finite_line.tolerance)
+    assert_equal( Vector3.new(2,2,2), point1)
+    assert_equal( Vector3.new(3,2,2), point2)
+    assert_in_delta(1.0, parameter1, target_finite_line.tolerance)
+    assert_in_delta(0.0, parameter2, target_finite_line.tolerance)
+
+    #not intersect case3
+    target_finite_line = FiniteLine.new(Vector3.new(-3.0, 5.0, 5.0), Vector3.new(0.0, 2.0, 2.0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(Math::sqrt(2), distance, target_finite_line.tolerance)
+    assert_equal( Vector3.new(1,1,2), point1)
+    assert_equal( Vector3.new(0,2,2), point2)
+    assert_in_delta(0.5, parameter1, target_finite_line.tolerance)
+    assert_in_delta(1.0, parameter2, target_finite_line.tolerance)
+
+    #not intersect case4
+    target_finite_line = FiniteLine.new(Vector3.new(-2.0, 5.0, 0), Vector3.new(-2.0, 2.0, 0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(Math::sqrt(12), distance, target_finite_line.tolerance)
+    assert_equal( Vector3.new(0,0,2), point1)
+    assert_equal( Vector3.new(-2,2,0), point2)
+    assert_in_delta(0, parameter1, target_finite_line.tolerance)
+    assert_in_delta(1, parameter2, target_finite_line.tolerance)
+    
+    #parallel case1
+    target_finite_line = FiniteLine.new(Vector3.new(4,4,0),Vector3.new(5,5,0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(Math::sqrt(12), distance, target_finite_line.tolerance)
+    assert_equal( Vector3.new(2,2,2), point1)
+    assert_equal( Vector3.new(4,4,0), point2)
+    assert_in_delta(1.0, parameter1, target_finite_line.tolerance)
+    assert_in_delta(0.0, parameter2, target_finite_line.tolerance)
+
+    #parallel case2
+    target_finite_line = FiniteLine.new(Vector3.new(2,2,0),Vector3.new(5,5,0))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(2, distance, target_finite_line.tolerance)
+    assert_equal( Vector3.new(2,2,2), point1)
+    assert_equal( Vector3.new(2,2,0), point2)
+    assert_in_delta(1.0, parameter1, target_finite_line.tolerance)
+    assert_in_delta(0.0, parameter2, target_finite_line.tolerance)
+
+    #parallel case3
+    target_finite_line = FiniteLine.new(Vector3.new(1,1,1),Vector3.new(5,5,1))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(1, distance, target_finite_line.tolerance)
+    assert_equal( nil, point1)
+    assert_equal( nil, point2)
+    assert_equal( nil, parameter1)
+    assert_equal( nil, parameter2)
+        
+    #including case1
+    target_finite_line = FiniteLine.new(Vector3.new(2,2,2),Vector3.new(5,5,2))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(0, distance, target_finite_line.tolerance)
+    assert_equal( Vector3.new(2,2,2), point1)
+    assert_equal( Vector3.new(2,2,2), point2)
+    assert_in_delta(1.0, parameter1, target_finite_line.tolerance)
+    assert_in_delta(0.0, parameter2, target_finite_line.tolerance)
+
+    #including case2
+    target_finite_line = FiniteLine.new(Vector3.new(1,1,2),Vector3.new(5,5,2))
+    distance, point1, point2, parameter1, parameter2 = finite_line.distance(target_finite_line)
+    assert_in_delta(0, distance, target_finite_line.tolerance)
+    assert_equal( nil, point1)
+    assert_equal( nil, point2)
+    assert_equal( nil, parameter1)
+    assert_equal( nil, parameter2)
+    
+  end
+  
+  def test_distance_to_invalid_value
+    finite_line = FiniteLine.new(Vector3.new(0,1,2), Vector3.new(2,3,4))
+    assert_raises ArgumentError do
+      finite_line.distance(4)
+    end
+    assert_raises ArgumentError do
+      finite_line.distance(nil)
+    end
+  end
+
+end

data/test/test_geom.rb

@@ -0,0 +1,14 @@
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class GeomTestCase < MiniTest::Unit::TestCase
+  def test_tolerance
+    default_tolerance = Geom.default_tolerance
+    geomObject = Geom.new
+    assert_equal(default_tolerance, geomObject.tolerance)
+    geomObject.tolerance = 1e-8
+    assert_equal(1e-8, geomObject.tolerance)
+    assert_equal(default_tolerance, Geom.default_tolerance)
+  end
+end

data/test/test_gmath3D.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'helper'
+require 'test_geom'
+require 'test_util'
+require 'test_vector3'
+require 'test_line'
+require 'test_finite_line'
+require 'test_plane'
+require 'test_rectangle'
+require 'test_triangle'
+require 'test_box'
+
+
+

data/test/test_line.rb

@@ -0,0 +1,105 @@
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class LineTestCase < MiniTest::Unit::TestCase
+  def test_initialize
+    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
+    direction_tmp  = Vector3.new(1.0, 1.0, 1.0)
+    line = Line.new(base_point_tmp, direction_tmp)
+
+    assert(base_point_tmp == line.base_point)
+    assert(direction_tmp  == line.direction )
+
+    lineDefault = Line.new()
+    assert(Vector3.new(0,0,0) == lineDefault.base_point)
+    assert(Vector3.new(1,0,0) == lineDefault.direction )
+  end
+
+  def test_point
+    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
+    direction_tmp  = Vector3.new(1.0, 1.0, 0.0)
+    line = Line.new(base_point_tmp, direction_tmp)
+
+    assert(Vector3.new(2.0, 3.0, 5.0) == line.point(0.0))
+    assert(Vector3.new(3.0, 4.0, 5.0) == line.point(1.0))
+    assert(Vector3.new(2.5, 3.5, 5.0) == line.point(0.5))
+    assert(Vector3.new(4.0, 5.0, 5.0) == line.point(2))
+    assert(Vector3.new(1.0, 2.0, 5.0) == line.point(-1.0))
+  end
+
+  def test_distance_to_point
+    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
+    direction_tmp  = Vector3.new(1.0, 1.0, 0.0)
+    line = Line.new(base_point_tmp, direction_tmp)
+
+    check_point1 = base_point_tmp + Vector3.new(-1.0, 1.0, 0.0)
+    distance, closest_point, parameter = line.distance(check_point1)
+    assert_in_delta(Math::sqrt(2.0), distance, line.tolerance)
+    assert(base_point_tmp == closest_point)
+    assert_in_delta(0.0, parameter, line.tolerance)
+
+    check_point2 = check_point1 + direction_tmp
+    distance, closest_point, parameter = line.distance(check_point2)
+    assert_in_delta(Math::sqrt(2.0), distance, line.tolerance)
+    assert(base_point_tmp + direction_tmp == closest_point)
+    assert_in_delta(1.0, parameter, line.tolerance)
+
+    check_point3 = line.point(0.3)
+    distance, closest_point = line.distance(check_point3)
+    assert_in_delta(0.0, distance, line.tolerance)
+    assert(check_point3 == closest_point)
+
+    target_point4 = Vector3.new(2,3,3)
+    line2 = Line.new( Vector3.new(1,2,3), Vector3.new(0,2,0))
+    distance, point_on_line, parameter = line2.distance( target_point4 )
+    assert_in_delta( 1, distance, line.tolerance )
+    assert_equal( Vector3.new(1,3,3), point_on_line )
+    assert_in_delta( 0.5, parameter, line.tolerance ) 
+  end
+
+  def test_distance_to_line
+    base_point_tmp1 = Vector3.new(0.0, 0.0, 0.0)
+    direction_tmp1  = Vector3.new(1.0, 1.0, 0.0)
+    line1 = Line.new(base_point_tmp1, direction_tmp1)
+
+    base_point_tmp2 = Vector3.new(1.0, 1.0, 3.0)
+    direction_tmp2  = Vector3.new(-1.0, 1.0, 0.0)
+    line2 = Line.new(base_point_tmp2, direction_tmp2)
+
+    distance, point1, point2, parameter1, parameter2 = line1.distance(line2)
+    assert_in_delta(3.0, distance, line1.tolerance)
+    assert(Vector3.new(1.0, 1.0, 0.0) == point1)
+    assert(Vector3.new(1.0, 1.0, 3.0) == point2)
+    assert_in_delta(1.0, parameter1, line1.tolerance)
+    assert_in_delta(0.0, parameter2, line2.tolerance)
+
+    # distance for same lines
+    distance, point1, point2, parameter1, parameter2 = line1.distance(line1)
+    assert_in_delta(0.0, distance, line1.tolerance)
+    assert_equal(nil, point1)
+    assert_equal(nil, point2)
+    assert_equal(nil, parameter1)
+    assert_equal(nil, parameter2)
+
+    # parallel case
+    base_point_tmp3 = Vector3.new(0.0, 0.0, 4.0)
+    direction_tmp3  = Vector3.new(-1.0, -1.0, 0.0)
+    line3 = Line.new(base_point_tmp3, direction_tmp3)
+    distance, point1, point2, parameter1, parameter2 = line1.distance(line3)
+    assert_in_delta(4.0, distance, line3.tolerance)
+    assert_equal(nil, point1)
+    assert_equal(nil, point2)
+    assert_equal(nil, parameter1)
+    assert_equal(nil, parameter2)
+  end
+
+  def test_distance_to_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = Line.new.distance(nil)
+    end
+    assert_raises ArgumentError do
+      invalidResult = Line.new.distance(5.0)
+    end
+  end
+end

data/test/test_plane.rb

@@ -0,0 +1,160 @@
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class PlaneTestCase < MiniTest::Unit::TestCase
+  def setup
+    @base_point = Vector3.new(0,0,1)
+    @normal = Vector3.new(0,0,1)
+    @plane = Plane.new(@base_point, @normal)
+    @plane_default = Plane.new()
+  end
+
+  def test_initialize
+    assert_equal(@base_point, @plane.base_point)
+    assert_equal(@normal, @plane.normal)
+    assert_equal(Vector3.new(0,0,0),@plane_default.base_point)
+    assert_equal(Vector3.new(0,0,1),@plane_default.normal)
+    assert_equal(Geom.default_tolerance, @plane_default.tolerance)
+  end
+
+  def test_distance_to_point
+    target_point = Vector3.new(1,2,3)
+    distance, closest_point = @plane.distance(target_point)
+    assert_in_delta(2, distance, target_point.tolerance)
+    assert_equal(Vector3.new(1,2,1),closest_point)
+
+    target_point = Vector3.new(1,-4,-5)
+    distance, closest_point = @plane_default.distance(target_point)
+    assert_in_delta(5, distance, target_point.tolerance)
+    assert_equal(Vector3.new(1,-4,0),closest_point)
+
+    target_point = Vector3.new(-2,4.5,1.0)
+    distance, closest_point = @plane.distance(target_point)
+    assert_in_delta(0, distance, target_point.tolerance)
+    assert_equal(Vector3.new(-2,4.5,1.0),closest_point)
+
+    plane2 = Plane.new(Vector3.new( 1.0, 1.0, 1.0), Vector3.new(1.0, 1.0, 0.0))
+    target_point = Vector3.new( 0.0, 0.0, 0.0 )
+    distance, closest_point = plane2.distance(target_point)
+    assert_in_delta( Math::sqrt(2), distance, plane2.tolerance)
+    assert_equal( Vector3.new( 1,1,0 ), closest_point)
+  end
+
+  def test_distance_to_line
+    #intersect case
+    target_line = Line.new(Vector3.new(1,1,2),Vector3.new(1,1,1))
+    distance, intersect_point, parameter = @plane.distance(target_line)
+    assert_in_delta(0, distance, @plane.tolerance)
+    assert_equal(Vector3.new(0,0,1), intersect_point)
+    assert_in_delta(-1, parameter, intersect_point.tolerance)
+
+    #intersect case 2
+    target_line = Line.new(Vector3.new(0,0,0),Vector3.new(2,2,2))
+    distance, intersect_point, parameter = @plane.distance(target_line)
+    assert_in_delta(0, distance, @plane.tolerance)
+    assert_equal(Vector3.new(1,1,1), intersect_point)
+    assert_in_delta(0.5, parameter, intersect_point.tolerance)
+
+    #parallel case
+    target_line = Line.new(Vector3.new(1,1,1.5),Vector3.new(1,1,0))
+    distance, intersect_point, parameter = @plane_default.distance(target_line)
+    assert_in_delta(1.5, distance, @plane_default.tolerance)
+    assert_equal(nil, intersect_point)
+    assert_equal(nil, parameter)
+
+    #contains case
+    target_line = Line.new(Vector3.new(1,1,1),Vector3.new(1,2.0,0))
+    distance, intersect_point, parameter = @plane.distance(target_line)
+    assert_in_delta(0, distance, @plane.tolerance)
+    assert_equal(nil, intersect_point)
+    assert_equal(nil, parameter)
+  end
+
+  def test_distance_to_finite_line
+    #intersect case
+    target_finite_line = FiniteLine.new(Vector3.new(0,0,0),Vector3.new(2,2,2))
+    distance, point_on_plane, point_on_line, parameter_on_line = @plane.distance(target_finite_line)
+    assert_in_delta(0, distance, @plane.tolerance)
+    assert_equal( Vector3.new(1,1,1), point_on_plane)
+    assert_equal( Vector3.new(1,1,1), point_on_line)
+    assert_in_delta(0.5, parameter_on_line, @plane.tolerance)
+
+    #intersect case2
+    target_finite_line = FiniteLine.new(Vector3.new(0,0,0),Vector3.new(1,1,1))
+    distance, point_on_plane, point_on_line, parameter_on_line = @plane.distance(target_finite_line)
+    assert_in_delta(0, distance, @plane.tolerance)
+    assert_equal( Vector3.new(1,1,1), point_on_plane)
+    assert_equal( Vector3.new(1,1,1), point_on_line)
+    assert_in_delta(1, parameter_on_line, @plane.tolerance)
+
+    #not intersect case
+    target_finite_line = FiniteLine.new(Vector3.new(2,2,2),Vector3.new(4,5,6))
+    distance, point_on_plane, point_on_line, parameter_on_line = @plane.distance(target_finite_line)
+    assert_in_delta(1, distance, @plane.tolerance)
+    assert_equal( Vector3.new(2,2,1), point_on_plane)
+    assert_equal( Vector3.new(2,2,2), point_on_line)
+    assert_in_delta(0, parameter_on_line, @plane.tolerance)
+
+    #not intersect case2
+    target_finite_line = FiniteLine.new(Vector3.new(3,6,-9),Vector3.new(-2,3,-5))
+    distance, point_on_plane, point_on_line, parameter_on_line = @plane.distance(target_finite_line)
+    assert_in_delta(6, distance, @plane.tolerance)
+    assert_equal( Vector3.new(-2,3,1), point_on_plane)
+    assert_equal( Vector3.new(-2,3,-5), point_on_line)
+    assert_in_delta(1, parameter_on_line, @plane.tolerance)
+
+    #parallel case
+    target_finite_line = FiniteLine.new(Vector3.new(3,3,3),Vector3.new(1,-4,3))
+    distance, point_on_plane, point_on_line, parameter_on_line = @plane.distance(target_finite_line)
+    assert_in_delta(2, distance, @plane.tolerance)
+    assert_equal( nil, point_on_plane)
+    assert_equal( nil, point_on_line)
+    assert_equal( nil, parameter_on_line)
+
+    #including case
+    target_finite_line = FiniteLine.new(Vector3.new(3,3,1),Vector3.new(1,-4,1))
+    distance, point_on_plane, point_on_line, parameter_on_line = @plane.distance(target_finite_line)
+    assert_in_delta(0, distance, @plane.tolerance)
+    assert_equal( nil, point_on_plane)
+    assert_equal( nil, point_on_line)
+    assert_equal( nil, parameter_on_line)
+  end
+
+  def test_distance_to_plane
+    #intersect case
+    target_plane = Plane.new(Vector3.new(1,1,4), Vector3.new(1,-1,0))
+    distance, intersect_line = @plane.distance(target_plane)
+    assert_in_delta(0, distance, @plane.tolerance)
+    assert(intersect_line.direction.parallel?(Vector3.new(1,1,0)))
+
+    #parallel case
+    target_plane = Plane.new(Vector3.new(1,1,4), Vector3.new(0,0,-1))
+    distance, intersect_line = @plane.distance(target_plane)
+    assert_in_delta(3, distance, @plane.tolerance)
+    assert_equal(nil, intersect_line)
+
+    #including case
+    target_plane = Plane.new(Vector3.new(1,1,1), Vector3.new(0,0,3))
+    distance, intersect_line = @plane.distance(target_plane)
+    assert_in_delta(0, distance, @plane.tolerance)
+    assert_equal(nil, intersect_line)
+  end
+
+  def test_distance_to_invalid_value
+    assert_raises ArgumentError do
+      @plane.distance(4)
+    end
+    assert_raises ArgumentError do
+      @plane.distance(nil)
+    end
+  end
+  
+  def test_project
+    assert_equal( Vector3.new( 2.0, 4.0, 1.0), @plane.project(Vector3.new(2.0, 4.0, -5.0)))
+    assert_equal( Vector3.new( 2.0, 4.0, 1.0), @plane.project(Vector3.new(2.0, 4.0, 5.0)))
+    assert_equal( Vector3.new( 0.0, -4.0, 1.0), @plane.project(Vector3.new(0.0, -4.0, 1.0)))
+    plane2 = Plane.new( Vector3.new(1,1,1), Vector3.new(1,1,0))
+    assert_equal( Vector3.new( 1,1,5), plane2.project( Vector3.new( 0,0,5)))
+  end
+end

data/test/test_rectangle.rb

@@ -0,0 +1,123 @@
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class RectangleTestCase < MiniTest::Unit::TestCase
+  def setup
+    @rectangle = Rectangle.new( Vector3.new(1,2,3), Vector3.new(0,-0.5,0), Vector3.new(0,0,2))
+    @rectangle_default = Rectangle.new()
+  end
+
+  def test_initialize
+    assert_equal(Vector3.new(1, 2,3), @rectangle.base_point)
+    assert_equal(Vector3.new(0,-0.5,0), @rectangle.u_vector)
+    assert_equal(Vector3.new(0, 0,2), @rectangle.v_vector)
+
+    assert_equal(Vector3.new(0,0,0), @rectangle_default.base_point)
+    assert_equal(Vector3.new(1,0,0), @rectangle_default.u_vector)
+    assert_equal(Vector3.new(0,1,0), @rectangle_default.v_vector)
+  end
+
+  def test_point
+    point = @rectangle.point(0.2, 1.0)
+    assert_equal(Vector3.new(1, 1.9, 5), point)
+
+    point = @rectangle.point(-2.0, 0.5)
+    assert_equal(Vector3.new(1, 3, 4), point)
+
+    point = @rectangle_default.point(0,0)
+    assert_equal(Vector3.new(0,0,0), point)
+
+    point = @rectangle_default.point(0.5, 0.5)
+    assert_equal(@rectangle_default.center_point, point)
+  end
+
+  def test_edges
+    edges = @rectangle.edges
+    assert_equal(4, edges.size)
+    assert_equal(Vector3.new(1,2,  3), edges[0].start_point)
+    assert_equal(Vector3.new(1,1.5,3), edges[0].end_point)
+    assert_equal(Vector3.new(1,1.5,3), edges[1].start_point)
+    assert_equal(Vector3.new(1,1.5,5), edges[1].end_point)
+    assert_equal(Vector3.new(1,1.5,5), edges[2].start_point)
+    assert_equal(Vector3.new(1,2  ,5), edges[2].end_point)
+    assert_equal(Vector3.new(1,2  ,5), edges[3].start_point)
+    assert_equal(Vector3.new(1,2  ,3), edges[3].end_point)
+  end
+
+  def test_normal
+    assert_equal(Vector3.new(-1,0,0), @rectangle.normal)
+    assert_equal(Vector3.new(0,0,1), @rectangle_default.normal)
+  end
+
+  def test_opposite_point
+    assert_equal(Vector3.new(1,1.5,5), @rectangle.opposite_point)
+    assert_equal(Vector3.new(1,1,0), @rectangle_default.opposite_point)
+  end
+
+  def test_center_point
+    assert_equal(Vector3.new(1,1.75,4), @rectangle.center_point)
+    assert_equal(Vector3.new(0.5,0.5,0), @rectangle_default.center_point)
+  end
+
+  def test_area
+    assert_in_delta( 1.0, @rectangle.area, @rectangle.tolerance)
+    assert_in_delta( 1.0, @rectangle_default.area, @rectangle_default.tolerance)
+  end
+
+  def test_uv_param
+    # inside case
+    check_point = @rectangle.center_point
+    u, v = @rectangle.uv_parameter(check_point)
+    assert_in_delta(0.5, u, @rectangle.tolerance)
+    assert_in_delta(0.5, v, @rectangle.tolerance)
+
+    # inside case2
+    check_point = @rectangle.point(0.3,0.6) + @rectangle.normal*1.0
+    u, v = @rectangle.uv_parameter(check_point)
+    assert_in_delta(0.3, u, @rectangle.tolerance)
+    assert_in_delta(0.6, v, @rectangle.tolerance)
+
+    # on edge
+    u, v = @rectangle.uv_parameter(Vector3.new(2, 1.75, 5))
+    assert_in_delta(0.5, u, @rectangle.tolerance)
+    assert_in_delta(1, v, @rectangle.tolerance)
+
+    # on vertex
+    u, v = @rectangle.uv_parameter(@rectangle.opposite_point)
+    assert_in_delta(1.0, u, @rectangle.tolerance)
+    assert_in_delta(1, v, @rectangle.tolerance)
+
+    # outside case1
+    u, v = @rectangle.uv_parameter(@rectangle.point(2.0, -3.0))
+    assert_in_delta(2.0, u, @rectangle.tolerance)
+    assert_in_delta(-3.0, v, @rectangle.tolerance)
+  end
+
+  def test_distance_to_point
+    # inside case
+    distance, point_on_rectangle = @rectangle.distance(Vector3.new(0.5,1.75,4.5))
+    assert_in_delta( 0.5, distance, @rectangle.tolerance)
+    assert_equal(Vector3.new(1, 1.75, 4.5), point_on_rectangle)
+
+    # on edge
+    distance, point_on_rectangle = @rectangle.distance(Vector3.new(2.0,1.5,4.5))
+    assert_in_delta( 1.0, distance, @rectangle.tolerance)
+    assert_equal(Vector3.new(1, 1.5, 4.5), point_on_rectangle)
+
+    # on vertex
+    distance, point_on_rectangle = @rectangle.distance(Vector3.new(-0.5,2,3))
+    assert_in_delta( 1.5, distance, @rectangle.tolerance)
+    assert_equal(Vector3.new(1,2,3), point_on_rectangle)
+
+    # outside on edge
+    distance, point_on_rectangle = @rectangle.distance(Vector3.new(0,1.75,2))
+    assert_in_delta( Math::sqrt(2), distance, @rectangle.tolerance)
+    assert_equal(Vector3.new(1,1.75,3), point_on_rectangle)
+
+    # outside on vertex
+    distance, point_on_rectangle = @rectangle.distance(Vector3.new(0,0,0))
+    assert_in_delta( Math::sqrt(12.25), distance, @rectangle.tolerance)
+    assert_equal(Vector3.new(1,1.5,3), point_on_rectangle)
+  end
+end