gmath3D 0.2.3 → 0.2.4

data/Gemfile.lock

@@ -6,7 +6,7 @@ GEM
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
-    rake (0.9.2)
+    rake (0.9.2.2)
 
 PLATFORMS
   ruby

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.2.4

data/gmath3D.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gmath3D}
-  s.version = "0.2.3"
+  s.version = "0.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Toshiyasu Shimizu"]
-  s.date = %q{2011-11-03}
+  s.date = %q{2011-11-26}
   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 = [
@@ -27,11 +27,11 @@ Gem::Specification.new do |s|
     "gmath3D.gemspec",
     "lib/box.rb",
     "lib/ellipse.rb",
+    "lib/ext.rb",
     "lib/finite_line.rb",
     "lib/geom.rb",
     "lib/gmath3D.rb",
     "lib/line.rb",
-    "lib/matrix_util.rb",
     "lib/plane.rb",
     "lib/polyline.rb",
     "lib/quat.rb",

data/lib/box.rb

@@ -5,7 +5,6 @@ module GMath3D
   # Box represents an axitially aligned box on 3D space.
   #
   class Box < Geom
-public
     attr_reader :min_point
     attr_reader :max_point
 
@@ -15,8 +14,8 @@ public
     # [Output]
     #  return new instance of Box.
     def initialize(point1 = Vector3.new(0,0,0), point2 = Vector3.new(1,1,1))
-      Util.check_arg_type(Vector3, point1)
-      Util.check_arg_type(Vector3, point2)
+      Util3D.check_arg_type(Vector3, point1)
+      Util3D.check_arg_type(Vector3, point2)
       super()
       @min_point = Vector3.new();
       @max_point = Vector3.new();
@@ -75,6 +74,42 @@ public
       return width*height*depth
     end
 
+    # [Output]
+    #  return all vertices of Box.
+    def vertices
+      verts = Array.new(8)
+      length_ary = self.length
+      verts[0] = @min_point.clone
+      verts[1] = @min_point + Vector3.new(length_ary[0],             0,            0 )
+      verts[2] = @min_point + Vector3.new(length_ary[0], length_ary[1],            0 )
+      verts[3] = @min_point + Vector3.new(            0, length_ary[1],            0 )
+      verts[4] = @min_point + Vector3.new(            0,             0, length_ary[2])
+      verts[5] = @min_point + Vector3.new(length_ary[0],             0, length_ary[2])
+      verts[6] = @min_point + Vector3.new(length_ary[0], length_ary[1], length_ary[2])
+      verts[7] = @min_point + Vector3.new(            0, length_ary[1], length_ary[2])
+      return verts
+    end
+
+    # [input]
+    #  _vec_ should be Vector3.
+    # [Output]
+    #  return translated box as Box.
+    def translate(vec)
+      return Box.new(min_point + vec, max_point + vec)
+    end
+
+    # [input]
+    #  _quat_ should be Quat.
+    # [Output]
+    #  return rotated box as Box.
+    #  since Box is AABB, returned box might be bigger than original one.
+    def rotate(quat)
+      rot_matrix = Matrix.from_quat(quat)
+      verts = self.vertices
+      verts = verts.collect {|item| rot_matrix*item}
+      return Box.from_points(verts)
+    end
+
 private
     def equals_inner(rhs)
       return false if( !rhs.kind_of?(Box) )
@@ -103,7 +138,7 @@ private
         end
         return added_box
       end
-      Util.raise_argurment_error(rhs)
+      Util3D.raise_argurment_error(rhs)
     end
   end
 end

data/lib/ext.rb

@@ -0,0 +1,82 @@
+require 'gmath3D'
+require 'matrix'
+
+module GMath3D
+  class ::Matrix
+    def self.from_axis(axis, angle)
+      Util3D::check_arg_type(Vector3, axis)
+      Util3D::check_arg_type(Numeric, angle)
+
+      return Matrix[
+             [axis.x*axis.x*(1 - Math.cos(angle)) +        Math.cos(angle),
+                      axis.x*axis.y*(1 - Math.cos(angle)) + axis.z*Math.sin(angle),
+                      axis.x*axis.z*(1 - Math.cos(angle)) - axis.y*Math.sin(angle)],
+             [axis.x*axis.y*(1 - Math.cos(angle)) - axis.z*Math.sin(angle),
+                      axis.y*axis.y*(1 - Math.cos(angle)) +        Math.cos(angle),
+                      axis.y*axis.z*(1 - Math.cos(angle)) + axis.x*Math.sin(angle)],
+             [axis.x*axis.z*(1 - Math.cos(angle)) + axis.y*Math.sin(angle),
+                      axis.y*axis.z*(1 - Math.cos(angle)) - axis.x*Math.sin(angle),
+                      axis.z*axis.z*(1 - Math.cos(angle)) +        Math.cos(angle)]]
+    end
+
+    def self.from_quat(quat)
+      Util3D::check_arg_type(Quat, quat)
+      qw = quat.w
+      qx = quat.x
+      qy = quat.y
+      qz = quat.z
+
+      x2 = 2.0 * qx * qx;
+      y2 = 2.0 * qy * qy;
+      z2 = 2.0 * qz * qz;
+      xy = 2.0 * qx * qy;
+      yz = 2.0 * qy * qz;
+      zx = 2.0 * qz * qx;
+      wx = 2.0 * qw * qx;
+      wy = 2.0 * qw * qy;
+      wz = 2.0 * qw * qz;
+
+      return Matrix[
+             [ 1.0 - y2 - z2, xy + wz, zx - wy],
+             [ xy - wz, 1.0 - z2 - x2, yz + wx],
+             [ zx + wy, yz - wx, 1.0 - x2 - y2]]
+    end
+
+    alias_method :multi_inner, :*  # hold original multiply processing
+    def multi_new(rhs)
+      if(rhs.kind_of?(Vector3))
+        ans = self.multi_inner(rhs.to_column_vector)
+      return Vector3.new(ans[0,0], ans[1,0], ans[2,0])
+      end
+      multi_inner(rhs)
+    end
+    alias_method :*, :multi_new   # overwrite new multiply processing
+  end
+
+  class ::Array
+    def sum
+      s, n = self.sum_with_number
+      return s
+    end
+    def avg
+      s, n = self.sum_with_number
+      return s / n
+    end
+
+    def sum_with_number
+      return nil, 0 if(self.size <= 0)
+      s = nil
+      n = 0
+      self.each do |v|
+        next if v.nil?
+        if(s==nil)
+          s = v
+        else
+          s += v
+        end
+        n += 1
+      end
+      return s, n
+    end
+  end
+end

data/lib/finite_line.rb

@@ -16,8 +16,8 @@ public
     # [Output]
     #  return new instance as FiniteLine
     def initialize(start_point = Vector3.new(0,0,0), end_point = Vector3.new(1,0,0))
-      Util.check_arg_type(Vector3, start_point)
-      Util.check_arg_type(Vector3, end_point)
+      Util3D.check_arg_type(Vector3, start_point)
+      Util3D.check_arg_type(Vector3, end_point)
       super()
       @start_point = start_point
       @end_point  = end_point
@@ -105,12 +105,12 @@ public
       elsif(target.kind_of?(FiniteLine))
         return distance_to_finite_line(target)
       end
-      Util.raise_argurment_error(target)
+      Util3D.raise_argurment_error(target)
     end
 
     def self.ary_distanc_to_point(finite_lines, target_point)
-      Util.check_arg_type(::Array, finite_lines)
-      Util.check_arg_type(Vector3, target_point)
+      Util3D.check_arg_type(::Array, finite_lines)
+      Util3D.check_arg_type(Vector3, target_point)
       distance_ary = Array.new(0)
       points_ary   = Array.new(0)
       finite_lines.each do | item |
@@ -124,8 +124,8 @@ public
     end
 
     def self.ary_distance_to_line(finite_lines, target_line)
-      Util.check_arg_type(::Array, finite_lines)
-      Util.check_arg_type(Line, target_line)
+      Util3D.check_arg_type(::Array, finite_lines)
+      Util3D.check_arg_type(Line, target_line)
       distance_ary = Array.new(0)
       point_on_target_ary = Array.new(0)
       point_on_finite_line_ary = Array.new(0)

data/lib/gmath3D.rb

@@ -1,10 +1,12 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
 require 'util'
+require 'ext'
+
 require 'geom'
-require 'vector3'
 require 'quat'
-require 'matrix_util'
+
+require 'vector3'
 
 require 'line'
 require 'finite_line'

data/lib/line.rb

@@ -18,8 +18,8 @@ module GMath3D
     # [Output]
     #  return new instance of Line.
     def initialize(point = Vector3.new(0.0,0.0,0.0), direction = Vector3.new(1.0,0.0,0.0))
-      Util.check_arg_type(Vector3, point)
-      Util.check_arg_type(Vector3, direction)
+      Util3D.check_arg_type(Vector3, point)
+      Util3D.check_arg_type(Vector3, direction)
       super()
       @base_point = point
       @direction  = direction
@@ -47,7 +47,7 @@ module GMath3D
     # [Output]
     #  return a point on line at input parameter position as Vector3
     def point(parameter)
-      Util.check_arg_type(::Numeric, parameter)
+      Util3D.check_arg_type(::Numeric, parameter)
       @base_point + @direction*parameter
     end
 
@@ -69,7 +69,7 @@ module GMath3D
       elsif(target.kind_of?(Line))
         return distance_to_line(target)
       end
-      Util.raise_argurment_error(target)
+      Util3D.raise_argurment_error(target)
     end
 
     private

data/lib/plane.rb

@@ -5,7 +5,6 @@ module GMath3D
   # Plane represents a infinite plane on 3D space.
   #
   class Plane < Geom
-public
     attr_accessor:base_point
     attr_accessor:normal
 
@@ -14,8 +13,8 @@ public
     # [Output]
     #  returns new instance of Plane.
     def initialize(base_point = Vector3.new(), normal = Vector3.new(0,0,1))
-      Util.check_arg_type(::Vector3, normal)
-      Util.check_arg_type(::Vector3, base_point)
+      Util3D.check_arg_type(::Vector3, normal)
+      Util3D.check_arg_type(::Vector3, base_point)
       super()
       @base_point = base_point
       @normal = normal.normalize()
@@ -70,7 +69,7 @@ public
       elsif(target.kind_of?(Plane))
         return distance_to_plane(target)
       end
-      Util.raise_argurment_error(target)
+      Util3D.raise_argurment_error(target)
     end
 
     # [Input]
@@ -78,7 +77,7 @@ public
     # [Output]
     #  retrun projected point on plane as Vector3.
     def project( target_point )
-      Util.check_arg_type(::Vector3, target_point)
+      Util3D.check_arg_type(::Vector3, target_point)
       distance, closest_point = self.distance( target_point )
       return closest_point
     end

data/lib/polyline.rb

@@ -16,7 +16,7 @@ module GMath3D
     # [Output]
     #  return new instance of Polyline.
     def initialize(vertices = [], is_open = true)
-      Util.check_arg_type(Array, vertices)
+      Util3D.check_arg_type(Array, vertices)
       super()
       @vertices = vertices
       @is_open  = is_open

data/lib/quat.rb

@@ -16,10 +16,10 @@ public
     # [Output]
     #  return new instance of Quat.
     def initialize(x=0.0,y=0.0,z=0.0,w=0.0)
-      Util.check_arg_type(Numeric, x)
-      Util.check_arg_type(Numeric, y)
-      Util.check_arg_type(Numeric, z)
-      Util.check_arg_type(Numeric, w)
+      Util3D.check_arg_type(Numeric, x)
+      Util3D.check_arg_type(Numeric, y)
+      Util3D.check_arg_type(Numeric, z)
+      Util3D.check_arg_type(Numeric, w)
       super()
       @x = x
       @y = y
@@ -32,8 +32,8 @@ public
     # [Output]
     #  return new instance of Quat.
     def self.from_axis(axis, angle)
-      Util.check_arg_type(Vector3, axis)
-      Util.check_arg_type(Numeric, angle)
+      Util3D.check_arg_type(Vector3, axis)
+      Util3D.check_arg_type(Numeric, angle)
       s = Math.sin(0.5*angle)
       x = s * axis.x
       y = s * axis.y
@@ -134,7 +134,7 @@ public
     # [Output]
     #  return added result as Quat.
     def +(rhs)
-      Util.check_arg_type(Quat, rhs)
+      Util3D.check_arg_type(Quat, rhs)
       t1 = Vector3.new(self.x, self.y, self.z)
       t2 = Vector3.new(rhs.x, rhs.y, rhs.z)
       dot = t1.dot(t2)
@@ -154,7 +154,7 @@ public
     # [Output]
     #  return (outer products) multiplyed result as Quat.
     def *(rhs)
-      Util.check_arg_type(Quat, rhs)
+      Util3D.check_arg_type(Quat, rhs)
 
       pw = self.w; px = self.x; py = self.y; pz = self.z;
       qw = rhs.w ; qx = rhs.x ; qy = rhs.y ; qz = rhs.z;

data/lib/rectangle.rb

@@ -20,9 +20,9 @@ public
     # [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))
-      Util.check_arg_type(::Vector3, base_point_arg)
-      Util.check_arg_type(::Vector3, u_vector_arg)
-      Util.check_arg_type(::Vector3, v_vector_arg)
+      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
@@ -57,8 +57,8 @@ public
     # [Output]
     #  return point on rectangle as Vector3.
     def point(u, v)
-      Util.check_arg_type(::Numeric, u)
-      Util.check_arg_type(::Numeric, v)
+      Util3D.check_arg_type(::Numeric, u)
+      Util3D.check_arg_type(::Numeric, v)
       return base_point + u_vector*u + v_vector*v
     end
 
@@ -113,7 +113,7 @@ public
     # [Output]
     #  return u, v parametes on check_point as [Numeric, Numeric].
     def uv_parameter(check_point)
-      Util.check_arg_type(::Vector3, 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]]
@@ -134,7 +134,7 @@ public
         #with Line
 #        return distance_to_line(target)
       end
