xrvg 0.0.3 → 0.0.4

data/test/test_bezierbuilders.rb

@@ -0,0 +1,92 @@
+require 'test/unit'
+require 'bezierbuilders'
+
+
+class BezierBuilderTest < Test::Unit::TestCase
+
+  def test_abstract
+    assert_raise(NotImplementedError){BezierBuilder.new.compute}
+  end
+
+  def test_lissage
+    bezier = Bezier.multi( [[:vector, V2D::O, V2D::X, V2D::X, V2D::X], [:vector, V2D::X, V2D::X, V2D::X * 2.0, V2D::X]] )
+    assert_equal( bezier.pointlist, BezierBuilder.lissage( bezier, 0.0 ).pointlist )
+    assert_equal( [V2D::O, V2D::X, V2D::X, V2D::O, V2D::X, V2D::O, V2D::X * 2.0, V2D::X], BezierBuilder.lissage( bezier, 1.0 ).pointlist(:vector) )
+  end
+
+end
+
+class SimilarMotifIteratorTest < Test::Unit::TestCase
+
+  def test_all
+    bezier = Bezier.multi( [[:vector, V2D::O, V2D::X, V2D::X, V2D::X]] )
+    simibezier = SimilarMotifIterator[ :curvesampler, bezier, :motif, bezier, :nmotifs, 2 ]
+    assert( V2D.vequal?( bezier.firstpoint, simibezier.firstpoint ))
+    assert( V2D.vequal?(bezier.lastpoint, simibezier.lastpoint ))
+    assert( V2D.vequal?(bezier.point( 0.5 ), simibezier.bezier(0).lastpoint ))
+  end
+end
+
+class AttributeMotifIteratorTest < Test::Unit::TestCase
+
+  def test_all
+    require 'beziermotifs'
+    bezier = Bezier.multi( [[:vector, V2D::O, V2D::X, V2D::X, V2D::X]] )
+    simibezier = AttributeMotifIterator[ :curvesampler, bezier, :motifclass, LinearBezier, :nmotifs, 2, :closed, false ]
+    assert( V2D.vequal?( bezier.firstpoint, simibezier.firstpoint ))
+    assert( V2D.vequal?(bezier.lastpoint, simibezier.lastpoint ))
+    assert( V2D.vequal?(bezier.point( 0.5 ), simibezier.bezier(0).lastpoint ))
+  end
+
+  def test_all2
+    require 'beziermotifs'
+    bezier = Bezier.multi( [[:vector, V2D::O, V2D::X, V2D::X, V2D::X]] )
+    simibezier = AttributeMotifIterator[ :curvesampler, bezier, :motifclass, LinearBezier, :nmotifs, 2, :closed, true ]
+    assert( V2D.vequal?( bezier.firstpoint, simibezier.firstpoint ))
+    assert( V2D.vequal?(bezier.point( 0.5 ), simibezier.lastpoint ))
+    assert( V2D.vequal?(bezier.point( 0.5 ), simibezier.bezier(0).lastpoint ))
+    assert_equal( 4, simibezier.piecenumber )
+  end
+
+  def test_all3
+    require 'beziermotifs'
+    bezier = Bezier.multi( [[:vector, V2D::O, V2D::X, V2D::X, V2D::X]] )
+    simibezier = AttributeMotifIterator[ :curvesampler, bezier, :motifclass, PicBezier, :attributes, [:height, (0.0..1.0)], :nmotifs, 2, :closed, true ]
+    assert( V2D.vequal?( bezier.firstpoint, simibezier.firstpoint ))
+    assert( V2D.vequal?(bezier.point( 0.5 ), simibezier.lastpoint ))
+    assert( V2D.vequal?(bezier.point( 0.5 ), simibezier.bezier(1).lastpoint ))
+    assert_equal( 6, simibezier.piecenumber )
+  end
+
+  def test_all4
+    require 'beziermotifs'
+    bezier = Bezier.multi( [[:vector, V2D::O, V2D::X, V2D::X, V2D::X]] )
+    simibezier = AttributeMotifIterator[ :curvesampler, bezier, :motifclass, ArcBezier, :attributes, [:height, 1.0], :nmotifs, 2, :closed, true ]
+    assert( V2D.vequal?( bezier.firstpoint, simibezier.firstpoint ))
+    assert( V2D.vequal?(bezier.point( 0.5 ), simibezier.lastpoint ))
+    assert( V2D.vequal?(bezier.point( 0.5 ), simibezier.bezier(2).firstpoint ))
+    assert_equal( 4, simibezier.piecenumber )
+  end
+
+  def test_complete
+    assert_equal( V2D::O, LinearBezier.buildwithangle( 0.0 ).firstpoint )
+  end
+
+end
+
+class FitBezierBuilderTest < Test::Unit::TestCase
+
+  def test_all
+    bezier = Bezier.raw( V2D[0.0, 0.0], V2D[100.0, 0.0], V2D[0.0, 100.0], V2D[100.0, 100.0] )
+    points = bezier.samples( 15 )
+    fit  = FitBezierBuilder[ :points, points, :maxerror, 0.001 ]
+    assert_equal( 3, fit.piecenumber )
+  end
+end
+
+class CircleTest < Test::Unit::TestCase
+
+  def test_bezier
+    assert_equal( 2, Circle[].bezier.piecenumber )
+  end
+end

