mageo 0.0.0

data/test/test_polar3d.rb

@@ -0,0 +1,95 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "helper"
+require "mageo/polar3d.rb"
+require "mageo/vector3d.rb"
+
+class TC_Polar3D < Test::Unit::TestCase
+	$tolerance = 10**(-10)
+
+	include Math
+
+	def setup
+		@p3d00 = Polar3D.new( 0.0, 0.00*PI, 0.00*PI)
+		@p3d01 = Polar3D.new( 2.0, 0.00*PI, 0.25*PI)
+		@p3d02 = Polar3D.new( 2.0, 0.25*PI, 0.00*PI)
+		@p3d03 = Polar3D.new( 2.0, 0.25*PI, 0.25*PI)
+	end
+
+	def test_to_v3d
+		assert_equal( Vector3D, @p3d00.to_v3d.class )
+		assert_in_delta( 0.0, @p3d00.to_v3d[0], $tolerance )
+		assert_in_delta( 0.0, @p3d00.to_v3d[1], $tolerance )
+		assert_in_delta( 0.0, @p3d00.to_v3d[2], $tolerance )
+
+		assert_equal( Vector3D, @p3d01.to_v3d.class )
+		assert_in_delta( 0.0, @p3d01.to_v3d[0], $tolerance )
+		assert_in_delta( 0.0, @p3d01.to_v3d[1], $tolerance )
+		assert_in_delta( 2.0, @p3d01.to_v3d[2], $tolerance )
+
+		assert_equal( Vector3D, @p3d02.to_v3d.class )
+		assert_in_delta( Math::sqrt(2.0), @p3d02.to_v3d[0], $tolerance )
+		assert_in_delta( 0.0            , @p3d02.to_v3d[1], $tolerance )
+		assert_in_delta( Math::sqrt(2.0), @p3d02.to_v3d[2], $tolerance )
+
+		assert_equal( Vector3D, @p3d03.to_v3d.class )
+		#√2 * cos(0.25PI)
+		assert_in_delta( 1.0 , @p3d03.to_v3d[0], $tolerance)
+		assert_in_delta( 1.0 , @p3d03.to_v3d[1], $tolerance)
+		assert_in_delta( Math::sqrt(2.0), @p3d03.to_v3d[2], $tolerance )
+
+	end
+
+	def test_minimize_phi!
+		p2pA = Polar3D.new( 2.0, 0.5*PI, -2.5*PI )
+		p2pA.minimize_phi!
+		assert_in_delta( 1.5*PI, p2pA.phi, $tolerance )
+
+		p2pB = Polar3D.new( 2.0, 0.5*PI, -0.5*PI )
+		p2pB.minimize_phi!
+		assert_in_delta( 1.5*PI, p2pB.phi, $tolerance )
+
+		p2pC = Polar3D.new( 2.0, 0.5*PI,  1.5*PI )
+		p2pC.minimize_phi!
+		assert_in_delta( 1.5*PI, p2pC.phi, $tolerance )
+
+		p2pD = Polar3D.new( 2.0, 0.5*PI,  3.5*PI )
+		p2pD.minimize_phi!
+		assert_in_delta( 1.5*PI, p2pD.phi, $tolerance )
+
+		p2pE = Polar3D.new( 2.0, 0.5*PI,  5.5*PI )
+		p2pE.minimize_phi!
+		assert_in_delta( 1.5*PI, p2pE.phi, $tolerance )
+
+		p2pF = Polar3D.new( 2.0, 0.5*PI,  4.5*PI )
+		p2pF.minimize_phi!
+		assert_in_delta( 0.5*PI, p2pF.phi, $tolerance )
+
+	end
+
+	def test_minimize_phi
+		p2pA = Polar3D.new( 2.0, 0.5*PI, -2.5*PI ).minimize_phi
+		assert_in_delta( 1.5*PI, p2pA.phi, $tolerance )
+
+		p2pB = Polar3D.new( 2.0, 0.5*PI, -0.5*PI ).minimize_phi
+		assert_in_delta( 1.5*PI, p2pB.phi, $tolerance )
+
+		p2pC = Polar3D.new( 2.0, 0.5*PI,  1.5*PI ).minimize_phi
+		assert_in_delta( 1.5*PI, p2pC.phi, $tolerance )
+
+		p2pD = Polar3D.new( 2.0, 0.5*PI,  3.5*PI ).minimize_phi
+		assert_in_delta( 1.5*PI, p2pD.phi, $tolerance )
+
+		p2pE = Polar3D.new( 2.0, 0.5*PI,  5.5*PI ).minimize_phi
+		assert_in_delta( 1.5*PI, p2pE.phi, $tolerance )
+
+		p2pF = Polar3D.new( 2.0, 0.5*PI,  4.5*PI ).minimize_phi
+		assert_in_delta( 0.5*PI, p2pF.phi, $tolerance )
+
+	end
+
+
+end
+

