xrvg 0.0.81 → 0.0.82

data/CHANGES

@@ -1,5 +1,13 @@
 = CHANGES
 
+== 0.0.82 (2008.12.05)
+=== Content
+- Debug Ondulation with negative amplitudes
+- Debug sampler.rand to avoid stack overflow
+- add .sides method on Bezier class
+- Debug gem install (attributable.rb missing)
+- Remove Spiral's dependancy upon Forwardable
+
 == 0.0.81 (2008.08.26)
 === Content
 - tutorials updated with the new SyncS

data/Rakefile

@@ -68,7 +68,7 @@ RDOC_FILES = FileList["README", "CHANGES"]
 
 # Ruby library code.
 LIB_DIR = "lib"
-PRE_LIB_FILES = FileList["trace.rb", "samplation.rb", "interpolation.rb", "parametriclength.rb", "utils.rb", "geometry2D.rb", "intersection.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", "geovariety.rb", "spiral.rb", "xrvg.rb"]
+PRE_LIB_FILES = FileList["attributable.rb", "trace.rb", "samplation.rb", "interpolation.rb", "parametriclength.rb", "utils.rb", "geometry2D.rb", "intersection.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", "geovariety.rb", "spiral.rb", "xrvg.rb"]
 LIB_FILES = FileList["#{LIB_DIR}/*.rb"]
 
 # Example code.
@@ -202,7 +202,7 @@ task "gen-blog" do
   # Rake::Task["clobber"].invoke
   Rake::Task["muse"].invoke
   # Rake::Task["examples"].invoke; # must be done with emacs
-  Rake::Task["finish"].invoke
+  # Rake::Task["finish"].invoke
 end
 
 #---

data/examples/colorbezier.rb

@@ -0,0 +1,38 @@
+require 'xrvg'
+include XRVG
+
+render = SVGRender[:imagesize, "20cm" ]
+palette  = Palette[ :colorlist, [ 0.0, Color.blue,
+                                  0.1, Color.grey(0.5),
+                                  0.3, Color.grey(0.25),
+                                  0.5, Color.grey(0.75),
+                                  0.7, Color.grey(0.25),
+                                  0.9, Color.grey(0.5),
+                                  1.0, Color.yellow],
+                    :interpoltype, :simplebezier]
+style = Style[ :fill, Color.black ]
+line = Line[ :points, [V2D::O, V2D::X] ]
+SyncS[line, palette].samples( 100 ) do |point, color|
+  style.fill = color
+  render.add( Circle[:center, point, :radius, 0.01 ], style)
+end
+
+curves = []
+palette.interpolators.each do |interpol|
+  curves << interpol.getcurve
+end
+
+curves.each do |curve|
+  render.add( curve, Style[ :stroke, Color.black, :strokewidth, 0.01 ] )
+  curve.gdebug( render )
+end
+
+
+line = Line[ :points, [V2D::O, V2D::X] ].translate( V2D::Y * 0.1 )
+palette.interpoltype = :linear
+SyncS[line, palette].samples( 100 ) do |point, color|
+  style.fill = color
+  render.add( Circle[:center, point, :radius, 0.01 ], style)
+end
+
+render.end

data/examples/colorlinear.rb

@@ -0,0 +1,28 @@
+require 'xrvg'
+include XRVG
+
+render = SVGRender[:imagesize, "3cm" ]
+palette  = Palette[ :colorlist, [ 0.0, Color.blue,   0.25,  Color.orange,  
+                                  0.5, Color.yellow, 0.75,  Color.green,
+                                  1.0, Color.blue],
+                    :interpoltype, :linear]
+style = Style[ :fill, Color.black ]
+line = Line[ :points, [V2D::O, V2D::X] ]
+SyncS[line, palette].samples( 100 ) do |point, color|
+  style.fill = color
+  render.add( Circle[:center, point, :radius, 0.01 ], style)
+end
+
+curves = []
+palette.interpolators.each do |interpol|
+  points = []
+  interpol.samples( 100 ).each_with_index do |y, index|
+    points << V2D[ index.to_f/100.0, y ]
+  end
+  curves << SimpleBezier[ :support, points  ]
+end
+
+curves.each do |curve|
+  render.add( curve, Style[ :stroke, Color.black, :strokewidth, 0.01 ] )
+end
+render.end