data/test/test_beziertools.rb

@@ -0,0 +1,97 @@
+require 'beziertools'
+require 'test/unit'
+
+class SimpleBezierTest < Test::Unit::TestCase
+  def test_all
+    bezier = SimpleBezier[ :support, [V2D::O,V2D::X, V2D::X+V2D::Y] ]
+    assert_equal( V2D::O, bezier.firstpoint )
+    assert_equal( 2, bezier.piecenumber )
+    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
+end
+
+class ClosureTest < Test::Unit::TestCase
+
+  def test_all
+    bezier = SimpleBezier[ :support, [V2D::O, V2D::X, V2D::X+V2D::Y] ]
+    closure = ClosureBezier[ :bezierlist, [bezier, LinearBezier[ :support, [V2D::X, -V2D::X] ]]]
+    assert_equal( V2D::O, closure.lastpoint )
+    assert_equal( 5, closure.piecenumber )
+  end
+
+end
+
+class OffestTest < Test::Unit::TestCase
+
+  def test_all
+    bezier = LinearBezier.buildwithangle( 0.0 )
+    offset = Offset[ :support, bezier, :ampl, 1.0, :nsamples, 10 ]
+    assert( V2D.vequal?( V2D::O + V2D::Y, offset.firstpoint ) )
+    assert( V2D.vequal?( V2D::O + V2D::X + V2D::Y, offset.lastpoint ) )
+  end
+
+  def test_roller
+    bezier = LinearBezier.buildwithangle( 0.0 )
+    offset = Offset[ :support, bezier, :ampl, (0.0..1.0).samples(10), :nsamples, 10 ]
+    assert( V2D.vequal?( V2D::O, offset.firstpoint ) )
+    assert( V2D.vequal?( V2D::O + V2D::X + V2D::Y, offset.lastpoint ) )
+  end
+
+  def test_sampler
+    bezier = LinearBezier.buildwithangle( 0.0 )
+    offset = Offset[ :support, bezier, :ampl, (0.0..1.0), :nsamples, 10 ]
+    assert( V2D.vequal?( V2D::O, offset.firstpoint ) )
+    assert( V2D.vequal?( V2D::O + V2D::X + V2D::Y, offset.lastpoint ) )
+  end
+
+end
+    
+class FuseauTest < Test::Unit::TestCase
+
+  def test_all
+    bezier = LinearBezier.buildwithangle( 0.0 )
+    offset = Fuseau[ :support, bezier, :maxwidth, 1.0, :nsamples, 10 ]
+    assert( V2D.vequal?( V2D::O + V2D::X, offset.lastpoint ) )
+    assert( V2D.vequal?( V2D::O + V2D::Y, offset.firstpoint ) )
+  end
+
+end
+
+class BezierLevelTest < Test::Unit::TestCase
+
+  def test_all
+    offset = BezierLevel[ :samplelist, [0.0,0.0, 1.0,1.0]]
+    assert( V2D.vequal?( V2D::O, offset.firstpoint ) )
+    assert( V2D.vequal?( V2D::O + V2D::Y + V2D::X, offset.lastpoint ) )
+  end
+
+end
+
+class OndulationTest < Test::Unit::TestCase
+
+  def test_all
+    bezier = LinearBezier.buildwithangle( 0.0 )
+    ondulation = Ondulation[ :support, bezier, :ampl, 1.0, :freq, 2 ]
+    assert( V2D.vequal?( V2D::O, ondulation.firstpoint ) )
+    assert_equal( 4, ondulation.piecenumber )
+  end
+
+  def test_roller
+    bezier = LinearBezier.buildwithangle( 0.0 )
+    ondulation = Ondulation[ :support, bezier, :ampl, (0.0..1.0).samples(2), :freq, 2 ]
+    assert( V2D.vequal?( V2D::O, ondulation.firstpoint ) )
+    assert_equal( 4, ondulation.piecenumber )
+  end
+
+  def test_sampler
+    bezier = LinearBezier.buildwithangle( 0.0 )
+    ondulation = Ondulation[ :support, bezier, :ampl, (0.0..1.0), :freq, 2 ]
+    assert( V2D.vequal?( V2D::O, ondulation.firstpoint ) )
+    assert_equal( 4, ondulation.piecenumber )
+  end
+
+end
+
+
+    