data/test/test_polyhedron.rb

@@ -0,0 +1,14 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "helper"
+require "mageo/polyhedron.rb"
+
+# initialize でインスタンスを生成できないことのみテストする。
+# その他の機能はサブクラスでテスト。
+class TC_Polyhedron < Test::Unit::TestCase
+	def test_initialize
+		assert_raise( NotImplementedError ) { Polyhedron.new }
+	end
+end

data/test/test_segment.rb

@@ -0,0 +1,82 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "helper"
+require "mageo/segment.rb"
+
+class TC_Segment < Test::Unit::TestCase
+	$tolerance = 1.0 * 10.0 ** (-10)
+
+	VEC_00 = Vector3D[1.0, 2.0, 3.0]
+	VEC_01 = Vector3D[4.0, 6.0, 8.0]
+
+	VEC_10 = Vector3D[0.0, 0.0, 1.0]
+	VEC_11 = Vector3D[0.0, 0.0, 3.0]
+
+	VEC_20 = Vector3D[1.0, 1.0, 1.0]
+	VEC_21 = Vector3D[0.0, 0.0, 0.0]
+	def setup
+		@s00 = Segment.new(VEC_00, VEC_01)
+		@s01 = Segment.new(VEC_10, VEC_11)
+		@s02 = Segment.new(VEC_20, VEC_21)
+	end
+
+	def test_initialize
+		vec00 = [1.0, 2.0, 3.0]
+		vec01 = [4.0, 6.0, 8.0]
+		assert_raise(Segment::InitializeError){
+			Segment.new(vec00, vec01)
+		}
+		assert_raise(Segment::InitializeError){
+			Segment.new(VEC_00, VEC_00)
+		}
+	end
+
+	def test_endpoints
+		assert_equal(VEC_00, @s00.endpoints[0])
+		assert_equal(VEC_01, @s00.endpoints[1])
+	end
+
+	def test_include?
+		assert_raise(Segment::TypeError){
+			@s02.include?([0.0, 0.0, 0.0], $tolerance)
+		}
+
+		#直線上
+		assert_equal(false, @s02.include?(Vector3D[-1.0,-1.0,-1.0], $tolerance))
+		assert_equal(true , @s02.include?(Vector3D[ 0.0, 0.0, 0.0], $tolerance))
+		assert_equal(true , @s02.include?(Vector3D[ 0.3, 0.3, 0.3], $tolerance))
+		assert_equal(true , @s02.include?(Vector3D[ 1.0, 1.0, 1.0], $tolerance))
+		assert_equal(false, @s02.include?(Vector3D[ 2.0, 2.0, 2.0], $tolerance))
+
+		#横に出てる
+		assert_equal(false, @s02.include?(Vector3D[0.1, 0.1, 0.2], $tolerance))
+		assert_equal(true , @s02.include?(Vector3D[0.1, 0.1, 0.2], 1.0))
+	end
+
+	def test_to_v3d
+		assert_equal(Vector3D[ 3.0, 4.0, 5.0], @s00.to_v3d)
+		assert_equal(Vector3D[ 0.0, 0.0, 2.0], @s01.to_v3d)
+		assert_equal(Vector3D[-1.0,-1.0,-1.0], @s02.to_v3d)
+	end
+
+	def test_eql?
+		assert_raise(Segment::TypeError){ @s00.eql?([[0,0,0],[1,1,1]])}
+
+		assert_equal(true , @s00.eql?(Segment.new(VEC_01, VEC_00)))
+		assert_equal(false, @s00.eql?(@s01))
+	end
+
+	def test_equal2
+		assert_raise(Segment::TypeError){ @s00.eql?([[0,0,0],[1,1,1]])}
+
+		assert_equal(true , @s00 == Segment.new(VEC_00, VEC_01))
+		assert_equal(false, @s00 == Segment.new(VEC_01, VEC_00))
+		assert_equal(false, @s00 == @s01)
+	end
+
+	#undef test_include?
+
+end
+

