mageo 0.0.0 → 0.0.1

data/lib/mageo/polar3d.rb

@@ -10,38 +10,37 @@ require 'mageo/vector3d.rb'
 #まあ人間用に degree 用インターフェイスも用意することもあるかもしれんが。
 class Polar3D
 
-	include Math
-	
-	attr_reader :r, :theta, :phi
-
-	#
-	def initialize( r, theta, phi)
-		@r = r
-		@theta = theta
-		@phi = phi
-	end
-
-	#3次元 Vector に変換。
-	def to_v3d
-		#Vector[ @r * cos( @theta ), @r * sin( @theta ) ]
-		x = @r * sin( @theta ) * cos( @phi )
-		y = @r * sin( @theta ) * sin( @phi )
-		z = @r * cos( @theta )
-		Vector3D[ x, y, z ]
-	end
-
-	#phi を 0 <= phi < 2*PI の間の角度に変換する破壊破壊的メソッド。
-	def minimize_phi!
-		tmp = ( @phi / (2.0*PI) )
-		tmp = tmp - tmp.floor
-		@phi = (2.0*PI) * tmp
-	end
-
-	#phi を 0 <= phi < 2*PI の間の角度に変換したオブジェクトを返す非破壊破壊的メソッド。
-	def minimize_phi
-		result = Marshal.load( Marshal.dump( self ) )
-		result.minimize_phi!
-		result
-	end
-
+  include Math
+  
+  attr_reader :r, :theta, :phi
+
+  #
+  def initialize( r, theta, phi)
+    @r = r
+    @theta = theta
+    @phi = phi
+  end
+
+  #3次元 Vector に変換。
+  def to_v3d
+    #Vector[ @r * cos( @theta ), @r * sin( @theta ) ]
+    x = @r * sin( @theta ) * cos( @phi )
+    y = @r * sin( @theta ) * sin( @phi )
+    z = @r * cos( @theta )
+    Vector3D[ x, y, z ]
+  end
+
+  #phi を 0 <= phi < 2*PI の間の角度に変換する破壊破壊的メソッド。
+  def minimize_phi!
+    tmp = ( @phi / (2.0*PI) )
+    tmp = tmp - tmp.floor
+    @phi = (2.0*PI) * tmp
+  end
+
+  #phi を 0 <= phi < 2*PI の間の角度に変換したオブジェクトを返す非破壊破壊的メソッド。
+  def minimize_phi
+    result = Marshal.load( Marshal.dump( self ) )
+    result.minimize_phi!
+    result
+  end
 end

data/lib/mageo/polyhedron.rb

@@ -20,76 +20,75 @@ require "array_include_eql.rb"
 #     see Tetrahedron.rb
 #   - メインのテストは 四面体 Tetrahedron クラスで行っている。
 class Polyhedron
-	attr_reader :vertices
+  attr_reader :vertices
 
-	class TypeError < Exception; end
+  class TypeError < Exception; end
 
-	# initialize で例外を返すことでインスタンスを生成できない抽象クラスを表現。
-	# subclass で再定義する。
-	def initialize()
-		raise NotImplementedError, "need to define `initialize'"
-	end
+  # initialize で例外を返すことでインスタンスを生成できない抽象クラスを表現。
+  # subclass で再定義する。
+  def initialize()
+    raise NotImplementedError, "need to define `initialize'"
+  end
 
-	def edges
-		results = []
-		edges = triangles.each do |triangle|
-			triangle.edges.each do |edge|
-				results << edge unless results.include_eql?(edge)
-			end
-		end
-		return results
-	end
+  def edges
+    results = []
+    edges = triangles.each do |triangle|
+      triangle.edges.each do |edge|
+        results << edge unless results.include_eql?(edge)
+      end
+    end
+    return results
+  end
 