data/test/test_color.rb

@@ -13,10 +13,20 @@ class ColorTest < Test::Unit::TestCase
   end
 
   def test_colors
-    black = Color[0.0, 0.0, 0.0, 1.0]
-    white = Color[1.0, 1.0, 1.0, 1.0]
+    black  = Color[0.0, 0.0, 0.0, 1.0]
+    white  = Color[1.0, 1.0, 1.0, 1.0]
+    blue   = Color[0.0, 0.0, 1.0, 1.0]
+    red    = Color[1.0, 0.0, 0.0, 1.0]
+    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]
     assert_equal( black, Color.black )
     assert_equal( white, Color.white )
+    assert_equal( red, Color.red )
+    assert_equal( blue, Color.blue )
+    assert_equal( green, Color.green )
+    assert_equal( yellow, Color.yellow )
+    assert_equal( orange, Color.orange )
   end
 
   def test_svg
@@ -30,6 +40,43 @@ class ColorTest < Test::Unit::TestCase
     assert_equal( black, Color.hsv( 0.0, 0.0, 0.0, 1.0 ) )
     assert_equal( white, Color.hsv( 0.0, 0.0, 1.0, 1.0 ) )
     assert_equal( red,   Color.hsv( 0.0, 1.0, 1.0, 1.0 ) )
+    assert_equal( black, Color.hsv( 0.2, 1.0, 0.0, 1.0 ) )
+    assert_equal( black, Color.hsv( 0.4, 1.0, 0.0, 1.0 ) )
+    assert_equal( black, Color.hsv( 0.6, 1.0, 0.0, 1.0 ) )
+    assert_equal( black, Color.hsv( 0.8, 1.0, 0.0, 1.0 ) )
+    assert_equal( black, Color.hsv( 1.0, 1.0, 0.0, 1.0 ) )
+  end
+
+  def test_hsl
+    black = Color[0.0, 0.0, 0.0, 1.0]
+    white = Color[1.0, 1.0, 1.0, 1.0]
+    red   = Color[1.0, 0.0, 0.0, 1.0]
+    assert_equal( black, Color.hsl( 0.0, 0.0, 0.0, 1.0 ) )
+    assert_equal( white, Color.hsl( 0.0, 0.0, 1.0, 1.0 ) )
+    assert_equal( white, Color.hsl( 0.0, 1.0, 1.0, 1.0 ) )
+    assert_equal( white, Color.hsl( 2.0, 1.0, 1.0, 1.0 ) )
+    assert_equal( white, Color.hsl( 0.6, 1.0, 1.0, 1.0 ) )
+  end
+
+
+  def test_accessors
+    black = Color[0.0, 0.0, 0.0, 1.0]
+    assert_equal( 0.0, black.r )
+    assert_equal( 0.0, black.g )
+    assert_equal( 0.0, black.b )
+    assert_equal( 1.0, black.a )
+    black.r = 1.0
+    assert_equal( 1.0, black.r )
+    black.g = 1.0
+    assert_equal( 1.0, black.g )
+    black.b = 1.0
+    assert_equal( 1.0, black.b )
+    black.a = 0.0
+    assert_equal( 0.0, black.a )
+  end
+
+  def test_format255
+    assert_equal( [255,255,255,255], Color.white.format255 )
   end
 
 end
@@ -40,40 +87,34 @@ class PaletteTest < Test::Unit::TestCase
   def test_palette
     palette = Palette.new( :colorlist, [ 0.0, Color.black, 1.0, Color.white ] )
     assert_equal( Color[0.5, 0.5, 0.5, 1.0], palette.color( 0.5 ) )
+    assert_equal( Color[0.5, 0.5, 0.5, 1.0], palette.sample( 0.5 ) )
+  end
+
+  def test_reverse
+    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
+  
 end
 
 class GradientTest < Test::Unit::TestCase
 
   def test_gradient
