xrvg 0.0.5 → 0.0.6

data/lib/samplation.rb

@@ -3,6 +3,8 @@
 # The base module is FloatFunctor, used by Samplable and Splittable
 #
 
+require 'attributable'
+
 module XRVG
 #
 # Base module to define float lists processing and computation.
@@ -25,7 +27,7 @@ module FloatFunctor
 
   # building recursivity method
   #
-  # is private ?
+  # is private => no for Array
   def addfilter( newfilter )
     if not @subfilter
       @subfilter = newfilter
@@ -123,9 +125,20 @@ module FloatFunctor
     return self.addfilter( Filter.with {|x| 1.0 - Math.exp(-speed * x)} )
   end
 
+  # geometric filter full
+  def geofull( factor )
+    return self.addfilter( GeoFullFilter.new( factor ) )
+  end
+
+
+  # sin filter
+  def sin( speed=1.0, phase=0.0 )
+    return self.addfilter( Filter.with {|x| Math.sin( speed * x * Math::PI + phase) } )
+  end
+
   # random filter
-  def random()
-    return self.addfilter( RandomFilter.new )
+  def random(*args)
+    return self.addfilter( RandomFilter.new(*args) )
   end
   
   # sorting filter
@@ -133,6 +146,12 @@ module FloatFunctor
     return self.addfilter( SortFilter.new )
   end
 
+  # shuffle filter
+  def shuffle()
+    return self.addfilter( ShuffleFilter.new )
+  end
+  
+
   # alternate filter
   def alternate()
     return self.addfilter( AlternateFilter.new )
@@ -190,14 +209,6 @@ module Samplable
   # alias for mean
   alias middle mean
   
-  # alias for .random.samples
-  def rand(nsamples=1,&block)
-    inputs = []
-    nsamples.times {|v| inputs.push( Kernel::rand )}
-    result = self.process( inputs, :sample, &block )
-    return nsamples == 1 ? result[0] : result
-  end
-
   # to be overloaded if needed
   #
   # called by FloatFunctor apply method
@@ -297,7 +308,6 @@ end
 # this allow to do for example 
 #  [bezier1.filter(:point), bezier1.filter(:tangent), palette].samples( 10 ) do |point, tangent, color|
 class Filter
-
   include Samplable
   
   # to define a filter on "object" with method "samplemethod", or with a block (exclusive)
@@ -329,26 +339,85 @@ class Filter
 end
 
 
-# RandomFilter class, to resample randomly
+# = RandomFilter class, to resample randomly
+# == Attributes
+#   attribute :mindiff, 0.0
+#   attribute :sort, false
+# :mindiff specifies which minimum interval must be preserved between random values. Of course, the number of sampling must then be above a given value so that this constraint can be verified.
 class RandomFilter < Filter
-  def initialize(*args)  #:nodoc:
+  include Attributable
+  attribute :mindiff, 0.0
+  attribute :sort, false
+
+  # make sampling by trying to check :mindiff constraint
+  # 
+  # generate an exception if not possible
+  def rawtransforms(nsamples)
+    size  = 1.0
+    nsplit = nsamples - 1
+    rsize = size - nsplit * @mindiff
+    if rsize < 0.0
+      raise("RandomFilter rawtransforms error: nsamples #{nsamples} mindiff #{@mindiff} are incompatible")
+    end
+    
+    mindiffs = Array.new( nsplit, @mindiff )
+    
+    # compute now nsplit values whose sum is <= to rsize
+    randarray = [0.0]
+    subarray = (0.0..rsize).rand( nsplit-1 )
+    if not subarray.is_a? Array
+      subarray = [subarray]
+    end
+    randarray += subarray
+    randarray.push( rsize )
+    randarray.sort!
+
+    rsizes = Array.new
+    randarray.each_cons(2) { |min, max| rsizes.push( (0.0..max-min).rand ) }
+
+    rsum = rsizes.sum
+    root = (0.0..(rsize-rsum)).rand
+
+    Trace("mindiffs #{mindiffs.inspect} rsizes #{rsizes.inspect} rsize #{rsize} rsum #{rsum} root #{root}")
+
+    preresult = []
+    mindiffs.zip( rsizes ) {|mindiff, rsize| preresult.push( mindiff + rsize )}
+
+    result = [root]
+    preresult.each {|v| newv = result[-1] + v; result << newv }
+
+    return result
   end
   
