Class: XRVG::BezierSpline
- Includes:
- ParametricLength
- Defined in:
- lib/bezierspline.rb
Overview
You may never have to use this class. Prefer the use of Bezier
class
Constant Summary
Constants included from ParametricLength
Class Method Summary collapse
-
.[](*args) ⇒ Object
:nodoc:.
Instance Method Summary collapse
-
#acc(t, result = nil) ⇒ Object
compute the acc of bezier curve at t abscissa.
-
#axesym(origin, v) ⇒ Object
simple axe sym operation : sym every point of the piece return a new BezierSpline.
- #checktype(type) ⇒ Object
- #checkvalues(v1, v2, v3, v4) ⇒ Object
-
#compute_factors ⇒ Object
————————————————————- bezier formula ————————————————————-.
- #compute_rawpointlist ⇒ Object
- #compute_vectorpointlist ⇒ Object
- #data ⇒ Object
-
#firstpoint ⇒ Object
shortcut method to get piece first point.
-
#firstvector ⇒ Object
shortcut method to get piece first vector.
- #gdebug(render) ⇒ Object
- #initdata(type, v1, v2, v3, v4) ⇒ Object
-
#initialize(type, v1, v2, v3, v4) ⇒ BezierSpline
constructor
A new instance of BezierSpline.
-
#lastpoint ⇒ Object
shortcut method to get piece last point.
-
#lastvector ⇒ Object
shortcut method to get piece last vector.
- #parameter_range ⇒ Object
-
#point(t, result = nil) ⇒ Object
(also: #pointfromparameter)
get point from the bezier curve this method use the definition of the bezier curve.
- #pointlist(type = :raw) ⇒ Object
- #reverse ⇒ Object
-
#rotate(angle, center) ⇒ Object
simple rotation operation : rotate every point of the piece return a new BezierSpline.
-
#subpiece(t1, t2) ⇒ Object
compute a subpiece of the current bezier t1 and t2 must correspond to the same atomic bezier.
-
#subtangents(t1, t2) ⇒ Object
compute tangent vectors corresponding to the new subbezier very strange method, but effective.
-
#sym(center) ⇒ Object
simple sym operation : sym every point of the piece return a new BezierSpline.
-
#tangent(t, result = nil) ⇒ Object
compute the bezier tangent vector.
-
#translate(v) ⇒ Object
simple translation operation : translate every point of the piece return a new BezierSpline.
Methods included from ParametricLength
#compute_length, #compute_length_interpolator, #length, #length_interpolator, #parameterfromlength
Constructor Details
#initialize(type, v1, v2, v3, v4) ⇒ BezierSpline
Returns a new instance of BezierSpline.
17 18 19 20 21 |
# File 'lib/bezierspline.rb', line 17 def initialize( type, v1, v2, v3, v4 ) self.checktype( type ) self.checkvalues( v1, v2, v3, v4 ) self.initdata( type, v1, v2, v3, v4 ) end |
Class Method Details
.[](*args) ⇒ Object
:nodoc:
13 14 15 |
# File 'lib/bezierspline.rb', line 13 def BezierSpline.[](*args) return BezierSpline.new( *args ) end |
Instance Method Details
#acc(t, result = nil) ⇒ Object
compute the acc of bezier curve at t abscissa
149 150 151 152 153 154 155 156 157 158 159 160 161 162 |
# File 'lib/bezierspline.rb', line 149 def acc( t, result=nil ) if not result result = V2D[0.0,0.0] end if not @factors compute_factors end result.x = @afactors[1].x + @afactors[0].x * t result.y = @afactors[1].y + @afactors[0].y * t return result end |
#axesym(origin, v) ⇒ Object
simple axe sym operation : sym every point of the piece return a new BezierSpline
207 208 209 210 |
# File 'lib/bezierspline.rb', line 207 def axesym( origin, v ) newpoints = self.pointlist.map {|point| point.axesym( origin, v )} return BezierSpline[ :raw, *newpoints ] end |
#checktype(type) ⇒ Object
31 32 33 34 35 |
# File 'lib/bezierspline.rb', line 31 def checktype( type ) if not type == :raw || type == :vector Kernel::raise( "BezierSpline : type #{type.inspect} is not :raw or :vector" ) end end |
#checkvalues(v1, v2, v3, v4) ⇒ Object
23 24 25 26 27 28 29 |
# File 'lib/bezierspline.rb', line 23 def checkvalues( v1, v2, v3, v4 ) [v1, v2, v3, v4].each do |v| if not (v.respond_to?(:x) || v.respond_to?(:y)) Kernel::raise( "BezierSpline : init value #{v.inspect} does not respond to :x or :y" ) end end end |
#compute_factors ⇒ Object
bezier formula
101 102 103 104 105 106 |
# File 'lib/bezierspline.rb', line 101 def compute_factors p1, p2, p3, p4 = self.pointlist @factors = [-(p1 - p2 * 3.0 + p3 * 3.0 - p4), (p1 - p2 * 2.0 + p3) * 3.0, (p2 - p1) * 3.0, p1] @tfactors = [@factors[0], @factors[1] * 2.0 / 3.0, @factors[2] / 3.0] @afactors = [@tfactors[0] * 2.0, @tfactors[1]] end |
#compute_rawpointlist ⇒ Object
51 52 53 54 |
# File 'lib/bezierspline.rb', line 51 def compute_rawpointlist # Assert{ @vectorpointlist } @rawpointlist = [@vectorpointlist[0], @vectorpointlist[0] + @vectorpointlist[1], @vectorpointlist[2] + @vectorpointlist[3], @vectorpointlist[2]] end |
#compute_vectorpointlist ⇒ Object
56 57 58 59 |
# File 'lib/bezierspline.rb', line 56 def compute_vectorpointlist # Assert{ @rawpointlist } @vectorpointlist = [@rawpointlist[0], @rawpointlist[1] - @rawpointlist[0], @rawpointlist[3], @rawpointlist[2] - @rawpointlist[3]] end |
#data ⇒ Object
37 38 39 |
# File 'lib/bezierspline.rb', line 37 def data() return [:raw] + self.pointlist end |
#firstpoint ⇒ Object
shortcut method to get piece first point
78 79 80 |
# File 'lib/bezierspline.rb', line 78 def firstpoint return self.pointlist()[0] end |
#firstvector ⇒ Object
shortcut method to get piece first vector
88 89 90 |
# File 'lib/bezierspline.rb', line 88 def firstvector return self.pointlist(:vector)[1] end |
#gdebug(render) ⇒ Object
212 213 214 215 216 217 218 219 220 221 222 223 224 |
# File 'lib/bezierspline.rb', line 212 def gdebug(render) p1, pc1, pc2, p2 = self.pointlist() v1 = pc1 - p1 r1 = v1.r / 30.0 v2 = pc2 - p2 r2 = v2.r / 30.0 render.add( Circle[ :center, p1, :radius, r1 ], Style[ :fill, "red" ]) render.add( Circle[ :center, pc1, :radius, r1 ], Style[ :fill, "red" ]) render.add( Line[ :points, [p1, pc1] ], Style[ :stroke, "red", :strokewidth, (r1 / 10.0) ]) render.add( Circle[ :center, p2, :radius, r2 ], Style[ :fill, "red" ]) render.add( Circle[ :center, pc2, :radius, r1 ], Style[ :fill, "red" ]) render.add( Line[ :points, [p2, pc2] ], Style[ :stroke, "red", :strokewidth, (r2 / 10.0) ]) end |
#initdata(type, v1, v2, v3, v4) ⇒ Object
41 42 43 44 45 46 47 48 49 |
# File 'lib/bezierspline.rb', line 41 def initdata( type, v1, v2, v3, v4 ) @rawpointlist = nil @vectorpointlist = nil if type == :raw @rawpointlist = [v1, v2, v3, v4] else @vectorpointlist = [v1, v2, v3, v4] end end |
#lastpoint ⇒ Object
shortcut method to get piece last point
83 84 85 |
# File 'lib/bezierspline.rb', line 83 def lastpoint return self.pointlist()[-1] end |
#lastvector ⇒ Object
shortcut method to get piece last vector
93 94 95 |
# File 'lib/bezierspline.rb', line 93 def lastvector return self.pointlist(:vector)[-1] end |
#parameter_range ⇒ Object
228 229 230 |
# File 'lib/bezierspline.rb', line 228 def parameter_range return (0.0..1.0) end |
#point(t, result = nil) ⇒ Object Also known as: pointfromparameter
get point from the bezier curve this method use the definition of the bezier curve
110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
# File 'lib/bezierspline.rb', line 110 def point( t, result=nil ) t2 = t * t t3 = t2 * t if not result result = V2D[0.0,0.0] end if not @factors compute_factors end # decomposed because avoid to build useless V2D result.x = @factors[3].x + @factors[2].x * t + @factors[1].x * t2 + @factors[0].x * t3 result.y = @factors[3].y + @factors[2].y * t + @factors[1].y * t2 + @factors[0].y * t3 return result end |
#pointlist(type = :raw) ⇒ Object
62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
# File 'lib/bezierspline.rb', line 62 def pointlist(type=:raw) self.checktype( type ) if type == :raw if not @rawpointlist self.compute_rawpointlist end return @rawpointlist elsif type == :vector if not @vectorpointlist self.compute_vectorpointlist end return @vectorpointlist end end |
#reverse ⇒ Object
179 180 181 |
# File 'lib/bezierspline.rb', line 179 def reverse() return BezierSpline[ :raw, *self.pointlist().reverse ] end |
#rotate(angle, center) ⇒ Object
simple rotation operation : rotate every point of the piece return a new BezierSpline
192 193 194 195 |
# File 'lib/bezierspline.rb', line 192 def rotate( angle, center ) newpoints = self.pointlist.map {|point| center + (point-center).rotate( angle )} return BezierSpline[ :raw, *newpoints ] end |
#subpiece(t1, t2) ⇒ Object
compute a subpiece of the current bezier t1 and t2 must correspond to the same atomic bezier
174 175 176 177 |
# File 'lib/bezierspline.rb', line 174 def subpiece (t1, t2) tan1, tan2 = self.subtangents( t1, t2 ) return BezierSpline.new( :vector, self.point( t1 ), tan1, self.point( t2 ), tan2 ) end |
#subtangents(t1, t2) ⇒ Object
compute tangent vectors corresponding to the new subbezier very strange method, but effective
166 167 168 169 170 |
# File 'lib/bezierspline.rb', line 166 def subtangents (t1, t2 ) v1 = self.tangent( t1 ) * (t2 - t1) v2 = self.tangent( t2 ) * (t1 - t2) return [v1, v2] end |
#sym(center) ⇒ Object
simple sym operation : sym every point of the piece return a new BezierSpline
199 200 201 202 |
# File 'lib/bezierspline.rb', line 199 def sym( center ) newpoints = self.pointlist.map {|point| center.sym( point )} return BezierSpline[ :raw, *newpoints ] end |
#tangent(t, result = nil) ⇒ Object
compute the bezier tangent vector
Beware that what is actually computed here is 1/3 tangent !!
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 |
# File 'lib/bezierspline.rb', line 131 def tangent( t, result=nil ) t2 = t * t if not result result = V2D[0.0,0.0] end if not @factors compute_factors end # decomposed because avoid to build useless V2D result.x = @tfactors[2].x + @tfactors[1].x * t + @tfactors[0].x * t2 result.y = @tfactors[2].y + @tfactors[1].y * t + @tfactors[0].y * t2 return result end |
#translate(v) ⇒ Object
simple translation operation : translate every point of the piece return a new BezierSpline
185 186 187 188 |
# File 'lib/bezierspline.rb', line 185 def translate( v ) newpoints = self.pointlist.map {|point| point + v} return BezierSpline[ :raw, *newpoints ] end |