+    assert_raise(NotImplementedError) {Gradient[ :colorlist, [0.0, Color.black, 1.0, Color.white]].defsvg}
+  end
+
+  def test_lineargradient
     gradient = LinearGradient.new( :colorlist, [0.0, Color.black, 1.0, Color.white] )
     assert_equal( gradient.svgdef,
 		 "<linearGradient id=\"%ID%\" x1=\"0%\" y1=\"0%\" x2=\"0%\" y2=\"100%\">\n<stop offset=\"0.0\" stop-color=\"rgb(0,0,0)\" stop-opacity=\"1.0\"/>\n<stop offset=\"1.0\" stop-color=\"rgb(255,255,255)\" stop-opacity=\"1.0\"/>\n</linearGradient>")
 	
   end
 
-  if nil
-  def test_gradient1
-    require 'render'
-    require 'shape'
-    render = SVGRender.new( :filename, "gradient1.svg" )
-    render.add( Circle.new, Style.new( :stroke, "none", :fill, LinearGradient.new( :colorlist, [0.0, Color.black, 1.0, Color.white] ) ) )
-    render.end
-    assert( File.exist?( "gradient1.png" ) )
-  end
-  end
+  def test_circulargradient
+    circle   = Circle.new
+    gradient = CircularGradient.new( :colorlist, [0.0, Color.black(1.0), 1.0, Color.black(0.0)], :circle, circle )
+    assert_equal( gradient.svgdef,
+		 "<radialGradient id=\"%ID%\" gradientUnits=\"userSpaceOnUse\" cx=\"0.0\" cy=\"0.0\" r=\"1.0\">\n<stop offset=\"0.0\" stop-color=\"rgb(0,0,0)\" stop-opacity=\"1.0\"/>\n<stop offset=\"1.0\" stop-color=\"rgb(0,0,0)\" stop-opacity=\"0.0\"/>\n</radialGradient>")
 
-  if nil
-  def test_gradient2
-    require 'render'
-    require 'shape'
-    render = SVGRender.new( :filename, "gradient2.svg" )
-    circle = Circle.new
-    style = Style.new( :stroke, "none", :fill, CircularGradient.new( :colorlist, [0.0, Color.black(1.0), 1.0, Color.black(0.0)], :circle, circle ) )
-    render.add( circle, style )
-    render.end
-    assert( File.exist?( "gradient2.png" ) )
   end
-  end
-
 end

data/test/test_fitting.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+require 'fitting'
+
+class FittingTest < Test::Unit::TestCase
+
+  def test_base
+    bezier = Bezier.raw( V2D[0.0, 0.0], V2D[100.0, 0.0], V2D[0.0, 100.0], V2D[100.0, 100.0] )
+    points = bezier.samples( 30 )
+    fit    = Fitting.compute( points, 0.000001, 500 )
+    assert( V2D.vequal?( bezier.pointlist[1], fit.pointlist[1], 0.01) )
+    assert( V2D.vequal?( bezier.pointlist[2], fit.pointlist[2], 0.01) )
+  end
+
+  def test_base2
+    bezier = Bezier.raw( V2D[0.0, 0.0], V2D[100.0, 0.0], V2D[0.0, 100.0], V2D[100.0, 100.0] )
+    points = bezier.samples( 15 )
+    fit, error  = Fitting.adaptative_compute( points, 0.01 )
+    assert_equal( 1, fit.piecenumber )
+  end
+
+  def test_base3
+    bezier = Bezier.raw( V2D[0.0, 0.0], V2D[100.0, 0.0], V2D[0.0, 100.0], V2D[100.0, 100.0] )
+    points = bezier.samples( 15 )
+    fit, error  = Fitting.adaptative_compute( points, 0.001 )
+    assert_equal( 3, fit.piecenumber )
+  end
+
+
+  def test_limit
+    points = [V2D[0.0, 0.0]] * 10
+    fit, error  = Fitting.adaptative_compute( points, 0.01 )
+    assert_equal( 1, fit.piecenumber )
+  end
+
+
+  def test_limit2
+    bezier = Bezier.raw( V2D[0.0, 0.0], V2D[100.0, 0.0], V2D[0.0, 100.0], V2D[100.0, 100.0] )
+    points = bezier.samples( 30 )
+    points = [points[0]] + points
+    fit    = Fitting.compute( points, 0.000001, 500 )
+    assert( V2D.vequal?( bezier.pointlist[1], fit.pointlist[1], 0.01) )
+    assert( V2D.vequal?( bezier.pointlist[2], fit.pointlist[2], 0.01) )
+  end
+
+
+
+end

data/test/test_frame.rb

@@ -5,8 +5,13 @@ require 'geometry2D'
 class FrameTest < Test::Unit::TestCase
   
   def test_frame1
