gmath3D 0.2.5 → 1.0.0

data/lib/rectangle.rb

@@ -1,155 +1,155 @@
-require 'matrix'
-
-require 'gmath3D'
-
-module GMath3D
-  #
-  # Rectangle represents a four edged finite plane on 3D space.
-  #
-  class Rectangle < Geom
-public
-    attr_accessor:base_point
-    attr_accessor:u_vector
-    attr_accessor:v_vector
-
-    include BoxAvailable
-
-    # [Input]
-    #  _base_point_ , _u_vector_, _v_vector_ should be Vector3.
-    # _u_vector_ and _v_vector_ should be orthogonalized.
-    # [Output]
-    #  return new instance of Rectangle.
-    def initialize(base_point_arg = Vector3.new(), u_vector_arg = Vector3.new(1,0,0), v_vector_arg = Vector3.new(0,1,0))
-      Util3D.check_arg_type(::Vector3, base_point_arg)
-      Util3D.check_arg_type(::Vector3, u_vector_arg)
-      Util3D.check_arg_type(::Vector3, v_vector_arg)
-      super()
-      self.base_point = base_point_arg
-      self.u_vector = u_vector_arg
-      self.v_vector = v_vector_arg
-    end
-
-    def initialize_copy( original_obj )
-      @base_point = original_obj.base_point.dup
-      @u_vector = original_obj.u_vector.dup
-      @v_vector = original_obj.v_vector.dup
-    end
-
-    # [Input]
-    #  _rhs_ is Rectangle.
-    # [Output]
-    #  return true if rhs equals myself.
-    def ==(rhs)
-      return false if rhs == nil
-      return false if( !rhs.kind_of?(Rectangle) )
-      return false if( self.base_point != rhs.base_point)
-      return false if( self.u_vector != rhs.u_vector)
-      return false if( self.v_vector != rhs.v_vector)
-      return true
-    end
-
-    def to_s
-      "Rectangle[base#{@base_point.to_element_s}, u#{@u_vector.to_element_s}, v#{@v_vector.to_element_s}"
-    end
-
-    # [Input]
-    #  _u_, _v_ should be Numeric.
-    # [Output]
-    #  return point on rectangle as Vector3.
-    def point(u, v)
-      Util3D.check_arg_type(::Numeric, u)
-      Util3D.check_arg_type(::Numeric, v)
-      return base_point + u_vector*u + v_vector*v
-    end
-
-    # [Output]
-    #  return edges of rectangle as Array of FiniteLine.
-    def edges
-      edge_ary = Array.new(4)
-      edge_ary[0] = FiniteLine.new( base_point, base_point+u_vector)
-      edge_ary[1] = FiniteLine.new( base_point+u_vector, base_point+u_vector+v_vector)
-      edge_ary[2] = FiniteLine.new( base_point+u_vector+v_vector, base_point+v_vector)
-      edge_ary[3] = FiniteLine.new( base_point+v_vector, base_point)
-      return edge_ary
-    end
-
-    # [Output]
-    #  return vertices of rectangle as Array of Vector3.
-    def vertices
-      vertices = Array.new(4)
-      vertices[0] = base_point
-      vertices[1] = base_point+u_vector
-      vertices[2] = base_point+u_vector+v_vector
-      vertices[3] = base_point+v_vector
-      return vertices
-    end
-
-    # [Output]
-    #  return normal of rectangle as Vector3.
-    def normal
-      return (u_vector.cross(v_vector)).normalize()
-    end
-
-    # [Output]
-    #  return point of opposite to base_point as Vector3.
-    def opposite_point
-      return base_point + u_vector + v_vector
-    end
-
-    # [Output]
-    #  return center point as Vector3.
-    def center_point
-      return base_point + u_vector*0.5 + v_vector*0.5
-    end
-
-    # [Output]
-    #  return rectangle area as Numeric.
-    def area
-      return (u_vector.cross(v_vector)).length
-    end
-
-    # [Input]
-    #  _check_point_ shold be Vector3.
-    # [Output]
-    #  return u, v parametes on check_point as [Numeric, Numeric].
-    def uv_parameter(check_point)
-      Util3D.check_arg_type(::Vector3, check_point)
-      mat = Matrix[[u_vector.x, u_vector.y, u_vector.z],
-            [v_vector.x, v_vector.y, v_vector.z],
-            [normal.x, normal.y, normal.z]]
-      vec = (check_point - base_point).to_column_vector
-      ans = mat.t.inv*vec
-      return ans[0,0], ans[1,0]
-    end
-
-    # [Input]
-    #  _target_ shold be Vector3.
-    # [Output]
-    #  return "distance, point on rectangle" as [Numeric, Vector3].
-    def distance(target)
-      # with Point
-      if(target.kind_of?(Vector3))
-        return distance_to_point(target)
-      elsif(target.kind_of?(Line))
-        #with Line
-#        return distance_to_line(target)
-      end
-      Util3D.raise_argurment_error(target)
-    end
-
-private
-    def distance_to_point(check_point)
-      u,v = self.uv_parameter(check_point)
-      if(u >= 0 && u <= 1 && v >= 0 && v <= 1)
-        point_on_rect = self.point( u, v )
-        distance = point_on_rect.distance(check_point)
-        return distance, point_on_rect
-      end
-      # rectangle does not contain projected point
-      # check distance to FiniteLines
-      finite_lines = self.edges
-      return FiniteLine.ary_distanc_to_point(finite_lines, check_point)
-    end
-  end
-end
-
+require 'matrix'
+
+require 'gmath3D'
+
+module GMath3D
+  #
+  # Rectangle represents a four edged finite plane on 3D space.
+  #
+  class Rectangle < Geom
+public
+    attr_accessor:base_point
+    attr_accessor:u_vector
+    attr_accessor:v_vector
+
+    include BoxAvailable
+
+    # [Input]
+    #  _base_point_ , _u_vector_, _v_vector_ should be Vector3.
+    # _u_vector_ and _v_vector_ should be orthogonalized.
+    # [Output]
+    #  return new instance of Rectangle.
+    def initialize(base_point_arg = Vector3.new(), u_vector_arg = Vector3.new(1,0,0), v_vector_arg = Vector3.new(0,1,0))
+      Util3D.check_arg_type(::Vector3, base_point_arg)
+      Util3D.check_arg_type(::Vector3, u_vector_arg)
+      Util3D.check_arg_type(::Vector3, v_vector_arg)
+      super()
+      self.base_point = base_point_arg
+      self.u_vector = u_vector_arg
+      self.v_vector = v_vector_arg
+    end
+
+    def initialize_copy( original_obj )
+      @base_point = original_obj.base_point.dup
+      @u_vector = original_obj.u_vector.dup
+      @v_vector = original_obj.v_vector.dup
+    end
+
+    # [Input]
+    #  _rhs_ is Rectangle.
+    # [Output]
+    #  return true if rhs equals myself.
+    def ==(rhs)
+      return false if rhs == nil
+      return false if( !rhs.kind_of?(Rectangle) )
+      return false if( self.base_point != rhs.base_point)
+      return false if( self.u_vector != rhs.u_vector)
+      return false if( self.v_vector != rhs.v_vector)
+      return true
+    end
+
+    def to_s
+      "Rectangle[base#{@base_point.to_element_s}, u#{@u_vector.to_element_s}, v#{@v_vector.to_element_s}"
+    end
+
+    # [Input]
+    #  _u_, _v_ should be Numeric.
+    # [Output]
+    #  return point on rectangle as Vector3.
+    def point(u, v)
+      Util3D.check_arg_type(::Numeric, u)
+      Util3D.check_arg_type(::Numeric, v)
+      return base_point + u_vector*u + v_vector*v
+    end
+
+    # [Output]
+    #  return edges of rectangle as Array of FiniteLine.
+    def edges
+      edge_ary = Array.new(4)
+      edge_ary[0] = FiniteLine.new( base_point, base_point+u_vector)
+      edge_ary[1] = FiniteLine.new( base_point+u_vector, base_point+u_vector+v_vector)
+      edge_ary[2] = FiniteLine.new( base_point+u_vector+v_vector, base_point+v_vector)
+      edge_ary[3] = FiniteLine.new( base_point+v_vector, base_point)
+      return edge_ary
+    end
+
+    # [Output]
+    #  return vertices of rectangle as Array of Vector3.
+    def vertices
+      vertices = Array.new(4)
+      vertices[0] = base_point
+      vertices[1] = base_point+u_vector
+      vertices[2] = base_point+u_vector+v_vector
+      vertices[3] = base_point+v_vector
+      return vertices
+    end
+
+    # [Output]
+    #  return normal of rectangle as Vector3.
+    def normal
+      return (u_vector.cross(v_vector)).normalize()
+    end
+
+    # [Output]
+    #  return point of opposite to base_point as Vector3.
+    def opposite_point
+      return base_point + u_vector + v_vector
+    end
+
+    # [Output]
+    #  return center point as Vector3.
+    def center_point
+      return base_point + u_vector*0.5 + v_vector*0.5
+    end
+
+    # [Output]
+    #  return rectangle area as Numeric.
+    def area
+      return (u_vector.cross(v_vector)).length
+    end
+
+    # [Input]
+    #  _check_point_ shold be Vector3.
+    # [Output]
+    #  return u, v parametes on check_point as [Numeric, Numeric].
+    def uv_parameter(check_point)
+      Util3D.check_arg_type(::Vector3, check_point)
+      mat = Matrix[[u_vector.x, u_vector.y, u_vector.z],
+            [v_vector.x, v_vector.y, v_vector.z],
+            [normal.x, normal.y, normal.z]]
+      vec = (check_point - base_point).to_column_vector
+      ans = mat.t.inv*vec
+      return ans[0,0], ans[1,0]
+    end
+
+    # [Input]
+    #  _target_ shold be Vector3.
+    # [Output]
+    #  return "distance, point on rectangle" as [Numeric, Vector3].
+    def distance(target)
+      # with Point
+      if(target.kind_of?(Vector3))
+        return distance_to_point(target)
+      elsif(target.kind_of?(Line))
+        #with Line
+#        return distance_to_line(target)
+      end
+      Util3D.raise_argurment_error(target)
+    end
+
+private
+    def distance_to_point(check_point)
+      u,v = self.uv_parameter(check_point)
+      if(u >= 0 && u <= 1 && v >= 0 && v <= 1)
+        point_on_rect = self.point( u, v )
+        distance = point_on_rect.distance(check_point)
+        return distance, point_on_rect
+      end
+      # rectangle does not contain projected point
+      # check distance to FiniteLines
+      finite_lines = self.edges
+      return FiniteLine.ary_distanc_to_point(finite_lines, check_point)
+    end
+  end
+end
+

