xrvg 0.0.3 → 0.0.4

data/lib/style.rb

@@ -5,6 +5,7 @@ require 'attributable'
 require 'utils'
 require 'color'
 
+module XRVG
 #
 # Style class 
 #
@@ -72,4 +73,4 @@ class Style
 				 "%strokeopacity%" => strokeopacity} )
   end
 end
-
+end

data/lib/trace.rb

@@ -2,6 +2,7 @@
 #  
 # Consists in a Trace class, and a Trace global method
 
+module XRVG
 # Trace "static" class, to be able to globally inhibit or activate traces 
 #  Trace.inihibit
 #  Trace.activate
@@ -26,3 +27,4 @@ def Trace(string)
     puts string
   end
 end
+end

data/lib/utils.rb

@@ -11,7 +11,6 @@
 require 'enumerator'
 require 'trace'
 require 'samplation'
-require 'assertion'
 
 #
 # Extend class Range with module Samplable and other utilitary methods
@@ -48,6 +47,12 @@ class Range
     return Range::Angle.clone
   end
 
+  # return symetric angle between 0 and of size .. 2*size
+  #   (-size..size)
+  def Range.sym( size )
+    size = size > 0.0 ? size : -size
+    return (-size..size)
+  end
 
   # compute the symetric of value in context of range
   #  (0.0..1.0).complement( 0.3 ) => 0.7
@@ -57,12 +62,33 @@ class Range
     return (self.end - diff)
   end
 
+  # utilitary method to force value to be in range
+  #  (0.0..1.0).trim( 3.0  ) => 1.0
+  #  (0.0..1.0).trim( -3.0 ) => 0.0
+  def trim( value )
+    if value > self.max
+      value = self.max
+    elsif value < self.min
+      value = self.min
+    end
+    return value
+  end
+
+  # return max value of range
+  def max
+    return (self.begin > self.end) ? self.begin : self.end
+  end
+
+  # return min value of range
+  def min
+    return (self.begin < self.end) ? self.begin : self.end
+  end
 
 # -------------------------------------------------------------
 #  Samplable interface include and overriding
 # -------------------------------------------------------------
-  include Samplable
-  include Splittable
+  include XRVG::Samplable
+  include XRVG::Splittable
 
   # Range base FloatFunctor overloading to do
   #   (1.0..2.0).sample( 0.3 ) => 1.3
@@ -131,7 +157,11 @@ class Range
   # inverse function of .sample
   #   (1.0..2.0).abscissa( 0.3 ) => 1.3
   def abscissa( value )
-    return (value - self.begin) / (self.end - self.begin)
+    if self.begin == self.end
+      return self.begin
+    else
+      return (value - self.begin) / (self.end - self.begin)
+    end
   end
   
   # return a new range with boundaries translated of "value"
@@ -139,6 +169,56 @@ class Range
   def translate( value )
     return (self.begin + value..self.end + value)
   end
+
+
+# -------------------------------------------------------------
+#   old methods to be refactored
+# -------------------------------------------------------------
+
+  # deprecated
+  #
+  # ratios sum must be equal to 1.0
+  def multisamples( nsamples, ratios )
+    ratiosum  = ratios.sum
+    samplesum = nsamples.sum
+    ratios = ratios.map {|ratio| ratio / ratiosum}
+    
+    rratios = ratios
+    index = 0
+    ratios.each do |ratio|
+      rratios[index] = ratio / nsamples[index]
+      index += 1
+    end
+    
+    sum = 0.0
+    samples = [0.0]
+    periodindex = 0
+    while sum <= 1.0
+      sum += rratios[ periodindex ]
+      if sum > 1.0
+	break
+      end
+      samples += [sum]
+      periodindex += 1
+      if periodindex >= rratios.length
+	periodindex = 0.0
+      end 
+    end
+    return self.samples( samples )
+  end
+
+  # deprecated
+  #
+  # TODO : must add gauss parameters
+  def randgauss()
+    begin 
+      x1 = 2.0 * Kernel::rand - 1.0
+      x2 = 2.0 * Kernel::rand - 1.0
+      w  = x1 * x1 + x2 * x2
+    end while w >= 1.0
+    w = Math.sqrt( ( -2.0 * Math.log( w ) ) / w )
+    return 1.0/2.0 * ( 1.0 + x1 * w )
+  end
   
 end
 
