xrvg 0.0.3 → 0.0.4

data/lib/beziermotifs.rb

@@ -0,0 +1,114 @@
+# See 
+# - BezierMotif
+# - PicBezier
+# - ArcBezier
+# - LinearBezier
+
+require 'bezierbuilders'
+
+module XRVG
+
+# = BezierMotif class
+# == Content
+# Abstract class to define prototype of a motif bezier factory
+# Motif is localized by the :support attribute
+# == Attributes
+#  attribute :support
+class BezierMotif < BezierBuilder
+  include Attributable
+  attribute :support
+end
+
+
+
+# = PicBezier class
+# == Content
+# Build a curved "pic" bezier whose base is specified by two points, and whose shape is controlled by two attributes, :height and :curvature.
+# :height parameter is a factor of base length
+# == Attributes
+#   attribute :height,    1.0
+#   attribute :curvature, 1.0
+# == Example
+#  pic = PicBezier[ :support, [V2D::O, V2D::X], :height, 1.0, :curvature, 2.0 ]
+class PicBezier < BezierMotif
+  attribute :height,    1.0
+  attribute :curvature, 1.0
+
+  # BezierBuilder compute overloading.
+  #
+  # See code for algorithm
+  def compute
+    p1, p2 = self.support
+    onethird = (1.0 / 3.0)
+    p1top2  = p2 - p1
+    pp1     =  p1 + p1top2.ortho.*(@height)
+    pp2     = pp1 + ( p1top2 * @curvature )
+
+    p1topp2 = pp2 - p1
+    pc1     = p1 + ( p1topp2 * onethird )
+    pc2     = p2 + ( p1topp2 * onethird )
+
+    p3      = p1 + ( p1top2 * @curvature )
+    p4      = p1 + ( p1top2 * ( @curvature + 1.0 ) )
+    
+    pp1top2 = p3 - pp1
+    pp1top3 = p4 - pp1
+
+    pp1c1 = pp1 + ( pp1top2 * onethird )
+    pp1c2 = pp1 + ( pp1top3 * onethird )
+    
+    return [[:raw, p1, pc1, pp1c1, pp1], [:raw, pp1, pp1c2, pc2, p2]]
+  end
+end
+
+# = ArcBezier class
+# == Content
+# Build an "arc" bezier whose base is specified by two points, and whose shape is controlled by a :height attribute.
+# :height parameter is a factor of base length
+# == Attributes
+#   attribute :height,    1.0
+# == Example
+#  arc = ArcBezier[ :support, [V2D::O, V2D::X], :height, 1.0 ]
+class ArcBezier < BezierMotif
+  attribute :height,    1.0
+
+  # BezierBuilder compute overloading.
+  #
+  # See code for algorithm  
+  def compute
+    p1, p2 = self.support
+    v = (p2 - p1).ortho * @height
+    return [[:vector, p1, v, p2, v]]
+  end
+end
+
+# = LinearBezier class
+# == Content
+# Build an line bezier whose base is specified by two points.
+# == Attributes
+# None, apart from :support
+# == Example
+#  line = LinearBezier[ :support, [V2D::O, V2D::X] ]
+class LinearBezier < BezierMotif
+  attribute :support, [V2D::O, V2D::X]
+
+  # BezierBuilder compute overloading.
+  #
+  # See code for algorithm
+  def compute
+    p1, p2 = self.support
+    return [[:vector, p1, (p2-p1) * 1.0 / 3.0,  p2, (p1 - p2) * 1.0 / 3.0]]
+  end
+
+  # Utilitary method to build a unit bezier line with angle
+  def LinearBezier.buildwithangle( angle )
+    return LinearBezier[ :support, [V2D::O, V2D::X.rotate( angle )]]
+  end
+
+end
+
+end # end XRVG
+
+
+
+

data/lib/bezierspline.rb

@@ -1,8 +1,9 @@
 # +BezierSpline+ source
 
 require 'interpolation'
+require 'parametriclength'
 