-      Util.raise_argurment_error(target)
+      Util3D.raise_argurment_error(target)
     end
 
 private

data/lib/tri_mesh.rb

@@ -17,15 +17,15 @@ module GMath3D
     #  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)
+      Util3D.check_arg_type(Array, vertices)
+      Util3D.check_arg_type(Array, tri_indices)
       vertices.each do |item|
-        Util.check_arg_type(Vector3, item)
+        Util3D.check_arg_type(Vector3, item)
       end
       tri_indices.each do |tri_index|
-        Util.check_arg_type(Array, tri_index)
+        Util3D.check_arg_type(Array, tri_index)
         tri_index.each do |item|
-          Util.check_arg_type(Integer, item)
+          Util3D.check_arg_type(Integer, item)
         end
       end
       super()
@@ -49,7 +49,7 @@ module GMath3D
     # [Output]
     #  return new instance of TriMesh.
     def self.from_box(box)
-      Util.check_arg_type(Box, box)
+      Util3D.check_arg_type(Box, box)
       width, height, depth = box.length()
       vertices = Array.new(8)
       vertices[0] = box.min_point
@@ -82,7 +82,7 @@ module GMath3D
     # [Output]
     #  return new instance of TriMesh.
     def self.from_rectangle(rect)
-      Util.check_arg_type(Rectangle, rect)
+      Util3D.check_arg_type(Rectangle, rect)
       return TriMesh.new(rect.vertices, [[0,1,3], [1,2,3]])
     end
 
