class GMath3D::Plane

Plane represents a infinite plane on 3D space.

Attributes

base_point[RW]
normal[RW]

Public Class Methods

new(base_point = Vector3.new(), normal = Vector3.new(0,0,1)) click to toggle source
Input

base_point and normal should be Vector3.

Output

returns new instance of Plane.

Calls superclass method GMath3D::Geom::new
# File lib/plane.rb, line 15
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

Public Instance Methods

==(rhs) click to toggle source
Input

rhs is Plane.

Output

return true if rhs equals myself.

# File lib/plane.rb, line 32
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
distance(target) click to toggle source

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].

# File lib/plane.rb, line 58
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
initialize_copy( original_obj ) click to toggle source
# File lib/plane.rb, line 23
def initialize_copy( original_obj )
  @base_point = original_obj.base_point.dup
  @normal = original_obj.normal.dup
end
project( target_point ) click to toggle source
Input

target_point should be Vector3.

Output

retrun projected point on plane as Vector3.

# File lib/plane.rb, line 79
def project( target_point )
  Util3D.check_arg_type(::Vector3, target_point)
  distance, closest_point = self.distance( target_point )
  return closest_point
end
to_s() click to toggle source
# File lib/plane.rb, line 40
def to_s
  "Plane[point#{@base_point.to_element_s}, normal#{@normal.to_element_s}]"
end

Private Instance Methods

distance_to_finite_line(target_finite_line) click to toggle source
# File lib/plane.rb, line 104
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
distance_to_line(target_line) click to toggle source
# File lib/plane.rb, line 92
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
distance_to_plane(target_plane) click to toggle source
# File lib/plane.rb, line 117
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
distance_to_point(target_point) click to toggle source
# File lib/plane.rb, line 85
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