-
+module XRVG
 # BezierSpline class
 #
 # Internal class to represent a single-piece cubic bezier curve, defined by four points or two point + two vectors.
@@ -42,7 +43,7 @@ class BezierSpline #:nodoc:
     @vectorpointlist   = nil
     if type == :raw
       @rawpointlist       = [v1, v2, v3, v4]
-    elsif
+    else
       @vectorpointlist    = [v1, v2, v3, v4]
     end
   end
@@ -73,16 +74,25 @@ class BezierSpline #:nodoc:
     end
   end
 
-  # shortcut method to get curve first point
+  # shortcut method to get piece first point
   def firstpoint
     return self.pointlist()[0]
   end
 
-  # shortcut method to get curve last point
+  # shortcut method to get piece last point
   def lastpoint
     return self.pointlist()[-1]
   end
 
+  # shortcut method to get piece first vector
+  def firstvector
+    return self.pointlist(:vector)[1]
+  end
+
+  # shortcut method to get piece last vector
+  def lastvector
+    return self.pointlist(:vector)[-1]
+  end
 
 # -------------------------------------------------------------
 #  bezier formula
@@ -191,78 +201,13 @@ class BezierSpline #:nodoc:
     render.add( Line[ :points, [p2, pc2]          ],  Style[ :stroke, "red", :strokewidth, (r2 / 10.0) ])
   end
 
-# -------------------------------------------------------------
-#  length computation
-# -------------------------------------------------------------
-
-
-  # compute the length of the bezier curve defined by the points
-  #
-  # Algo : recursively approximate curve by lines, until length variation is under some epsilon
-  # 
-  # for the moment, just take a fix number of samples, and some it
-  def compute_length_interpolator() #:nodoc:
-    sum = 0.0
-    previous = nil
-    samplelist = [0.0, 0.0]
-    new      = V2D[0.0,0.0]
-    previous = nil
-    (0.0..1.0).samples( 129 ) do |abs|
-      self.point( abs, new )
-      if previous
-	sum+= (new - previous).r
-	samplelist += [sum, abs]
-      else
-	previous = V2D[0.0,0.0]
-      end
-      previous.x = new.x
-      previous.y = new.y
-    end
-    @length = samplelist[-2]
-
-    length_interpolator = nil
-    if @length == 0.0
-      newsamplelist = [0.0,0.0,0.0,1.0]
-      invsamplelist = [0.0,0.0,1.0,0.0]
-    else
-      newsamplelist = []
-      invsamplelist = []
-      samplelist.foreach do |sum, abs|
-	newsamplelist += [sum / @length, abs ]
-	invsamplelist += [abs, sum / @length ]
-      end
-      samplelist = newsamplelist
-    end
-    @abs_interpolator = InterpolatorQuad.new( :samplelist, invsamplelist )
-    return InterpolatorQuad.new( :samplelist, samplelist )
-  end
-
-  def length_interpolator() #:nodoc:
-    if @length_interpolator == nil
-      @length_interpolator = self.compute_length_interpolator()
-    end
-    return @length_interpolator
-  end
-
-  def length(t=nil)
-    if @length == nil
-      self.compute_length()
-    end
-    if not t
-      return @length
-    else
-      return @abs_interpolator.interpolate( t )
-    end
+  # length computation
+  include ParametricLength
+  def parameter_range
+    return (0.0..1.0)
   end
 
-  def compute_length() #:nodoc:
-    self.length_interpolator()
-    return @length
-  end
+  alias pointfromparameter point 
 
-  def parameterfromlength( lvalue ) #:nodoc:
-    result = self.length_interpolator.interpolate( lvalue )
-    return result
-  end  
 end
-
+end

data/lib/beziertools.rb