data/lib/attributable.rb

@@ -0,0 +1,184 @@
+#
+# Module to be able to declare attribute, initializing them by default, with type checking
+# also define syntaxically simpler builder
+#
+# See :
+# - +Object+
+# - +Attributable+
+
+#
+# Object extension to provide the Class[] syntax for building objects, with +Attributable+ module.
+#
+# TODO : must be defined only for Class objects !!
+class Object
+
+  # operator [] definition for shorter and more recognizable object creation syntax. 
+  #
+  # Especially useful when creating Attributable dependant objects.
+  #   c = Circle[ :center, p, :radius, 0.1 ]
+  def Object.[](*args)
+    return self.new( *args )
+  end
+end
+
+module XRVG
+# Attribute class used by Attributable module
+#
+# Attribute syntax : 
+#   attribute :attr1 default_value type
+# with :
+# - dvalue nil if no default_value (in that case, attribute is said to be required )
+# - if type is not specified, default_value must be, and type will be the type of this default_value
+# type can be an Array of types
+#
+# A special :sampled :type is added, to ease declaration of multiform parameter used as Samplation. It can be specified as:
+# - Array     => used as Roller
+# - Samplable => used as it
+# - Constant  => used as Roller
+class Attribute
+  attr_accessor :symbol, :default_value, :type
+
+  @@custom_types ||= {}
+
+  def initialize( symbol, default_value, type )  #:nodoc:
+    @symbol = symbol
+    @default_value = default_value
+    @type = type
+  end
+
+  # method to add a "custom" type builder, which acts as a filter on raw attributes to provide a more elaborate one. For example,
+  # see :samplable type, which transforms array and const as samplable objects by encapsulating them in a Roller filter
+  def Attribute.addtype( symbol, builder ) 
+    @@custom_types[ symbol ] = builder
+  end
+
+  def Attribute.typekey?( symbol )
+    return @@custom_types.key?( symbol )
+  end
+
+  def Attribute.typebuilder( symbol )
+    return @@custom_types[ symbol ]
+  end
+
+end
+
+# Attributable module
+# 
+# Allows class attribute definition in a concise and effective way. Can be viewed as a :attr_accessor extension. See also +Attribute+
+#
+# Example :
+#   class A
+#      attribute :a, 1.0; # type is then Float
+#      attribute :b      # attribute is required
+#   end
+#
+#   a = A[ :a, 10.0, :b, 2.0 ]
+#   a.a => 10.0
+module Attributable
+
+  module ClassMethods #:nodoc:
+    def init_attributes
+      if not @attributes
+	@attributes = {}
+	newattributes = (self.superclass.ancestors.include? Attributable) ? self.superclass.attributes : {}
+	@attributes = @attributes.merge( newattributes )
+      end
+    end
+
+    def add_attribute( attribute )
+      init_attributes
+      @attributes[ attribute.symbol ] = attribute
+    end
+
+    def attributes()
+      init_attributes
+      return @attributes
+    end
+
+    def checkvaluetype( value, type )
+      typeOK = nil
+      types = type
+      types.each do |type|
+	if not type.is_a? Symbol
+	  if value.is_a? type
+	    typeOK = true
+	    break
+	  end
+	end
+      end
+      if not typeOK
+	raise( "Attributable::checkvaluetype for class #{self} : default_value #{value.inspect} is not of type #{types.inspect}" )
+      end
+    end
+
+    def attribute( symbol, default_value=nil, type=nil )
+      if (not type and default_value)
+	type = [default_value.class]
+      elsif type
+	if not type.is_a? Symbol
+	  if not type.is_a? Array
+	    type = [type]
+	  end
+	  if default_value
+	    checkvaluetype( default_value, type )
+	  end
+        else
+	  if not Attribute.typekey?( type )
+	    raise( "Custom type #{type} has not been defined in Attribute class map: use Attribute.addtype to do it" )
+	  end
+	  if default_value
+	    default_value = Attribute.typebuilder( type ).call( default_value )
+	  end
+	end
+      end
+
+      self.add_attribute( Attribute.new( symbol, default_value, type ) )
+      attr_accessor symbol
+    end
+  end
+
+  def self.included( receiver )  #:nodoc:
+    # inherit_attributes; does not work without this because Module is not inherited by subclasses
+    receiver.extend( ClassMethods )
+  end
+
+  def initialize(*args)  #:nodoc:
+    # first check if every specified attribute is meaningfull for the class
+    args.foreach do |symbol, value|
+      if not self.class.attributes.key? symbol
+	raise( "Attributable::initialize for class #{self} does not have attribute #{symbol}" )
+      end
+    end
+
+    # then check specification coherence, and do initialization
+    spec = Hash[ *args ]
+    self.class.attributes.each_pair do |symbol, attr|
+      init_value = nil
+      if spec.key? symbol
+	value = spec[ symbol ]
+	if attr.type
+	  if attr.type.is_a? Symbol
+	    value = Attribute.typebuilder( attr.type ).call( value )
+	  else
+	    self.class.checkvaluetype( value, attr.type )
+	  end
+	end
+	init_value = value
+      else
+	if attr.default_value == nil
+	  raise( "Attributable::initialize for class #{self} : attribute #{symbol} is required : attribute defs #{self.class.attributes.inspect}" )
+	end
+	default_value = attr.default_value
+	# following code is bad, but does the right thing
+	if default_value.is_a? Array
+	  default_value = default_value.clone
+	end
+	init_value = default_value
+      end
+      # do init after checking
+      self.method("#{symbol.to_s}=").call(init_value)
+    end
+  end
+end
+
+end # end XRVG

