xrvg 0.0.3 → 0.0.4

data/CHANGES

@@ -1,5 +1,26 @@
 = CHANGES
 
+== 0.0.4 (2008.03.16)
+Really big functional release. Several additional releases are needed to add appropriate tests and docs.
+=== Content
+- XRVG namespace creation: you must now add "include XRVG" after "require 'xrvg'" to make your previous work OK.
+- bezier curve fitting algorithm implementation
+- adaptative bezier curve fitting algorithm implementation
+- bezier builder hierarchy introducing
+- ArcBezier and PicBezier bezier motifs
+- Offset, Ondulation, ClosureBezier bezier builders 
+- meta bezier builders: iterator builders, fitting builders
+=== Other little additions
+- new FloatFunctor filter Alternate (must be consolidated though)
+=== Removed Bugs
+- splits enumerator works again
+- debug bezier filter method
+=== Refactoring
+- make bezier frame with container
+- ParametricLength module extraction from BezierSpline
+=== TODO
+- complete Circle curve, with split interface (maybe add generic method in Curve, from bezier, as circle -> bezier method is available)
+
 == 0.0.3 (2008.02.17)
 === Content
 - just bug correction, optims and refactoring

data/README

@@ -1,6 +1,6 @@
 = XRVG -- X Ruby Vector Graphics
 
-Supporting XRVG version: 0.0.3
+Supporting XRVG version: 0.0.4
 
 This package contains XRVG, a Ruby vector graphic programming library.
 
@@ -64,7 +64,7 @@ new feature to be submitted in the form of new unit tests.
 
 For other information, feel free to ask on the ruby-talk mailing list
 (which is mirrored to comp.lang.ruby) or contact
-mailto:jblondinet@nospam@yahoo.com.
+mailto:julien.leonard@nospam@ensta.org.
 
 
 = Other stuff
@@ -75,7 +75,7 @@ Thanks for Rake project, whose README file has been adapted to do this one.
 
 == Summary
 
-Author::   Julien L�onard <jblondinet@nospam@yahoo.com>
+Author::   Julien L�onard <julien.leonard@nospam@ensta.org>
 Requires:: Ruby 1.8.0 or later (but not compatible with 1.9.0)
 License::  Copyright 2008 by Julien L�onard.
            Released under an MIT-style license.

data/Rakefile

@@ -11,7 +11,7 @@ PROJECT = "XRVG"
 MY_NAME = "Julien L�onard"
 
 # Your email address, used in packaging.
-MY_EMAIL = "jblondinet@nospam@yahoo.com"
+MY_EMAIL = "julien.leonard@nospam@ensta.org"
 
 # Short summary of your project, used in packaging.
 PROJECT_SUMMARY = "Ruby vector graphics library"
@@ -45,7 +45,7 @@ REQUIRE_PATHS << EXT_DIR if HAVE_EXT
 $LOAD_PATH.concat(REQUIRE_PATHS)
 # This library file defines the RAKEVERSION constant.
 require "#{UNIX_NAME}"
-PROJECT_VERSION = eval("\"#{XRVG_VERSION}\"") # e.g. "1.0.2"
+PROJECT_VERSION = eval("\"#{XRVG_VERSION}\"")
 
 #---
 # Options common to RDocTask AND Gem::Specification.
@@ -63,7 +63,7 @@ RDOC_FILES = FileList["README", "CHANGES"]
 
 # Ruby library code.
 LIB_DIR = "lib"
-PRE_LIB_FILES = FileList["assertion.rb", "attributable.rb", "color.rb", "frame.rb", "geometry2D.rb", "interpolation.rb", "render.rb", "samplation.rb", "shape.rb", "style.rb", "trace.rb", "utils.rb", "bezier.rb", "bezierspline.rb", "xrvg.rb"]
+PRE_LIB_FILES = FileList["trace.rb", "samplation.rb", "interpolation.rb", "parametriclength.rb", "utils.rb", "geometry2D.rb",  "color.rb", "frame.rb", "shape.rb", "render.rb", "shape.rb", "style.rb", "bezier.rb", "bezierspline.rb", "fitting.rb", "bezierbuilders.rb", "beziermotifs.rb", "beziertools.rb", "interbezier.rb", "xrvg.rb"]
 LIB_FILES = FileList["#{LIB_DIR}/*.rb"]
 
 # Example code.
@@ -72,7 +72,7 @@ EXAMPLE_FILES = FileList["#{EXAMPLE_DIR}/*.rb"]
 
 # Filelist with Test::Unit test cases.
 TEST_DIR = "test"
