xrvg 0.0.3 → 0.0.4

data/lib/color.rb

@@ -8,8 +8,8 @@ require 'interpolation'
 require 'attributable'
 require 'utils'
 require 'shape'; # for gradient
-require 'matrix'
 
+module XRVG
 #
 # Color class
 #
@@ -35,6 +35,10 @@ class Color
   #
   # r, g, b, a must be between 0.0 and 1.0
   def initialize( r, g, b, a)
+    r = Range.O.trim( r )
+    g = Range.O.trim( g )
+    b = Range.O.trim( b )
+    a = Range.O.trim( a )
     @items = [r,g,b,a]
   end
 
@@ -96,31 +100,31 @@ class Color
   # set the red composant
   #  Color[0.1,0.2,0.3,0.4].r = 0.5 => Color[0.5,0.2,0.3,0.4]
   def r=(n)
-    self[0]= n
+    @items[0]= n
   end
 
   # set the green composant
   #  Color[0.1,0.2,0.3,0.4].g = 0.5 => Color[0.1,0.5,0.3,0.4]
   def g=(n)
-    self[1] = n
+    @items[1] = n
   end
 
   # set the blue composant
   #  Color[0.1,0.2,0.3,0.4].b = 0.5 => Color[0.1,0.2,0.5,0.4]
   def b=(n)
-    self[2] = n
+    @items[2] = n
   end
 
   # set the opacity composant
   #  Color[0.1,0.2,0.3,0.4].a = 0.5 => Color[0.1,0.2,0.3,0.5]
   def a=(n)
-    self[3] = n
+    @items[3] = n
   end
 
   # return an array containing colors on 255 integer format
   #  Color[0.0,1.0,0.0,1.0].format255 => [0,255,0,255]
   def format255()
-    return self.map {|v| (v * 255.0).to_i}
+    return @items.map {|v| (v * 255.0).to_i}
   end
 
   # return a random color vector, with 1.0 opacity !!
@@ -165,13 +169,23 @@ class Color
   end
 
   # build a color vector from hsv parametrization (convert from hsv to rgb) h, s, v being between 0.0 and 1.0
+  #
   # taken from wikipedia[http://en.wikipedia.org/wiki/HSV_color_space]
+  #
+  # error on algo with h = 1.0 => hi == 6 mustbe taken into account
   def Color.hsv( h, s, v, a)
+    h = Range.O.trim( h )
+    s = Range.O.trim( s )
+    v = Range.O.trim( v )
+    a = Range.O.trim( a )
     if s == 0.0
       return Color[v, v, v, a]
     end
     h *= 360.0
     hi = (h/60.0).floor
+    if hi == 6
+      hi = 5
+    end
     f  = (h/60.0) - hi
     p  = v * ( 1 -             s )
     q  = v * ( 1 -       f   * s )
@@ -220,6 +234,10 @@ class Color
   # taken from [[http://en.wikipedia.org/wiki/HSV_color_space]]
   # h, s, l must be between 0.0 and 1.0
   def Color.hsl( h, s, l, a)
+    h = Range.O.trim( h )
+    s = Range.O.trim( s )
+    l = Range.O.trim( l )
+    a = Range.O.trim( a )
     h *= 360.0
     if l < 0.5
       q = l * (1.0 + s)
@@ -292,7 +310,7 @@ end
 
 class Gradient < Palette #:nodoc:
   def defsvg()
-    Kernel::raise("Gradient::defsvg must be redefined in subclasses")
+    raise NotImplementedError.new("#{self.class.name}#defsvg is an abstract method.")
   end
 end
 
@@ -332,3 +350,4 @@ class CircularGradient < Gradient #:nodoc:
 				 "%r%"     => circle.radius} )
   end
 end
+end

data/lib/fitting.rb