@@ -182,17 +262,10 @@ class Array
     return self.sum / self.size
   end
 
-  # compute range of an array
-  # - if proc nil, returns (min..max)
-  # - else, first compute new array with proc, then (min..max) on this array
+  # compute range of an array by returning (min..max)
   #   [1.0, 3.0, 2.0].range => (1.0..3.0) 
   def range( proc=nil )
-    if not proc
-      return (self.min..self.max)
-    else
-      arraytmp = self.map {|item| item.send( proc )}
-      return arraytmp.range
-    end
+    return (self.min..self.max)
   end
 
   # alias for sub(2)
@@ -314,8 +387,8 @@ class Array
 # -------------------------------------------------------------
 #  Samplable interface include and overriding
 # -------------------------------------------------------------
-  include Samplable
-  include Splittable
+  include XRVG::Samplable
+  include XRVG::Splittable
 
   # FloatFunctor overloading to synchronize content sampling and splitting
   def compute( inputs, type, &block )
@@ -342,8 +415,8 @@ class Float #:nodoc:
     return ( max - ( self.to_f - min ) )
   end
 
-  def fequal?( other )
-    return ((self - other).abs < 0.0000000001)
+  def fequal?( other, epsilon=0.0000000001 )
+    return ((self - other).abs < epsilon)
   end
 
   def randsplit(minsize=0.0)
@@ -354,6 +427,27 @@ class Float #:nodoc:
     return [min, max]
   end
 
+  def Float.sort_float_list( floatlist, epsilon=0.0000001 )
+    floatlist = floatlist.uniq.sort
+    result = [floatlist[0]]
+    floatlist[1..-1].each do |item|
+      if not item.fequal?( result[-1], epsilon)
+	result.push( item )
+      end
+    end
+    return result
+  end
+
+  def Float.floatlist_include?( floatlist, float, epsilon=0.0000001 )
+    floatlist.each do |item|
+      if item.fequal?( float, epsilon )
+	return true
+      end
+    end
+    return false
+  end
+
+
 end
 
 

data/lib/xrvg.rb

@@ -3,19 +3,23 @@
 # Please refer to README for XRVG introduction
 
 # XRVG version (used in rakefile)
-XRVG_VERSION = "0.0.3"
+XRVG_VERSION = "0.0.4"
+
+# XRVG namespace
+module XRVG
+end
 
 # Standard Ruby extensions
 require 'enumerator'
 
 # XRVG Infrastructure
 require 'trace'
-require 'assertion'
 
 # XRVG new mixins 
 require 'samplation'
 require 'attributable'
 require 'interpolation'
+require 'parametriclength'
 
 # XRVG base class extensions
 require 'utils'
@@ -29,8 +33,14 @@ require 'render'
 require 'bezier'
 
 # XRVG extensions
-# require 'bezierbuilders'
-# require 'beziertools'
-# require 'interbezier'
-# require 'ondulation'
+require 'fitting'
+require 'bezierbuilders'
+require 'beziermotifs'
+require 'beziertools'
+require 'interbezier'
+# require 'geovariety'
+# require 'spiral'
+# require 'graph'
+
+
 

data/test/test_attributable.rb

@@ -1,18 +1,33 @@
 require 'test/unit'
 require 'attributable'
 require 'utils'
+include XRVG
 
 class AttrClass
-  include Attributable
-
+  include XRVG::Attributable
+  
   attribute :a, 1.0
   attribute :b, nil, Float
   attribute :c
 end
 
+class AttrClass1
+  include XRVG::Attributable
+  
+  attribute :a, []
+  
+  def adda (value)
+    @a.push( value )
+  end
+end
 
 # Test class
 class AttributableTest < Test::Unit::TestCase