@@ -91,19 +91,18 @@ module GMath3D
     # [Output]
     #  return new instance of TriMesh
     def self.from_triangles(tris)
-      Util.check_arg_type(Array, tris)
+      Util3D.check_arg_type(Array, tris)
       tris.each do | item |
-        Util.check_arg_type(Triangle, item)
+        Util3D.check_arg_type(Triangle, item)
       end
 
       tri_idx = 0
       vert_tris_map = Hash.new(nil)
-      tris.each do | triangle |
+      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
-        tri_idx += 1
       end
 
       tri_indices = Array.new( tris.size )
@@ -237,6 +236,23 @@ module GMath3D
       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
 

data/lib/triangle.rb

@@ -15,9 +15,9 @@ public
     # [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
@@ -52,7 +52,7 @@ public
     # [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
@@ -90,9 +90,23 @@ public
       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
 
@@ -101,7 +115,7 @@ public
     # [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]
@@ -171,7 +185,7 @@ public
       #with Plane
         return distance_to_plane(target)
       end
-      Util.raise_argurment_error(target)
+      Util3D.raise_argurment_error(target)
     end
 
     # [Input]
@@ -179,7 +193,7 @@ public
     # [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 )

data/lib/util.rb

@@ -1,16 +1,16 @@
-module GMath3D
-  class Util
-    def self.check_arg_type(type, instance)
-      unless(instance.kind_of?(type))
-        raise(ArgumentError::new("type mismatch: #{instance.class} for #{type}"))
-      end
+module Util3D
+  def self.check_arg_type(type, instance)
+    unless(instance.kind_of?(type))
+      raise(ArgumentError::new("type mismatch: #{instance.class} for #{type}"))
     end