data/lib/tri_mesh.rb

@@ -1,258 +1,258 @@
-require 'gmath3D'
-
-module GMath3D
-  #
-  # TriMesh represents an structured trianglular mesh.
-  #
-  class TriMesh < Geom
-    attr_reader :vertices
-    attr_reader :tri_indices
-
-    include BoxAvailable
-
-    # [Input]
-    #  vertices is Array of Vector3.
-    #  tri_indices is Array of triangle whick is consist of 3 vertices index.
-    # [Output]
-    #  return new instance of TriMesh.
-    def initialize(vertices, tri_indices)
-      # check arg
-      Util3D.check_arg_type(Array, vertices)
-      Util3D.check_arg_type(Array, tri_indices)
-      vertices.each do |item|
-        Util3D.check_arg_type(Vector3, item)
-      end
-      tri_indices.each do |tri_index|
-        Util3D.check_arg_type(Array, tri_index)
-        tri_index.each do |item|
-          Util3D.check_arg_type(Integer, item)
-        end
-      end
-      super()
-      @vertices = vertices
-      @tri_indices = tri_indices
-    end
-
-    def initialize_copy( original_obj )
-      @vertices = Array.new(original_obj.vertices.size)
-      for i in 0..@vertices.size-1
-        @vertices[i] = original_obj.vertices[i].dup
-      end
-      @tri_indices = Array.new(original_obj.tri_indices.size)
-      for i in 0..@tri_indices.size-1
-        @tri_indices[i] = original_obj.tri_indices[i].dup
-      end
-    end
-
-    # [Input]
-    #  _box_ is a Box object.
-    # [Output]
-    #  return new instance of TriMesh.
-    def self.from_box(box)
-      Util3D.check_arg_type(Box, box)
-      width, height, depth = box.length()
-      vertices = Array.new(8)
-      vertices[0] = box.min_point
-      vertices[1] = box.min_point + Vector3.new(width, 0, 0)
-      vertices[2] = box.min_point + Vector3.new(width, 0, depth)
-      vertices[3] = box.min_point + Vector3.new(0    , 0, depth)
-      vertices[4] = box.min_point + Vector3.new(0    , height, 0)
-      vertices[5] = box.min_point + Vector3.new(width, height, 0)
-      vertices[6] = box.min_point + Vector3.new(width, height, depth)
-      vertices[7] = box.min_point + Vector3.new(0    , height, depth)
-
-      tri_indices =[
-        [0, 1, 2],
-        [0, 2, 3],
-        [1, 5, 6],
-        [1, 6, 2],
-        [5, 4, 7],
-        [5, 7, 6],
-        [4, 0, 3],
-        [4, 3, 7],
-        [2, 6, 7],
-        [2, 7, 3],
-        [0, 4, 5],
-        [0, 5, 1]]
-      return TriMesh.new( vertices, tri_indices )
-    end
-
-    # [Input]
-    #  _rect_ is a Rectangle object.
-    # [Output]
-    #  return new instance of TriMesh.
-    def self.from_rectangle(rect)
-      Util3D.check_arg_type(Rectangle, rect)
-      return TriMesh.new(rect.vertices, [[0,1,3], [1,2,3]])
-    end
-
-    # [Input]
-    #  _tris_ is Array of Triangle object.
-    # [Output]
-    #  return new instance of TriMesh
-    def self.from_triangles(tris)
-      Util3D.check_arg_type(Array, tris)
-      tris.each do | item |
-        Util3D.check_arg_type(Triangle, item)
-      end
-
-      tri_idx = 0
-      vert_tris_map = Hash.new(nil)
-      tris.each_with_index do | triangle, tri_idx |
-        triangle.vertices.each do | vertex |
-          vert_tris_map[vertex] = Array.new() if( !vert_tris_map.key?(vertex) )
-          vert_tris_map[vertex] = vert_tris_map[vertex].push(tri_idx)
-        end
-      end
-
-      tri_indices = Array.new( tris.size )
-      vertices = vert_tris_map.keys
-
-      vert_idx = 0
-      vert_tris_map.each do | vertex, tri_index_ary |
-        tri_index_ary.each do | tri_index |
-          tri_indices[tri_index] = Array.new() if( !tri_indices[tri_index] )
-          tri_indices[tri_index].push(vert_idx)
-        end
-        vert_idx += 1
-      end
-
-      # modify noamal direction
-      tri_idx = 0
-      tri_indices.each do | tri_index_ary |
-        if ( tri_index_ary.size > 2 )
-          tmp_tri = Triangle.new(vertices[tri_index_ary[0]], vertices[tri_index_ary[1]], vertices[tri_index_ary[2]])
-          if( tmp_tri.normal.dot(tris[tri_idx].normal) < 0 )
-            tri_index_ary.reverse!
-          end
-        end
-        tri_idx += 1
-      end
-
-      return TriMesh.new( vertices, tri_indices )
-    end
-
-    # [Input]
-    #  _polyline_ is Poyline object that should be convex.
-    # [Output]
-    #  return new instance of TriMesh
-    def self.from_convex_polyline(polyline)
-      trimesh_vertices = Array.new(polyline.vertices.size + 1)
-      trimesh_vertices[0] = polyline.center
-      i = 1
-      polyline.vertices.each do | poly_vert |
-        trimesh_vertices[i] = poly_vert.clone
-        i += 1
-      end
-      trimesh_tri_indices = Array.new(polyline.vertices.size)
-      for i in 0..polyline.vertices.size-1
-        trimesh_tri_indices[i] = [0,i+1,i+2]
-      end
-      trimesh_tri_indices[trimesh_tri_indices.size - 1] = [0,polyline.vertices.size,1]
-      return TriMesh.new( trimesh_vertices, trimesh_tri_indices )
-    end
-
-    # [Input]
-    #  _polyline_ is Poyline object.
-    #  _extrude_direction_ is Vector3.
-    # [Output]
-    #  return new instance of TriMesh that is extruded polyline
-    def self.from_extrude_polyline(polyline, extrude_direction)
-      trimesh_vertices = Array.new(polyline.vertices.size*2)
-      poly_vert_cnt = polyline.vertices.size
-      i = 0
-      polyline.vertices.each do | poly_vert |
-        trimesh_vertices[i] = poly_vert.clone
-        trimesh_vertices[i + poly_vert_cnt] = poly_vert + extrude_direction
-        i+=1
-      end
-
-      tri_indices_cnt = (poly_vert_cnt-1)*2
-      trimesh_tri_indices = Array.new(tri_indices_cnt)
-
-      for i in 0..poly_vert_cnt-2
-        trimesh_tri_indices[2*i    ] = [i,     i + 1,                 i + poly_vert_cnt]
-        trimesh_tri_indices[2*i + 1] = [i + 1, i + 1 + poly_vert_cnt, i + poly_vert_cnt]
-      end
-      if(!polyline.is_open)
-        trimesh_tri_indices[2*(poly_vert_cnt - 1)    ] = [poly_vert_cnt - 1, 0, 2*(poly_vert_cnt - 1) + 1]
-        trimesh_tri_indices[2*(poly_vert_cnt - 1) + 1] = [0, poly_vert_cnt, 2*(poly_vert_cnt - 1) + 1]
-      end
-      return TriMesh.new(trimesh_vertices, trimesh_tri_indices)
-    end
-
-    # [Input]
-    #  _rhs_ is TriMesh.
-    # [Output]
-    #  return true if rhs equals myself.
-    def ==(rhs)
-      return false if rhs == nil
-      return false if( !rhs.kind_of?(TriMesh) )
-      return false if(@vertices.size != rhs.vertices.size)
-      return false if(@tri_indices.size != rhs.tri_indices.size)
-
-      for i in 0..(@vertices.size-1)
-        return false if( @vertices[i] != rhs.vertices[i])
-      end
-
-      for i in 0..(@tri_indices.size-1)
-        return false if( @tri_indices[i] != rhs.tri_indices[i])
-      end
-      return true
-    end
-
-    def to_s
-      "TriMesh[triangle_count:#{tri_indices.size}, vertex_count:#{vertices.size}]"
-    end
-
-   # [Input]
-    #  _index_ is index of triangle.
-    # [Output]
-    #  return new instance of Triangle.
-    def triangle(index)
-      return nil if( index < 0 || @tri_indices.size <= index )
-      tri_index = @tri_indices[index]
-      return Triangle.new(vertices[tri_index[0]], vertices[tri_index[1]], vertices[tri_index[2]])
-    end
-
-    # [Output]
-    #  return Array of Triangle.
-    def triangles
-      tris = Array.new(tri_indices.size)
-      i = 0
-      tri_indices.each do |tri_index|
-        tris[i] =  self.triangle(i)
-        i += 1
-      end
-      return tris
-    end
-
-    # [Output]
-    #  return surface area of TriMesh.
-    def area
-      area_sum = 0
-      triangles.each do | tri |
-        area_sum += tri.area
-      end
-      return area_sum
-    end
-
-    # [Output]
-    #  return normal vector for each vertex as Hash{ Vector3 vertex => Vector3 normal_vector}.
-    def normals_for_each_vertices
-      normals_map = Hash.new(nil)
-      triangles.each_with_index do | tri, tri_idx |
-        tri.vertices.each_with_index do | vertex, ver_idx |
-          normals_map[vertex] = Vector3.new() if( !normals_map.key?(vertex) )
-          normals_map[vertex] += tri.normal*tri.angle(ver_idx)
-        end
-      end
-      normals_map.each do |vertex, normal|
-        normals_map[vertex] = normal.normalize
-      end
-      return  normals_map
-    end
-
-  end
-end
-
+require 'gmath3D'
+
+module GMath3D
+  #
+  # TriMesh represents an structured trianglular mesh.
+  #
+  class TriMesh < Geom
+    attr_reader :vertices
+    attr_reader :tri_indices
+
+    include BoxAvailable
+
+    # [Input]
+    #  vertices is Array of Vector3.
+    #  tri_indices is Array of triangle whick is consist of 3 vertices index.
+    # [Output]
+    #  return new instance of TriMesh.
+    def initialize(vertices, tri_indices)
+      # check arg
+      Util3D.check_arg_type(Array, vertices)
+      Util3D.check_arg_type(Array, tri_indices)
+      vertices.each do |item|
+        Util3D.check_arg_type(Vector3, item)
+      end
+      tri_indices.each do |tri_index|
+        Util3D.check_arg_type(Array, tri_index)
+        tri_index.each do |item|
+          Util3D.check_arg_type(Integer, item)
+        end
+      end
+      super()
+      @vertices = vertices
+      @tri_indices = tri_indices
+    end
+
+    def initialize_copy( original_obj )
+      @vertices = Array.new(original_obj.vertices.size)
+      for i in 0..@vertices.size-1
+        @vertices[i] = original_obj.vertices[i].dup
+      end
+      @tri_indices = Array.new(original_obj.tri_indices.size)
+      for i in 0..@tri_indices.size-1
+        @tri_indices[i] = original_obj.tri_indices[i].dup
+      end
+    end
+
+    # [Input]
+    #  _box_ is a Box object.
+    # [Output]
+    #  return new instance of TriMesh.
+    def self.from_box(box)
+      Util3D.check_arg_type(Box, box)
+      width, height, depth = box.length()
+      vertices = Array.new(8)
+      vertices[0] = box.min_point
+      vertices[1] = box.min_point + Vector3.new(width, 0, 0)
+      vertices[2] = box.min_point + Vector3.new(width, 0, depth)
+      vertices[3] = box.min_point + Vector3.new(0    , 0, depth)
+      vertices[4] = box.min_point + Vector3.new(0    , height, 0)
+      vertices[5] = box.min_point + Vector3.new(width, height, 0)
+      vertices[6] = box.min_point + Vector3.new(width, height, depth)
+      vertices[7] = box.min_point + Vector3.new(0    , height, depth)
+
+      tri_indices =[
+        [0, 1, 2],
+        [0, 2, 3],
+        [1, 5, 6],
+        [1, 6, 2],
+        [5, 4, 7],
+        [5, 7, 6],
+        [4, 0, 3],
+        [4, 3, 7],
+        [2, 6, 7],
+        [2, 7, 3],
+        [0, 4, 5],
+        [0, 5, 1]]
+      return TriMesh.new( vertices, tri_indices )
+    end
+
+    # [Input]
+    #  _rect_ is a Rectangle object.
+    # [Output]
+    #  return new instance of TriMesh.
+    def self.from_rectangle(rect)
+      Util3D.check_arg_type(Rectangle, rect)
+      return TriMesh.new(rect.vertices, [[0,1,3], [1,2,3]])
+    end
+
+    # [Input]
+    #  _tris_ is Array of Triangle object.
+    # [Output]
+    #  return new instance of TriMesh
+    def self.from_triangles(tris)
+      Util3D.check_arg_type(Array, tris)
+      tris.each do | item |
+        Util3D.check_arg_type(Triangle, item)
+      end
+
+      tri_idx = 0
+      vert_tris_map = Hash.new(nil)
+      tris.each_with_index do | triangle, tri_idx |
+        triangle.vertices.each do | vertex |
+          vert_tris_map[vertex] = Array.new() if( !vert_tris_map.key?(vertex) )
+          vert_tris_map[vertex] = vert_tris_map[vertex].push(tri_idx)
+        end
+      end
+
+      tri_indices = Array.new( tris.size )
+      vertices = vert_tris_map.keys
+
+      vert_idx = 0
+      vert_tris_map.each do | vertex, tri_index_ary |
+        tri_index_ary.each do | tri_index |
+          tri_indices[tri_index] = Array.new() if( !tri_indices[tri_index] )
+          tri_indices[tri_index].push(vert_idx)
+        end
+        vert_idx += 1
+      end
+
+      # modify noamal direction
+      tri_idx = 0
+      tri_indices.each do | tri_index_ary |
+        if ( tri_index_ary.size > 2 )
+          tmp_tri = Triangle.new(vertices[tri_index_ary[0]], vertices[tri_index_ary[1]], vertices[tri_index_ary[2]])
+          if( tmp_tri.normal.dot(tris[tri_idx].normal) < 0 )
+            tri_index_ary.reverse!
+          end
+        end
+        tri_idx += 1
+      end
+
+      return TriMesh.new( vertices, tri_indices )
+    end
+
+    # [Input]
+    #  _polyline_ is Poyline object that should be convex.
+    # [Output]
+    #  return new instance of TriMesh
+    def self.from_convex_polyline(polyline)
+      trimesh_vertices = Array.new(polyline.vertices.size + 1)
+      trimesh_vertices[0] = polyline.center
+      i = 1
+      polyline.vertices.each do | poly_vert |
+        trimesh_vertices[i] = poly_vert.clone
+        i += 1
+      end
+      trimesh_tri_indices = Array.new(polyline.vertices.size)
+      for i in 0..polyline.vertices.size-1
+        trimesh_tri_indices[i] = [0,i+1,i+2]
+      end
+      trimesh_tri_indices[trimesh_tri_indices.size - 1] = [0,polyline.vertices.size,1]
+      return TriMesh.new( trimesh_vertices, trimesh_tri_indices )
+    end
+
+    # [Input]
+    #  _polyline_ is Poyline object.
+    #  _extrude_direction_ is Vector3.
+    # [Output]
+    #  return new instance of TriMesh that is extruded polyline
+    def self.from_extrude_polyline(polyline, extrude_direction)
+      trimesh_vertices = Array.new(polyline.vertices.size*2)
+      poly_vert_cnt = polyline.vertices.size
+      i = 0
+      polyline.vertices.each do | poly_vert |
+        trimesh_vertices[i] = poly_vert.clone
+        trimesh_vertices[i + poly_vert_cnt] = poly_vert + extrude_direction
+        i+=1
+      end
+
+      tri_indices_cnt = (poly_vert_cnt-1)*2
+      trimesh_tri_indices = Array.new(tri_indices_cnt)
+
+      for i in 0..poly_vert_cnt-2
+        trimesh_tri_indices[2*i    ] = [i,     i + 1,                 i + poly_vert_cnt]
+        trimesh_tri_indices[2*i + 1] = [i + 1, i + 1 + poly_vert_cnt, i + poly_vert_cnt]
+      end
+      if(!polyline.is_open)
+        trimesh_tri_indices[2*(poly_vert_cnt - 1)    ] = [poly_vert_cnt - 1, 0, 2*(poly_vert_cnt - 1) + 1]
+        trimesh_tri_indices[2*(poly_vert_cnt - 1) + 1] = [0, poly_vert_cnt, 2*(poly_vert_cnt - 1) + 1]
+      end
+      return TriMesh.new(trimesh_vertices, trimesh_tri_indices)
+    end
+
+    # [Input]
+    #  _rhs_ is TriMesh.
+    # [Output]
+    #  return true if rhs equals myself.
+    def ==(rhs)
+      return false if rhs == nil
+      return false if( !rhs.kind_of?(TriMesh) )
+      return false if(@vertices.size != rhs.vertices.size)
+      return false if(@tri_indices.size != rhs.tri_indices.size)
+
+      for i in 0..(@vertices.size-1)
+        return false if( @vertices[i] != rhs.vertices[i])
+      end
+
+      for i in 0..(@tri_indices.size-1)
+        return false if( @tri_indices[i] != rhs.tri_indices[i])
+      end
+      return true
+    end
+
+    def to_s
+      "TriMesh[triangle_count:#{tri_indices.size}, vertex_count:#{vertices.size}]"
+    end
+
+   # [Input]
+    #  _index_ is index of triangle.
+    # [Output]
+    #  return new instance of Triangle.
+    def triangle(index)
+      return nil if( index < 0 || @tri_indices.size <= index )
+      tri_index = @tri_indices[index]
+      return Triangle.new(vertices[tri_index[0]], vertices[tri_index[1]], vertices[tri_index[2]])
+    end
+
+    # [Output]
+    #  return Array of Triangle.
+    def triangles
+      tris = Array.new(tri_indices.size)
+      i = 0
+      tri_indices.each do |tri_index|
+        tris[i] =  self.triangle(i)
+        i += 1
+      end
+      return tris
+    end
+
+    # [Output]
+    #  return surface area of TriMesh.
+    def area
+      area_sum = 0
+      triangles.each do | tri |
+        area_sum += tri.area
+      end
+      return area_sum
+    end
+
+    # [Output]
+    #  return normal vector for each vertex as Hash{ Vector3 vertex => Vector3 normal_vector}.
+    def normals_for_each_vertices
+      normals_map = Hash.new(nil)
+      triangles.each_with_index do | tri, tri_idx |
+        tri.vertices.each_with_index do | vertex, ver_idx |
+          normals_map[vertex] = Vector3.new() if( !normals_map.key?(vertex) )
+          normals_map[vertex] += tri.normal*tri.angle(ver_idx)
+        end
+      end
+      normals_map.each do |vertex, normal|
+        normals_map[vertex] = normal.normalize
+      end
+      return  normals_map
+    end
+
+  end
+end
+