data/test/test_sphere.rb

@@ -0,0 +1,20 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "helper"
+require "test/unit"
+require "mageo/sphere.rb"
+require "mageo/vector3d.rb"
+
+class TC_Sphere < Test::Unit::TestCase
+	def setup
+		@s00 = Sphere.new([0.0, 1.0, 2.0], 3.0)
+	end
+
+	def test_initialize
+		assert_equal(Vector3D[0.0, 1.0, 2.0], @s00.position)
+		assert_equal(3.0, @s00.radius)
+	end
+
+end
+

data/test/test_tetrahedron.rb

@@ -0,0 +1,132 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "rubygems"
+gem "builtinextension"
+require "array_include_eql.rb"
+require "mageo/tetrahedron.rb"
+
+class Tetrahedron
+	public :center
+end
+
+class TC_Tetrahedron < Test::Unit::TestCase
+	$tolerance = 10**(-10)
+
+	V_00 = Vector3D[ 0.0, 0.0, 0.0]
+	V_01 = Vector3D[10.0, 0.0, 0.0]
+	V_02 = Vector3D[ 0.0,10.0, 0.0]
+	V_03 = Vector3D[ 0.0, 0.0,10.0]
+
+	V_10 = Vector3D[10.0,20.0,30.0]
+	V_11 = Vector3D[ 0.0,20.0,30.0]
+	V_12 = Vector3D[10.0, 0.0,30.0]
+	V_13 = Vector3D[10.0,20.0, 0.0]
+
+	def setup
+		@t00 = Tetrahedron.new( [ V_00, V_01, V_02, V_03 ])
+		@t01 = Tetrahedron.new( [ V_10, V_11, V_12, V_13 ])
+	end
+
+	def test_initialize
+		assert_raise( ArgumentError ){ Tetrahedron.new }
+		assert_raise( ArgumentError ){ Tetrahedron.new() }
+		assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( nil ) }
+		assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [] ) }
+		assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [ 0, 1, 2, 3 ] ) }
+		assert_raise( Tetrahedron::InitializeError ){ Tetrahedron.new( [ [], [], [], [] ] ) }
+		assert_raise( Tetrahedron::InitializeError ){
+			Tetrahedron.new( [ V_00, V_01, V_02, [ 0.0, 0.0 ] ])
+		}
+		assert_raise( Tetrahedron::InitializeError ){
+			Tetrahedron.new( [ V_00, V_01, V_02, [ 0.0, 0.0, 1.0, 0.0 ] ])
+		}
+
+		# 5点ある
+		assert_raise( Tetrahedron::InitializeError ){
+			Tetrahedron.new( [ V_00, V_01, V_02, V_03, [ 1.0, 1.0, 1.0] ])
+		}
+	
+		# 体積が 0.0 になるのはエラー
+		assert_raise( Tetrahedron::InitializeError ){
+			Tetrahedron.new( [ V_00, V_01, V_02, [ 2.0, 2.0, 0.0] ])
+		}
+
+		# Vector3DInternal なら 例外
+		assert_raise( Tetrahedron::InitializeError ){
+			Tetrahedron.new( 
+				[ Vector3DInternal[ 0.0, 0.0, 0.0],
+					Vector3DInternal[ 1.0, 0.0, 0.0],
+					Vector3DInternal[ 0.0, 1.0, 0.0],
+					Vector3DInternal[ 0.0, 0.0, 1.0]
+				]
+			)
+		}
+	
+		# Vector3D なら OK
+		assert_nothing_raised{
+			Tetrahedron.new( [ V_00, V_01, V_02, V_03 ])
+		}
+	end
+
+	def test_inside?
+		assert_equal( true , @t00.inside?( [ 1.0, 1.0, 1.0] ) )
+		assert_equal( false, @t00.inside?( [ 5.0, 5.0, 5.0] ) )
+		assert_equal( false, @t00.inside?( [-5.0,-5.0,-5.0] ) )
+		assert_equal( false, @t00.inside?( [ 0.0, 0.0, 0.0] ) ) #頂点上
+
+		assert_raise(Polyhedron::TypeError){@t00.inside?(Vector3DInternal[1.0, 1.0, 1.0])}
+		assert_raise(Tetrahedron::TypeError){@t00.inside?(Vector3DInternal[1.0, 1.0, 1.0])}
+		#pp Polyhedron::TypeError.ancestors
+		#pp Tetrahedron::TypeError.ancestors
+	end
+
+	def test_include?
+		assert_equal( true , @t00.include?([ 1.0, 1.0, 1.0], $tolerance))
+		assert_equal( false, @t00.include?([ 5.0, 5.0, 5.0], $tolerance))
+		assert_equal( false, @t00.include?([-5.0,-5.0,-5.0], $tolerance))
+		assert_equal( true , @t00.include?([ 0.0, 0.0, 0.0], $tolerance)) #頂点上
+
+		assert_equal( false, @t01.include?(Vector3D[ 3.0, 6.0, 30.0], $tolerance))
+
+		assert_raise(Polyhedron::TypeError){@t00.include?(Vector3DInternal[1.0, 1.0, 1.0], $tolerance)}
+	end
+
+	def test_volume
+		assert_in_delta( 1000.0/6.0 , @t00.volume, $tolerance )
+	end
+
+	def test_center
+		assert_in_delta( 10.0/4.0, @t00.center[0], $tolerance)
+		assert_in_delta( 10.0/4.0, @t00.center[1], $tolerance)
+		assert_in_delta( 10.0/4.0, @t00.center[2], $tolerance)
+	end
+
+	def test_vertices
+		assert_equal( [ V_00, V_01, V_02, V_03 ], @t00.vertices)
+	end
+
+	def test_triangles
+		t = @t00.triangles
+		assert_equal(4, t.size)
+		assert_equal(Triangle.new([V_00, V_01, V_02]) ,t[0])
+		assert_equal(Triangle.new([V_01, V_02, V_03]) ,t[1])
+		assert_equal(Triangle.new([V_02, V_03, V_00]) ,t[2])
+		assert_equal(Triangle.new([V_03, V_00, V_01]) ,t[3])
+	end
+
+	def test_edges
+		t = @t00.edges
+		assert_equal(6, t.size)
+		assert_equal(true, (t.include_eql?(Segment.new(V_00, V_01))))
+		assert_equal(true, (t.include_eql?(Segment.new(V_00, V_02))))
+		assert_equal(true, (t.include_eql?(Segment.new(V_00, V_03))))
+		assert_equal(true, (t.include_eql?(Segment.new(V_01, V_02))))
+		assert_equal(true, (t.include_eql?(Segment.new(V_01, V_03))))
+		assert_equal(true, (t.include_eql?(Segment.new(V_02, V_03))))
+	end
+
+
+end
+