-PRE_TEST_FILES = FileList["test_bezier.rb", "test_attributable.rb", "test_color.rb", "test_frame.rb", "test_geometry2D.rb", "test_render.rb", "test_style.rb", "test_utils.rb", "test_shape.rb", "test_interpolation.rb"]
+PRE_TEST_FILES = FileList["test_*.rb"]
 TEST_FILES = FileList["test/*.rb"]
 
 # Executable scripts, all non-garbage files under bin/.

data/examples/bezierbasic.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "bezierbasic.svg" ]
 bezier = Bezier.raw( V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0] )

data/examples/bezierbasicvector.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "bezierbasicvector.svg" ]
 bezier = Bezier.vector( V2D[0.0, 1.0], V2D[1.0, 0.0], V2D[1.0, 0.0], V2D[-1.0, 0.0] )

data/examples/foreach.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "foreach.svg", :background, "white" ]
 Circle[].samples(10).foreach do |p1,p2|

data/examples/geodash.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "geodash.svg" ]
 bezier = Bezier.raw( V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0] )

data/examples/geodash2.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "geodash2.svg" ]
 bezier = Bezier.raw( V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0] )

data/examples/hellocrown.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "hellocrown.svg" ]
 Circle[].samples( 8 ) do |point|

data/examples/hellocrown2.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "hellocrown2.svg" ]
 [Circle[], (0.2..0.1)].samples( 10 ) do |point, radius|

data/examples/hellocrownrecurse.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "hellocrownrecurse.svg" ]
 Circle[].samples( 8 ) do |point|

data/examples/helloworldcompact.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 SVGRender.[] do |render|
   render.add( Circle[] )

data/examples/helloworldexpanded.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender.new( :filename, "helloworldexpanded.svg" )
 render.add( Circle.new )

data/examples/multibezierbasic.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "multibezierbasic.svg" ]
 bezier = Bezier.multi( [[:vector, V2D[0.0, 1.0], V2D[1.0, 0.0], V2D[1.0, 0.0], V2D[-1.0, 0.0]],

data/examples/palette_circle.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "palette_circle.svg", :background, "white" ]
 

data/examples/randomdash.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "randomdash.svg" ]
 bezier = Bezier.raw( V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0] )

data/examples/range_examples.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 # Samplable module
 (1.0..2.0).sample(0.5);      #=> 1.5

data/examples/range_examples2.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 Range.O;                   #=> (0.0..1.0)
 Range.Angle;               #=> (0.0..2*Math::PI)

data/examples/sample.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "sample.svg" ]
 

data/examples/simpledash.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "simpledash.svg" ]
 bezier = Bezier.raw( V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0] )

data/examples/uplets.rb

@@ -1,4 +1,5 @@
 require 'xrvg'
+include XRVG
 
 render = SVGRender[ :filename, "uplets.svg", :background, "white" ]
 Circle[].samples(10).uplets do |p1,p2|

data/lib/bezier.rb

@@ -4,6 +4,7 @@
 require 'bezierspline'
 require 'shape'
 
+module XRVG
 # = Base class for cubic bezier curves
 # == Basics
 # See http://en.wikipedia.org/wiki/B%C3%A9zier_curve
@@ -94,7 +95,7 @@ class Bezier < Curve
   # args is a list of points and control points as [p1, v1, p2, v2, p3, v3]
   #
   # Beware that 
-  #  Bezier.vector( p1, v1, p2, v2 ) == Bezier.raws( p1, v1, p2, -v2)
+  #  Bezier.vector( p1, v1, p2, v2 ) == Bezier.vectors( p1, v1, p2, -v2)
   def Bezier.vectors( *args )
     rawpieces = []
     args.foreach(2).pairs do |pair1, pair2|
@@ -182,6 +183,11 @@ class Bezier < Curve
   def bezier( index )
     return Bezier.single( *self.piece( index ).data )
   end
+
+  # shortcut method to retrieve data list of a bezier
+  def data
+    return self.pieces.map{ |piece| piece.data }
+  end
   
 
 # -------------------------------------------------------------
@@ -195,19 +201,10 @@ class Bezier < Curve
     check_parametertype( parametertype )
     result = []
     if parametertype == :length
-      if index < 0.0 
-	index = 0.0
-      elsif index > 1.0
-	index = 1.0
-      end
+      index = (0.0..1.0).trim( index )
       result = length_parameter_mapping( index, side )
     else # no need to test parametertype value, as check_parametertype already do it