-  def transform(abs)  #:nodoc:
+  # do (0.0..1.0).rand to speed up computation if @mindiff is 0.0
+  def basictransform( v )
     return (0.0..1.0).rand
   end
 
   def transforms( inputs, type )  #:nodoc:
-    result = inputs.map { |v| self.transform( v ) }
     if type == :split
-      result[0]  = 0.0
-      result[-1] = 1.0
+      @sort = true
+    end
+    if @mindiff == 0.0
+      result = inputs.map { |v| self.basictransform( v ) }
+      if @sort
+	result = result.sort
+      end
+      if type == :split
+	result[0]  = 0.0
+	result[-1] = 1.0
+      end
+    else
+      result = self.rawtransforms( inputs.size )
+      if not @sort
+	result = result.shuffle
+      end
     end
     return result
   end
 end
 
-# SortFilter, to sort inputs (in particular from Random)
+# SortFilter, to sort inputs (in particular from Shuffle)
 class SortFilter < Filter
   def initialize(*args)  #:nodoc:
   end
@@ -356,9 +425,42 @@ class SortFilter < Filter
   def transforms( inputs, type )  #:nodoc:
     return inputs.sort
   end
+end
+
+# GeoFullFilter, to transform inputs into geometrical sequence converging to 1.0
+class GeoFullFilter < Filter
+  def initialize(factor)  #:nodoc:
+    @factor = factor
+  end
 
+
+  # make sampling by trying to check :mindiff constraint
+  # 
+  # generate an exception if not possible
+  def transforms( inputs, type )  #:nodoc:
+    nsamples = inputs.size
+    result = [1.0]
+    (nsamples-1).times do
+      result << result[-1] / @factor
+    end
+    range = (1.0..result[-1])
+    result = result.map {|v| range.abscissa( v )}
+    return result
+  end
+end
+
+
+# ShuffleFilter, to unsort inputs (in particular from Random)
+class ShuffleFilter < Filter
+  def initialize(*args)  #:nodoc:
+  end
+
+  def transforms( inputs, type )  #:nodoc:
+    return inputs.sort_by { rand }
+  end
 end
 
+
 # AlternateFilter, to inverse one value per two
 class AlternateFilter < Filter
   def initialize(range=nil)  #:nodoc:

data/lib/shape.rb

@@ -4,10 +4,10 @@
 # - Curve interface
 # - Line class
 # - Circle class
+require 'utils'
 require 'frame'
 require 'geometry2D'
-require 'utils'
-require 'attributable'
+
 
 module XRVG
 # Shape abstract interface

data/lib/spiral.rb