@@ -0,0 +1,203 @@
+#
+# Fitting file. See +Fitting+
+#
+
+require 'matrix'; # for matrix inversion
+require 'bezier.rb'; # for error computation
+
+module XRVG
+#
+# = Fitting computation class
+# == Intro
+# Used to compute cubic curve fitting on a list of points (that is sampling inverse operation). Only 2D.
+# == Example
+# Compute the most fitting single piece bezier curve given list of points
+#  bezier    = Fitting.compute( points )
+# Compute multipieces bezier curve given list of points
+#  bezier    = Fitting.adaptative_compute( points )
+class Fitting
+
+  # compute first parameter t estimated values from length between consecutive points
+  def Fitting.initparameters( pointlist, parameters=nil ) #:nodoc:
+    lengths = [0.0]
+    pointlist.pairs do |p1, p2|
+      lengths.push( lengths[-1] + (p1-p2).r )
+    end
+    tlength = lengths[-1]
+    if not parameters
+      if not tlength == 0.0
+	parameters = lengths.map {|length| length / tlength}
+      else
+	parameters = [0.0] * pointlist.length
+      end
+    end
+    return [parameters, tlength]
+  end
+
+  # compute control points from polynomial bezier representation
+  #
+  # a, b, c, d are such as 
+  #  piece( t ) = at3 + bt2 + ct + d
+  def Fitting.bezierpiece( a, b, c, d )
+    p0 = d
+    p1 = p0 + c / 3.0
+    p2 = p1 + c / 3.0 + b / 3.0
+    p3 = p0 + c + b + a
+    return [p0, p1, p2, p3]
+  end
+
+
+  # Base method
+  # 
+  # Given a pointlist, compute the closest matching cubic bezier curve
+  #
+  # Result is in the form [p1, pc1, pc2, p2], with [p1, pc1, pc2, p2] V2D
+  #
+  # maxerror is normalized with curve length. In case of good match (that is pointlist can be modelized by cubic bezier curve), 
+  # result error will be under maxerror. If not, result may be above maxerror. In that case, computation is stopped because error
+  # no longer decrease, or because iteration is too long.
+  def Fitting.compute( pointlist, maxerror=0.01, maxiter=100 )
+    parameters, tlength = Fitting.initparameters( pointlist )
+    perror = 1.0
+    niter = 0
+    while true
+      bezier, coeffs = Fitting.iterate( pointlist, parameters )
+      error = Fitting.error( bezier, pointlist, parameters ) / tlength
+      parameters = Fitting.renormalize( bezier, coeffs, pointlist, parameters )
+      if (error < maxerror || (error-perror).abs < 0.00001 || niter > maxiter )
+	break
+      end
+      niter += 1
+    end
+    return bezier
+  end
+
+  # adaptative computation with automatic splitting if error not low enough, or if convergence is not fast enough
+  #
+  #
+  def Fitting.adaptative_compute( pointlist, maxerror=0.0001, maxiter=10, tlength=nil )
+    parameters, tlengthtmp = Fitting.initparameters( pointlist )
+    if parameters == [0] * pointlist.length
+      return [Bezier.single(:vector, pointlist[0], V2D::O, pointlist[0], V2D::O),0.0]
+    end
+    tlength ||= tlengthtmp
+    niter = 0
+    bezier = nil
+    while true
+      bezier, coeffs = Fitting.iterate( pointlist, parameters )
+      error = Fitting.error( bezier, pointlist, parameters ) / tlength
+      parameters = Fitting.renormalize( bezier, coeffs, pointlist, parameters )
+
+      # pointlist.length > 8 because matching with a bezier needs at least 4 points
+      if (niter > maxiter and error > maxerror and pointlist.length > 8)
+	pointlists = [pointlist[0..pointlist.length/2 - 1], pointlist[pointlist.length/2 - 1 ..-1]]
+	beziers = []
+	errors  = []
+	pointlists.each do |subpointlist|
+	  subbezier, suberror = Fitting.adaptative_compute( subpointlist, maxerror, maxiter, tlength )
+	  beziers << subbezier
+	  errors  << suberror
+	end
+	bezier = beziers.sum
+	error  = errors.max
+	break
+      elsif (error < maxerror || niter > maxiter)
+	break
+      end
+      perror = error
+      niter += 1
+    end
+    return [bezier, error]
+  end
+
+  # algo comes from http://www.tinaja.com/glib/bezdist.pdf
+  def Fitting.renormalize( bezier, coeffs, pointlist, parameters )
+    a3, a2, a1, a0 = coeffs
+    dxdu = Proc.new {|u| 3.0*a3.x*u**2 + 2.0*a2.x*u + a1.x}
+    dydu = Proc.new {|u| 3.0*a3.y*u**2 + 2.0*a2.y*u + a1.y}
+    container = V2D[]
+    z    = Proc.new {|u,p4| p = bezier.point( u, container, :parameter ); (p.x - p4.x) * dxdu.call( u ) + (p.y - p4.y) * dydu.call( u )}
+    newparameters = []
+    [pointlist, parameters].forzip do |point, parameter|
+      u1 = parameter
+      if parameter < 0.99
+	u2 = parameter + 0.01
+      else
+	u2 = parameter - 0.01
+      end
+      z1 = z.call(u1,point)
+      z2 = z.call(u2,point)
+      if z1 == z2
+	u2 += 0.01
+	z2 = z.call(u2,point)
+      end
+      if z1 == z2
+	u2 -= 0.01
+	z2 = z.call(u2,point)
+      end
+      newparameters << (z2 * u1 - z1 * u2)/(z2-z1)
+    end
+    return newparameters
+  end
+  
+  # error is max error  between points in pointlist and points sampled from bezier with parameters
+  def Fitting.error( bezier, pointlist, parameters )
+    maxerror = 0.0
+    container = V2D[]
+    [pointlist, parameters].forzip do |point, parameter|
+      Trace("point #{point.inspect} parameter #{parameter}")
+      error = (point - bezier.point( parameter, container, :parameter )).r
+      if error > maxerror
+	maxerror = error
+      end
+    end
+    Trace("Fitting.error #{maxerror}")
+    return maxerror
+  end
+
+  # iterate method compute new bezier parameters from pointlist and previous bezier parameters
+  # 
+  # Algo comes from http://www.tinaja.com/glib/bezdist.pdf
+  #
+  # TODO : optimized
+  def Fitting.iterate( pointlist, parameters )
+    p0 = pointlist[0]
+    p1 = pointlist[-1]
+
+    sumt0 = parameters.map{ |t| t**0.0 }.sum
+    sumt1 = parameters.map{ |t| t**1.0 }.sum
+    sumt2 = parameters.map{ |t| t**2.0 }.sum
+    sumt3 = parameters.map{ |t| t**3.0 }.sum
+    sumt4 = parameters.map{ |t| t**4.0 }.sum
+    sumt5 = parameters.map{ |t| t**5.0 }.sum
+    sumt6 = parameters.map{ |t| t**6.0 }.sum
+
+    psumt1 = [pointlist, parameters].forzip.foreach(2).map {|point, t| point * (t**1.0) }.inject(V2D::O){|sum, item| sum + item}
+    psumt2 = [pointlist, parameters].forzip.foreach(2).map {|point, t| point * (t**2.0) }.inject(V2D::O){|sum, item| sum + item}
+    psumt3 = [pointlist, parameters].forzip.foreach(2).map {|point, t| point * (t**3.0) }.inject(V2D::O){|sum, item| sum + item}
+
+    coeff11 = sumt6 - 2 * sumt4 + sumt2
+    coeff12 = sumt5 - sumt4 - sumt3 + sumt2
+
+    coeff21 = coeff12
+    coeff22 = sumt4 - 2 * sumt3 + sumt2
+
+    result1 = (p0 - p1) * (sumt4 - sumt2) - p0 * (sumt3 - sumt1) + psumt3 - psumt1
+    result2 = (p0 - p1) * (sumt3 - sumt2) - p0 * (sumt2 - sumt1) + psumt2 - psumt1
+    
+    matrix = Matrix[ [coeff11, coeff12], [coeff21, coeff22] ]
+    matrixinv = matrix.inverse
+    ax, bx = (matrixinv * Vector[result1.x, result2.x])[0..-1]
+    ay, by = (matrixinv * Vector[result1.y, result2.y])[0..-1]
+
+    a = V2D[ax, ay]
+    b = V2D[bx, by]
+    d = p0
+    c = p1- (a + b + p0)
+
+    piece = Fitting.bezierpiece( a, b, c, d )
+    return [Bezier.raw( *piece ), [a, b, c, d] ]
+  end    
+end
+
+end # end XRVG