+  end
 
-    def self.raise_argurment_error(instance)
-      raise(ArgumentError::new("type mismatch: #{instance.class}"))
-    end
+  def self.raise_argurment_error(instance)
+    raise(ArgumentError::new("type mismatch: #{instance.class}"))
   end
+end
 
+module GMath3D
   # Including 'vertices' methodshould be implimented that gets geometry vertices as Array of Vector3.
   module BoxAvailable
     # [Output]
@@ -21,30 +21,3 @@ module GMath3D
   end
 end
 
-class Array
-public
-  def sum
-    s, n = self.sum_with_number
-    return s
-  end
-  def avg
-    s, n = self.sum_with_number
-    return s / n
-  end
-
-  def sum_with_number
-    return nil, 0 if(self.size <= 0)
-    s = nil
-    n = 0
-    self.each do |v|
-      next if v.nil?
-      if(s==nil)
-        s = v
-      else
-        s += v
-      end
-      n += 1
-    end
-    return s, n
-  end
-end

data/lib/vector3.rb

@@ -6,7 +6,6 @@ module GMath3D
   # Vector3 represents a point or a vector on 3D space.
   #
   class Vector3 < Geom
-public
     attr_accessor :x
     attr_accessor :y
     attr_accessor :z
@@ -16,9 +15,9 @@ public
     # [Output]
     #  return new instance as Vector3.
     def initialize(x=0.0,y=0.0,z=0.0)