+
+  def test_object
+    object = Object[]
+  end
+
   
   def test_nominal
     obj = AttrClass[ :b, 2.0, :c, 3.0 ]
@@ -21,4 +36,21 @@ class AttributableTest < Test::Unit::TestCase
     assert_equal( 3.0, obj.c)
   end
 
+  def test_nominal2
+    obj1 = AttrClass[ :b, 2.0, :c, 2.0 ]
+    obj2 = AttrClass[ :b, 3.0, :c, 3.0 ]
+    
+    assert_equal( 1.0, obj1.a)
+    assert_equal( 2.0, obj1.b)
+    assert_equal( 3.0, obj2.c)
+  end
+
+  def test_init
+    obj1 = AttrClass1[]
+    obj2 = AttrClass1[]
+    obj2.adda(1)
+    assert_equal( [], obj1.a )
+  end
+
 end
+

data/test/test_bezier.rb

@@ -14,6 +14,9 @@ class BezierTest < Test::Unit::TestCase
     b = Bezier.new( :pieces, [BezierSpline[:raw, V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0]]] )
     assert_equal( V2D[0.0, 1.0], b.firstpoint )
 
+    b = Bezier[ :pieces, [BezierSpline[:raw, V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0]]]]
+    assert_equal( V2D[0.0, 1.0], b.firstpoint )
+
     b = Bezier.single( :raw, V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0] )
     assert_equal( V2D[0.0, 1.0], b.firstpoint )
 
@@ -39,6 +42,24 @@ class BezierTest < Test::Unit::TestCase
     assert_equal( V2D[0.0, 1.0], b.firstpoint )
     assert( V2D.vequal?( @@bezier.point( 0.1, nil, :parameter ), b.point( 0.1, nil, :parameter ) ) )
   end
+
+  def test_builder3
+    b = Bezier[ :pieces, [BezierSpline[:vector, V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0]]]]
+    assert_equal( V2D[0.0, 1.0], b.firstpoint )
+    assert_equal( V2D[0.0, 0.0], b.lastpoint )
+
+    assert_raise(RuntimeError) {Bezier.raws( 1.0, V2D[1.0, 1.0], V2D[1.0, 0.0], V2D[2.0, 0.0] )}
+  end
+
+  def test_piece_f
+    piece = BezierSpline[:vector, V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0]]
+    assert_equal( V2D[0.0, 1.0], piece.firstpoint )
+    assert_equal( V2D[0.0, 0.0], piece.lastpoint )
+    piece = BezierSpline[:vector, V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0]]
+    assert_equal( V2D[1.0, 1.0], piece.tangent(0.0) )
+    piece = BezierSpline[:vector, V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0]]
+    assert_equal( V2D[-2.0, -6.0], piece.acc(0.0) )
+  end
   
   def test_O
     assert_equal( [V2D::O, V2D::O, V2D::O, V2D::O], Bezier::O.pointlist )
@@ -88,6 +109,10 @@ class BezierTest < Test::Unit::TestCase
 
     assert_equal( [ V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0]], @@multibezier.piece(0.2, :parameter).pointlist )
     assert_equal( [ V2D[1.0, 0.0], V2D[2.0, 2.0], V2D[1.0, 1.0], V2D[2.0, 0.0]], @@multibezier.piece(1.2, :parameter).pointlist )
+
+    assert_raise(RuntimeError) {@@multibezier.pointlist(:toto)}
+    assert_raise(RuntimeError) {@@multibezier.piece(0.2,:toto).pointlist}
+    
   end
 
   def test_firstpoint
@@ -105,6 +130,24 @@ class BezierTest < Test::Unit::TestCase
     assert_equal( V2D[1.0, 0.0], beziers[1].firstpoint )
   end
 
