xrvg 0.0.6 → 0.0.7

data/lib/bezierbuilders.rb

@@ -1,210 +0,0 @@
-# BezierBuilder file
-# See:
-# - BezierBuilder
-# - SimilarMotifIterator
-# - AttributeMotifIterator
-# - FitBezierBuilder
-
-require 'bezier'
-require 'fitting'
-
-module XRVG
-
-# = BezierBuilder class
-# == Content
-# Abstract class to define prototype of a bezier factory
-#
-# Provides the notation
-#  bezierresult = BezierBuilder[ :parameter1, arg1, :parameter2, arg2 ]
-# with bezierresult the computed Bezier object from the BezierBuilder algorithm
-class BezierBuilder
-  include Attributable
-
-  # Hook for subclassing : must return a list of raw pieces, to be provided to Bezier.multi
-  def compute()
-    raise NotImplementedError.new("#{self.class.name}#compute is an abstract method.")
-  end
-
-  # syntax sugar method to replace BezierBuilder.build notation with the simpler BezierBuilder[] one
-  #
-  # Note that BezierBuilder[] does not return a BezierBuilder object, but a Bezier one
-  def BezierBuilder.[](*args)
-    return self.build( *args )
-  end
-
-  # create the BezierBuilder, and build a Bezier.multi by calling BezierBuilder.compute
-  def BezierBuilder.build( *args )
-    builder = self.new( *args )
-    return Bezier.multi( builder.compute )
-  end
-
-  # multipiece bezier operator to smooth tangents of piece junctions
-  #
-  # Algo:
-  # - for each pair of pieces, take last and first vector
-  # - compute the mean of these vectors
-  # - for each vector, linearly interpolate given :factor between initial vector and mean
-  # As a consequence, default :factor value means that by default, we take vector means, and this operator
-  # do nothing if you set :factor to 0.0
-  def BezierBuilder.lissage( bezier, factor=1.0 )
-    result = [[:vector] + (bezier.pieces[0].pointlist(:vector))[0..1]]
-    bezier.pieces.pairs do |piece1, piece2|
-      p = piece1.lastpoint;# equal to piece2.firstpoint
-      v1, v2 = [-piece1.lastvector, piece2.firstvector]
-      mean = (v1..v2).mean
-      newv1 = (v1..mean).sample( factor )
-      newv2 = (v2..mean).sample( factor )
-      result[-1] += [p,-newv1]
-      result << [:vector, p, newv2]
-    end
-    result[-1] += (bezier.pieces[-1].pointlist(:vector))[-2..-1]
-    return Bezier.multi( result )
-  end
-end
-
-
-#-------------------------------------------------------------------------------
-# We can now build on these atomic motifs some motif iterators
-#-------------------------------------------------------------------------------
-
-# = Similar Motif Iterator
-# == Content
-# Take a bezier curve as :motif, and a "curvesampler" as a support with sampling description, and iterate motif on each pair computed by sampling
-# == Attributes
-#  attribute :curvesampler, nil, Samplable
-#  attribute :motif, nil, Bezier
-#  attribute :nmotifs, 10
-# == Example
-#  motif        = PicBezier[ :support, [V2D::O, V2D::X], :height, -1.0 ]
-#  curvesampler = bezier.geo( 3.0 )
-#  bezier       = SimilarMotifIterator[ :curvesampler, curvesampler, :motif, motif, :nmotifs, 10 ]
-# == TODO
-# Represents the basic operator to compute bezier fractal curves !!
-class SimilarMotifIterator < BezierBuilder
-  attribute :curvesampler, nil, Samplable
-  attribute :motif, nil, Bezier
-  attribute :nmotifs, 10
-
-  # BezierBuilder overloading
-  #
-  # Algo
-  # - sample @nmotif+1 times @curvesampler to get @nmotifs point pairs
-  # - foreach pair, compute new bezier by calling Bezier.similar on @motif
-  def compute
-    result = []
-    self.curvesampler.samples( self.nmotifs + 1).pairs do |p1,p2|
-      Trace("SimilarMotifIterator::compute p1 #{p1.inspect} p2 #{p2.inspect}")
-      newbezier = self.motif.similar( (p1..p2) )
-      result += newbezier.data
-    end
-    return result
-  end
-
-end
-
-# = Attribute Motif Iterator
-# == Content
-# More advanced motif iterator than SimilarMotifIterator, and also more expensive, AttributeMotifIterator samples
-# a curvesampler and foreach pair build a new bezier motif, with varying attributes
-# == Attributes
-#  attribute :curvesampler, nil, Splittable
-#  attribute :motifclass
-#  attribute :nmotifs, 10
-#  attribute :attributes, [], Array
-#  attribute :closed, false
-# :motifclass is a BezierBuilder class, as ArcBezier, PicBezier, or even AttributeMotifIterator...
-#
-# :attributes is of the form [attribute1, specification1, :attribute2, specification, ...] with
-# - attribute1, attribute2 attributes of the :motifclass
-# - specification can be : 
-#   - single value
-#   - sampler
-#
-# :closed attribute state if each subbezier computed for each point pair must be closed with the corresponding subbezier of the :curvesampler
-# == Example
-#  motif        = PicBezier[ :support, [V2D::O, V2D::X], :height, -1.0 ]
-#  curvesampler = bezier.geo( 3.0 )
-#  result = AttributeMotifIterator[ :curvesampler, curvesampler, :motifclass, ArcBezier, :attributes, [:height, (-2.0..0.0).random], :nmotifs, 30, :closed, true ]
-# == WARNING
-# Only works with BezierMotif defined by two points
-class AttributeMotifIterator < BezierBuilder
-  attribute :curvesampler, nil, Splittable
-  attribute :motifclass
-  attribute :nmotifs, 10
-  attribute :attributes, [], Array
-  attribute :closed, false
-
-  # BezierBuilder overloading
-  #
-  # See AttributeMotifIterator class description for details
-  def compute
-    result = []
-    attrvalues = []
-    self.attributes.foreach do |name, spec|
-      attrvalues += [name, Samplable.build( spec ).samples( self.nmotifs )]
-    end
-    self.curvesampler.splits( self.nmotifs ).each_with_index do |subbezier,index|
-      pair = [subbezier.firstpoint, subbezier.lastpoint]
-      p1, p2 = pair
-      args = [:support, pair]
-      attrvalues.foreach do |name, values|
-	args += [name, values[index]]
-      end
-      newbezier = self.motifclass[ *args ]
-      if self.closed
-	newbezier = newbezier + subbezier.reverse
-      end
-      result += newbezier.data
-    end
-    return result
-  end
-
-end
-
-# = FitBezierBuilder class
-# == Content
-# Build a bezier from a point list defined by :points by computing adaptative multipiece bezier fitting.
-#
-# While this class is by itself quite usefull, it can also be subclassed by overloading "points" method to
-# compute all sorts of curve (as Offset for example)
-# == Attributes
-#    attribute :points, [], Array; # to be able to subclass FitBezierBuilder to compute points by diverse means
-#    attribute :maxerror, 0.001
-# :maxerror attribute represents the bezier curve matching error (as explained in Fitting)
-class FitBezierBuilder < BezierBuilder
-  attribute :points, [], Array; # to be able to subclass FitBezierBuilder to compute points by diverse means
-  attribute :maxerror, 0.001
-  
-  def FitBezierBuilder.build( *args )
-    builder = self.new( *args )
-    return Fitting.adaptative_compute( builder.points, builder.maxerror )[0]
-  end
-
-end
-
-# Extend Circle class for subcurve definition
-class Circle
-  # return approximating bezier curve
-  def bezier
-    # following computation is too expensive
-    # return FitBezierBuilder[ :points, self.samples( 20 ) ]
-
-    # based on http://www.whizkidtech.redprince.net/bezier/circle/
-    kappa = 0.5522847498
-
-    beziers = []
-    self.frames( (0.0..1.0).samples(5) ).pairs do |f1,f2|
-      beziers << Bezier.vector( f1.center, f1.vector.norm * kappa * self.radius, f2.center, f2.vector.norm * kappa * (-self.radius) )
-    end
-
-    result = beziers[0]
-    beziers[1..-1].each do |b|
-      result = result + b
-    end
-
-    return result
-  end
-end
-
-
-end # end XRVG