data/lib/bezier.rb

@@ -183,11 +183,51 @@ class Bezier < Curve
     return self.pointlist()[-1]
   end
 
-  # shortcut method to build Bezier objects for each piece
+  # shortcut method to build Bezier objects from each piece
   def beziers
     return self.pieces.map{ |piece| Bezier.single( *piece.data ) }
   end
 
+  # shortcut method to build Bezier objects from each not regular part
+  def sides
+    result = []
+    # Trace("pieces pointlist:")
+    # self.pieces.each do |piece|
+    #   Trace("- #{piece.pointlist(:vector).inspect}")
+    # end
+    v0 = self.pieces[0].pointlist(:vector)[1]
+    v1 = self.pieces[0].pointlist(:vector)[3]
+    subpieces = [self.pieces[0]]
+    self.pieces[1..-1].each do |piece|
+      fv = piece.pointlist(:vector)[1]
+      if not V2D.vequal?( (fv * -1.0).norm, v1.norm, 0.01 )
+	# Trace("fv #{fv.inspect} v1 #{v1.inspect}")
+	result << subpieces
+	subpieces = []
+      end
+      subpieces << piece
+      v1 = piece.pointlist(:vector)[3]
+    end
+    if V2D.vequal?( (v0 * -1.0).norm, v1.norm, 0.01 )
+      # Trace("v0 #{v0.inspect} v1 #{v1.inspect}")
+      if result[0]
+	result[0] =  subpieces + result[0]
+      else
+	result = [subpieces]
+      end
+      subpieces = []
+    else
+      result << subpieces
+    end
+
+    newresult = []
+    result.each do |subpieces|
+      newresult << Bezier[ :pieces, subpieces ]
+    end
+    
+    return newresult
+  end
+
   # shortcut method to retrieve a piece as an Bezier object
   def bezier( index )
     return Bezier.single( *self.piece( index ).data )
