xrvg 0.0.7 → 0.0.8

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

@@ -0,0 +1,33 @@
+# frame.rb file
+# 
+# See +Frame+
+require 'attributable'
+
+module XRVG
+#
+# Frame class
+# = Intro
+# Defines a local geometry. Used by +Curve+ interface.
+# = Attributes
+#   attribute :center
+#   attribute :vector
+#   attribute :rotation
+#   attribute :scale
+class Frame
+  include Attributable
+  attribute :center
+  attribute :vector
+  attribute :rotation
+  attribute :scale
+
+  def ==(other)
+    if self.center == other.center and
+	self.vector == other.vector and
+	self.rotation == other.rotation and
+	self.scale == other.scale
+      return true
+    end
+    return false
+  end
+end
+end

data/lib/geovariety.rb

@@ -0,0 +1,128 @@
+# File for GeoVariety
+# See (also):
+# - InterBezier
+# - Offsetvariety
+# - FuseauVariety
+
+require 'interbezier'
+
+module XRVG
+
+# = GeoVariety abstract module
+# == Principle
+# Base module to define geometrical spaces or canvas different from simple euclidean one to draw curves on.
+# It provides three different services:
+# - point computation
+# - geodesic computation
+# - arbitrary bezier computation, this one by computing sampling of euclidean curve on the variety, and then fitting point
+#   sequence with FitBezierBuilder
+module GeoVariety
+  
+  # must be overriden
+  def point( point )
+    raise NotImplementedError.new("#{self.class.name}#point is an abstract method.")
+  end
+  
+  # must be overriden
+  def line( x1, x2, y )
+    raise NotImplementedError.new("#{self.class.name}#line is an abstract method.")
+  end
+
+  # see GeoVariety module description for algorithm
+  def bezier( pointrange, bezier )
+    bezier = bezier.similar( pointrange )
+    points = bezier.samples( 20 )
+    points = points.map {|point| self.point( point )}
+    return FitBezierBuilder[ :points, points ]
+  end
+end
+
+# = InterBezier GeoVariety implementation
+# == Principle
+# InterBezier defines a surface by the set of every possible curve sample from one interpolated curve to the other.
+# Geodesic corresponds then to one interpolated result, and point to a point of this curve
+class InterBezier
+  include GeoVariety
+  
+  # Compute the geodesic curve by doing self.sample with y coord, and then compute point of this curve with length "x"
+  def point( point )
+    curve = self.sample( point.y )
+    return curve.point( point.x )
+  end
+
+  # Compute the geodesic subcurve with y coord between x1 and x2
+  def line( x1, x2, y )
+    # Trace("interbezier line x1 #{x1} x2 #{x2} y #{y}")
+    curve = self.sample( y )
+    result = curve.apply_split( x1, x2 )
+    # Trace("interbezier line result #{result.inspect}")
+    return result
+  end
+
+end
+
+# = OffsetVariety implementation
+# == Principle
+# Geovariety is defined by the set of offset curves from -ampl to +ampl
+# == Extension
+# Parameter could be a :samplable parameter : in that case, ampl will vary
+#
+# Another extension would be to parametrize range straightforwardly
+#
+# Finally, the two previous remarks must be synthetized :-)
+class OffsetVariety
+  include Attributable
+  attribute :support
+  attribute :ampl, nil, Float
+
+  include GeoVariety
+
+  # builder: init static offset range with (-self.ampl..self.ampl)
+  def initialize( *args )
+    super( *args )
+    @range = (-self.ampl..self.ampl)
+  end
+
+  # point computed by computing offset curve with ampl y coord mapped onto offset range, and then sampling the curve with x coord
+  def point( point )
+    curve = Offset[ :support, @support, :ampl, @range.sample( point.y ) ]
+    return curve.point( point.x )
+  end
+
+  # subgeodesic computed by computing offset curve with ampl y coord
+  def line( x1, x2, y )
+    curve = Offset[ :support, @support, :ampl, @range.sample( y ) ]
+    return curve.apply_split( x1, x2 )
+  end
+  
+end  
+
+# = FuseauVariety implementation
+# == Principle
+# Same as OffsetVariety, with Fuseau shape, that is with linearly varying ampl range
+class FuseauVariety
+  include Attributable
+  attribute :support
+  attribute :ampl, nil, Float
+
+  include GeoVariety
+
+  def initialize( *args )
+    super( *args )
+    @range = (-self.ampl..self.ampl)
+  end
+
+  def point( point )
+    curve = Offset[ :support, @support, :ampl, (0.0..@range.sample( point.y ))]
+    return curve.point( point.x )
+  end
+
+  def line( x1, x2, y )
+    curve = Offset[ :support, @support, :ampl, (0.0..@range.sample( y ))]
+    return curve.apply_split( x1, x2 )
+  end
+end
+
+end # XRVG
+
+# see geovariety_test to see tests

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.length}")
+    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/intersection.rb

@@ -0,0 +1,89 @@
+#
+# Contains Ruby geometric V2D extension to deal with intersection. 
+# taken from http://geometryalgorithms.com/Archive/algorithm_0108/algorithm_0108.htm
+# See :
+# - +V2D+
+
+require 'geometry2D'
+
+module XRVG
+
+  class V2D
+
+    # compute if self is Left|On|Right of the line p0 to p1
+    # >0 for Left, 0 for On, <0 for right
+    def isLeft( p0, p1 )
+      criteria = (p1.x - p0.x)*(self.y-p0.y) - (self.x - p0.x) * (p1.y - p0.y)
+      if criteria > 0.0
+	return :left
+      elsif criteria < 0.0
+	return :right
+      else
+	return :on
+      end
+    end
+
+    alias xyorder <=>
+    
+  end
+  
+  # 2D segment 
+  class V2DS
+    include Attributable 
+    attribute :p0, nil, V2D
+    attribute :p1, nil, V2D
+
+    # create a new 2D segment
+    #  v = V2DS[V2D::O,V2D::X]
+    def V2DS.[](p0,p1)
+      return V2DS.new(p0,p1)
+    end
+
+    # initialize overloading on Attributable to speed up
+    def initialize(p0,p1) #:nodoc:
+      self.p0 = p0
+      self.p1 = p1
+    end
+
+    def left
+      return p0.x < p1.x ? p0 : p1
+    end
+
+    def right
+      return p0.x > p1.x ? p0 : p1
+    end
+
+    def V2DS.sameside?( s1, s2 )
+      lsign = s1.left.isLeft( s2.left, s2.right )
+      rsign = s1.right.isLeft( s2.left, s2.right )
+      if lsign == rsign and lsign != :on
+	return true
+      end
+      return false
+    end
+
+    def intersect?( other )
+      if V2DS.sameside?( other, self )
+	return false
+      elsif V2DS.sameside?( self, other )
+	return false
+      end
+      return true
+    end
+
+    def intersection( other )
+      if not self.intersect?( other )
+	return nil
+      end
+
+      x1, y1 = self.p0.coords
+      x2, y2 = self.p1.coords
+      x3, y3 = other.p0.coords
+      x4, y4 = other.p1.coords
+	
+      newx = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4 ) ) / (( x1 - x2) * (y3 - y4) - ( y1 - y2 ) * (x3 - x4))
+      newy = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4 ) ) / (( x1 - x2) * (y3 - y4) - ( y1 - y2 ) * (x3 - x4))
+      return V2D[ newx, newy ]
+    end
+  end
+end