-      Util.check_arg_type(Numeric, x)
-      Util.check_arg_type(Numeric, y)
-      Util.check_arg_type(Numeric, z)
+      Util3D.check_arg_type(Numeric, x)
+      Util3D.check_arg_type(Numeric, y)
+      Util3D.check_arg_type(Numeric, z)
       super()
       @x = x
       @y = y
@@ -93,7 +92,7 @@ public
     # [Output]
     #  return inner product as Numeric
     def dot(rhs)
-      Util.check_arg_type(Vector3, rhs)
+      Util3D.check_arg_type(Vector3, rhs)
       self.x*rhs.x + self.y*rhs.y + self.z*rhs.z
     end
 
@@ -102,7 +101,7 @@ public
     # [Output]
     #  return cross product as Vector3.
     def cross(rhs)
-      Util.check_arg_type(Vector3, rhs)
+      Util3D.check_arg_type(Vector3, rhs)
       Vector3.new(
               self.y*rhs.z - self.z*rhs.y,
               self.z*rhs.x - self.x*rhs.z,
@@ -137,7 +136,7 @@ public
     # [Output]
     #  return distance between two points as Numeric.
     def distance(rhs)
-      Util.check_arg_type(Vector3, rhs)
+      Util3D.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
 
@@ -146,7 +145,7 @@ public
     # [Output]
     #  return two vectors angle as Numeric (rad).
     def angle(rhs)
-      Util.check_arg_type(Vector3, rhs)
+      Util3D.check_arg_type(Vector3, rhs)
       vec1Length = self.length ;
       vec2Length = rhs.length   ;
       return 0.0 if(vec1Length*vec2Length < self.tolerance )
@@ -165,7 +164,7 @@ public
     # [Output]
     #  return true if myself and rhs is parallel as boolean
     def parallel?(rhs)
-      Util.check_arg_type(Vector3, rhs)
+      Util3D.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
@@ -176,7 +175,7 @@ public
     # [Output]
     #  return true if myself and rhs have same direction as boolean.
     def same_direction?(rhs)
-      Util.check_arg_type(Vector3, rhs)
+      Util3D.check_arg_type(Vector3, rhs)
       return false if(!parallel?(rhs))
       return false if(self.dot(rhs) < self.tolerance)
       return true
@@ -188,7 +187,7 @@ public
     # [Output]
     #  return projected result as Vector3.
     def project_to(rhs)
-      Util.check_arg_type(Vector3, rhs)
+      Util3D.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
@@ -208,19 +207,19 @@ public
       true
     end
     def add(rhs)
-      Util.check_arg_type(Vector3, rhs)
+      Util3D.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)
+      Util3D.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)
+      Util3D.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)
+      Util3D.check_arg_type(::Numeric, rhs)
       Vector3.new(self.x.to_f / rhs, self.y / rhs.to_f, self.z / rhs.to_f)
     end
   end

