gmath3D 0.2.1 → 0.2.2

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.2

data/gmath3D.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gmath3D}
-  s.version = "0.2.1"
+  s.version = "0.2.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Toshiyasu Shimizu"]
-  s.date = %q{2011-10-19}
+  s.date = %q{2011-10-25}
   s.description = %q{This library defines 3D geometric elements(point, line, plane etc..). It can get two(or more) elements relation, like distance between two elements.}
   s.email = %q{toshi0328@gmail.com}
   s.extra_rdoc_files = [
@@ -32,8 +32,10 @@ Gem::Specification.new do |s|
     "lib/line.rb",
     "lib/matrix_util.rb",
     "lib/plane.rb",
+    "lib/polyline.rb",
     "lib/quat.rb",
     "lib/rectangle.rb",
+    "lib/tri_mesh.rb",
     "lib/triangle.rb",
     "lib/util.rb",
     "lib/vector3.rb",
@@ -44,8 +46,10 @@ Gem::Specification.new do |s|
     "test/test_line.rb",
     "test/test_matrix_util.rb",
     "test/test_plane.rb",
+    "test/test_polyline.rb",
     "test/test_quat.rb",
     "test/test_rectangle.rb",
+    "test/test_tri_mesh.rb",
     "test/test_triangle.rb",
     "test/test_util.rb",
     "test/test_vector3.rb"

data/lib/box.rb

@@ -6,8 +6,8 @@ module GMath3D
   #
   class Box < Geom
 public
-    attr_accessor :min_point
-    attr_accessor :max_point
+    attr_reader :min_point
+    attr_reader :max_point
 
     # [Input]
     #  _point1_ and _point2_ should be Vector3.
@@ -51,7 +51,7 @@ public
     end
 
     # [Output]
-    #  return x length, y lenght and z length as [Numeric, Numeric, Numeric]
+    #  return width, height, depth as [Numeric, Numeric, Numeric]
     def length
       return max_point.x - min_point.x, max_point.y - min_point.y, max_point.z - min_point.z
     end

data/lib/finite_line.rb

@@ -21,6 +21,11 @@ public
       @end_point  = end_point
     end
 
+    def initialize_copy( original_obj )
+      @start_point = original_obj.start_point.dup
+      @end_point = original_obj.end_point.dup
+    end
+
     def to_s
       "FiniteLine[from#{start_point.to_element_s}, to#{end_point.to_element_s}]"
     end
@@ -31,7 +36,7 @@ public
     #  return true if rhs equals myself.
     def ==(rhs)
       return false if rhs == nil
-      Util.check_arg_type(FiniteLine, rhs)
+      return false if !rhs.kind_of?(FiniteLine)
       return false if( self.start_point != rhs.start_point)
       return false if( self.end_point != rhs.end_point)
       return true

data/lib/gmath3D.rb

@@ -12,3 +12,7 @@ require 'plane'
 require 'rectangle'
 require 'triangle'
 require 'box'
+
+require 'polyline'
+
+require 'tri_mesh'

data/lib/line.rb

@@ -25,6 +25,23 @@ module GMath3D
       @direction  = direction
     end
 
+    def initialize_copy( original_obj )
+      @base_point = original_obj.base_point.dup
+      @direction = original_obj.direction.dup
+    end
+
+    # [Input]
+    #  _rhs_ is Line.
+    # [Output]
+    #  return true if rhs equals myself.
+    def ==(rhs)
+      return false if rhs == nil
+      return false if( !rhs.kind_of?(Line) )
+      return false if( self.base_point != rhs.base_point)
+      return false if( self.direction != rhs.direction)
+      return true
+    end
+
     # [Input]
     #  _parameter_ should be Numeric.
     # [Output]

data/lib/plane.rb

@@ -21,6 +21,23 @@ public
       @normal = normal.normalize()
     end
 
+    def initialize_copy( original_obj )
+      @base_point = original_obj.base_point.dup
+      @normal = original_obj.normal.dup
+    end
+
+    # [Input]
+    #  _rhs_ is Plane.
+    # [Output]
+    #  return true if rhs equals myself.
+    def ==(rhs)
+      return false if rhs == nil
+      return false if( !rhs.kind_of?(Plane) )
+      return false if( self.base_point != rhs.base_point)
+      return false if( self.normal != rhs.normal)
+      return true
+    end
+
     def to_s
       "Plane[point#{@base_point.to_element_s}, normal#{@normal.to_element_s}]"
     end
@@ -39,7 +56,6 @@ public
     #   as [Numeric, Vector3, Vector3, Numeric].
     #  [in case _target_ is Plane]
     #   return "distance, intersect line" as [Numeric, Vector3].
-
     def distance(target)
       # with Point
       if(target.kind_of?(Vector3))

data/lib/polyline.rb

@@ -0,0 +1,71 @@
+require 'gmath3D'
+
+module GMath3D
+  #
+  # Polyline represents a closed or open polyline on 3D space.
+  #
+  class Polyline < Geom
+    public
+    attr_accessor :vertices
+    attr_accessor :is_open
+
+    # [Input]
+    #  _vertices_ should be Array of Vector3.
+    # [Output]
+    #  return new instance of Polyline.
+    def initialize(vertices = [], is_open = true)
+      Util.check_arg_type(Array, vertices)
+      super()
+      @vertices = vertices
+      @is_open  = is_open
+    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
+      @is_open = original_obj.is_open
+    end
+
+    # [Input]
+    #  _rhs_ is Polyline.
+    # [Output]
+    #  return true if rhs equals myself.
+    def ==(rhs)
+      return false if rhs == nil
+      return false if( !rhs.kind_of?(Polyline) )
+      return false if( self.is_open != rhs.is_open )
+      return false if(@vertices.size != rhs.vertices.size)
+      for i in 0..(@vertices.size-1)
+        return false if( self.vertices[i] != rhs.vertices[i])
+      end
+      return true
+    end
+
+    def to_s
+      str = "Polyline["
+      vertices.each do |vertex|
+        str += vertex.to_element_s + ", "
+      end
+      str.slice!(str.length - 2, 2) if(vertices.size > 0)
+      str += "] "
+      str += "open" if(@is_open)
+      str += "closed" if(!@is_open)
+      return str
+    end
+
+    # [Output]
+    #  return center point as Vector3.
+    def center
+      center = Vector3.new()
+      @vertices.each do |vertex|
+        center += vertex
+      end
+      center /= @vertices.size
+      return center
+    end
+
+  end
+end
+

data/lib/quat.rb

@@ -146,7 +146,7 @@ public
       tf = t1 + t2 + t3
       rtn_w = self.w * rhs.w - dot
 
-      return Quat.new(tf.x, tf.y, tf.z, rtn_w).normalize
+      return Quat.new(tf.x, tf.y, tf.z, rtn_w)
     end
 
     # [Input]
@@ -165,139 +165,6 @@ public
       z = pw * qz + px * qy - py * qx + pz * qw
       return Quat.new( x,y,z,w )
     end
-
-=begin
-    # [Input]
-    #  _rhs_ should be Vector3.
-    # [Output]
-    #  return subtracted result as Vector3.
-    def -(rhs)
-      subtract(rhs)
-    end
-
-
-    # [Input]
-    #  _rhs_ should be Numeric.
-    # [Output]
-    #  return divided result as Vector3.
-    def /(rhs)
-      divide(rhs)
-    end
-
-    # [Input]
-    #  _rhs_ should be Vector3.
-    # [Output]
-    #  return inner product as Numeric
-    def dot(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      self.x*rhs.x + self.y*rhs.y + self.z*rhs.z
-    end
-
-    # [Input]
-    #  _rhs_ should be Vector3.
-    # [Output]
-    #  return cross product as Vector3.
-    def cross(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      Vector3.new(
-              self.y*rhs.z - self.z*rhs.y,
-              self.z*rhs.x - self.x*rhs.z,
-              self.x*rhs.y - self.y*rhs.x)
-    end
-
-    # [Output]
-    #  return vector length as Numeric
-    def length
-      Math::sqrt(self.x*self.x + self.y*self.y + self.z*self.z)
-    end
-
-    # [Input]
-    #  _rhs_ should be Vector3.
-    # [Output]
-    #  return distance between two points as Numeric.
-    def distance(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      Math::sqrt((self.x - rhs.x)*(self.x - rhs.x) + (self.y - rhs.y)*(self.y - rhs.y) + (self.z - rhs.z)*(self.z - rhs.z))
-    end
-
-    # [Input]
-    #  _rhs_ should be Vector3.
-    # [Output]
-    #  return two vectors angle as Numeric (rad).
-    def angle(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      vec1Length = self.length ;
-      vec2Length = rhs.length   ;
-      return 0.0 if(vec1Length*vec2Length < self.tolerance )
-      v = self.dot(rhs)/(vec1Length*vec2Length)
-      Math::acos( v )
-    end
-
-    # [Output]
-    #  return normalized vector as Vector3
-    def normalize()
-      self / self.length.to_f
-    end
-
-    # [Input]
-    #  _rhs_ should be Vector3
-    # [Output]
-    #  return true if myself and rhs is parallel as boolean
-    def parallel?(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      return false if(self.length < self.tolerance or rhs.length < rhs.tolerance)
-      return false if(self.cross(rhs).length > self.tolerance)
-      return true
-    end
-
-    # [Input]
-    #  _rhs_ should be Vector3.
-    # [Output]
-    #  return true if myself and rhs have same direction as boolean.
-    def same_direction?(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      return false if(!parallel?(rhs))
-      return false if(self.dot(rhs) < self.tolerance)
-      return true
-    end
-
-    # This function projects self vector to rhs vector.
-    # [Input]
-    #  _rhs_ should be Vector3.
-    # [Output]
-    #  return projected result as Vector3.
-    def project_to(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      return Vector3.new, 0.0 if( rhs.length < rhs.tolerance )
-      parameter = self.dot( rhs ) / ( rhs.x * rhs.x + rhs.y * rhs.y + rhs.z * rhs.z ).to_f
-      return rhs*parameter, parameter
-    end
-
-    # [Output]
-    #  return column vector as Matrix
-    def to_column_vector
-      return Matrix.column_vector([x,y,z])
-    end
-
-    private
-
-    def add(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      Vector3.new(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z)
-    end
-    def subtract(rhs)
-      Util.check_arg_type(Vector3, rhs)
-      Vector3.new(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
-    end
-    def multiply(rhs)
-      Util.check_arg_type(::Numeric, rhs)
-      Vector3.new(self.x * rhs, self.y * rhs, self.z * rhs)
-    end
-    def divide(rhs)
-      Util.check_arg_type(::Numeric, rhs)
-      Vector3.new(self.x.to_f / rhs, self.y / rhs.to_f, self.z / rhs.to_f)
-    end
-=end
   end
 end
 

data/lib/rectangle.rb

@@ -27,6 +27,25 @@ public
       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
@@ -52,6 +71,17 @@ public
       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

data/lib/tri_mesh.rb

@@ -0,0 +1,240 @@
+require 'gmath3D'
+
+module GMath3D
+  #
+  # TriMesh represents an structured trianglular mesh.
+  #
+  class TriMesh < Geom
+    attr_reader :vertices
+    attr_reader :tri_indices
+
+    # [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
+      Util.check_arg_type(Array, vertices)
+      Util.check_arg_type(Array, tri_indices)
+      vertices.each do |item|
+        Util.check_arg_type(Vector3, item)
+      end
+      tri_indices.each do |tri_index|
+        Util.check_arg_type(Array, tri_index)
+        tri_index.each do |item|
+          Util.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)
+      Util.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)
+      Util.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)
+      Util.check_arg_type(Array, tris)
+      tris.each do | item |
+        Util.check_arg_type(Triangle, item)
+      end
+
+      tri_idx = 0
+      vert_tris_map = Hash.new(nil)
+      tris.each do | triangle |
+        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
+        tri_idx += 1
+      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
+  end
+end
+

data/lib/triangle.rb

@@ -20,6 +20,27 @@ public
       @vertices = Array.new([vertex1, vertex2, vertex3])
     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
+    end
+
+    # [Input]
+    #  _rhs_ is Line.
+    # [Output]
+    #  return true if rhs equals myself.
+    def ==(rhs)
+      return false if rhs == nil
+      return false if( !rhs.kind_of?(Triangle) )
+      return false if(@vertices.size != rhs.vertices.size)
+      for i in 0..@vertices.size-1
+        return false if(@vertices[i] != rhs.vertices[i])
+      end
+      return true
+    end
+
     def to_s
       "Triangle[#{@vertices[0].to_element_s}, #{@vertices[1].to_element_s}, #{@vertices[2].to_element_s}]"
     end
@@ -67,6 +88,12 @@ public
       return (vec1.cross(vec2).normalize)
     end
 
+    # [Output]
+    #  return normal vector reversed triangle
+    def reverse()
+      return Triangle.new(@vertices[0], @vertices[2], @vertices[1])
+    end
+
     # [Input]
     #  _check_point_ should be Vector3.
     # [Output]