-      if index < 0.0 
-	index = 0.0
-      elsif index > self.piecenumber
-	index = self.piecenumber.to_f
-      end
-
+      index = (0.0..self.piecenumber.to_f).trim( index )
       pieceindex = index < self.piecenumber ? index.to_i : (index-1).to_i
       t          = index - pieceindex
       result = [pieceindex, t]
@@ -252,12 +249,16 @@ class Bezier < Curve
   end
 
   # curve method redefinition to factorize parametermapping
-  def frame( t, parametertype=:length )
+  def frame( t, container=nil, parametertype=:length )
     pieceindex, t = parametermapping( t, parametertype )
-    tangent = self.piece( pieceindex ).tangent( t )
+    containerpoint   = container ? container.center : nil
+    containertangent = container ? container.vector : nil
+    point    = self.piece( pieceindex ).point( t, containerpoint )
+    tangent  = self.piece( pieceindex ).tangent( t, containertangent )
     rotation = self.rotation( nil, tangent )
     scale    = self.scale( nil, tangent )
-    return Frame[ :center, self.piece( pieceindex ).point( t ), :vector, tangent, :rotation, rotation, :scale, scale ]
+    result = container ? container : Frame[ :center, point, :vector, tangent, :rotation, rotation, :scale, scale ]
+    return result
   end
 
 # -------------------------------------------------------------
@@ -291,17 +292,6 @@ class Bezier < Curve
     return Bezier.new( :pieces, self.subpieces( t1, t2 ) )
   end
 
-  # split method
-  if nil
-  def split(nchildren=2, type=:regular)
-    return self.range.split(nchildren,type).map { |range| self.subbezier( range.begin, range.end ) }
-  end
-
-  def subdivise( samples )
-    return samples.pairs.map { |t1, t2| self.subbezier( t1, t2 ) }
-  end
-  end
-
 # -------------------------------------------------------------
 #  reverse
 # -------------------------------------------------------------
@@ -365,20 +355,6 @@ class Bezier < Curve
     return Bezier.new( :pieces, self.pieces + other.pieces )
   end
 
-# -------------------------------------------------------------
-#  range
-# -------------------------------------------------------------
-
-  # TODO
-  def ranges #:nodoc:
-    (0..self.piecenumber).to_a.pairs.map {|start,stop| Range.new( start, stop )}
-  end
-  
-  # TODO
-  def range #:nodoc:
-    return (0..self.piecenumber)
-  end
-
 # -------------------------------------------------------------
 #  svg
 # -------------------------------------------------------------
@@ -437,7 +413,7 @@ class Bezier < Curve
   #        must use an interpolator ?
   def compute_length #:nodoc:
     lengths = self.pieces.map {|piece| piece.length}
-    Trace("pieces #{self.pieces.inspect} lenghts #{lengths.inspect}")
+    # Trace("pieces #{self.pieces.inspect} lenghts #{lengths.inspect}")
     result  = lengths.sum
     if result == 0.0
       lengths = [1.0]
@@ -476,13 +452,13 @@ class Bezier < Curve
 
   def length_parameter_mapping( t, side ) #:nodoc:
     pieceindex = -1
-    Trace("self.lengthranges #{self.lengthranges.inspect}")
+    # Trace("self.lengthranges #{self.lengthranges.inspect}")
     self.lengthranges.each_with_index do |lrange,i|
       if lrange.include?( t )
 	pieceindex = i
 	t = lrange.abscissa( t )
 	t = self.piece( i ).parameterfromlength( t )
-	Trace("pieceindex #{pieceindex} t #{t}")
+	# Trace("pieceindex #{pieceindex} t #{t}")
 	break
       end
     end
@@ -510,11 +486,7 @@ class Bezier < Curve
   #
   # TODO : must be defined on Curve interface !!
   def filter(type=:point, &block)
-    if type == :length
-      return super(:pointbylength, &block )
-    else
-      return super(type, &block).addfilter( self.range )
-    end
+      return super(type, &block).addfilter( (0.0..1.0) )
   end
 
   def apply_split( t1, t2 ) #:nodoc:
@@ -527,10 +499,4 @@ class Bezier < Curve
 
   # TODO : add generic bezier builder from points : must be adaptative !! (use Fitting)
 end
-
-
-
-
-  
-
-
+end

data/lib/bezierbuilders.rb

@@ -0,0 +1,194 @@
+# 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
+    return FitBezierBuilder[ :points, self.samples( 20 ) ]
+  end
+end
+
+
+end # end XRVG