gmath3D 0.2.4 → 0.2.5

data/lib/line.rb

@@ -1,122 +1,122 @@
-require 'gmath3D'
-
-module GMath3D
-  #
-  # Line represents a infinite line on 3D space.
-  #
-  class Line < Geom
-    public
-    attr_accessor :base_point
-    attr_accessor :direction
-
-    def to_s
-      "Line[point#{@base_point.to_element_s}, vector#{@direction.to_element_s}"
-    end
-
-    # [Input]
-    #  _point_ and _direction_ should be Vector3.
-    # [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))
-      Util3D.check_arg_type(Vector3, point)
-      Util3D.check_arg_type(Vector3, direction)
-      super()
-      @base_point = point
-      @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]
-    #  return a point on line at input parameter position as Vector3
-    def point(parameter)
-      Util3D.check_arg_type(::Numeric, parameter)
-      @base_point + @direction*parameter
-    end
-
-    # This function returns closest distance between Line and anothor element.
-    # [Input]
-    #  _target_ should be Vector3 or Line.
-    #
-    # [Output]
-    #  [in case _target_ is Vector3]
-    #   return "distance, closest point on myself, parameter on myself" as [Numeric, Vector3, Numeric]
-    #  [in case _target_ is Line]
-    #   return "distance, point on myself, point on target, parameter on myself, parameter on tatget" 
-    #   as [Numeric, Vector3, Vector3, Numeric, Numeric]
-    def distance(target)
-      # with Point
-      if(target.kind_of?(Vector3))
-        return distance_to_point(target)
-        #with Line
-      elsif(target.kind_of?(Line))
-        return distance_to_line(target)
-      end
-      Util3D.raise_argurment_error(target)
-    end
-
-    private
-    def distance_to_point(target_point)
-      point_on_line1 = self.base_point
-      point_on_line2 = self.base_point + self.direction
-
-      vecAB = point_on_line2 - point_on_line1
-      vecAP = target_point - point_on_line1
-      vecAQ, parameter = vecAP.project_to(vecAB)
-      cross_point = point_on_line1 + vecAQ
-      vecPQ = vecAQ - vecAP
-      return vecPQ.length, cross_point, parameter
-    end
-
-    def distance_to_line(target_line)
-      if(self.direction.parallel?(target_line.direction)) then
-        distanceInfo = self.distance(target_line.base_point)
-        return distanceInfo[0], nil, nil, nil, nil
-      else
-        line1_point1 = self.base_point
-        line1_point2 = self.base_point + self.direction
-        line2_point1 = target_line.base_point
-        line2_point2 = target_line.base_point + target_line.direction
-
-        vec_da = line1_point2 - line1_point1
-        vec_db = line2_point2 - line2_point1
-        vec_ab = line2_point1 - line1_point1
-
-        abs_vec_db = vec_db.length*vec_db.length
-        abs_vec_da = vec_da.length*vec_da.length
-
-        delta = (abs_vec_da*abs_vec_db - vec_da.dot( vec_db )*vec_da.dot( vec_db ))
-
-        if( delta < self.tolerance )
-          # TODO ASSERT(false)
-          return nil
-        end
-        parameter1 = (abs_vec_db*vec_ab.dot(vec_da) - vec_da.dot( vec_db )*vec_ab.dot( vec_db ) ) / delta
-        parameter2 = (vec_da.dot( vec_db )*vec_ab.dot( vec_da ) - abs_vec_da*vec_ab.dot( vec_db ))/ delta
-
-        line1_closest_point = line1_point1 + vec_da*parameter1
-        line2_closest_point = line2_point1 + vec_db*parameter2
-        distance = line1_closest_point.distance( line2_closest_point )
-        return distance, line1_closest_point, line2_closest_point, parameter1, parameter2
-      end
-    end
-  end
-end
-
+require 'gmath3D'
+
+module GMath3D
+  #
+  # Line represents a infinite line on 3D space.
+  #
+  class Line < Geom
+    public
+    attr_accessor :base_point
+    attr_accessor :direction
+
+    def to_s
+      "Line[point#{@base_point.to_element_s}, vector#{@direction.to_element_s}"
+    end
+
+    # [Input]
+    #  _point_ and _direction_ should be Vector3.
+    # [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))
+      Util3D.check_arg_type(Vector3, point)
+      Util3D.check_arg_type(Vector3, direction)
+      super()
+      @base_point = point
+      @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]
+    #  return a point on line at input parameter position as Vector3
+    def point(parameter)
+      Util3D.check_arg_type(::Numeric, parameter)
+      @base_point + @direction*parameter
+    end
+
+    # This function returns closest distance between Line and anothor element.
+    # [Input]
+    #  _target_ should be Vector3 or Line.
+    #
+    # [Output]
+    #  [in case _target_ is Vector3]
+    #   return "distance, closest point on myself, parameter on myself" as [Numeric, Vector3, Numeric]
+    #  [in case _target_ is Line]
+    #   return "distance, point on myself, point on target, parameter on myself, parameter on tatget" 
+    #   as [Numeric, Vector3, Vector3, Numeric, Numeric]
+    def distance(target)
+      # with Point
+      if(target.kind_of?(Vector3))
+        return distance_to_point(target)
+        #with Line
+      elsif(target.kind_of?(Line))
+        return distance_to_line(target)
+      end
+      Util3D.raise_argurment_error(target)
+    end
+
+    private
+    def distance_to_point(target_point)
+      point_on_line1 = self.base_point
+      point_on_line2 = self.base_point + self.direction
+
+      vecAB = point_on_line2 - point_on_line1
+      vecAP = target_point - point_on_line1
+      vecAQ, parameter = vecAP.project_to(vecAB)
+      cross_point = point_on_line1 + vecAQ
+      vecPQ = vecAQ - vecAP
+      return vecPQ.length, cross_point, parameter
+    end
+
+    def distance_to_line(target_line)
+      if(self.direction.parallel?(target_line.direction)) then
+        distanceInfo = self.distance(target_line.base_point)
+        return distanceInfo[0], nil, nil, nil, nil
+      else
+        line1_point1 = self.base_point
+        line1_point2 = self.base_point + self.direction
+        line2_point1 = target_line.base_point
+        line2_point2 = target_line.base_point + target_line.direction
+
+        vec_da = line1_point2 - line1_point1
+        vec_db = line2_point2 - line2_point1
+        vec_ab = line2_point1 - line1_point1
+
+        abs_vec_db = vec_db.length*vec_db.length
+        abs_vec_da = vec_da.length*vec_da.length
+
+        delta = (abs_vec_da*abs_vec_db - vec_da.dot( vec_db )*vec_da.dot( vec_db ))
+
+        if( delta < self.tolerance )
+          # TODO ASSERT(false)
+          return nil
+        end
+        parameter1 = (abs_vec_db*vec_ab.dot(vec_da) - vec_da.dot( vec_db )*vec_ab.dot( vec_db ) ) / delta
+        parameter2 = (vec_da.dot( vec_db )*vec_ab.dot( vec_da ) - abs_vec_da*vec_ab.dot( vec_db ))/ delta
+
+        line1_closest_point = line1_point1 + vec_da*parameter1
+        line2_closest_point = line2_point1 + vec_db*parameter2
+        distance = line1_closest_point.distance( line2_closest_point )
+        return distance, line1_closest_point, line2_closest_point, parameter1, parameter2
+      end
+    end
+  end
+end
+