+  def test_bezier_index
+    assert_equal( V2D[0.0, 1.0],  @@multibezier.bezier(0).firstpoint )
+    assert_equal( V2D[1.0, 0.0],  @@multibezier.bezier(1).firstpoint )
+  end
+
+  def test_data
+    assert_equal( [@@piece], @@bezier.data )
+  end
+
+  def test_subbezier
+    assert_equal( 1, @@multibezier.subbezier(0.0,0.1).piecenumber )
+    assert_equal( 2, @@multibezier.subbezier(0.1,0.6).piecenumber )
+
+    pieces = [[:raw, V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[0.0, 0.0], V2D[1.0, 0.0] ],
+              [: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 )
+  end
 
   def test_computelength
     assert( (1.0 -  Bezier.raw( V2D[0.0, 0.0], V2D[1.0, 0.0], V2D[0.0, 0.0], V2D[1.0, 0.0] ).length()).abs < 0.00001 ) 
@@ -151,8 +194,23 @@ class BezierTest < Test::Unit::TestCase
     assert( V2D.vequal?( V2D[0.0, 0.0], container ) )
   end
   
-  def test_ranges
-    assert_equal( [(0.0..1.0), (1.0..2.0)],  @@multibezier.ranges )
+  def test_frame
+    frame = @@bezier.frame( 0.0 )
+    assert_equal( @@bezier.point( 0.0 ), frame.center )
+    assert_equal( @@bezier.tangent( 0.0 ), frame.vector )
+  end
+
+  def test_reverse
+    assert_equal( [V2D[1.0, 0.0], V2D[0.0, 0.0], V2D[1.0, 1.0], V2D[0.0, 1.0]], @@bezier.reverse.pointlist )
+  end
+
+  def test_translate
+    assert_equal( [V2D[1.0, 4.0], V2D[2.0, 4.0], V2D[1.0, 3.0], V2D[2.0, 3.0] ], @@bezier.translate( V2D[1.0,3.0] ).pointlist )
+  end
+
+  def test_similar
+    assert_equal( [V2D[1.0, 4.0], V2D[2.0, 4.0], V2D[1.0, 3.0], V2D[2.0, 3.0] ], @@bezier.similar( (V2D[1.0,4.0]..V2D[2.0,3.0]) ).pointlist )
+    assert_raise(RuntimeError) {(@@bezier + @@bezier.reverse).similar( (V2D::O..V2D::X) )}
   end
 
   def test_split1
@@ -165,6 +223,39 @@ class BezierTest < Test::Unit::TestCase
     assert( V2D.vequal?( V2D::O, Bezier::O.split( 0.5,0.8 ).lastpoint ) )
   end
 
+  def test_splitblock
+    result = []
+    @@beziersym.splits( 2 ) do |subbezier|
+      result << subbezier
+    end
+    assert_equal( 2, result.length )
+  end
+
+  def test_svg
+    assert_equal( "<path d=\"M 0.0,1.0C 1.0,1.0 0.0,0.0 1.0,0.0\"/>", @@bezier.svg )
+    assert_equal( "<path d=\"M 0.0,1.0C 1.0,1.0 0.0,0.0 1.0,0.0C 0.0,0.0 1.0,1.0 0.0,1.0 z\"/>", (@@bezier + @@bezier.reverse).svg )
+  end
+
+  def test_gdebug
+    require 'render'
+    render = SVGRender[]
+    @@bezier.gdebug( render )
+  end
+
+  def test_piecelength
+    assert_equal( [0.0,1.0], @@bezier.piecelengths )
+    assert_equal( [0.0,0.5,1.0], (@@bezier + @@bezier.reverse).piecelengths )
+  end
+
+  def test_length_parameter_mapping
+    assert_equal( [1,0.0], (@@bezier + @@bezier.reverse).length_parameter_mapping(0.5, :left) )
+    assert_raise(RuntimeError) {@@multibezier.length_parameter_mapping(1.1, :left)}
+  end
+
+  def test_filter
+    assert( V2D.vequal?( V2D[0.5, 0.5], @@beziersym.filter(:point).sample( 0.5 ) ) )
+  end
+
 
 end