@@ -498,7 +538,11 @@ class Bezier < Curve
       if lrange.include?( t )
 	pieceindex = i
 	t = lrange.abscissa( t )
-	t = self.piece( i ).parameterfromlength( t )
+	if self.piece( i ).length.fequal?(0.0) 
+	  t = 0.0
+	else
+	  t = self.piece( i ).parameterfromlength( t )
+	end
 	# Trace("pieceindex #{pieceindex} t #{t}")
 	break
       end
@@ -541,12 +585,13 @@ class Bezier < Curve
 	    # compute distances rapport
 	    r0 = (inter - s01[1]).r / (s02[1] - s01[1]).r
 	    r1 = (inter - s11[1]).r / (s12[1] - s11[1]).r
+	    # Trace("Bezier.intersections rapports r0 #{r0} r1 #{r1} s0 V2DS #{V2DS[s01[1], s02[1]].inspect} s1 V2DS #{V2DS[s11[1], s12[1]].inspect}")
 	    rawresult += [s01[0], s02[0], r0, s11[0], s12[0], r1]
 	  end
 	end
       end
       
-      Trace("rawresult #{rawresult.inspect}")
+      # Trace("Bezier.intersections rawresult #{rawresult.inspect}")
 
       # compute accurately coords
       # for the moment, just return mean
@@ -555,6 +600,8 @@ class Bezier < Curve
 	result += [(t1..t2).sample( r12 ), (t3..t4).sample( r34 )]
       end
 
+      # Trace("Bezier.intersections result #{result.inspect}")
+      
       return result
     end
 

data/lib/bezierbuilders.rb

@@ -93,7 +93,7 @@ class SimilarMotifIterator < BezierBuilder
   def compute
     result = []
     self.curvesampler.samples( self.nmotifs + 1).pairs do |p1,p2|
-      Trace("SimilarMotifIterator::compute p1 #{p1.inspect} p2 #{p2.inspect}")
+      # Trace("SimilarMotifIterator::compute p1 #{p1.inspect} p2 #{p2.inspect}")
       newbezier = self.motif.similar( (p1..p2) )
       result += newbezier.data
     end

data/lib/beziertools.rb

@@ -208,7 +208,6 @@ class Ondulation < BezierBuilder
     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
@@ -216,15 +215,18 @@ class Ondulation < BezierBuilder
     t1 = (tpoint - p1 ) / 6.0
     t2 = (tpoint - p2 ) / 6.0
     # Trace("newpoint #{newpoint.inspect} p1 #{p1.inspect} (newpoint - p1) #{(newpoint - p1).inspect}")
+    # TODO: following lines repetitive
     halftangent = self.support.tangent( mabs ).norm * (newpoint - p1).length / 3.0
-    # halftangent = self.support.tangent( mabs ).norm * (p2 - p1).length / 3.0
+    halftangent = self.support.tangent( mabs ).norm * (p2 - p1).length / 3.0
+    # Trace("halftangent #{halftangent.inspect} t1 #{t1.inspect} t2 #{t2.inspect}")
     return [[:vector, p1, t1, newpoint, -halftangent], [:vector, newpoint, halftangent, p2, t2]]
   end
   
   def compute_interpol( abs1, abs2, amplitude, sens )
-    arc = Bezier.multi( self.compute_arc( abs1, abs2, 1.0, sens ) )
+    orientation = amplitude > 0.0 ? 1.0 : -1.0
+    arc = Bezier.multi( self.compute_arc( abs1, abs2, orientation, sens ) )
     subsupport = self.support.subbezier( abs1, abs2 )
-    return InterBezier[ :bezierlist, [0.0, subsupport, 1.0, arc] ].sample( amplitude ).data
+    return InterBezier[ :bezierlist, [0.0, subsupport, 1.0, arc] ].sample( amplitude.abs ).data
   end
 
   # algo : for each abscissa, 0.0 of the curve (given the normal)