data/lib/frame.rb

@@ -3,6 +3,7 @@
 # See +Frame+
 require 'attributable'
 
+module XRVG
 #
 # Frame class
 # = Intro
@@ -29,4 +30,4 @@ class Frame
     return false
   end
 end
-
+end

data/lib/geometry2D.rb

@@ -5,6 +5,7 @@
 
 require 'Attributable'
 
+module XRVG
 #
 # 2D vector
 #
@@ -98,9 +99,9 @@ class V2D
 
   # method necessary to make V2D Ranges
   # 
-  # simply call succ on each coord
+  # simply add 1.0 to each coord
   def succ()
-    return V2D[ self.x.succ, self.y.succ ]
+    return V2D[ self.x + 1.0, self.y + 1.0 ]
   end
 
   # compute length of 2D vector (r notation to be compatible with V2D)
@@ -169,8 +170,8 @@ class V2D
     return V2D[ -self.y, self.x ]
   end
 
-  # compute the symetric of vector considered as point, with center of symetrie being "other" considered as point
-  #  V2D[1.0,2.0].sym( V2D[0.0,0.0] ) => V2D[-1.0,-2.0]
+  # compute the symetric of vector "other" considering self as symetry center
+  #  V2D[1.0,2.0].sym( V2D[0.0,0.0] ) => V2D[2.0,4.0]
   def sym( other )
     return self * 2.0 - other
   end