-	def triangles
-		results = @vertex_indices_of_triangles.map do |indices|
-			Triangle.new( indices.map{|i| @vertices[i] } )
-		end
-		return results
-	end
+  def triangles
+    results = @vertex_indices_of_triangles.map do |indices|
+      Triangle.new( indices.map{|i| @vertices[i] } )
+    end
+    return results
+  end
 
-	#面で囲まれた空間の中にあれば true を返す。
-	def inside?( pos )
-		raise TypeError if pos.class == Vector3DInternal
+  #面で囲まれた空間の中にあれば true を返す。
+  def inside?( pos )
+    raise TypeError if pos.class == Vector3DInternal
 
-		result = true
-		triangles.each do |triangle|
-			result = false unless triangle.same_side?( center, pos.to_v3d )
-		end
-		return result
-	end
+    result = true
+    triangles.each do |triangle|
+      result = false unless triangle.same_side?( center, pos.to_v3d )
+    end
+    return result
+  end
 
-	def include?(pos, tolerance)
-		raise TypeError if pos.class == Vector3DInternal
+  def include?(pos, tolerance)
+    raise TypeError if pos.class == Vector3DInternal
 
-		return true if inside?( pos )
-		triangles.each do |triangle|
-			#pp pos
-			#pp triangle
-			return true if triangle.include?(pos.to_v3d, tolerance)
-		end
-		return false
-	end
+    return true if inside?( pos )
+    triangles.each do |triangle|
+      #pp pos
+      #pp triangle
+      return true if triangle.include?(pos.to_v3d, tolerance)
+    end
+    return false
+  end
 
-	# 体積を返す。
-	def volume
-		result = 0.0
-		@vertex_indices_of_triangles.each do |tri_vertices|
-			vectors =  tri_vertices.map { |i| @vertices[i] - center }
-			volume = Vector3D.scalar_triple_product( *vectors ).abs
-			volume /= 6.0
-			result += volume
-		end
-		return result
-	end
-
-	#各頂点の座標の平均値を返す。
-	def center
-		tmp = Vector3D[ 0.0, 0.0, 0.0 ]
-		@vertices.each do |vertex|
-			tmp += vertex
-		end
-		return tmp * ( 1.0 / @vertices.size.to_f ) # 座標の平均の算出
-	end
+  # 体積を返す。
+  def volume
+    result = 0.0
+    @vertex_indices_of_triangles.each do |tri_vertices|
+      vectors =  tri_vertices.map { |i| @vertices[i] - center }
+      volume = Vector3D.scalar_triple_product( *vectors ).abs
+      volume /= 6.0
+      result += volume
+    end
+    return result
+  end
 
+  #各頂点の座標の平均値を返す。
+  def center
+    tmp = Vector3D[ 0.0, 0.0, 0.0 ]
+    @vertices.each do |vertex|
+      tmp += vertex
+    end
+    return tmp * ( 1.0 / @vertices.size.to_f ) # 座標の平均の算出
+  end
 end
 

data/lib/mageo/segment.rb

@@ -5,79 +5,78 @@ require "mageo/vector3d.rb"
 
 # 線分を表すクラス。
 class Segment