@@ -0,0 +1,72 @@
+# File dedicated to Spiral curves
+# - Spiral
+# - SpiralParam
+# - SpiralFrise
+
+require 'shape'
+
+module XRVG
+
+# abstract class to define spiral types
+# 
+# use compute_radius to compute nsamples reference points, before interpolating with SimpleBezier
+class GSpiral < BezierBuilder
+  attribute :center, V2D::O, V2D
+  attribute :ext,    V2D::O + V2D::X, V2D
+  attribute :curvature, 1.0
+  attribute :nsamples, 100
+  
+  def compute_radius( r0, angle0, curvature, angle )
+    raise NotImplementedError.new("#{self.class.name}#compute_radius is an abstract method.")
+  end
+  
+  def maxangle( r0, angle0, curvature )
+    raise NotImplementedError.new("#{self.class.name}#maxangle is an abstract method.")
+  end
+
+  def compute()
+    points = []
+    r0, angle0 = (@ext - @center).coords(:polar)
+    maxangle = self.maxangle( r0, angle0, @curvature )
+    [(r0..0.0), (angle0..maxangle)].samples( self.nsamples ) do |radius, angle|
+      r = self.compute_radius( r0, angle0, @curvature, angle )
+      point = V2D.polar( r, angle )
+      points.push( @center + point )
+    end
+    return SimpleBezier.build( :support, points ).data
+  end
+end  
+
+# at angle angle0,             r = r0
+# at angle angle0 + curvature, r = 0.0
+class SpiralLinear < GSpiral
+
+  def maxangle( r0, angle0, curvature )
+    return (angle0 + curvature)
+  end
+
+  def compute_radius( r0, angle0, curvature, angle )
+    return r0 * (1.0 - ( 1.0 + (Math.exp( - 10.0 * ( angle- angle0) / curvature ) ) ) * ( angle - angle0 ) /curvature )
+    # return r0 * (1.0 - ( angle - angle0 ) /curvature )
+  end
+
+end
+
+# curvature is in number of tour before center % extremity
+class SpiralLog < GSpiral
+
+  def nsamples
+    return (curvature * 15.0).to_i
+  end
+
+  def compute_radius( r0, angle0, curvature, angle )
+    return r0 * Math.exp( -(angle-angle0) / curvature )
+  end
+
+  def maxangle( r0, angle0, curvature )
+    return angle0 - curvature * Math.log( 0.001 )
+  end
+end
+
+end #XRVG
+

data/lib/utils.rb

@@ -74,6 +74,39 @@ class Range
     return value
   end
 
+  # return modulo of value given interval
+  #  (-1.0..1.5).modulo( 2.0 ) => -0.5
+  #
+  # TODO: manage special case range size = 0.0
+  def modulo( value )
+    return ((value - self.min)%self.size + self.min)
+  end
+
+  # compute list of "modulo boundaries"
+  #  (-1.0..1.5).modulos( (-1.2..2.4) ) => [(1.3..1.5), (-1.0..1.5), (-1.0..0.4)]
+  def modulos( range )
+    t1 = self.modulo( range.min )
+    t2 = self.modulo( range.max )
+    s1 = ((range.min - self.min)/self.size).floor
+    s2 = ((range.max - self.min)/self.size).floor
+    if s1 == s2
+      result = [(t1..t2)]
+    else
+      result = [(t1..self.max)]
+      (s2-s1-1).times do 
+	result << (self.min..self.max)
+      end
+      if t2 - self.min > 0.0
+	result << (self.min..t2)
+      end
+    end
+    if range.begin > range.end
+      result = result.reverse.map {|v| v.reverse}
+    end
+    # Trace("modulos range #{range.inspect} result #{result.inspect}")
+    return result
+  end
+
   # return max value of range
   def max
     return (self.begin > self.end) ? self.begin : self.end
@@ -84,6 +117,11 @@ class Range
     return (self.begin < self.end) ? self.begin : self.end
   end
 
+  # return size of the range
+  def size
+    return (self.max - self.min)
+  end
+
 # -------------------------------------------------------------
 #  Samplable interface include and overriding
 # -------------------------------------------------------------
@@ -97,8 +135,10 @@ class Range
     return (self.begin + ( self.end - self.begin ) * value)
   end
 
-  # to speed up samplation on ranges, as used everywhere
-  def generate( nsamples ) #:nodoc:
+  # Very fundamental generator
+  #
+  # Generates a sequence of "nsamples" floats between 0.0 and 1.0 (included)
+  def Range.generate( nsamples )
     result = []
     if nsamples == 1
       result = [0.0]
@@ -107,21 +147,26 @@ class Range
     end
     return result
   end
+  
+  # Simply redirect on Range.generate
+  def generate( nsamples ) #:nodoc:
+    return Range.generate( nsamples )
+  end
 
   # apply_sample is good by default
   # apply_split  is good by default
 
-  # size of the range
-  #  (0.0..2.0).size => 2.0
-  def size
-    return self.end - self.begin
-  end
-
   # returns a reversed range 
   #  (1.0..2.0).reverse => (2.0..1.0)
   def reverse
     return Range.new( self.end, self.begin )
   end