@@ -230,4 +231,4 @@ class V2D
     return [xmax - xmin, ymax - ymin]
   end
 end
-
+end

data/lib/interbezier.rb

@@ -0,0 +1,87 @@
+require 'bezier'
+
+module XRVG
+class InterBezier
+  include Attributable
+  attribute :bezierlist
+
+  include Interpolation
+
+  def initialize( *args )
+    super( *args )
+    self.init_interpolation_structures
+  end
+
+  def init_interpolation_structures
+    beziers = []
+    indexes = []
+    @bezierlist.foreach do |index, bezier| 
+      beziers.push( bezier )
+      indexes.push( index )
+    end
+
+    lengthH = {}
+    alllengths = []
+    beziers.each do |bezier|
+      lengths = bezier.piecelengths
+      # Trace("bezier lengths #{lengths.inspect}")
+      lengthH[ bezier ] = lengths
+      alllengths += lengths
+    end
+    alllengths = Float.sort_float_list( alllengths )
+    # Trace("alllengths #{alllengths.inspect}")
+    
+    newbezierlist = []
+    beziers.each do |bezier|
+      newpieces = []
+      initlengths = lengthH[ bezier ]
+      alllengths.pairs do |l1, l2| 
+	newpieces += bezier.subbezier( l1, l2 ).pieces
+      end
+      newbezier = Bezier[ :pieces, newpieces ]
+      newbezierlist << newbezier
+    end
+
+    # Trace("newbezierlist #{newbezierlist.inspect}")
+    beziers = newbezierlist
+    bezierpointlists = beziers.map {|bezier| bezier.pointlist(:vector) }
+    # Trace("bezierpointlists #{bezierpointlists.map {|list| list.length}.inspect}")
+    pointsequencelist = bezierpointlists.forzip
+    @interpolatorlist = []
+    pointsequencelist.foreach(beziers.size) do |pointsequence|
+      interlist = [indexes, pointsequence].forzip
+      @interpolatorlist.push( Interpolator.new( :samplelist, interlist ) )
+    end
+  end
+
+  def interpolate( abs, container=nil )
+    pieces = []
+    @interpolatorlist.foreach(4) do |interpiece|
+      piece = interpiece.map {|inter| inter.interpolate( abs )}
+      pieces.push( [:vector] + piece )
+    end
+    return Bezier.multi( pieces )    
+  end
+
+  include Samplable
+  alias apply_sample interpolate
+
+end
+
+class GradientBezier < InterBezier
+
+  # TODO : does not work !!
+  def samples( nsamples, &block )
+    return super( nsamples + 1, &block )
+  end
+
+  def apply_samples( samples )
+    samples = super( samples )
+    result = []
+    samples.pairs do |bezier1, bezier2|
+      result.push( ClosureBezier.build( :bezierlist, [bezier1, bezier2.reverse]) )
+    end
+    return result
+  end
+end
+end # XRVG  

data/lib/interpolation.rb

@@ -7,7 +7,9 @@
 
 require 'utils'
 require 'attributable'
+require 'samplation'
 
+module XRVG
 # Interpolation module
 # = Intro
 # Defines an interpolation service from a samplelist that must be a list [value1, index1, value2, index2, ..., valueN, indexN],
@@ -24,7 +26,7 @@ module Interpolation
   # for example, Palette redefines samplelist as
   #  alias samplelist colorlist
   def samplelist()
-    Kernel::raise("Interpolation::samplelist method must be redefined in subclasses")
+    raise NotImplementedError.new("#{self.class.name}#samplelist is an abstract method.")
   end
 
   # computing method
@@ -59,6 +61,8 @@ class Interpolator
   include Attributable
   attribute :samplelist
   include Interpolation
+  include Samplable
+  alias apply_sample interpolate
 end
 
 class QuadRange
@@ -70,10 +74,6 @@ class QuadRange
     @range     = range
   end
 
-  def limit
-    return @limit
-  end
-
   def range( index )
     if @limit
       if index < @limit
@@ -156,3 +156,4 @@ class InterpolatorQuad < Interpolator
     return result
   end
 end
+end