data/test/test_box.rb

@@ -116,4 +116,52 @@ class BoxTestCase < MiniTest::Unit::TestCase
     assert_in_delta( 1.0, @box_default.volume, @box_default.tolerance )
     assert_in_delta( 112.5, @box.volume, @box.tolerance )
   end
+
+  def test_vertices
+    verts = @box_default.vertices
+    assert(verts.include?(Vector3.new(0,0,0)))
+    assert(verts.include?(Vector3.new(1,0,0)))
+    assert(verts.include?(Vector3.new(1,1,0)))
+    assert(verts.include?(Vector3.new(0,1,0)))
+    assert(verts.include?(Vector3.new(0,0,1)))
+    assert(verts.include?(Vector3.new(1,0,1)))
+    assert(verts.include?(Vector3.new(1,1,1)))
+    assert(verts.include?(Vector3.new(0,1,1)))
+
+    verts = @box.vertices #.new(-3,2,5), Vector3.new(2,-2.5, 0))
+    assert(verts.include?(Vector3.new(-3, -2.5, 0)))
+    assert(verts.include?(Vector3.new( 2, -2.5, 0)))
+    assert(verts.include?(Vector3.new( 2,  2.0, 0)))
+    assert(verts.include?(Vector3.new(-3,  2.0, 0)))
+    assert(verts.include?(Vector3.new(-3, -2.5, 5)))
+    assert(verts.include?(Vector3.new( 2, -2.5, 5)))
+    assert(verts.include?(Vector3.new( 2,  2.0, 5)))
+    assert(verts.include?(Vector3.new(-3,  2.0, 5)))
+  end
+
+  def test_translate
+    trans = Vector3.new(1,2.5,-0.5)
+    translated = @box_default.translate(trans)
+    assert_equal(Box.new(Vector3.new(1,2.5,-0.5), Vector3.new(2,3.5,0.5)), translated)
+
+    # this procedure is not destructive
+    assert_equal(Box.new(Vector3.new(0,0,0), Vector3.new(1,1,1)), @box_default)
+  end
+
+  def test_rotate
+    angle_90 = 90.0*Math::PI/180.0
+    angle_45 = 45.0*Math::PI/180.0
+    rotation1 = Quat.from_axis(Vector3.new(0,0,1), angle_90)
+    rotation2 = Quat.from_axis(Vector3.new(0,0,1), angle_45)
+#    rotation3 = Quat.from_axis(Vector3.new(1,1,1).normalize, angle_90)
+    rotated1 = @box_default.rotate(rotation1)
+    rotated2 = @box_default.rotate(rotation2)
+    assert_equal(Box.new(Vector3.new(0,-1,0), Vector3.new(1,0,1)), rotated1)
+    assert_equal(Box.new(
+                     Vector3.new(0, -(Math.sqrt(2.0)/2) ,0),
+                     Vector3.new(Math.sqrt(2.0), (Math.sqrt(2.0)/2) ,1)), rotated2)
+
+    # this procedure is not destructive
+    assert_equal(Box.new(Vector3.new(0,0,0), Vector3.new(1,1,1)), @box_default)
+  end
 end