-	attr_reader :endpoints
-
-	class InitializeError < Exception; end
-	class TypeError < Exception; end
-
-	
-	# 端点を2つ渡す。
-	def initialize(vector0, vector1)
-		raise InitializeError if vector0.class != Vector3D
-		raise InitializeError if vector1.class != Vector3D
-		raise InitializeError if vector0 == vector1
-		
-		@endpoints = [vector0, vector1]
-	end
-
-	# position で与えられた点が線分の中にある点か？
-	# tolerance = 0.0 では計算誤差のためにほとんど真とならない。
-	# position は Vector3D クラスインスタンスでなければならない。
-	def include?(position, tolerance)
-		raise TypeError if position.class != Vector3D
-
-		vec_self = @endpoints[1] - @endpoints[0]
-		vec_other = position - @endpoints[0]
-
-		# 両端の点は計算誤差で失敗しやすいので true にしておく。
-		return true if position == @endpoints[0]
-		return true if position == @endpoints[1]
-
-		# 長さ方向チェック
-		inner_product = vec_self.inner_product(vec_other)
-		return false if (inner_product < 0.0 )
-		return false if ( vec_self.r ** 2 < inner_product)
-
-		# 垂直方向チェック
-		vec_outer = vec_other - vec_self * (inner_product / (vec_self.r)**2)
-		return false if tolerance < vec_outer.r
-
-		# ここまでチェックを通過すれば true
-		return true
-
-		##ex_product = vec_self.exterior_product(vec_other)
-		#あかんな。
-		#normalize して、
-		#この方向の成分を出さんと。
-		#外積もおかしい。
-
-		#return false if ( ex_product[2].abs > tolerance )
-
-	end
-
-	# endpoints で取り出せる座標2つのうち、最初のものから最後のものへのベクトルを表す
-	# Vector3D クラスインスタンスを返す。
-	def to_v3d
-		return @endpoints[1] - @endpoints[0]
-	end
-
-	# 等価チェック。
-	# uniq できるようにするため。
-	def eql?(other)
-		raise TypeError if other.class != Segment
-		@endpoints.each do |point|
-			return false unless other.endpoints.include?(point)
-		end
-		return true
-	end
-
-	def ==(other)
-		raise TypeError if other.class != Segment
-		@endpoints.size.times do |i|
-			return false unless other.endpoints[i] == @endpoints[i]
-		end
-		return true
-	end
-
+  attr_reader :endpoints
+
+  class InitializeError < Exception; end
+  class TypeError < Exception; end
+
+  
+  # 端点を2つ渡す。
+  def initialize(vector0, vector1)
+    raise InitializeError if vector0.class != Vector3D
+    raise InitializeError if vector1.class != Vector3D
+    raise InitializeError if vector0 == vector1
+    
+    @endpoints = [vector0, vector1]
+  end
+
+  # position で与えられた点が線分の中にある点か？
+  # tolerance = 0.0 では計算誤差のためにほとんど真とならない。
+  # position は Vector3D クラスインスタンスでなければならない。
+  def include?(position, tolerance)
+    raise TypeError if position.class != Vector3D
+
+    vec_self = @endpoints[1] - @endpoints[0]
+    vec_other = position - @endpoints[0]
+
+    # 両端の点は計算誤差で失敗しやすいので true にしておく。
+    return true if position == @endpoints[0]
+    return true if position == @endpoints[1]
+
+    # 長さ方向チェック
+    inner_product = vec_self.inner_product(vec_other)
+    return false if (inner_product < 0.0 )
+    return false if ( vec_self.r ** 2 < inner_product)
+
+    # 垂直方向チェック
+    vec_outer = vec_other - vec_self * (inner_product / (vec_self.r)**2)
+    return false if tolerance < vec_outer.r
+
+    # ここまでチェックを通過すれば true
+    return true
+
+    ##ex_product = vec_self.exterior_product(vec_other)
+    #あかんな。
+    #normalize して、
+    #この方向の成分を出さんと。
+    #外積もおかしい。
+
+    #return false if ( ex_product[2].abs > tolerance )
+
+  end
+
+  # endpoints で取り出せる座標2つのうち、最初のものから最後のものへのベクトルを表す
+  # Vector3D クラスインスタンスを返す。
+  def to_v3d
+    return @endpoints[1] - @endpoints[0]
+  end
+
+  # 等価チェック。
+  # uniq できるようにするため。
+  def eql?(other)
+    raise TypeError if other.class != Segment
+    @endpoints.each do |point|
+      return false unless other.endpoints.include?(point)
+    end
+    return true
+  end
+
+  def ==(other)
+    raise TypeError if other.class != Segment
+    @endpoints.size.times do |i|
+      return false unless other.endpoints[i] == @endpoints[i]
+    end
+    return true
+  end
 end
 

data/lib/mageo/sphere.rb