@@ -0,0 +1,211 @@
+# Some BezierBuilder implementations
+# - old-fashioned SimpleBezier
+# - useful BezierLevel
+# - powerful Offset
+# - interesting Ondulation
+# - simple ClosureBezier
+
+require 'bezierbuilders'
+
+module XRVG
+# = SimpleBezier
+# == Content
+# Simple Bezier interpolator, that builds a multipiece "regular" bezier curve from a list of points
+# == Algo
+# For each point triplet :
+# - tangent vector of the middle point is the vector mean of vector from first to middle and vector frommiddle to last.
+# First and last tangents are computed by symetry
+# == Note
+# FittingBezier is a better class for point bezier interpolation. However, this class is kept mainly for historical reasons.
+class SimpleBezier < BezierBuilder
+  attribute :support, nil, Array
+
+  # BezierBuilder overloading: see SimpleBezier description for algorithm
+  def compute( )
+    points = @support
+    if points.length < 2
+      Kernel::raise("SimpleBezier support must have at least two points")
+    elsif points.length == 2
+      return LinearBezier.build( :support, points).data
+    end
+    
+    result = Array.new
+    p1      = points[0]
+    v1      = V2D::O
+    cpiece = [:vector, p1, v1]
+    
+    points.triplets do |p1, p2, p3|
+      v = ((p2 - p1)..( p3 - p2 )).middle * 1.0 / 3.0
+      result.push( cpiece + [p2, v.reverse] )
+      cpiece = [:vector, p2, v]
+    end
+
+    pr2 = points[-1]
+    vr2 = V2D::O
+    result.push( cpiece + [pr2, vr2] )
+
+    # compute first and last piece again, by symetry
+    piece0 = Bezier.single( *result[0] )
+    p1, v1, p2, v2 = piece0.pointlist(:vector)
+    pv     = (p2 - p1)
+    angle  = v2.angle - pv.angle 
+    v1     = (-v2).rotate( -2.0 * angle )
+    result[0] = [:vector, p1, v1, p2, v2]
+
+    piecel = Bezier.single( *result[-1] )
+    p1, v1, p2, v2 = piecel.pointlist(:vector)
+    pv     = (p2 - p1)
+    angle  = v1.angle - pv.angle 
+    v2     = (-v1).rotate(  -2.0 * angle )
+    result[-1] = [:vector, p1, v1, p2, v2]
+
+    return result
+  end
+end
+
+
+# = Offset bezier builder
+# == Content
+# Generic offset bezier builder.
+# == Attributes
+#  attribute :support, nil, Curve
+#  attribute :abscissasampler, (0.0..1.0), Samplable
+#  attribute :ampl, 0.5, :samplable
+#  attribute :nsamples, 100
+class Offset < FitBezierBuilder
+  attribute :support, nil, Curve
+  attribute :abscissasampler, (0.0..1.0), Samplable
+  attribute :ampl, 0.5, :samplable
+  attribute :nsamples, 100
+
+  # overload FitBezierBuilder.points to compute Offset points
+  #
+  # Algo: for each sample, compute point, normal and amp, and newpoint = point + normal.norm * ampl
+  def points
+    result = []
+    [self.abscissasampler, self.ampl].samples( self.nsamples) do |abscissa, amplsample|
+      frame = self.support.frame( abscissa )
+      result << frame.center + frame.vector.ortho.norm * amplsample
+    end
+    return result
+  end
+end
+
+# = Fuseau bezier builder
+# == Content
+# Just shortcut class for Offset with :ampl = (1.0..0.0)
+# == Attributes
+#    attribute :maxwidth, 0.1
+class Fuseau < Offset
+  attribute :maxwidth, 0.1
+
+  # overload Offset.ampl method by returning (self.maxwidth..0.0)
+  def ampl
+    return (self.maxwidth..0.0)
+  end
+end
+
+
+
+# = BezierLevel bezier builder
+# == Content
+# Compute "roller coaster" bezier curves
+#
+# Can be used as a x-progressing curve, that is as an interpolation curve
+# == Attributes
+#  attribute :samplelist, [], Array
+# :samplelist must contain pairs of cartesien coords [x1,y1,x2,y2,...], x between 0.0 and 1.0 (as for interpolator)
+class BezierLevel < BezierBuilder
+  attribute :samplelist, [], Array
+
+  # Overload BezierBuilder build method
+  #
+  # Algo: simply interpolate [x,y] couples as V2D, with SimpleBezier bezier builder
+  def BezierLevel.build( *args )
+    builder = BezierLevel.new( *args )
+    points = []
+    builder.samplelist.foreach do |x,y|
+      points << V2D[x,y]
+    end
+    return SimpleBezier[ :support, points ]
+  end
+end
+
+# = ClosureBezier bezier builder
+# == Content
+# Simple bezier operator that take a list of beziers and produce a concatenate multipieces closed bezier curve.
+# Missing segments are completed with lines
+class ClosureBezier < BezierBuilder
+  attribute :bezierlist
+
+  # BezierBuilder compute overloading
+  def compute
+    result = []
+    result += self.bezierlist[0].pieces
+    self.bezierlist[1..-1].each do |bezier|
+      lastpoint = result[-1].lastpoint
+      newpoint  = bezier.firstpoint
+      if not V2D.vequal?( lastpoint, newpoint )
+	result += LinearBezier[ :support, [lastpoint, newpoint]].pieces
+      end
+      result += bezier.pieces
+    end
+    lastpoint = result[-1].lastpoint
+    newpoint  = result[0].firstpoint
+    if not V2D.vequal?( lastpoint, newpoint )
+      result += LinearBezier[ :support, [lastpoint, newpoint]].pieces
+    end
+    result = result.map {|piece| piece.data}
+    # Trace("result #{result.inspect}")
+    return result
+  end
+end
+
+# = Ondulation bezier builder
+# == Content
+# Generic ondulation bezier builder.
+# == Attributes
+#  attribute :support, nil, Curve
+#  attribute :ampl, 0.5, :samplable
+#  attribute :abscissasampler, (0.0..1.0), Samplable
+#  attribute :freq, 10
+# :support is a Curve
+# :abscissas must be a Float Samplable, as (0.0..1.0).geo(3.0)
+# :ampl can be a constant or a sampler
+# :freq is the number of oscillations to be computed
+class Ondulation < BezierBuilder
+  attribute :support, nil, Curve
+  attribute :ampl, 0.5, :samplable
+  attribute :abscissasampler, (0.0..1.0), Samplable
+  attribute :freq, 10
+
+  
+  # algo : for each abscissa, 0.0 of the curve (given the normal)
+  #    and for each mean abscissa, :amp normal
+  def compute
+    abscissas = self.abscissasampler.samples( self.freq + 1 )
+    sens = 1.0
+    pieces = []
+    [abscissas.pairs, self.ampl.samples( self.freq )].forzip do |abspair, amplitude|
+      abs1, abs2 = abspair
+      mabs = (abs1 + abs2)/2.0
+      p1, halfpoint, p2 = self.support.points( [abs1, mabs, abs2] )
+      # Trace("mabs #{mabs} abs1 #{abs1} abs2 #{abs2} halfpoint #{halfpoint.inspect} p1 #{p1.inspect} p2 #{p2.inspect}")
+      # Trace("normal #{@support.normal( mabs )}")
+      halfnormal = self.support.normal( mabs ).norm * ( sens * amplitude * (p2 - p1).length)
+      # Trace("halfnormal #{halfnormal.inspect}")
+      newpoint = halfpoint + halfnormal
+      tpoint = halfpoint + halfnormal * 3.0
+      t1 = (tpoint - p1 ) / 6.0
+      t2 = (tpoint - p2 ) / 6.0
+      # Trace("newpoint #{newpoint.inspect} p1 #{p1.inspect} (newpoint - p1) #{(newpoint - p1).inspect}")
+      halftangent = self.support.tangent( mabs ).norm * (newpoint - p1).length / 3.0
+      # halftangent = self.support.tangent( mabs ).norm * (p2 - p1).length / 3.0
+      pieces += [[:vector, p1, t1, newpoint, -halftangent], [:vector, newpoint, halftangent, p2, t2]]
+      sens *= -1.0
+    end
+    return pieces
+  end
+end
+
+end # XRVG