data/test/test_tri_mesh.rb

@@ -173,4 +173,14 @@ class TriMeshTestCase < MiniTest::Unit::TestCase
     box_mesh = get_box_mesh()
     assert_equal(94, box_mesh.area)
   end
+
+  def test_normals_for_each_vertices
+    box = Box.new(Vector3.new(-1,-1,-1), Vector3.new(1,1,1))
+    box_mesh  = TriMesh.from_box(box)
+    result = box_mesh.normals_for_each_vertices
+    assert_equal( box_mesh.vertices.size, result.size )
+    box_mesh.vertices.each do |vertex|
+      assert_equal(vertex.normalize, result[vertex])
+    end
+  end
 end

data/test/test_triangle.rb

@@ -299,4 +299,20 @@ class TriangleTestCase < MiniTest::Unit::TestCase
     assert_equal( nil, point_on_triangle )
     assert_equal( nil, point_on_plane )
   end
+
+  def test_angle
+    triangle1 = Triangle.new( Vector3.new(0,0,1), Vector3.new(Math.sqrt(3.0),0,1), Vector3.new(0,1,1))
+    triangle2 = Triangle.new( Vector3.new(1,0,0), Vector3.new(0,0,1), Vector3.new(1,1,1))
+
+    assert_equal(nil, triangle1.angle(-1))
+    assert_equal(nil, triangle1.angle(3))
+
+    assert_in_delta(90.0*Math::PI/180.0, triangle1.angle(0), triangle1.tolerance)
+    assert_in_delta(30.0*Math::PI/180.0, triangle1.angle(1), triangle1.tolerance)
+    assert_in_delta(60.0*Math::PI/180.0, triangle1.angle(2), triangle1.tolerance)
+
+    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(0), triangle1.tolerance)
+    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(1), triangle1.tolerance)
+    assert_in_delta(60.0*Math::PI/180.0, triangle2.angle(2), triangle1.tolerance)
+  end
 end

data/test/test_util.rb

@@ -12,28 +12,28 @@ class UtilTestCase < MiniTest::Unit::TestCase
     stringInstance = 'string'
 
    # no exception raise
-    Util.check_arg_type(Integer, integerInstance)
-    Util.check_arg_type(Float, floatInstance)
-    Util.check_arg_type(String, stringInstance)
+    Util3D.check_arg_type(Integer, integerInstance)
+    Util3D.check_arg_type(Float, floatInstance)
+    Util3D.check_arg_type(String, stringInstance)
 
     # exception raise
     assert_raises ArgumentError do
-      Util.check_arg_type(Integer, floatInstance)
+      Util3D.check_arg_type(Integer, floatInstance)
     end
     assert_raises ArgumentError do
-      Util.check_arg_type(Integer, stringInstance)
+      Util3D.check_arg_type(Integer, stringInstance)
     end
     assert_raises ArgumentError do
-      Util.check_arg_type(Float, integerInstance)
+      Util3D.check_arg_type(Float, integerInstance)
     end
     assert_raises ArgumentError do