data/lib/plane.rb

@@ -1,131 +1,131 @@
-require 'gmath3D'
-
-module GMath3D
-  #
-  # Plane represents a infinite plane on 3D space.
-  #
-  class Plane < Geom
-    attr_accessor:base_point
-    attr_accessor:normal
-
-    # [Input]
-    #  _base_point_ and _normal_ should be Vector3.
-    # [Output]
-    #  returns new instance of Plane.
-    def initialize(base_point = Vector3.new(), normal = Vector3.new(0,0,1))
-      Util3D.check_arg_type(::Vector3, normal)
-      Util3D.check_arg_type(::Vector3, base_point)
-      super()
-      @base_point = base_point
-      @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
-
-    # This function returns closest distance between Line and anothor element.
-    # [Input]
-    #  _target_ should be Vector3 or Line or FiniteLine or Plane.
-    #
-    # [Output]
-    #  [in case _target_ is Vector3]
-    #   return "distance, closest point on myself" as [Numeric, Vector3].
-    #  [in case _target_ is Line]
-    #   return "distance, intersect point, parameter on tatget" as [Numeric, Vector3, Numeric].
-    #  [in case _target_ is FiniteLine]
-    #   return "distance, point on plane, point on target, parameter on target"
-    #   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))
-        return distance_to_point(target)
-      #with Line
-      elsif(target.kind_of?(Line))
-        return distance_to_line(target)
-      #with FiniteLine
-      elsif(target.kind_of?(FiniteLine))
-        return distance_to_finite_line(target)
-      #with Plane
-      elsif(target.kind_of?(Plane))
-        return distance_to_plane(target)
-      end
-      Util3D.raise_argurment_error(target)
-    end
-
-    # [Input]
-    #  _target_point_ should be Vector3.
-    # [Output]
-    #  retrun projected point on plane as Vector3.
-    def project( target_point )
-      Util3D.check_arg_type(::Vector3, target_point)
-      distance, closest_point = self.distance( target_point )
-      return closest_point
-    end
-private
-    def distance_to_point(target_point)
-      vector_QA = target_point - @base_point
-      distance = vector_QA.dot(@normal)
-      closest_point = target_point - @normal*distance
-      return distance.abs, closest_point
-    end
-
-    def distance_to_line(target_line)
-      inner_product_normal_and_line_vec = target_line.direction.dot(self.normal)
-      #parallel
-      if( inner_product_normal_and_line_vec.abs < @tolerance)
-        distance, closest_point = self.distance(target_line.base_point)
-        return distance, nil,nil
-      end
-      parameter = ( self.normal.dot(self.base_point) - self.normal.dot( target_line.base_point ) )/inner_product_normal_and_line_vec.to_f
-      intersect_point = target_line.point(parameter)
-      return 0.0, intersect_point, parameter
-    end
-
-    def distance_to_finite_line(target_finite_line)
-      target_infinite_line = Line.new(target_finite_line.start_point, target_finite_line.direction)
-      distance, intersect_point, parameter = self.distance(target_infinite_line)
-      point_on_line = intersect_point
-      point_on_plane = intersect_point
-      if(parameter != nil and (parameter < 0 or 1 < parameter))
-        parameter = [0, parameter].max
-        parameter = [1, parameter].min
-        point_on_line = target_finite_line.point(parameter)
-        distance, point_on_plane = self.distance(point_on_line)
-      end
-      return distance, point_on_plane, point_on_line, parameter
-    end
-    def distance_to_plane(target_plane)
-      line_vector = target_plane.normal.cross(self.normal)
-      if(target_plane.normal.parallel?(self.normal))
-        distance, point_on_plane = self.distance(target_plane.base_point)
-        return distance, nil
-      end
-      line_vector = line_vector.normalize()
-      tangent_vector_on_target_plane = line_vector.cross(target_plane.normal)
-      distance, intersect_point, parameter = self.distance(Line.new( target_plane.base_point, tangent_vector_on_target_plane))
-      intersect_line = Line.new(intersect_point, line_vector)
-      return 0, intersect_line
-    end
-  end
-end
-
+require 'gmath3D'
+
+module GMath3D
+  #
+  # Plane represents a infinite plane on 3D space.
+  #
+  class Plane < Geom
+    attr_accessor:base_point
+    attr_accessor:normal
+
+    # [Input]
+    #  _base_point_ and _normal_ should be Vector3.
+    # [Output]
+    #  returns new instance of Plane.
+    def initialize(base_point = Vector3.new(), normal = Vector3.new(0,0,1))
+      Util3D.check_arg_type(::Vector3, normal)
+      Util3D.check_arg_type(::Vector3, base_point)
+      super()
+      @base_point = base_point
+      @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
+
+    # This function returns closest distance between Line and anothor element.
+    # [Input]
+    #  _target_ should be Vector3 or Line or FiniteLine or Plane.
+    #
+    # [Output]
+    #  [in case _target_ is Vector3]
+    #   return "distance, closest point on myself" as [Numeric, Vector3].
+    #  [in case _target_ is Line]
+    #   return "distance, intersect point, parameter on tatget" as [Numeric, Vector3, Numeric].
+    #  [in case _target_ is FiniteLine]
+    #   return "distance, point on plane, point on target, parameter on target"
+    #   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))
+        return distance_to_point(target)
+      #with Line
+      elsif(target.kind_of?(Line))
+        return distance_to_line(target)
+      #with FiniteLine
+      elsif(target.kind_of?(FiniteLine))
+        return distance_to_finite_line(target)
+      #with Plane
+      elsif(target.kind_of?(Plane))
+        return distance_to_plane(target)
+      end
+      Util3D.raise_argurment_error(target)
+    end
+
+    # [Input]
+    #  _target_point_ should be Vector3.
+    # [Output]
+    #  retrun projected point on plane as Vector3.
+    def project( target_point )
+      Util3D.check_arg_type(::Vector3, target_point)
+      distance, closest_point = self.distance( target_point )
+      return closest_point
+    end
+private
+    def distance_to_point(target_point)
+      vector_QA = target_point - @base_point
+      distance = vector_QA.dot(@normal)
+      closest_point = target_point - @normal*distance
+      return distance.abs, closest_point
+    end
+
+    def distance_to_line(target_line)
+      inner_product_normal_and_line_vec = target_line.direction.dot(self.normal)
+      #parallel
+      if( inner_product_normal_and_line_vec.abs < @tolerance)
+        distance, closest_point = self.distance(target_line.base_point)
+        return distance, nil,nil
+      end
+      parameter = ( self.normal.dot(self.base_point) - self.normal.dot( target_line.base_point ) )/inner_product_normal_and_line_vec.to_f
+      intersect_point = target_line.point(parameter)
+      return 0.0, intersect_point, parameter
+    end
+
+    def distance_to_finite_line(target_finite_line)
+      target_infinite_line = Line.new(target_finite_line.start_point, target_finite_line.direction)
+      distance, intersect_point, parameter = self.distance(target_infinite_line)
+      point_on_line = intersect_point
+      point_on_plane = intersect_point
+      if(parameter != nil and (parameter < 0 or 1 < parameter))
+        parameter = [0, parameter].max
+        parameter = [1, parameter].min
+        point_on_line = target_finite_line.point(parameter)
+        distance, point_on_plane = self.distance(point_on_line)
+      end
+      return distance, point_on_plane, point_on_line, parameter
+    end
+    def distance_to_plane(target_plane)
+      line_vector = target_plane.normal.cross(self.normal)
+      if(target_plane.normal.parallel?(self.normal))
+        distance, point_on_plane = self.distance(target_plane.base_point)
+        return distance, nil
+      end
+      line_vector = line_vector.normalize()
+      tangent_vector_on_target_plane = line_vector.cross(target_plane.normal)
+      distance, intersect_point, parameter = self.distance(Line.new( target_plane.base_point, tangent_vector_on_target_plane))
+      intersect_line = Line.new(intersect_point, line_vector)
+      return 0, intersect_line
+    end
+  end
+end
+

data/lib/polyline.rb

@@ -1,73 +1,73 @@
-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
-
-    include BoxAvailable
-
-    # [Input]
-    #  _vertices_ should be Array of Vector3.
-    # [Output]
-    #  return new instance of Polyline.
-    def initialize(vertices = [], is_open = true)
-      Util3D.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
-
+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
+
+    include BoxAvailable
+
+    # [Input]
+    #  _vertices_ should be Array of Vector3.
+    # [Output]
+    #  return new instance of Polyline.
+    def initialize(vertices = [], is_open = true)
+      Util3D.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
+