Class: GMath3D::Plane

Inherits:
Geom
  • Object
show all
Defined in:
lib/plane.rb

Overview

Plane represents a infinite plane on 3D space.

Instance Attribute Summary collapse

Attributes inherited from Geom

#tolerance

Instance Method Summary collapse

Methods inherited from Geom

default_tolerance

Constructor Details

#initialize(base_point = Vector3.new(), normal = Vector3.new(0,0,1)) ⇒ Plane

[Input] base_point and normal should be Vector3. [Output] returns new instance of Plane.



15
16
17
18
19
20
21
 
# 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

Instance Attribute Details

#base_point ⇒ Object

Returns the value of attribute base_point.



8
9
10
 
# File 'lib/plane.rb', line 8

def base_point
  @base_point
end

#normal ⇒ Object

Returns the value of attribute normal.



9
10
11
 
# File 'lib/plane.rb', line 9

def normal
  @normal
end

Instance Method Details

#==(rhs) ⇒ Object

[Input] rhs is Plane. [Output] return true if rhs equals myself.



32
33
34
35
36
37
38
 
# 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) ⇒ Object

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



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# 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) ⇒ Object 



23
24
25
26
 
# 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) ⇒ Object

[Input] target_point should be Vector3. [Output] retrun projected point on plane as Vector3.



79
80
81
82
83
 
# 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 ⇒ Object 



40
41
42
 
# File 'lib/plane.rb', line 40

def to_s
  "Plane[point#{@base_point.to_element_s}, normal#{@normal.to_element_s}]"
end