gmath3D 0.2.4 → 0.2.5

data/lib/quat.rb

@@ -1,170 +1,170 @@
-require 'gmath3D'
-
-module GMath3D
-  #
-  # Quat represents quaternion.
-  #
-  class Quat
-public
-    attr_accessor :x
-    attr_accessor :y
-    attr_accessor :z
-    attr_accessor :w
-
-    # [Input]
-    #  _x_, _y_, _z_, _w_should be Numeric.
-    # [Output]
-    #  return new instance of Quat.
-    def initialize(x=0.0,y=0.0,z=0.0,w=0.0)
-      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
-      @z = z
-      @w = w
-    end
-
-    # [Input]
-    #  _axsi_ should be Vector3 and _angle_ should be Numeric.
-    # [Output]
-    #  return new instance of Quat.
-    def self.from_axis(axis, 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
-      z = s * axis.z
-      w = Math.cos(0.5*angle)
-      return Quat.new(x,y,z,w)
-    end
-
-    # [Input]
-    #  _matrix_ should be Matrix which row and column size are 3.
-    # [Output]
-    #  return new instance of Quat.
-    def self.from_matrix(mat)
-      fourWSquaredMinus1 = mat[0,0] + mat[1,1] + mat[2,2]
-      fourXSquaredMinus1 = mat[0,0] - mat[1,1] - mat[2,2]
-      fourYSquaredMinus1 = mat[1,1] - mat[0,0] - mat[2,2]
-      fourZSquaredMinus1 = mat[2,2] - mat[0,0] - mat[1,1]
-
-      biggestIndex = 0
-      fourBiggestSquaredMinus1 = fourWSquaredMinus1
-      if(fourXSquaredMinus1 > fourBiggestSquaredMinus1)
-        fourBiggestSquaredMinus1 = fourXSquaredMinus1
-        biggestIndex = 1
-      end
-      if(fourYSquaredMinus1 > fourBiggestSquaredMinus1)
-        fourBiggestSquaredMinus1 = fourYSquaredMinus1
-        biggestIndex = 2
-      end
-      if(fourZSquaredMinus1 > fourBiggestSquaredMinus1)
-        fourBiggestSquaredMinus1 = fourZSquaredMinus1
-        biggestIndex = 3
-      end
-
-      biggestVal = Math.sqrt(fourBiggestSquaredMinus1 + 1.0) * 0.5
-      multi = 0.25 / biggestVal
-
-      case biggestIndex
-      when 0
-        w = biggestVal
-        x = (mat[1,2] - mat[2,1]) *multi
-        y = (mat[2,0] - mat[0,2]) *multi
-        z = (mat[0,1] - mat[1,0]) *multi
-      when 1
-        x = biggestVal;
-        w = (mat[1,2] - mat[2,1]) *multi
-        y = (mat[0,1] + mat[1,0]) *multi
-        z = (mat[2,0] + mat[0,2]) *multi
-      when 2
-        y = biggestVal;
-        w = (mat[2,0] - mat[0,2]) *multi
-        x = (mat[0,1] + mat[1,0]) *multi
-        z = (mat[1,2] + mat[2,1]) *multi
-      when 3
-        z = biggestVal;
-        w = (mat[0,1] - mat[1,0]) *multi
-        x = (mat[2,0] + mat[0,2]) *multi
-        y = (mat[1,2] + mat[2,1]) *multi
-      end
-      return Quat.new(x,y,z,w)
-    end
-
-    def to_element_s
-      "[#{@x}, #{@y}, #{@z}, #{@w}]"
-    end
-
-    def to_s
-      "Quat" + to_element_s
-    end
-
-    # [Input]
-    #  _rhs_ should be Quat.
-    # [Output]
-    #  return true if rhs equals myself.
-    def ==(rhs)
-      return false if( !rhs.kind_of?(Quat) )
-      return false if(self.x != rhs.x)
-      return false if(self.y != rhs.y)
-      return false if(self.z != rhs.z)
-      return false if(self.w != rhs.w)
-      true
-    end
-
-    # [Output]
-    #  return conjugated Quat.
-    def conjugate
-      return Quat.new( -self.x, -self.y, -self.z, self.w)
-    end
-
-    # [Output]
-    #  return normalized result as Quat.
-    def normalize()
-      mag = Math.sqrt(self.x*self.x + self.y*self.y + self.z*self.z)
-      return Quat.new(self.x/mag, self.y/mag, self.z/mag, self.w/mag)
-    end
-
-    # [Input]
-    #  _rhs_ should be Quat.
-    # [Output]
-    #  return added result as Quat.
-    def +(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)
-      t3 = t2.cross(t1)
-
-      t1 *= rhs.w
-      t2 *= self.w
-
-      tf = t1 + t2 + t3
-      rtn_w = self.w * rhs.w - dot
-
-      return Quat.new(tf.x, tf.y, tf.z, rtn_w)
-    end
-
-    # [Input]
-    #  _rsh_ should be Quat.
-    # [Output]
-    #  return (outer products) multiplyed result as Quat.
-    def *(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;
-
-      w = pw * qw - px * qx - py * qy - pz * qz
-      x = pw * qx + px * qw + py * qz - pz * qy
-      y = pw * qy - px * qz + py * qw + pz * qx
-      z = pw * qz + px * qy - py * qx + pz * qw
-      return Quat.new( x,y,z,w )
-    end
-  end
-end
-
+require 'gmath3D'
+
+module GMath3D
+  #
+  # Quat represents quaternion.
+  #
+  class Quat
+public
+    attr_accessor :x
+    attr_accessor :y
+    attr_accessor :z
+    attr_accessor :w
+
+    # [Input]
+    #  _x_, _y_, _z_, _w_should be Numeric.
+    # [Output]
+    #  return new instance of Quat.
+    def initialize(x=0.0,y=0.0,z=0.0,w=0.0)
+      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
+      @z = z
+      @w = w
+    end
+
+    # [Input]
+    #  _axsi_ should be Vector3 and _angle_ should be Numeric.
+    # [Output]
+    #  return new instance of Quat.
+    def self.from_axis(axis, 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
+      z = s * axis.z
+      w = Math.cos(0.5*angle)
+      return Quat.new(x,y,z,w)
+    end
+
+    # [Input]
+    #  _matrix_ should be Matrix which row and column size are 3.
+    # [Output]
+    #  return new instance of Quat.
+    def self.from_matrix(mat)
+      fourWSquaredMinus1 = mat[0,0] + mat[1,1] + mat[2,2]
+      fourXSquaredMinus1 = mat[0,0] - mat[1,1] - mat[2,2]
+      fourYSquaredMinus1 = mat[1,1] - mat[0,0] - mat[2,2]
+      fourZSquaredMinus1 = mat[2,2] - mat[0,0] - mat[1,1]
+
+      biggestIndex = 0
+      fourBiggestSquaredMinus1 = fourWSquaredMinus1
+      if(fourXSquaredMinus1 > fourBiggestSquaredMinus1)
+        fourBiggestSquaredMinus1 = fourXSquaredMinus1
+        biggestIndex = 1
+      end
+      if(fourYSquaredMinus1 > fourBiggestSquaredMinus1)
+        fourBiggestSquaredMinus1 = fourYSquaredMinus1
+        biggestIndex = 2
+      end
+      if(fourZSquaredMinus1 > fourBiggestSquaredMinus1)
+        fourBiggestSquaredMinus1 = fourZSquaredMinus1
+        biggestIndex = 3
+      end
+
+      biggestVal = Math.sqrt(fourBiggestSquaredMinus1 + 1.0) * 0.5
+      multi = 0.25 / biggestVal
+
+      case biggestIndex
+      when 0
+        w = biggestVal
+        x = (mat[1,2] - mat[2,1]) *multi
+        y = (mat[2,0] - mat[0,2]) *multi
+        z = (mat[0,1] - mat[1,0]) *multi
+      when 1
+        x = biggestVal;
+        w = (mat[1,2] - mat[2,1]) *multi
+        y = (mat[0,1] + mat[1,0]) *multi
+        z = (mat[2,0] + mat[0,2]) *multi
+      when 2
+        y = biggestVal;
+        w = (mat[2,0] - mat[0,2]) *multi
+        x = (mat[0,1] + mat[1,0]) *multi
+        z = (mat[1,2] + mat[2,1]) *multi
+      when 3
+        z = biggestVal;
+        w = (mat[0,1] - mat[1,0]) *multi
+        x = (mat[2,0] + mat[0,2]) *multi
+        y = (mat[1,2] + mat[2,1]) *multi
+      end
+      return Quat.new(x,y,z,w)
+    end
+
+    def to_element_s
+      "[#{@x}, #{@y}, #{@z}, #{@w}]"
+    end
+
+    def to_s
+      "Quat" + to_element_s
+    end
+
+    # [Input]
+    #  _rhs_ should be Quat.
+    # [Output]
+    #  return true if rhs equals myself.
+    def ==(rhs)
+      return false if( !rhs.kind_of?(Quat) )
+      return false if(self.x != rhs.x)
+      return false if(self.y != rhs.y)
+      return false if(self.z != rhs.z)
+      return false if(self.w != rhs.w)
+      true
+    end
+
+    # [Output]
+    #  return conjugated Quat.
+    def conjugate
+      return Quat.new( -self.x, -self.y, -self.z, self.w)
+    end
+
+    # [Output]
+    #  return normalized result as Quat.
+    def normalize()
+      mag = Math.sqrt(self.x*self.x + self.y*self.y + self.z*self.z)
+      return Quat.new(self.x/mag, self.y/mag, self.z/mag, self.w/mag)
+    end
+
+    # [Input]
+    #  _rhs_ should be Quat.
+    # [Output]
+    #  return added result as Quat.
+    def +(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)
+      t3 = t2.cross(t1)
+
+      t1 *= rhs.w
+      t2 *= self.w
+
+      tf = t1 + t2 + t3
+      rtn_w = self.w * rhs.w - dot
+
+      return Quat.new(tf.x, tf.y, tf.z, rtn_w)
+    end
+
+    # [Input]
+    #  _rsh_ should be Quat.
+    # [Output]
+    #  return (outer products) multiplyed result as Quat.
+    def *(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;
+
+      w = pw * qw - px * qx - py * qy - pz * qz
+      x = pw * qx + px * qw + py * qz - pz * qy
+      y = pw * qy - px * qz + py * qw + pz * qx
+      z = pw * qz + px * qy - py * qx + pz * qw
+      return Quat.new( x,y,z,w )
+    end
+  end
+end
+

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
+