data/lib/beziermotifs.rb

@@ -1,121 +0,0 @@
-# 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
-
-  def BezierMotif.build( *args )
-    builder = self.new( *args )
-    result = []
-    builder.support.pairs do |p1,p2|
-      builder.support = [p1,p2]
-      result << Bezier.multi( builder.compute )
-    end
-    return result.sum
-  end
-
-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,235 +0,0 @@
-# +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.
-# You may never have to use this class. Prefer the use of +Bezier+ class
-class BezierSpline #:nodoc:
-
-  def BezierSpline.[](*args)
-    return BezierSpline.new( *args )
-  end
-  
-  def initialize( type, v1, v2, v3, v4 )
-    self.checktype( type )
-    self.checkvalues( v1, v2, v3, v4 )
-    self.initdata( type, v1, v2, v3, v4 )
-  end
-  
-  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
-
-  def checktype( type )
-    if not type == :raw || type == :vector
-      Kernel::raise( "BezierSpline : type #{type.inspect} is not :raw or :vector" )
-    end
-  end
-
-  def data()
-    return [:raw] + self.pointlist
-  end
-  
-  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
-
-  def compute_rawpointlist
-    # Assert{ @vectorpointlist }
-    @rawpointlist = [@vectorpointlist[0], @vectorpointlist[0] +  @vectorpointlist[1], @vectorpointlist[2] +  @vectorpointlist[3], @vectorpointlist[2]]
-  end
-
-  def compute_vectorpointlist
-    # Assert{ @rawpointlist }
-    @vectorpointlist = [@rawpointlist[0], @rawpointlist[1] - @rawpointlist[0], @rawpointlist[3], @rawpointlist[2] - @rawpointlist[3]]
-  end
-
-  
-  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
-
-  # shortcut method to get piece first point
-  def firstpoint
-    return self.pointlist()[0]
-  end
-
-  # 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
-# -------------------------------------------------------------
-
-  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
-
-  # get point from the bezier curve
-  # this method use the definition of the bezier curve
-  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
-
-  # compute the bezier tangent vector
-  #
-  # Beware that what is actually computed here is 1/3 tangent !!
-  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
-
-  # compute the acc of bezier curve at t abscissa
-  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
-
-  # compute tangent vectors corresponding to the new subbezier
-  # very strange method, but effective
-  def subtangents (t1, t2 )
-    v1 = self.tangent( t1 ) * (t2 - t1)
-    v2 = self.tangent( t2 ) * (t1 - t2)
-    return [v1, v2]
-  end
-
-  # compute a subpiece of the current bezier
-  # t1 and t2 must correspond to the same atomic bezier
-  def subpiece (t1, t2)
-    tan1, tan2 = self.subtangents( t1, t2 )
-    return BezierSpline.new( :vector, self.point( t1 ), tan1, self.point( t2 ), tan2 )
-  end
-
-  def reverse()
-    return BezierSpline[ :raw, *self.pointlist().reverse ]
-  end
-
-  # simple translation operation : translate every point of the piece
-  # return a new BezierSpline
-  def translate( v )
-    newpoints = self.pointlist.map {|point| point + v}
-    return BezierSpline[ :raw, *newpoints ]
-  end
-
-  # simple rotation operation : rotate every point of the piece
-  # return a new BezierSpline
-  def rotate( angle, center )
-    newpoints = self.pointlist.map {|point| center + (point-center).rotate( angle )}
-    return BezierSpline[ :raw, *newpoints ]
-  end
-
-  # simple sym operation : sym every point of the piece
-  # return a new BezierSpline
-  def sym( center )
-    newpoints = self.pointlist.map {|point| center.sym( point )}
-    return BezierSpline[ :raw, *newpoints ]
-  end
-
-
-  # simple axe sym operation : sym every point of the piece
-  # return a new BezierSpline
-  def axesym( origin, v )
-    newpoints = self.pointlist.map {|point| point.axesym( origin, v )}
-    return BezierSpline[ :raw, *newpoints ]
-  end
-
-  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
-
-  # length computation
-  include ParametricLength
-  def parameter_range
-    return (0.0..1.0)
-  end
-
-  alias pointfromparameter point 
-
-end
-end