+  
+  # returns an increasing Range
+  #  (2.0..1.0).sort => (1.0..2.0)
+  def sort
+    return (self.begin > self.end ? Range.new( self.end, self.begin ) : Range.new( self.begin, self.end ))
+  end
 
   # resize range by factor, with fixed point center of the range
   #  (1.0..2.0).resize( 0.5 ) => (1.25..1.75) 
@@ -207,6 +252,14 @@ class Range
     return self.samples( samples )
   end
 
+  # alias for .random.samples
+  def rand(nsamples=1,&block)
+    inputs = []
+    nsamples.times {|v| inputs.push( Kernel::rand )}
+    result = self.process( inputs, :sample, &block )
+    return nsamples == 1 ? result[0] : result
+  end
+
   # deprecated
   #
   # TODO : must add gauss parameters
@@ -262,10 +315,22 @@ class Array
     return self.sum / self.size
   end
 
+  # return a random item from array
+  def choice
+    return self[Kernel::rand(self.size)]
+  end
+
   # compute range of an array by returning (min..max)
   #   [1.0, 3.0, 2.0].range => (1.0..3.0) 
+  # if proc supplied, use it to return range of subvalues
+  #  [V2D::O, V2D::X].range( :x ) => (0.0..1.0)
   def range( proc=nil )
-    return (self.min..self.max)
+    if not proc
+      return (self.min..self.max)
+    else
+      arraytmp = self.map {|item| item.send( proc )}
+      return arraytmp.range
+    end
   end
 
   # alias for sub(2)
@@ -384,6 +449,11 @@ class Array
     return result
   end
 
+  # shuffle values in array
+  def shuffle
+    return self.sort_by{ rand }
+  end
+
 # -------------------------------------------------------------
 #  Samplable interface include and overriding
 # -------------------------------------------------------------
@@ -395,6 +465,10 @@ class Array
     return self.map {|v| v.compute( inputs, type )}.forzip(nil,&block)
   end
 
+  def addfilter( newfilter )
+    self.each {|v| v.addfilter( newfilter )}
+  end
+
 end
 
 # -------------------------------------------------------------
@@ -409,24 +483,21 @@ class String #:nodoc:
 
 end
 
-class Float #:nodoc:
-
-  def complement( max = 1.0, min = 0.0 )
-    return ( max - ( self.to_f - min ) )
-  end
-
+# Ruby base class Float extension
+#
+# Mainly to be able to compare two floats with specific accuracy
+class Float
+  
+  # compare two Float with specific precision
+  #  assert( 0.25.fequal?( 0.26,0.02) )
+  #  assert_equal( false, 0.25.fequal?( 0.26,0.01) )
   def fequal?( other, epsilon=0.0000000001 )
     return ((self - other).abs < epsilon)
   end
 
-  def randsplit(minsize=0.0)
-    v = self.to_f
-    rand = minsize + Kernel::rand * (1.0 - minsize )
-    min = v * rand
-    max = v - min
-    return [min, max]
-  end
-
+  # sort and remove duplicated elements of a float list with specific precision
+  #    assert_equal( [0.25],      Float.sort_float_list([0.26,0.25], 0.02 ) )
+  #    assert_equal( [0.25,0.26], Float.sort_float_list([0.26,0.25], 0.01 ) )
   def Float.sort_float_list( floatlist, epsilon=0.0000001 )
     floatlist = floatlist.uniq.sort
     result = [floatlist[0]]
@@ -438,6 +509,9 @@ class Float #:nodoc:
     return result
   end
 
+  # check if an Float item is included in a Float list, with specific precision
+  #   assert( Float.floatlist_include?( [1.0,2.0,3.0001,4.0], 3.0, 0.001 ) )
+  #   assert_equal( false, Float.floatlist_include?( [1.0,2.0,3.0001,4.0], 3.0, 0.0001 ) )
   def Float.floatlist_include?( floatlist, float, epsilon=0.0000001 )
     floatlist.each do |item|
       if item.fequal?( float, epsilon )
@@ -446,58 +520,5 @@ class Float #:nodoc:
     end
     return false
   end