@@ -7,13 +7,12 @@ require "mageo/vector3d.rb"
 # 球を表現するクラス。
 #
 class Sphere
-	attr_reader :position, :radius
-
-	# 座標と半径
-	def initialize(position, radius)
-		@position = Vector3D[*position]
-		@radius = radius
-	end
+  attr_reader :position, :radius
 
+  # 座標と半径
+  def initialize(position, radius)
+    @position = Vector3D[*position]
+    @radius = radius
+  end
 end
 

data/lib/mageo/tetrahedron.rb

@@ -11,32 +11,31 @@ require "mageo/polyhedron.rb"
 #
 class Tetrahedron < Polyhedron
 
-	class InitializeError < Exception; end
-
-	# vertices には四面体の頂点を順不同で入れた Array。
-	def initialize( vertices )
-		raise InitializeError if vertices.class != Array
-		raise InitializeError if vertices.size != 4
-		vertices.each do |vertex|
-			raise InitializeError if vertex.size != 3
-			raise InitializeError unless vertex.methods.include?( :[] )
-			raise InitializeError unless vertex.methods.include?( :map )
-		end
-		vertices.each do |vertex|
-			raise InitializeError if vertex.class == Vector3DInternal
-		end
-
-		@vertices = vertices.map { |vertex| vertex.to_v3d }
-
-		@vertex_indices_of_triangles = [
-			[ 0, 1, 2 ], 
-			[ 1, 2, 3 ],
-			[ 2, 3, 0 ], 
-			[ 3, 0, 1 ],
-		]
-
-		raise InitializeError, "volume is zero." if volume == 0.0
-	end
-
+  class InitializeError < Exception; end
+
+  # vertices には四面体の頂点を順不同で入れた Array。
+  def initialize( vertices )
+    raise InitializeError if vertices.class != Array
+    raise InitializeError if vertices.size != 4
+    vertices.each do |vertex|
+      raise InitializeError if vertex.size != 3
+      raise InitializeError unless vertex.methods.include?( :[] )
+      raise InitializeError unless vertex.methods.include?( :map )
+    end
+    vertices.each do |vertex|
+      raise InitializeError if vertex.class == Vector3DInternal
+    end
+
+    @vertices = vertices.map { |vertex| vertex.to_v3d }
+
+    @vertex_indices_of_triangles = [
+      [ 0, 1, 2 ], 
+      [ 1, 2, 3 ],
+      [ 2, 3, 0 ], 
+      [ 3, 0, 1 ],
+    ]
+
+    raise InitializeError, "volume is zero." if volume == 0.0
+  end
 end
 

data/lib/mageo/triangle.rb

@@ -13,213 +13,212 @@ require "mageo/segment.rb"
 #  initialize 時に点の指定の順序を決めることで定義はできるが、
 #  そうすると簡潔性が損なわれる。
 class Triangle