-    frame = Frame[ :center, V2D[0.0,0.0], :vector, V2D[1.0,0.0], :rotation, 0.0, :scale, 1.0 ]
-    assert_equal( 0.0, frame.center.x )
+    frame1 = Frame[ :center, V2D[0.0,0.0], :vector, V2D[1.0,0.0], :rotation, 0.0, :scale, 1.0 ]
+    frame2 = Frame[ :center, V2D[0.0,0.0], :vector, V2D[1.0,0.0], :rotation, 0.0, :scale, 1.0 ]
+    frame3 = Frame[ :center, V2D[0.0,0.0], :vector, V2D[1.0,0.0], :rotation, 1.0, :scale, 1.0 ]
+
+    assert_equal( 0.0, frame1.center.x )
+    assert( frame1 == frame2 )
+    assert( !(frame1 == frame3) )
   end
 
 end

data/test/test_geometry2D.rb

@@ -15,11 +15,7 @@ class V2DTest < Test::Unit::TestCase
     t = V2D[2,3]
     assert_equal(V2D[2,4], s + t)
   end
-  
-  def test_norm
-    assert_equal(V2D[0,1], V2D[0,2].norm)
-  end
-  
+    
   def test_angle
     assert_equal(0.0,  V2D[0,0].angle)
     assert_equal(0.0,  V2D[1,0].angle)
@@ -61,8 +57,8 @@ class V2DTest < Test::Unit::TestCase
   end
   
   def test_viewbox
-    assert_equal( [1.0, 1.0, 2.0, 2.0],
-		 V2D.viewbox( [V2D[1.0, 2.0], V2D[2.0, 1.0]] ))
+    assert_equal( [1.0, 1.0, 2.0, 2.0], V2D.viewbox( [V2D[1.0, 2.0], V2D[2.0, 1.0]] ))
+    assert_equal( [0.0, 0.0, 0.0, 0.0], V2D.viewbox( [] ))
   end
 		 
   def test_size
@@ -91,4 +87,27 @@ class V2DTest < Test::Unit::TestCase
     a.x = 3.0
     assert_equal( 3.0, v.x )
   end
+
+  def test_succ
+    assert_equal( V2D[1.0,1.0], V2D[].succ )
+  end
+
+  def test_scale
+    assert_equal( V2D[2.0,6.0], V2D[1.0,2.0].scale( V2D[2.0,3.0]) )
+  end
+
+  def test_sym
+    assert_equal( V2D[2.0,4.0], V2D[1.0,2.0].sym( V2D[0.0,0.0] ) )
+  end
+
+  def test_coords
+    assert_equal( [0.0,1.0], V2D[0.0,1.0].coords )
+    assert_equal( [1.0,Math::PI/2.0], V2D[0.0,1.0].coords(:polar) )
+    assert_raise(RuntimeError) {V2D[0.0,1.0].coords(:toto)}
+  end
+
+  def test_polar
+    assert( V2D.vequal?( V2D[0.0,1.0], V2D.polar( 1.0, Math::PI/2.0 ) ) )
+  end
+
 end

data/test/test_interbezier.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'interbezier.rb'
+
+# Test class
+class InterBezierTest < Test::Unit::TestCase
+  
+  def test_base
+    bezier1 = Bezier.raw( V2D::O, V2D::X, V2D::O, V2D::X  )
+    center  = V2D::O + V2D::Y
+    bezier2 = Bezier.raw( center, center, center, center )
+    interbezier  = InterBezier.new( :bezierlist, [0.0, bezier1, 1.0, bezier2] )
+    v = V2D::Y * 0.5
+    assert_equal( [V2D::O + v, V2D::X * 0.5 + v, V2D::O + v, V2D::X * 0.5 + v], interbezier.sample( 0.5 ).pointlist )
+  end
+end
+
+
+# Test class
+class GradientBezierTest < Test::Unit::TestCase
+  
+  def test_base
+    bezier1 = Bezier.raw( V2D::O, V2D::X, V2D::O, V2D::X  )
+    center  = V2D::O + V2D::Y
+    bezier2 = Bezier.raw( center, center, center, center )
+    interbezier  = GradientBezier.new( :bezierlist, [0.0, bezier1, 1.0, bezier2] )
+    v = V2D::Y * 0.5
+    assert_equal( [V2D::O + v, V2D::X * 0.5 + v, V2D::O + v, V2D::X * 0.5 + v], interbezier.samples( 10 )[5].bezier(0).pointlist )
+  end
+end