triangle.rb in gmath3D-0.2.4

- old
+ new

@@ -13,13 +13,13 @@
     # [Input]
     #  _vertex1_, _vertex2_, _vertex3_ should be Vector3.
     # [Output]
     #  return new instance of Triangle.
     def initialize(vertex1 = Vector3.new(), vertex2 = Vector3.new(1,0,0), vertex3 = Vector3.new(0,1,0))
-      Util.check_arg_type(::Vector3, vertex1)
-      Util.check_arg_type(::Vector3, vertex2)
-      Util.check_arg_type(::Vector3, vertex3)
+      Util3D.check_arg_type(::Vector3, vertex1)
+      Util3D.check_arg_type(::Vector3, vertex2)
+      Util3D.check_arg_type(::Vector3, vertex3)
       super()
       @vertices = Array.new([vertex1, vertex2, vertex3])
     end
 
     def initialize_copy( original_obj )
@@ -50,11 +50,11 @@
     # [Input]
     #  _parameter_ should be three element Array of Numeric.
     # [Output]
     #  return point on triangle at parameter position as Vector3.
     def point( parameter )
-      Util.check_arg_type(::Array, parameter )
+      Util3D.check_arg_type(::Array, parameter )
       # TODO Argument check
       return self.vertices[0]*parameter[0] + self.vertices[1]*parameter[1] + self.vertices[2]*parameter[2]
     end
 
     # [Output]
@@ -88,22 +88,36 @@
       vec1 = self.vertices[1] - self.vertices[0]
       vec2 = self.vertices[2] - self.vertices[0]
       return (vec1.cross(vec2).normalize)
     end
 
+    # [Input]
+    #  _vertex_index_ should be 0..2.
     # [Output]
+    #  return angle as Numeric(radian).
+    def angle( vertex_index )
+      return nil if(vertex_index < 0 || vertex_index > 2)
+      vert1 = self.vertices[vertex_index]
+      vert2 = self.vertices[(vertex_index+1)%3]
+      vert3 = self.vertices[(vertex_index+2)%3]
+      vec1 = vert2 - vert1
+      vec2 = vert3 - vert1
+      vec1.angle(vec2)
+    end
+
+    # [Output]
     #  return normal vector reversed triangle
-    def reverse()
+    def reverse
       return Triangle.new(@vertices[0], @vertices[2], @vertices[1])
     end
 
     # [Input]
     #  _check_point_ should be Vector3.
     # [Output]
     #  return barycentric_coordinate on check_point as three element Array of Numeric.
     def barycentric_coordinate( check_point )
-      Util.check_arg_type(::Vector3, check_point)
+      Util3D.check_arg_type(::Vector3, check_point)
 
       v0 = @vertices[0]
       v1 = @vertices[1]
       v2 = @vertices[2]
 
@@ -169,18 +183,18 @@
         return distance_to_line(target)
       elsif(target.kind_of?(Plane))
       #with Plane
         return distance_to_plane(target)
       end
-      Util.raise_argurment_error(target)
+      Util3D.raise_argurment_error(target)
     end
 
     # [Input]
     #  _check_point_ shold be Vector3.
     # [Output]
     #  return true if triangle contains _check_point_.
     def contains?( check_point )
-      Util.check_arg_type(Vector3, check_point )
+      Util3D.check_arg_type(Vector3, check_point )
       plane = Plane.new( vertices[0], self.normal)
       distance, projected_point = plane.distance(check_point)
       return false if( distance > self.tolerance )
       g_coord = self.barycentric_coordinate(check_point)
       g_coord.each do |item|