-	attr_reader :vertices
-
-	class InitializeError < Exception; end
-	class LinearException < Exception; end
-	class TypeError < Exception; end
-	#class InPlaneError < Exception; end
-	class NoIntersectionError < Exception; end
-
-	#An argument 'vertices' can be Array of 3 items, Vector of 3 items,
-	# or Vector3D class instance, which have [] and map methods.
-	#当面は Array を前提とする。
-	#座標が整数で入っていたとしても内部的には Float に変換して使用する。
-	#3点が1直線上に並んでいて三角形を囲まない場合は
-	#例外 Triangle::LinearException を投げる。
-	def initialize( vertices )
-		raise InitializeError unless vertices.methods.include?( :size )
-		raise InitializeError if vertices.size != 3
-		vertices.each do |pos|
-			raise InitializeError if pos.size != 3
-			raise InitializeError unless pos.methods.include?( :[] )
-			raise InitializeError unless pos.methods.include?( :map )
-		end
-		@vertices = vertices.map do |pos| 
-			( pos.map { |i| i.to_f }) . to_v3d
-		end
-
-		#Checking on linear.
-		edge1 = @vertices[1] - @vertices[0]
-		edge2 = @vertices[2] - @vertices[0]
-		if ( Vector3D[0.0, 0.0, 0.0] == Vector3D.vector_product( edge1, edge2 ))
-			raise LinearException
-		end
-
-	end
-
-	#引数で与えられた 2 つの座標が、三角形の面に対して同じ側にあれば true を返す。
-	#どちらか、もしくは両方が、面上の点(当然頂点、辺上を含む)であれば必ず false を返す。
-	def same_side?( pos0, pos1 )
-		raise TypeError if pos0.class != Vector3D
-		raise TypeError if pos1.class != Vector3D
-
-		edge1 = @vertices[1] - @vertices[0]
-		edge2 = @vertices[2] - @vertices[0]
-		pos0  = pos0.to_v3d - @vertices[0]
-		pos1  = pos1.to_v3d - @vertices[0]
-
-		triple_product_pos0 = Vector3D.scalar_triple_product( edge1, edge2, pos0 )
-		triple_product_pos1 = Vector3D.scalar_triple_product( edge1, edge2, pos1 )
-		if triple_product_pos0 * triple_product_pos1 > 0
-			return true
-		else
-			return false
-		end
-	end
-
-	# 3点で張られる面上にあり、三角形の内側にあれば true を返す。
-	# pos が Vector3D クラスインスタンスでなければ例外。
-	# ただし、面の法線方向には tolerance だけの許容値を設ける。
-	# 計算誤差の問題のため、これを設定しないと殆ど真とならない。
-	def include?(pos, tolerance)
-		raise TypeError if pos.class != Vector3D
-
-		axes = internal_axes
-		#一次独立チェックは initialize 時にされている筈。
-
-		pos   = (pos - @vertices[0]).to_v3d
-		internal_pos = pos.to_v3di(axes)
-		return false if internal_pos[2].abs > tolerance #面の外にあれば false
-		return false if (internal_pos[0] < 0.0 )
-		return false if (1.0 < internal_pos[0])
-		return false if (internal_pos[1] < 0.0 )
-		return false if (1.0 < internal_pos[1])
-		return false if (1.0 < internal_pos[0] + internal_pos[1])
-		#たしざんで 1 いかとか。
-		return true
-	end
-
-	## 三角形と線分が交差するか判定する。
-	## 以下の and 条件になる。
-	## - 面と直線が並行でないこと。
-	## - 面と直線の交点が三角形の内側であること
-	## - 面と直線の交点が線分の長さ方向に関して線分と同じ領域にあること
-	#def intersect?(segment)
-	#	
-	#end
-
-	# 三角形を含む面と線分の交点を返す。
-	# 交点がない、無数にある、三角形の内側にない、という場合には
-	# 例外 NoIntersectionError を返す。
-	def intersection(segment, tolerance)
-		# 平行のとき、例外。
-		raise NoIntersectionError if parallel_segment?(segment)
-
-		# 面内の直線のとき、例外。
-		endpoints_v3di = segment.endpoints.map do |v|
-			(v - @vertices[0]).to_v3di(internal_axes)
-		end
-		if ( (endpoints_v3di[0][2] == 0.0) && (endpoints_v3di[1][2] == 0.0) )
-			raise NoIntersectionError
-		end
-
-		# 面と直線の交点を求める。
-		# endpoints_v3di をベクトルと見たとき、 c 軸成分が 0 になるのは
-		# ベクトルの何倍か？
-		# ゼロ割りになる条件は、ここまでに弾いた条件に含まれる筈。
-		c_0 = endpoints_v3di[0][2]
-		c_1 = endpoints_v3di[1][2]
-		factor = c_0 / (c_0 - c_1)
-		intersection = (segment.endpoints[0] + (segment.to_v3d) * factor)
-
-		# 交点が線分上にあるか？すなわち両端点が面を挟んでいるか？
-		raise NoIntersectionError if c_0 * c_1 > 0
-
-		# 交点が三角形の内側にあるか？
-		if (! include?(intersection, tolerance))
-			raise NoIntersectionError
-		end
-
-		return intersection
-	end
-
-	# 線分と並行であることを判定する。
-	# 線分が三角形の面内の場合は false になる。
-	def parallel_segment?(segment)
-		#p segment.endpoints
-		t = segment.endpoints.map{|v|
-			v.to_v3di(internal_axes)
-		}
-
-		# 傾いてるときは常に false
-		return false if t[0][2] != t[1][2]
-
-		# 傾きがない場合、面に含まれていれば false
-		return false if t[0][2] == 0.0
-
-		# 残った場合が true
-		return true
-	end
-
-	# 法線ベクトルの1つを返す。
-	# 法線ベクトルは正反対の方向を示す 2つがあるが、
-	# 内部的には頂点の順が右ねじとなる方向(正確には外積の定義される方向)
-	# のものが選ばれる。
-	# また、長さが1に規格化されたものが返される。
-	def normal_vector
-		edge1 = (@vertices[1] - @vertices[0])
-		edge2 = (@vertices[2] - @vertices[1])
-		vec = edge1.exterior_product( edge2 )
-		normal = vec * (1.0/vec.r)
-
-		return normal
-	end
-
-	# 3つの頂点の座標が順不同で対応すれば真を返す。
-	# other が Triangle クラス以外のインスタンスなら例外 Triangle::TypeError を投げる。
-	# MEMO:
-	# 当初 eql? という名前を付けていたが、
-	# これは hash メソッドと関連があるので危険。
-	# よって別の名前の equivalent? というメソッド名にした。
-	# しかし eql? に依存したコードが残っているので当面 alias を残す。
-	# そのうち obsolete する。
-	def equivalent?(other, tolerance = 0.0)
-		raise TypeError unless other.class == Triangle
-
-		vertices.each do |v_self|
-			if (other.vertices.find{|v_other| v_self.equal_in_delta?(v_other, tolerance) })
-				next
-			else
-				return false 
-			end
-		end
-		#return false unless other.vertices.include?(v)
-		return true
-		
-		#vertices.each do |v|
-		#	return false unless other.vertices.include?(v)
-		#end
-		#return true
-	end
-	alias eql? equivalent?
-
-	# 3つの頂点の座標が順序通りに対応すれば真を返す。
-	def ==(other)
-		vertices.size.times do |i|
-			return false unless @vertices[i] == other.vertices[i]
-		end
-		return true
-	end
-
-	def edges
-		results = []
-		results << Segment.new(@vertices[0], @vertices[1])
-		results << Segment.new(@vertices[1], @vertices[2])
-		results << Segment.new(@vertices[2], @vertices[0])
-		return results
-	end
-
-	private
-
-	# 三角形の2辺のベクトルと、これらからなる外積ベクトル、
-	# 合計3つのベクトルから Axes クラスインスタンスを作る。
-	# vertices で取り出せる3頂点のうち、0th 要素を原点とし、
-	# 1st, 2nd 要素をそれぞれ順に軸としたものとする。
-	def internal_axes
-		edge1 = (@vertices[1] - @vertices[0])
-		edge2 = (@vertices[2] - @vertices[0])
-		return Axes.new([edge1, edge2, normal_vector])
-	end
-
+  attr_reader :vertices
+
+  class InitializeError < Exception; end
+  class LinearException < Exception; end
+  class TypeError < Exception; end
+  #class InPlaneError < Exception; end
+  class NoIntersectionError < Exception; end
+
+  #An argument 'vertices' can be Array of 3 items, Vector of 3 items,
+  # or Vector3D class instance, which have [] and map methods.
+  #当面は Array を前提とする。
+  #座標が整数で入っていたとしても内部的には Float に変換して使用する。
+  #3点が1直線上に並んでいて三角形を囲まない場合は
+  #例外 Triangle::LinearException を投げる。
+  def initialize( vertices )
+    raise InitializeError unless vertices.methods.include?( :size )
+    raise InitializeError if vertices.size != 3
+    vertices.each do |pos|
+      raise InitializeError if pos.size != 3
+      raise InitializeError unless pos.methods.include?( :[] )
+      raise InitializeError unless pos.methods.include?( :map )
+    end
+    @vertices = vertices.map do |pos| 
+      ( pos.map { |i| i.to_f }) . to_v3d
+    end
+
+    #Checking on linear.
+    edge1 = @vertices[1] - @vertices[0]
+    edge2 = @vertices[2] - @vertices[0]
+    if ( Vector3D[0.0, 0.0, 0.0] == Vector3D.vector_product( edge1, edge2 ))
+      raise LinearException
+    end
+
+  end
+
+  #引数で与えられた 2 つの座標が、三角形の面に対して同じ側にあれば true を返す。
+  #どちらか、もしくは両方が、面上の点(当然頂点、辺上を含む)であれば必ず false を返す。
+  def same_side?( pos0, pos1 )
+    raise TypeError if pos0.class != Vector3D
+    raise TypeError if pos1.class != Vector3D
+
+    edge1 = @vertices[1] - @vertices[0]
+    edge2 = @vertices[2] - @vertices[0]
+    pos0  = pos0.to_v3d - @vertices[0]
+    pos1  = pos1.to_v3d - @vertices[0]
+
+    triple_product_pos0 = Vector3D.scalar_triple_product( edge1, edge2, pos0 )
+    triple_product_pos1 = Vector3D.scalar_triple_product( edge1, edge2, pos1 )
+    if triple_product_pos0 * triple_product_pos1 > 0
+      return true
+    else
+      return false
+    end
+  end
+
+  # 3点で張られる面上にあり、三角形の内側にあれば true を返す。
+  # pos が Vector3D クラスインスタンスでなければ例外。
+  # ただし、面の法線方向には tolerance だけの許容値を設ける。
+  # 計算誤差の問題のため、これを設定しないと殆ど真とならない。
+  def include?(pos, tolerance)
+    raise TypeError if pos.class != Vector3D
+
+    axes = internal_axes
+    #一次独立チェックは initialize 時にされている筈。
+
+    pos   = (pos - @vertices[0]).to_v3d
+    internal_pos = pos.to_v3di(axes)
+    return false if internal_pos[2].abs > tolerance #面の外にあれば false
+    return false if (internal_pos[0] < 0.0 )
+    return false if (1.0 < internal_pos[0])
+    return false if (internal_pos[1] < 0.0 )
+    return false if (1.0 < internal_pos[1])
+    return false if (1.0 < internal_pos[0] + internal_pos[1])
+    #たしざんで 1 いかとか。
+    return true
+  end
+
+  ## 三角形と線分が交差するか判定する。
+  ## 以下の and 条件になる。
+  ## - 面と直線が並行でないこと。
+  ## - 面と直線の交点が三角形の内側であること
+  ## - 面と直線の交点が線分の長さ方向に関して線分と同じ領域にあること
+  #def intersect?(segment)
+  # 
+  #end
+
+  # 三角形を含む面と線分の交点を返す。
+  # 交点がない、無数にある、三角形の内側にない、という場合には
+  # 例外 NoIntersectionError を返す。
+  def intersection(segment, tolerance)
+    # 平行のとき、例外。
+    raise NoIntersectionError if parallel_segment?(segment)
+
+    # 面内の直線のとき、例外。
+    endpoints_v3di = segment.endpoints.map do |v|
+      (v - @vertices[0]).to_v3di(internal_axes)
+    end
+    if ( (endpoints_v3di[0][2] == 0.0) && (endpoints_v3di[1][2] == 0.0) )
+      raise NoIntersectionError
+    end
+
+    # 面と直線の交点を求める。
+    # endpoints_v3di をベクトルと見たとき、 c 軸成分が 0 になるのは
+    # ベクトルの何倍か？
+    # ゼロ割りになる条件は、ここまでに弾いた条件に含まれる筈。
+    c_0 = endpoints_v3di[0][2]
+    c_1 = endpoints_v3di[1][2]
+    factor = c_0 / (c_0 - c_1)
+    intersection = (segment.endpoints[0] + (segment.to_v3d) * factor)
+
+    # 交点が線分上にあるか？すなわち両端点が面を挟んでいるか？
+    raise NoIntersectionError if c_0 * c_1 > 0
+
+    # 交点が三角形の内側にあるか？
+    if (! include?(intersection, tolerance))
+      raise NoIntersectionError
+    end
+
+    return intersection
+  end
+
+  # 線分と並行であることを判定する。
+  # 線分が三角形の面内の場合は false になる。
+  def parallel_segment?(segment)
+    #p segment.endpoints
+    t = segment.endpoints.map{|v|
+      v.to_v3di(internal_axes)
+    }
+
+    # 傾いてるときは常に false
+    return false if t[0][2] != t[1][2]
+
+    # 傾きがない場合、面に含まれていれば false
+    return false if t[0][2] == 0.0
+
+    # 残った場合が true
+    return true
+  end
+
+  # 法線ベクトルの1つを返す。
+  # 法線ベクトルは正反対の方向を示す 2つがあるが、
+  # 内部的には頂点の順が右ねじとなる方向(正確には外積の定義される方向)
+  # のものが選ばれる。
+  # また、長さが1に規格化されたものが返される。
+  def normal_vector
+    edge1 = (@vertices[1] - @vertices[0])
+    edge2 = (@vertices[2] - @vertices[1])
+    vec = edge1.exterior_product( edge2 )
+    normal = vec * (1.0/vec.r)
+
+    return normal
+  end
+
+  # 3つの頂点の座標が順不同で対応すれば真を返す。
+  # other が Triangle クラス以外のインスタンスなら例外 Triangle::TypeError を投げる。
+  # MEMO:
+  # 当初 eql? という名前を付けていたが、
+  # これは hash メソッドと関連があるので危険。
+  # よって別の名前の equivalent? というメソッド名にした。
+  # しかし eql? に依存したコードが残っているので当面 alias を残す。
+  # そのうち obsolete する。
+  def equivalent?(other, tolerance = 0.0)
+    raise TypeError unless other.class == Triangle
+
+    vertices.each do |v_self|
+      if (other.vertices.find{|v_other| v_self.equal_in_delta?(v_other, tolerance) })
+        next
+      else
+        return false 
+      end
+    end
+    #return false unless other.vertices.include?(v)
+    return true
+    
+    #vertices.each do |v|
+    # return false unless other.vertices.include?(v)
+    #end
+    #return true
+  end
+  alias eql? equivalent?
+
+  # 3つの頂点の座標が順序通りに対応すれば真を返す。
+  def ==(other)
+    vertices.size.times do |i|
+      return false unless @vertices[i] == other.vertices[i]
+    end
+    return true
+  end
+
+  def edges
+    results = []
+    results << Segment.new(@vertices[0], @vertices[1])
+    results << Segment.new(@vertices[1], @vertices[2])
+    results << Segment.new(@vertices[2], @vertices[0])
+    return results
+  end
+
+  private
+
+  # 三角形の2辺のベクトルと、これらからなる外積ベクトル、
+  # 合計3つのベクトルから Axes クラスインスタンスを作る。
+  # vertices で取り出せる3頂点のうち、0th 要素を原点とし、
+  # 1st, 2nd 要素をそれぞれ順に軸としたものとする。
+  def internal_axes
+    edge1 = (@vertices[1] - @vertices[0])
+    edge2 = (@vertices[2] - @vertices[0])
+    return Axes.new([edge1, edge2, normal_vector])
+  end
 end