-      Util.check_arg_type(Float, stringInstance)
+      Util3D.check_arg_type(Float, stringInstance)
     end
     assert_raises ArgumentError do
-      Util.check_arg_type(String, integerInstance)
+      Util3D.check_arg_type(String, integerInstance)
     end
     assert_raises ArgumentError do
-      Util.check_arg_type(String, floatInstance)
+      Util3D.check_arg_type(String, floatInstance)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gmath3D
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-03 00:00:00.000000000 +09:00
+date: 2011-11-26 00:00:00.000000000 +09:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2156037040 !ruby/object:Gem::Requirement
+  requirement: &2151937640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2156037040
+  version_requirements: *2151937640
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2156035880 !ruby/object:Gem::Requirement
+  requirement: &2151936740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,7 +33,7 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *2156035880
+  version_requirements: *2151936740
 description: This library defines 3D geometric elements(point, line, plane etc..).
   It can get two(or more) elements relation, like distance between two elements.
 email: toshi0328@gmail.com
@@ -53,11 +53,11 @@ files:
 - gmath3D.gemspec
 - lib/box.rb
 - lib/ellipse.rb
+- lib/ext.rb
 - lib/finite_line.rb
 - lib/geom.rb
 - lib/gmath3D.rb
 - lib/line.rb
-- lib/matrix_util.rb
 - lib/plane.rb
 - lib/polyline.rb
 - lib/quat.rb
@@ -97,7 +97,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3556461112353261793
+      hash: -2832198732220705826
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/matrix_util.rb

@@ -1,55 +0,0 @@
-require 'gmath3D'
-require 'matrix'
-
-
-class Matrix
-  def self.from_axis(axis, angle)
-    Util.check_arg_type(Vector3, axis)
-    Util.check_arg_type(Numeric, angle)
-
-    return Matrix[
-           [axis.x*axis.x*(1 - Math.cos(angle)) +        Math.cos(angle),
-                    axis.x*axis.y*(1 - Math.cos(angle)) + axis.z*Math.sin(angle),
-                    axis.x*axis.z*(1 - Math.cos(angle)) - axis.y*Math.sin(angle)],
-           [axis.x*axis.y*(1 - Math.cos(angle)) - axis.z*Math.sin(angle),
-                    axis.y*axis.y*(1 - Math.cos(angle)) +        Math.cos(angle),
-                    axis.y*axis.z*(1 - Math.cos(angle)) + axis.x*Math.sin(angle)],
-           [axis.x*axis.z*(1 - Math.cos(angle)) + axis.y*Math.sin(angle),
-                    axis.y*axis.z*(1 - Math.cos(angle)) - axis.x*Math.sin(angle),
-                    axis.z*axis.z*(1 - Math.cos(angle)) +        Math.cos(angle)]]
-  end
-
-  def self.from_quat(quat)
-    Util.check_arg_type(Quat, quat)
-    qw = quat.w
-    qx = quat.x
-    qy = quat.y
-    qz = quat.z
-
-    x2 = 2.0 * qx * qx;
-    y2 = 2.0 * qy * qy;
-    z2 = 2.0 * qz * qz;
-    xy = 2.0 * qx * qy;
-    yz = 2.0 * qy * qz;
-    zx = 2.0 * qz * qx;
-    wx = 2.0 * qw * qx;
-    wy = 2.0 * qw * qy;
-    wz = 2.0 * qw * qz;
-
-    return Matrix[
-           [ 1.0 - y2 - z2, xy + wz, zx - wy],
-           [ xy - wz, 1.0 - z2 - x2, yz + wx],
-           [ zx + wy, yz - wx, 1.0 - x2 - y2]]
-  end
-
-  alias_method :multi_inner, :*  # hold original multiply processing
-  def multi_new(rhs)
-    if(rhs.kind_of?(Vector3))
-        ans = self.multi_inner(rhs.to_column_vector)
-      return Vector3.new(ans[0,0], ans[1,0], ans[2,0])
-    end
-    multi_inner(rhs)
-  end
-  alias_method :*, :multi_new   # overwrite new multiply processing
-end
-