data/lib/color.rb

@@ -332,7 +332,6 @@ 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.hsla( h, s, l, a)
-    Trace("Color hsla")
     h = Range.O.trim( h )
     s = Range.O.trim( s )
     l = Range.O.trim( l )
@@ -511,7 +510,6 @@ class Palette
   end
 
   def apply_sample( abs ) #:nodoc:
-    Trace("Palette#apply_sample abs #{abs}")
     return self.color( abs )
   end
 

data/lib/interbezier.rb

@@ -20,16 +20,17 @@ class InterBezier
       indexes.push( index )
     end
 
+    # TODO: lengthH is useless 
     lengthH = {}
     alllengths = []
     beziers.each do |bezier|
       lengths = bezier.piecelengths
-      Trace("bezier lengths #{lengths.inspect}")
+      # Trace("bezier lengths #{lengths.inspect}")
       lengthH[ bezier ] = lengths
       alllengths += lengths
     end
     alllengths = Float.sort_float_list( alllengths )
-    Trace("alllengths #{alllengths.inspect}")
+    # Trace("alllengths #{alllengths.inspect}")
     
     newbezierlist = []
     beziers.each do |bezier|
@@ -42,10 +43,10 @@ class InterBezier
       newbezierlist << newbezier
     end
 
-    Trace("newbezierlist #{newbezierlist.length}")
+    # Trace("newbezierlist #{newbezierlist.length}")
     beziers = newbezierlist
     bezierpointlists = beziers.map {|bezier| bezier.pointlist(:vector) }
-    Trace("bezierpointlists #{bezierpointlists.map {|list| list.length}.inspect}")
+    # Trace("bezierpointlists #{bezierpointlists.map {|list| list.length}.inspect}")
     pointsequencelist = bezierpointlists.forzip
     @interpolatorlist = []
     pointsequencelist.foreach(beziers.size) do |pointsequence|

data/lib/interpolation.rb

@@ -89,6 +89,7 @@ class BinaryTreeRange
   end
 
   def range( index )
+    # Trace("BinaryTreeRange range index #{index} @limit #{@limit} quadright #{@quadright} quadleft #{@quadleft}")
     if @limit
       if index < @limit
 	return @quadleft.range( index )

data/lib/parametriclength.rb

@@ -30,7 +30,6 @@ module ParametricLength
     previous = nil
     samplelist = [0.0, 0.0]
     new      = V2D[0.0,0.0]
-    previous = nil
     self.parameter_range.samples( ParametricLength::NSAMPLES ) do |abs|
       self.pointfromparameter( abs, new )
       # Trace("compute_length_interpolator: abs #{abs} point #{new.inspect}")
@@ -57,10 +56,9 @@ module ParametricLength
 	newsamplelist += [sum / @length, abs ]
 	invsamplelist += [abs, sum / @length ]
       end
-      samplelist = newsamplelist
     end
     @abs_interpolator = InterpolatorBinaryTree.new( :samplelist, invsamplelist )
-    return InterpolatorBinaryTree.new( :samplelist, samplelist )
+    return InterpolatorBinaryTree.new( :samplelist, newsamplelist )
   end
 
   def length_interpolator() #:nodoc:

data/lib/samplation.rb

@@ -202,11 +202,10 @@ module Samplable
   end
 
   def rand(nsamples=1,&block)#:nodoc:
-    self.random()
     if nsamples == 1
-      return sample( 0.0 )
+      return sample( Range.O.rand )
     else
-      return samples( nsamples, &block )
+      return samples( Range.O.rand(nsamples), &block )
     end
   end
 
@@ -431,7 +430,7 @@ class RandomFilter < Filter
     rsum = rsizes.sum
     root = (0.0..(rsize-rsum)).rand
 