data/test/test_triangle.rb

@@ -0,0 +1,258 @@
+#! /usr/bin/env ruby
+# coding: utf-8
+
+require "test/unit"
+require "mageo/triangle.rb"
+require "mageo/vector3d.rb"
+
+class Triangle
+	public :internal_axes
+end
+
+class TC_Triangle < Test::Unit::TestCase
+	$tolerance = 10.0 ** (-10)
+
+	VEC_O = Vector3D[0.0, 0.0, 0.0]
+	VEC_X = Vector3D[1.0, 0.0, 0.0]
+	VEC_Y = Vector3D[0.0, 1.0, 0.0]
+	VEC_Z = Vector3D[0.0, 0.0, 1.0]
+
+	def setup
+		@t00 = Triangle.new([VEC_O, VEC_X, VEC_Y])
+		@t01 = Triangle.new([VEC_X, VEC_Y, VEC_Z])
+		@t02 = Triangle.new([[10.0,10.0,10.0], [20.0,10.0,10.0], [10.0,20.0,10.0]])
+		@t03 = Triangle.new([[10.0,20.0,30.0], [ 0.0,20.0,30.0], [10.0, 0.0,30.0]])
+	end
+
+	def test_initialize
+		assert_raise( ArgumentError ){ Triangle.new }
+		assert_raise( ArgumentError ){ Triangle.new() }
+		assert_raise( Triangle::InitializeError ){ Triangle.new( nil ) }
+		assert_raise( Triangle::InitializeError ){ Triangle.new( [] ) }
+		assert_raise( Triangle::InitializeError ){ Triangle.new( [ 0, 1 ] ) }
+		assert_raise( Triangle::InitializeError ){ Triangle.new( [ 0, 1, 2 ] ) }
+		assert_raise( Triangle::InitializeError ){ Triangle.new( [ 0, 1, 2, 3 ] ) } 
+		assert_raise( Triangle::InitializeError ){ Triangle.new( [ [ 0, 0, 0 ], [ 1, 1, 1 ], [ 2, 3 ] ] ) } #3次元座標になっていないものがある。
+
+		assert_raise( Triangle::LinearException ){ Triangle.new( [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 2, 2, 2 ] ] ) } #同一の点を含む。
+		assert_raise( Triangle::LinearException ){ Triangle.new( [ [ 0, 0, 0 ], [ 1, 1, 1 ], [ 2, 2, 2 ] ] ) } #直線上に並ぶ
+
+		assert_equal( Triangle, Triangle.new( [ Vector3D[ 0, 0, 0 ], Vector3D[ 1, 0, 0 ], Vector3D[ 0, 1, 0 ] ] ).class )
+	end
+
+	def test_vertices
+		assert_equal( Array, @t00.vertices.class )
+		assert_equal( 3, @t00.vertices.size )
+		assert_equal( Vector3D[0, 0, 0], @t00.vertices[0] )
+		assert_equal( Vector3D[1, 0, 0], @t00.vertices[1] )
+		assert_equal( Vector3D[0, 1, 0], @t00.vertices[2] )
+	end
+
+	def test_same_side?
+		assert_raise(Triangle::TypeError){ @t00.same_side?( [ 2, 3,  7 ], [ -2, -3,  2 ])}
+
+		assert_equal( true , @t00.same_side?( Vector3D[ 2, 3,  7 ], Vector3D[ -2, -3,  2 ] ) )
+		assert_equal( true , @t00.same_side?( Vector3D[ 2, 3, -7 ], Vector3D[ -2, -3, -2 ] ) )
+		assert_equal( false, @t00.same_side?( Vector3D[ 2, 3,  7 ], Vector3D[ -2, -3, -2 ] ) )
+		assert_equal( false, @t00.same_side?( Vector3D[ 2, 3, -7 ], Vector3D[ -2, -3,  2 ] ) )
+		assert_equal( false, @t00.same_side?( Vector3D[ 1, 2,  0 ], Vector3D[ 10, 10, 10 ] ) ) #pos0 が面上の点
+		assert_equal( false, @t00.same_side?( Vector3D[10, 10,10 ], Vector3D[  1,  2,  0 ] ) ) #pos1 が面上の点
+		assert_equal( false, @t00.same_side?( Vector3D[10, 10, 0 ], Vector3D[  1,  2,  0 ] ) )   #両方 が面上の点
+
+		assert_equal( true , @t01.same_side?( Vector3D[  10,  10, 10 ], Vector3D[  20,  30,  40 ] ) )
+		assert_equal( true , @t01.same_side?( Vector3D[   0,   0,  0 ], Vector3D[ -10, -10, -10 ] ) )
+		assert_equal( false, @t01.same_side?( Vector3D[  10,  10, 10 ], Vector3D[ -10, -10, -10 ] ) )
+		assert_equal( false, @t01.same_side?( Vector3D[   0,   0,  0 ], Vector3D[  20,  30,  40 ] ) )
+		assert_equal( false, @t01.same_side?( Vector3D[ 0.5, 0.5,  0 ], Vector3D[  10,  10,  10 ] ) ) #pos0 が面上の点
+		assert_equal( false, @t01.same_side?( Vector3D[  10,  10, 10 ], Vector3D[ 0.5, 0.5,   0 ] ) ) #pos1 が面上の点
+		assert_equal( false, @t01.same_side?( Vector3D[ 0.5, 0.5,  0 ], Vector3D[   0, 0.5, 0.5 ] ) ) #両方 が面上の点
+	end
+
+	def test_include?
+		assert_raise(Triangle::TypeError){ @t00.include?([11.0, 11.0, 10.0], $tolerance)}
+
+		# on face
+		assert_equal(true, @t02.include?(Vector3D[11.0, 11.0, 10.0], $tolerance))
+
+		# on vertices
+		assert_equal(true, @t02.include?(Vector3D[10.0, 10.0, 10.0], $tolerance))
+		assert_equal(true, @t02.include?(Vector3D[20.0, 10.0, 10.0], $tolerance))
+		assert_equal(true, @t02.include?(Vector3D[10.0, 20.0, 10.0], $tolerance))
+
+		# on edge
+		assert_equal(true, @t02.include?(Vector3D[15.0, 10.0, 10.0], $tolerance))
+		assert_equal(true, @t02.include?(Vector3D[10.0, 15.0, 10.0], $tolerance))
+		assert_equal(true, @t02.include?(Vector3D[15.0, 15.0, 10.0], $tolerance))
+
+		# out
+		assert_equal(false, @t02.include?(Vector3D[ 30.0, 10.0, 10.0], $tolerance))
+		assert_equal(false, @t02.include?(Vector3D[ 10.0, 30.0, 10.0], $tolerance))
+		assert_equal(false, @t02.include?(Vector3D[-10.0, 10.0, 10.0], $tolerance))
+		assert_equal(false, @t02.include?(Vector3D[ 10.0,-10.0, 10.0], $tolerance))
+		assert_equal(false, @t02.include?(Vector3D[ 10.0, 10.0,  0.0], $tolerance))
+
+		assert_equal(false, @t03.include?(Vector3D[  3.0,  6.0, 30.0], $tolerance))
+
+		# 計算誤差
+		assert_equal(false, @t01.include?(Vector3D[  0.3,  0.3,  0.3], $tolerance))
+		assert_equal(true, @t01.include?(Vector3D[  0.3,  0.3,  0.3], 1.0))
+	end
+
+	def test_intersection
+		# 平行
+		pos0 = Vector3D[0.0, 0.0, 2.0]
+		pos1 = Vector3D[2.0, 0.0, 2.0]
+		seg01 = Segment.new(pos0, pos1)
+		assert_raise(Triangle::NoIntersectionError){ @t00.intersection(seg01, $tolerance) }
+
+		# 面に含まれる
+		pos0 = Vector3D[0.0, 0.0, 0.0]
+		pos1 = Vector3D[2.0, 0.0, 0.0]
+		seg01 = Segment.new(pos0, pos1)
+		assert_raise(Triangle::NoIntersectionError){ @t00.intersection(seg01, $tolerance) }
+
+		# 平行ではないが、三角形の外を通過。
+		pos2 = Vector3D[0.0,10.0, 0.0]
+		pos3 = Vector3D[0.0,10.0, 2.0]
+		seg01 = Segment.new(pos0, pos1)
+		assert_raise(Triangle::NoIntersectionError){ @t00.intersection(seg01, $tolerance) }
+
+		# 三角形を通る
+		pos2 = Vector3D[0.5, 0.5,-1.0]
+		pos3 = Vector3D[0.5, 0.5, 2.0]
+		seg01 = Segment.new(pos2, pos3)
+		assert_equal(Vector3D[0.5, 0.5, 0.0], @t00.intersection(seg01, $tolerance))
+		#
+		pos2 = Vector3D[0.5, 0.5, 0.0]
+		pos3 = Vector3D[0.5, 0.5, 1.0]
+		seg01 = Segment.new(pos2, pos3)
+		assert_equal(Vector3D[0.5, 0.5, 0.0], @t00.intersection(seg01, $tolerance))
+		#
+		pos2 = Vector3D[ 1.5, 1.5, 1.0]
+		pos3 = Vector3D[-0.5,-0.5,-1.0]
+		seg01 = Segment.new(pos2, pos3)
+		assert_equal(Vector3D[0.5, 0.5, 0.0], @t00.intersection(seg01, $tolerance))
+		#
+		pos2 = Vector3D[ 0.00, 0.00, 0.00]
+		pos3 = Vector3D[ 1.00, 1.00, 1.00]
+		seg01 = Segment.new(pos2, pos3)
+		t = @t01.intersection(seg01, $tolerance)
+		assert_in_delta(1.0/3.0, t[0], $tolerance)
+		assert_in_delta(1.0/3.0, t[1], $tolerance)
+		assert_in_delta(1.0/3.0, t[2], $tolerance)
+		#
+		pos2 = Vector3D[ 0.25, 0.25, 0.00]
+		pos3 = Vector3D[ 0.25, 0.25, 1.00]
+		seg01 = Segment.new(pos2, pos3)
+		assert_equal(Vector3D[0.25, 0.25, 0.50], @t01.intersection(seg01, $tolerance))
+	end
+
+	#def test_intersect?
+	#	TODO
+	#end
+
+	def test_parallel_segment?
+		# 平行
+		pos0 = Vector3D[0.0, 0.0, 2.0]
+		pos1 = Vector3D[2.0, 0.0, 2.0]
+		seg01 = Segment.new(pos0, pos1)
+		assert_equal(true , @t00.parallel_segment?(seg01))
+
+		# 面に含まれる
+		pos0 = Vector3D[0.0, 0.0, 0.0]
+		pos1 = Vector3D[2.0, 0.0, 0.0]
+		seg01 = Segment.new(pos0, pos1)
+		assert_equal(false, @t00.parallel_segment?(seg01))
+
+		# 平行ではない。
+		pos2 = Vector3D[0.0,10.0, 0.0]
+		pos3 = Vector3D[0.0,10.0, 2.0]
+		seg01 = Segment.new(pos0, pos1)
+		assert_equal(false, @t00.parallel_segment?(seg01))
+	end
+
+	def test_normal_vector
+		t = Vector3D[0.0, 0.0, 1.0]
+		assert_equal(t, @t00.normal_vector)
+
+		t = Vector3D[1.0, 1.0, 1.0]
+		t = t * (1.0/t.r)
+		assert_equal(t, @t01.normal_vector)
+
+		t = Vector3D[0.0, 0.0, 1.0]
+		assert_equal(t, @t02.normal_vector)
+	end
+
+	def test_equivalent?
+		assert_raise(Triangle::TypeError){
+			@t00.equivalent?([[ 0.0, 0.0, 0.0], [ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		}
+
+		t = Triangle.new([[ 0.0, 0.0, 0.0], [ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		assert_equal(true , @t00.eql?(t))
+
+		t = Triangle.new([[ 1.0, 0.0, 0.0], [ 0.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		assert_equal(true , @t00.eql?(t))
+
+		t = Triangle.new([[ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [ 0.0, 0.0, 0.0]])
+		assert_equal(true , @t00.eql?(t))
+
+		t = Triangle.new([[ 0.0, 0.0, 1.0], [ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		assert_equal(false, @t00.eql?(t))
+
+		# tolerance を設定の上 0.0
+		t = Triangle.new([[ 0.0, 0.0, 1.0], [ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		assert_equal(false, @t00.eql?(t, 0.0))
+
+		# tolerance を 1.0 に設定
+		t = Triangle.new([[ 0.0, 0.0, 1.0], [ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		assert_equal(true, @t00.eql?(t, 1.0))
+	end
+
+	def test_equal2
+		t = Triangle.new([[ 0.0, 0.0, 0.0], [ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		assert_equal(true , @t00 == t)
+
+		t = Triangle.new([[ 1.0, 0.0, 0.0], [ 0.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		assert_equal(false, @t00 == t)
+
+		t = Triangle.new([[ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [ 0.0, 0.0, 0.0]])
+		assert_equal(false, @t00 == t)
+
+		t = Triangle.new([[ 0.0, 0.0, 1.0], [ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0]])
+		assert_equal(false, @t00 == t)
+	end
+
+	def test_internal_axes
+		@t01 = Triangle.new([[ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [ 0.0, 0.0, 1.0]])
+		@t02 = Triangle.new([[10.0,10.0,10.0], [20.0,10.0,10.0], [10.0,20.0,10.0]])
+
+		t = Axes.new([[ 1.0, 0.0, 0.0], [ 0.0, 1.0, 0.0], [ 0.0, 0.0, 1.0]])
+		assert_equal(t, @t00.internal_axes)
+
+		t = @t01.internal_axes
+		assert_in_delta(-1.0, t[0][0]              , $tolerance)
+		assert_in_delta( 1.0, t[0][1]              , $tolerance)
+		assert_in_delta( 0.0, t[0][2]              , $tolerance)
+		assert_in_delta(-1.0, t[1][0]              , $tolerance)
+		assert_in_delta( 0.0, t[1][1]              , $tolerance)
+		assert_in_delta( 1.0, t[1][2]              , $tolerance)
+		assert_in_delta(1.0/Math.sqrt(3.0), t[2][0], $tolerance)
+		assert_in_delta(1.0/Math.sqrt(3.0), t[2][1], $tolerance)
+		assert_in_delta(1.0/Math.sqrt(3.0), t[2][2], $tolerance)
+
+		t = Axes.new([[ 10.0, 0.0, 0.0], [ 0.0, 10.0, 0.0], [ 0.0, 0.0, 1.0]])
+		assert_equal(t, @t02.internal_axes)
+	end
+
+	def test_edges
+		t = @t00.edges
+		assert_equal(3, t.size)
+		
+		assert_equal(Segment.new(VEC_O, VEC_X), t[0])
+		assert_equal(Segment.new(VEC_X, VEC_Y), t[1])
+		assert_equal(Segment.new(VEC_Y, VEC_O), t[2])
+	end
+
+end
+