-
-
-end
-
-
-class Integer #:nodoc:
-
-
-  def randsplit!(minsize=0.0)
-    size  = 1.0
-    nsplit = self.to_i
-    rsize = size - nsplit * minsize
-    if rsize < 0.0
-      return []
-    end
-    
-    minsizes = Array.new( nsplit, minsize )
-    # puts "minsizes #{minsizes.join(" ")}"
-    
-    randarray = [0.0]
-    subarray = (0.0..rsize).rand( nsplit - 1 )
-    Trace("subarray #{subarray.inspect}")
-    randarray += subarray
-    randarray.push( rsize )
-    randarray.sort!
-
-    # puts "randarray #{randarray.join(" ")}"
-    
-    rsizes = Array.new
-    randarray.each_cons(2) { |min, max| rsizes.push( max - min ) }
-
-    # puts "rsizes #{rsizes.join(" ")}"
-    
-    result = Array.new
-    minsizes.zip( rsizes ) {|minsize, rsize| result.push( minsize + rsize )}
-    
-    # puts "result randsplit! #{result.join(" ")}"
-
-    return result
-  end
-
-  def randsplitsum!(minsize=0.0)
-    preresult = self.randsplit!(minsize)
-    
-    result = Array.new
-    sum = 0
-    preresult.each {|v| sum += v; result.push( sum ) }
-    
-    # puts "result randsplitsum! #{result.join(" ")}"
-    return result
-  end
-
-
 end
 

data/lib/xrvg.rb

@@ -1,9 +1,9 @@
-# This file is to be included if you want to start a XRVG script
+# This file has to be included if you want to start a XRVG script
 #
 # Please refer to README for XRVG introduction
 
 # XRVG version (used in rakefile)
-XRVG_VERSION = "0.0.5"
+XRVG_VERSION = "0.0.6"
 
 # XRVG namespace
 module XRVG
@@ -39,7 +39,7 @@ require 'beziermotifs'
 require 'beziertools'
 require 'interbezier'
 require 'geovariety'
-# require 'spiral'
+require 'spiral'
 # require 'graph'
 
 

data/test/test_bezier.rb

@@ -147,6 +147,7 @@ class BezierTest < Test::Unit::TestCase
               [:raw, V2D[1.0, 0.0], V2D[2.0, 2.0], V2D[1.0, 1.0], V2D[2.0, 0.0] ],
               [:raw, V2D[2.0, 0.0], V2D[2.0, 2.0], V2D[1.0, 1.0], V2D[3.0, 0.0] ]]
     assert_equal( 3, Bezier.multi( pieces ).subbezier(0.1,0.9).piecenumber )
+    assert_equal( 3, Bezier.multi( pieces ).subbezier(0.9,0.1).piecenumber )
   end
 
   def test_computelength
@@ -237,7 +238,7 @@ class BezierTest < Test::Unit::TestCase
   end
 
   def test_gdebug
-    require 'render'
+    # require 'render'
     render = SVGRender[]
     @@bezier.gdebug( render )
   end
@@ -256,7 +257,21 @@ class BezierTest < Test::Unit::TestCase
     assert( V2D.vequal?( V2D[0.5, 0.5], @@beziersym.filter(:point).sample( 0.5 ) ) )
   end
 
-
+  def test_transform
+    bezier = Bezier.raw( V2D[0.0, 0.0], V2D[1.0, 0.0], V2D[-1.0, 0.0], V2D[1.0, 0.0] )
+    # assert_equal( [V2D[0.0, 0.0], V2D[-1.0, 0.0], V2D[1.0, 0.0], V2D[-1.0, 0.0]], bezier.rotate( Range.Angle.sample( 0.5 ) ).pointlist )
+    assert_equal( V2D[0.0, 0.0], bezier.rotate( Range.Angle.sample( 0.5 ) ).firstpoint )
+    # assert_equal( bezier.pointlist, bezier.rotate( Range.Angle.sample( 1.0 ) ).pointlist )
+    assert_equal( bezier.firstpoint, bezier.rotate( Range.Angle.sample( 1.0 ) ).firstpoint )
+    # assert_equal( [V2D[0.0, 0.0], V2D[-1.0, 0.0], V2D[1.0, 0.0], V2D[-1.0, 0.0]], bezier.sym( V2D::O ).pointlist )
+    assert_equal( V2D[0.0, 0.0], bezier.sym( V2D::O ).firstpoint )
+    # assert_equal( bezier.pointlist, bezier.sym( V2D::O ).sym( V2D::O ).pointlist  )
+    assert_equal( bezier.firstpoint, bezier.sym( V2D::O ).sym( V2D::O ).firstpoint  )
+    # assert_equal( [V2D[0.0, 0.0], V2D[-1.0, 0.0], V2D[1.0, 0.0], V2D[-1.0, 0.0]], bezier.axesym( V2D::O, V2D[0.0,1.0] ).pointlist )
+    assert_equal( V2D[0.0, 0.0], bezier.axesym( V2D::O, V2D[0.0,1.0] ).firstpoint )
+    # 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
 end
 
   