-    Trace("mindiffs #{mindiffs.inspect} rsizes #{rsizes.inspect} rsize #{rsize} rsum #{rsum} root #{root}")
+    # Trace("mindiffs #{mindiffs.inspect} rsizes #{rsizes.inspect} rsize #{rsize} rsum #{rsum} root #{root}")
 
     preresult = []
     mindiffs.zip( rsizes ) {|mindiff, rsize| preresult.push( mindiff + rsize )}

data/lib/spiral.rb

@@ -11,8 +11,6 @@ module XRVG
 # 
 # use compute_radius to compute nsamples reference points, before interpolating with SimpleBezier
 class GSpiral < Curve
-  extend Forwardable
-
   attribute :center, V2D::O, V2D
   attribute :ext,    V2D::O + V2D::X, V2D
   attribute :curvature, 1.0
@@ -21,13 +19,29 @@ class GSpiral < Curve
 
   attr_accessor :angle0, :r0, :maxangle
 
-  # setup prefered interface, enq() and deq()...
-  # def_delegator :@q, :push, :enq
-
   # delegate interfaces unknown for spiral to bezier
   # :length is computed by ParametricLength
-  def_delegators :bezier, :contour, :svg, :viewbox, :acc
+  # extend Forwardable
+  # def_delegators :bezier, :contour, :svg, :viewbox, :acc
+  def contour( *args )
+    return bezier.contour
+  end
 
+  def svg()
+    return bezier.svg
+  end
+
+  def viewbox()
+    return bezier.viewbox
+  end
+
+  def acc()
+    return bezier.acc
+  end
+
+  #
+  # builder
+  #
   def initialize( *args )
     super( *args )
     @r0, @angle0 = (@ext - @center).coords(:polar)

data/lib/xrvg.rb

@@ -3,7 +3,7 @@
 # Please refer to README for XRVG introduction
 
 # XRVG version (used in rakefile)
-XRVG_VERSION = "0.0.81"
+XRVG_VERSION = "0.0.82"
 
 # XRVG namespace
 module XRVG

data/test/test_bezier.rb

@@ -279,6 +279,17 @@ class BezierTest < Test::Unit::TestCase
     # assert_equal( bezier.pointlist, bezier.axesym( V2D::O, V2D[1.0,0.0] ).pointlist )
     assert_equal( bezier.firstpoint, bezier.axesym( V2D::O, V2D[1.0,0.0] ).firstpoint )
   end
+
+  def test_sides
+    assert_equal( 1, Circle[].bezier.sides.length )
+    c1 = Ondulation[ :support, LinearBezier[], :freq, 1, :ampl, 2.0 ]
+    c2 = Ondulation[ :support, LinearBezier[], :freq, 1, :ampl, -2.0 ]
+    c  = ClosureBezier[ :bezierlist, [c1, c2.reverse] ]
+    # assert_equal( 2, c.sides.length )
+
+    sub = c1.subbezier( 0.5, 0.6 )
+    # assert_equal( 2, (sub + LinearBezier[ :support, [sub.lastpoint, sub.firstpoint] ]).sides.length )
+  end
 end
 
   

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: xrvg
 version: !ruby/object:Gem::Version 
-  version: 0.0.81
-date: 2008-08-26 00:00:00 +02:00
+  version: 0.0.82
+date: 2008-12-05 00:00:00 +01:00
 summary: Ruby vector graphics library
 require_paths: 
 - lib
@@ -31,6 +31,7 @@ authors:
 files: 
 - Rakefile
 - LICENCE
+- lib/attributable.rb
 - lib/bezier.rb
 - lib/bezierbuilders.rb
 - lib/beziermotifs.rb
@@ -64,6 +65,8 @@ files:
 - examples/circlerecurse1.rb
 - examples/circlerecurse2.rb
 - examples/circlerecurseall.rb
+- examples/colorbezier.rb
+- examples/colorlinear.rb
 - examples/euclideangeo.rb
 - examples/evolution1.rb
 - examples/evolution2.rb