data/test/test_bezierbuilders.rb

@@ -87,6 +87,6 @@ end
 class CircleTest < Test::Unit::TestCase
 
   def test_bezier
-    assert_equal( 2, Circle[].bezier.piecenumber )
+    assert_equal( 4, Circle[].bezier.piecenumber )
   end
 end

data/test/test_beziertools.rb

@@ -9,6 +9,13 @@ class SimpleBezierTest < Test::Unit::TestCase
     assert_raise(RuntimeError){SimpleBezier[ :support, [V2D::O] ]}
     assert_equal( SimpleBezier[ :support, [V2D::O,V2D::X] ].point( 0.3 ), LinearBezier[ :support, [V2D::O,V2D::X] ].point( 0.3 )  )
   end
+
+  def test_interpolation
+    interpolator = Interpolator[ :samplelist, [0.0,0.0, 0.5,1.0, 1.0,0.0], :interpoltype, :simplebezier]
+    assert( 1.0.fequal?( interpolator.interpolate( 0.5 ) ) )
+    assert( 0.0.fequal?( interpolator.interpolate( 1.0 ) ) )
+  end
+
 end
 
 class ClosureTest < Test::Unit::TestCase

data/test/test_color.rb

@@ -20,6 +20,7 @@ class ColorTest < Test::Unit::TestCase
     green  = Color[0.0, 1.0, 0.0, 1.0]
     yellow = Color[1.0, 1.0, 0.0, 1.0]
     orange = Color[1.0, 0.5, 0.0, 1.0]
+    grey10 = Color[0.1, 0.1, 0.1, 1.0]
     assert_equal( black, Color.black )
     assert_equal( white, Color.white )
     assert_equal( red, Color.red )
@@ -27,6 +28,7 @@ class ColorTest < Test::Unit::TestCase
     assert_equal( green, Color.green )
     assert_equal( yellow, Color.yellow )
     assert_equal( orange, Color.orange )
+    assert_equal( grey10, Color.grey( 0.1 ) )
   end
 
   def test_rand
@@ -84,6 +86,10 @@ class ColorTest < Test::Unit::TestCase
     assert_equal( [25,25,25,25], Color[0.1,0.1,0.1,0.1].format255 )
   end
 
+  def test_operators
+    assert_equal( Color[0.2, 0.4, 0.6, 1.0], Color[0.1, 0.2, 0.3, 0.5 ] + Color[0.1, 0.2, 0.3, 0.5 ] )
+    assert_equal( Color[0.2, 0.4, 0.6, 1.0], Color[0.1, 0.2, 0.3, 0.5 ] * 2.0 )
+  end
 end
 
 
@@ -101,6 +107,12 @@ class PaletteTest < Test::Unit::TestCase
     palette = Palette.new( :colorlist, [ 0.0, Color.black, 0.3, Color.red,  1.0, Color.white ] ).reverse
     assert_equal( Color.red, palette.color( 0.7 ) )
   end
+
+  def test_interpolator
+    palette = Palette.new( :colorlist, [ 0.0, Color.black, 0.3, Color.red,  1.0, Color.white ] )
+    palette.interpoltype = :linear
+    assert_equal( :linear, palette.interpoltype  )
+  end
   
 end