xrvg 0.0.2 → 0.0.3

data/CHANGES

@@ -1,5 +1,17 @@
 = CHANGES
-== => v 0.0.2
+
+== 0.0.3 (2008.02.17)
+=== Content
+- just bug correction, optims and refactoring
+- quad tree implementation
+=== Testing
+- test_interpolator
+- some minors other additions
+==== Refactoring
+- implementing bezier length interpolator as quad tree => +60% perf sur sample( 50000 ) !!!
+- change order of list in interpolation ! now index before value (as nominal way of describing key,value pairs)
+
+== 0.0.2 (2008.02.10)
 === Content
 ==== New features
 - bezier curve !!
@@ -14,13 +26,13 @@
 - range examples correction, and added to unitary tests
 - Range .complement correction
 - Range split correction
-=== TODO
+=== TODO for 0.0.3
 - unitary tests to be completed (generate them from doc ?)
 - Shape Line and Circle interfaces must be completed to fill Curve abstract interface.
 - mabe bezier tutorial
 
 
-== => 0.0.1
+== 0.0.1 (2008.02.02)
 === Content
 - First delivery. Contains utilitary classes (utils, samplable, interpolation, attributable), render, color, style, shape.
 - But no bezier yet.

data/README

@@ -1,6 +1,6 @@
 = XRVG -- X Ruby Vector Graphics
 
-Supporting XRVG version: 0.0.2
+Supporting XRVG version: 0.0.3
 
 This package contains XRVG, a Ruby vector graphic programming library.
 

data/Rakefile

@@ -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"]
+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"]
 TEST_FILES = FileList["test/*.rb"]
 
 # Executable scripts, all non-garbage files under bin/.

data/examples/palette_circle.rb

@@ -2,7 +2,7 @@ require 'xrvg'
 
 render = SVGRender[ :filename, "palette_circle.svg", :background, "white" ]
 
-palette  = Palette[ :colorlist, [ Color.black, 0.0, Color.blue, 1.0 ] ]
+palette  = Palette[ :colorlist, [  0.0, Color.black,  1.0 ,  Color.blue] ]
 [Circle[], palette, (0.1..0.02).random()].samples(25) do |point, color, radius|
   render.add( Circle[ :center, point, :radius, radius ], Style[ :fill, color ])
 end

data/examples/sample.rb

@@ -2,9 +2,9 @@ require 'xrvg'
 
 render = SVGRender[ :filename, "sample.svg" ]
 
-palette  = Palette[ :colorlist, [ Color.blue, 0.0, Color.orange, 0.25, 
-                                  Color.yellow, 0.5, Color.green, 0.75, 
-                                  Color.blue, 1.0 ] ]
+palette  = Palette[ :colorlist, [ 0.0, Color.blue,   0.25,  Color.orange,  
+                                  0.5, Color.yellow, 0.75,  Color.green,
+                                  1.0, Color.blue] ]
 [Circle[], palette, (0.1..0.02).random()].samples(25) do |point, color, radius|
   render.add( Circle[ :center, point, :radius, radius ], Style[ :fill, color ])
 end

data/lib/bezier.rb

@@ -49,22 +49,64 @@ class Bezier < Curve
     self.new( *args )
   end
 
+  # Uni Bezier builder 
+  #
+  # type can be :raw or :vector
   def Bezier.single( type, p1, p2, p3, p4 )
     return Bezier.new( :pieces, [BezierSpline[type, p1, p2, p3, p4]] )
   end
 
+  # Uni Bezier builder in :raw format
   def Bezier.raw( p1, pc1, pc2, p2 )
     return Bezier.single( :raw, p1, pc1, pc2, p2 )
   end
 
+  # Uni Bezier builder in :vector format
   def Bezier.vector( p1, v1, p2, v2 )
     return Bezier.single( :vector, p1, v1, p2, v2 )
   end
 
+  # Basic Multi Bezier builder
+  #
+  # raw pieces must be an array of arrays of the form [type, p1, p2, p3, p4] as defined for single
   def Bezier.multi( rawpieces )
     return Bezier.new( :pieces, rawpieces.map {|piece| BezierSpline[*piece]} )
   end
 
+  # "regular" Multi Bezier :raw specification
+  #
+  # args is a list of points and control points as [p1, pc1, p2, pc2, p3, pc3]
+  #
+  # Beware that 
+  #  Bezier.raw( p1, pc1, pc2, p2 ) == Bezier.raws( p1, pc1, p2, p2 + (p2-pc2))
+  def Bezier.raws( *args )
+    rawpieces = []
+    args.foreach(2).pairs do |pair1, pair2|
+      p1, pc1 = pair1 
+      p2, pc2 = pair2
+      rawpieces << [:raw, p1, pc1, p2+(p2-pc2), p2]
+    end
+    return Bezier.multi( rawpieces )
+  end
+
+  # "regular" Multi Bezier :vector specification
+  #
+  # 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)
+  def Bezier.vectors( *args )
+    rawpieces = []
+    args.foreach(2).pairs do |pair1, pair2|
+      p1, v1 = pair1 
+      p2, v2 = pair2
+      rawpieces << [:vector, p1, v1, p2, -v2]
+    end
+    return Bezier.multi( rawpieces )
+  end
+  
+
+  
 
   # bezier point, as 
   #   Bezier[:raw, V2D::O, V2D::O, V2D::O, V2D::O]
@@ -117,6 +159,7 @@ class Bezier < Curve
   def pointlist( type=:raw )
     result = []
     @pieces.each {|piece| result = result + piece.pointlist(type)}
+    # Trace("Bezier.pointlist result #{result.inspect}")
     return result
   end
     
@@ -135,6 +178,12 @@ class Bezier < Curve
     return self.pieces.map{ |piece| Bezier.single( *piece.data ) }
   end
 
+  # shortcut method to retrieve a piece as an Bezier object
+  def bezier( index )
+    return Bezier.single( *self.piece( index ).data )
+  end
+  
+
 # -------------------------------------------------------------
 #  piece delegation computation
 # -------------------------------------------------------------
@@ -142,7 +191,7 @@ class Bezier < Curve
   # with index (must be Float) and parametertype as inputs, must compute :
   # - the index of the piece on which the computation must take place
   # - the new parameter value corresponding to bezier computation input
-  def parametermapping( index, parametertype=:length ) #:nodoc:
+  def parametermapping( index, parametertype=:length, side=:right ) #:nodoc:
     check_parametertype( parametertype )
     result = []
     if parametertype == :length
@@ -151,7 +200,7 @@ class Bezier < Curve
       elsif index > 1.0
 	index = 1.0
       end
-      result = length_parameter_mapping( 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
@@ -217,8 +266,10 @@ class Bezier < Curve
 
   # generalize Bezier method
   def subpieces (t1, t2) #:nodoc:
-    pieceindex1, t1 = parametermapping( t1 )
-    pieceindex2, t2 = parametermapping( t2 )
+    # Trace("subpieces t1 #{t1} t2 #{t2}")
+    pieceindex1, t1 = parametermapping( t1, :length, :left )
+    pieceindex2, t2 = parametermapping( t2, :length, :right )
+    # Trace("after translation pieceindex1 #{pieceindex1} t1 #{t1}  pieceindex2 #{pieceindex2} t2 #{t2}")
     result = []
 
     if pieceindex1 == pieceindex2
@@ -228,7 +279,7 @@ class Bezier < Curve
       if pieceindex1 + 1 != pieceindex2
 	result += self.pieces[pieceindex1+1..pieceindex2-1]
       end
-      result << self.piece( pieceindex1 ).subpiece( 0, t2 )
+      result << self.piece( pieceindex2 ).subpiece( 0.0, t2 )
     end
     return result
   end
@@ -386,6 +437,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}")
     result  = lengths.sum
     if result == 0.0
       lengths = [1.0]
@@ -396,27 +448,50 @@ class Bezier < Curve
     lmin = 0.0
     @lengthranges = []
     lengths.each do |llength|
+      Trace("lmin #{lmin} llength #{llength}")
       @lengthranges << (lmin..llength)
       lmin = llength
     end
+    @lengthranges[-1] = @lengthranges[-1].begin..1.0
+    return result
+  end
+  
+  # utilitary method for interbezier
+  #
+  # return list of piece lengths relatives to total bezier lengths, and cumulated
+  #  Bezier.new( :pieces, [piece1, piece2] ).piecelengths; => [0.0, piece1.length / bezier.length, 1.0]
+  def piecelengths
+    result = self.lengthranges.map {|range| range.begin}
+    result << 1.0
     return result
   end
 
-  def length_parameter_mapping( t ) #:nodoc:
+  # private method, to compute lengthranges if not existing
+  def lengthranges #:nodoc:
     if not @lengthranges
       compute_length
     end
+    return @lengthranges
+  end
+
+  def length_parameter_mapping( t, side ) #:nodoc:
     pieceindex = -1
-    @lengthranges.each_with_index do |lrange,i|
+    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}")
 	break
       end
     end
+    if ((side == :left) and  t.fequal?(1.0) and (pieceindex < self.piecenumber - 1))
+      pieceindex += 1
+      t = 0.0
+    end
     if pieceindex == -1
-      Kernel::raise("length_parameter_mapping error : t #{t} is not in length range #{@lengthranges.inspect}")
+      Kernel::raise("length_parameter_mapping error : t #{t} is not in length range #{self.lengthranges.inspect}")
     end
     return [pieceindex, t]
   end

data/lib/bezierspline.rb

@@ -1,5 +1,8 @@
 # +BezierSpline+ source
 
+require 'interpolation'
+
+
 # BezierSpline class
 #
 # Internal class to represent a single-piece cubic bezier curve, defined by four points or two point + two vectors.
@@ -18,8 +21,8 @@ class BezierSpline #:nodoc:
   
   def checkvalues( v1, v2, v3, v4 )
     [v1, v2, v3, v4].each do |v| 
-      if not v.is_a? V2D
-	Kernel::raise( "BezierSpline : init value #{v.inspect} is not a V2D" )
+      if not (v.respond_to?(:x) || v.respond_to?(:y))
+	Kernel::raise( "BezierSpline : init value #{v.inspect} does not respond to :x or :y" )
       end
     end
   end
@@ -204,34 +207,34 @@ class BezierSpline #:nodoc:
     samplelist = [0.0, 0.0]
     new      = V2D[0.0,0.0]
     previous = nil
-    (0.0..1.0).samples( 100 ) do |abs|
+    (0.0..1.0).samples( 129 ) do |abs|
       self.point( abs, new )
       if previous
 	sum+= (new - previous).r
-	samplelist += [abs, sum]
+	samplelist += [sum, abs]
       else
 	previous = V2D[0.0,0.0]
       end
       previous.x = new.x
       previous.y = new.y
     end
-    @length = samplelist[-1]
+    @length = samplelist[-2]
 
     length_interpolator = nil
     if @length == 0.0
-      newsamplelist = [0.0,0.0,1.0,0.0]
-      invsamplelist = [0.0,0.0,0.0,1.0]
+      newsamplelist = [0.0,0.0,0.0,1.0]
+      invsamplelist = [0.0,0.0,1.0,0.0]
     else
       newsamplelist = []
       invsamplelist = []
-      samplelist.foreach do |abs, sum|
-	newsamplelist += [abs, sum / @length]
-	invsamplelist += [sum / @length, abs]
+      samplelist.foreach do |sum, abs|
+	newsamplelist += [sum / @length, abs ]
+	invsamplelist += [abs, sum / @length ]
       end
       samplelist = newsamplelist
     end
-    @abs_interpolator = Interpolator.new( :samplelist, invsamplelist )
-    return Interpolator.new( :samplelist, samplelist )
+    @abs_interpolator = InterpolatorQuad.new( :samplelist, invsamplelist )
+    return InterpolatorQuad.new( :samplelist, samplelist )
   end
 
   def length_interpolator() #:nodoc:
@@ -257,10 +260,9 @@ class BezierSpline #:nodoc:
     return @length
   end
 
-  def parameterfromlength( l ) #:nodoc:
-    result = self.length_interpolator.interpolate( l )
+  def parameterfromlength( lvalue ) #:nodoc:
+    result = self.length_interpolator.interpolate( lvalue )
     return result
-  end
-
-
+  end  
 end
+

data/lib/color.rb

@@ -251,7 +251,7 @@ end
 # Palette defines color palettes, as interpolation between color points. As such, use Interpolation module, so uses for the moment only linear interpolation.
 # But once built with interpolation, palette provides a continuous color "interval", and so is Samplable !
 # = Use
-#  palette  = Palette[ :colorlist, [ Color.blue, 0.0, Color.orange, 0.5, Color.yellow, 1.0 ] ]
+#  palette  = Palette[ :colorlist, [ 0.0, Color.blue, 0.5, Color.orange, 1.0, Color.yellow ] ]
 #  palette.rand( 10 )   # => return 10 random colors in palette
 #  palette.color( 0.5 ) # => Color.orange
 class Palette
@@ -259,7 +259,7 @@ class Palette
   attribute :colorlist
 
   # compute color given float pourcentage.
-  #  Palette[ :colorlist, [ Color.black, 0.0, Color.white, 1.0 ] ].sample( 0.5 ) => Color[0.5,0.5,0.5,1.O]
+  #  Palette[ :colorlist, [ 0.0, Color.black, 1.0, Color.white ] ].sample( 0.5 ) => Color[0.5,0.5,0.5,1.O]
   # "sample" method as defined in Samplable module
   def color(dindex)
     result = self.interpolate(dindex)
@@ -269,8 +269,8 @@ class Palette
   # return a new palette by reversing the current one
   def reverse()
     newcolorlist = []
-    self.colorlist.reverse.foreach do |index,color|
-      newcolorlist += [color, (0.0..1.0).complement( index )]
+    self.colorlist.reverse.foreach do |color, index|
+      newcolorlist += [(0.0..1.0).complement( index ), color]
     end
     return Palette[ :colorlist, newcolorlist ]
   end
@@ -304,7 +304,7 @@ class LinearGradient < Gradient #:nodoc:
     stoptemplate = '<stop offset="%offset%" stop-color="%color%" stop-opacity="%opacity%"/>'
     
     stops = "\n"
-    self.colorlist.foreach do |color, index|
+    self.colorlist.foreach do |index, color|
       stops += stoptemplate.subreplace( {"%offset%" => index, "%color%" => color.svg, "%opacity%" => color.a} )
       stops += "\n"
     end
@@ -321,14 +321,14 @@ class CircularGradient < Gradient #:nodoc:
     stoptemplate = '<stop offset="%offset%" stop-color="%color%" stop-opacity="%opacity%"/>'
     
     stops = "\n"
-    self.colorlist.foreach do |color, index|
+    self.colorlist.foreach do |index, color|
       stops += stoptemplate.subreplace( {"%offset%" => index, "%color%" => color.svg, "%opacity%" => color.a} )
       stops += "\n"
     end
     
     return template.subreplace( {"%stops%" => stops,
-				 "%cx%" => circle.center.x,
-				 "%cy%" => circle.center.y,
-				 "%r%" => circle.radius} )
+				 "%cx%"    => circle.center.x,
+				 "%cy%"    => circle.center.y,
+				 "%r%"     => circle.radius} )
   end
 end

data/lib/geometry2D.rb

@@ -1,5 +1,5 @@
 #
-# Contains Ruby geometric Vector 2D class. 
+# Contains Ruby geometric V2D 2D class. 
 # See :
 # - +V2D+
 
@@ -10,7 +10,7 @@ require 'Attributable'
 #
 # V2D class definition, to provide several useful "geometrical" services
 #
-# Extends and somehow redefines Vector class, to speed up computation, as less generic
+# Extends and somehow redefines V2D class, to speed up computation, as less generic
 # 
 # For example :
 #   V2D[0.0,2.0].norm               => V2D[0.0,1.0]
@@ -103,7 +103,7 @@ class V2D
     return V2D[ self.x.succ, self.y.succ ]
   end
 
-  # compute length of 2D vector (r notation to be compatible with Vector)
+  # compute length of 2D vector (r notation to be compatible with V2D)
   def r()
     return Math.hypot( self.x, self.y )
   end
@@ -118,7 +118,7 @@ class V2D
     if r != 0.0
       return self / r
     else
-      return V::O
+      return V2D::O
     end
   end
 
@@ -210,7 +210,7 @@ class V2D
   end
 
   # compute the coord box enclosing every 2D elements considered as points
-  #  Vector.viewbox( [Vector[1.0,2.0], Vector[2.0,1.0]] ) => [1.0, 1.0, 2.0, 2.0]
+  #  V2D.viewbox( [V2D[1.0,2.0], V2D[2.0,1.0]] ) => [1.0, 1.0, 2.0, 2.0]
   def V2D.viewbox (pointlist)
     if pointlist.size == 0
       return [0.0, 0.0, 0.0, 0.0]
@@ -223,7 +223,7 @@ class V2D
   end
 
   # compute dimension of the box enclosing 2D elemnts considered as points
-  #   Vector.viewbox( [Vector[1.0,2.0], Vector[10.0,1.0]] ) => [9.0, 1.0]
+  #   V2D.viewbox( [V2D[1.0,2.0], V2D[10.0,1.0]] ) => [9.0, 1.0]
   # use +viewvox+
   def V2D.size (pointlist)
     xmin, ymin, xmax, ymax = V2D.viewbox( pointlist )

data/lib/interpolation.rb

@@ -3,6 +3,7 @@
 # See
 # - +Interpolation+
 # - +Interpolator+
+# - +InterpolatorQuad+
 
 require 'utils'
 require 'attributable'
@@ -33,8 +34,8 @@ module Interpolation
   # interpolate uses + and * scalar operators on interpolation values
   def interpolate( dindex )
     result = nil
-    pvalue, pindex = self.samplelist[0..1]
-    self.samplelist.foreach do |value, index|
+    pindex, pvalue = self.samplelist[0..1]
+    self.samplelist.foreach do |index, value|
       if dindex <= index
 	if dindex == index
 	  return value
@@ -45,7 +46,7 @@ module Interpolation
       pvalue, pindex = value, index
     end
     if not result
-      result = self.samplelist[-2]
+      result = self.samplelist[-1]
     end
     return result
   end
@@ -59,3 +60,99 @@ class Interpolator
   attribute :samplelist
   include Interpolation
 end
+
+class QuadRange
+
+  def initialize( limit, quadleft, quadright, range=nil )
+    @limit     = limit
+    @quadleft  = quadleft
+    @quadright = quadright
+    @range     = range
+  end
+
+  def limit
+    return @limit
+  end
+
+  def range( index )
+    if @limit
+      if index < @limit
+	return @quadleft.range( index )
+      else
+	return @quadright.range( index )
+      end
+    else
+      return @range
+    end
+  end
+end
+
+# QuadTree class
+# = Intro
+# Optim class to look for predefine ranges for a value. Is actually a binary tree data structure, but used as unlinear space partitioner.
+# = Example
+#  quad = QuadTree.new( [0.0,1.0, 0.2,0.0, 0.6,1.0,  0.8,0.0, 1.0,1.0]  )
+#  quad.range( 0.5 ); #=> [0.2,0.0,0.6,1.0]
+class QuadTree
+
+  def initialize( samplelist ) #:nodoc:
+    quads = []
+    ends  = []
+    samplelist.foreach(2).pairs do |ppair, pair|
+      pindex, pvalue = ppair
+      index, value   = pair
+      quads << QuadRange.new( nil, nil, nil, [pindex, pvalue, index, value] )
+      ends  << index
+    end
+    @root = build_quads( quads, ends )
+  end
+
+  def build_quads( quads, ends ) #:nodoc:
+    newquads = []
+    newends  = []
+    index = 0
+    quads.foreach do |quad1, quad2|
+      newquads << QuadRange.new( ends[2*index], quad1, quad2, nil)
+      newends  << ends[2*index + 1]
+      index += 1
+    end
+    if newquads.size == 1
+      return newquads[0]
+    else
+      return build_quads( newquads, newends )
+    end
+  end
+
+  # utilitary method to retrieve range of index
+  #  QuadTree.new( [0.0,1.0, 0.2,0.0, 0.6,1.0,  0.8,0.0, 1.0,1.0]  ).range( 0.5 ); #=> [0.2,0.0,0.6,1.0]  
+  def range( index )
+    return @root.range( index )
+  end
+end
+  
+# Quad tree interpolator
+# 
+# Use QuadTree to retrieve range of values between linear interpolation.
+#
+# Used in BezierSpline to compute parameter from length.
+class InterpolatorQuad < Interpolator
+
+  def compute_quad #:nodoc:
+    @quad = QuadTree.new( self.samplelist )
+  end
+  
+  # - first use QuadTree range to retrieve range of dindex, 
+  # - then linearly interpolate
+  def interpolate( dindex )
+    if not @quad
+      compute_quad
+    end
+    pindex, pvalue, index, value = @quad.range( dindex )
+    if pindex.fequal?(index)
+      result = value
+    else
+      result = pvalue + ((value + pvalue * (-1.0) ) * ((dindex - pindex) / (index - pindex )))
+    end
+    return result
+  end
+end

data/lib/render.rb

@@ -65,6 +65,9 @@ class SVGRender < Render
 
   def layers=( backtofront ) #:nodoc:
     @sortlayers = backtofront
+    @sortlayers.each do |key|
+      @layers[ key ] = ""
+    end
   end
   
   def add_content (string, layer) #:nodoc:
@@ -181,7 +184,7 @@ class SVGRender < Render
     xmin, ymin, width, height = get_carre_viewbox( get_final_viewbox() )
     template = '<rect x="%x%" y="%y%" width="%width%" height="%height%" fill="%fill%"/>' 
     bg = self.background
-    if bg.is_a? Color
+    if bg.respond_to? :svg
       bg = bg.svg
     end
     return template.subreplace( {"%x%"      => xmin,

data/lib/shape.rb

@@ -318,11 +318,20 @@ end
 # = Attributes
 #   attribute :center, V2D[0.0,0.0]
 #   attribute :radius, 1.0
+#   attribute :initangle, 0.0
 # = Example
 #  c = Circle[ :center, V2D::O, :radius, 1.0 ] # equiv Circle[] 
 class Circle < Curve
   attribute :center, V2D[0.0,0.0]
   attribute :radius, 1.0
+  attribute :initangle, 0.0
+
+  # Circle builder from points diametraly opposed
+  #   Circle.diameter( V2D[-1.0,0.0], V2D[1.0,0.0] ) == Circle[ :center, V2D::O, :radius, 1.0 ]
+  def Circle.diameter( p1, p2 )
+    initangle = ( p1 - p2 ).angle
+    return Circle[ :center, (p1 + p2)/2.0, :radius, (p1 - p2).r/2.0, :initangle, initangle ]
+  end
 
   # compute length of the circle
   def length
@@ -354,6 +363,10 @@ class Circle < Curve
   def size
     return [ self.radius, self.radius ]
   end
+
+  def rotate( angle )
+    @initangle += angle
+  end
   
   # svg description of the circle
   def svg
@@ -365,7 +378,7 @@ class Circle < Curve
 
   # compute point at abscissa
   def point (abscissa, container=nil)
-    angle = Range::Angle.sample( abscissa )
+    angle = Range::Angle.sample( abscissa ) + @initangle
     container ||=V2D[]
     container.x = self.cx + self.radius * Math.cos( angle )
     container.y = self.cy + self.radius * Math.sin( angle )

data/lib/utils.rb

@@ -168,7 +168,7 @@ class Array
   # return the sum of the elements of the Array
   # works for array whose content defines the + operator
   #  [1.0, 2.0].sum                           => 3.0
-  #  [Vector[-1.0,-1.0], Vector[1.0,1.0]].sum => Vector[0.0,0.0]
+  #  [V2D[-1.0,-1.0], V2D[1.0,1.0]].sum => V2D[0.0,0.0]
   #  [curve1, curve2].sum                     => concatenation of curves
   def sum
     sum = self[0]
@@ -177,7 +177,7 @@ class Array
   end
 
   # returns the mean of the array content
-  #  [Vector[0.0,0.0], Vector[1.0,1.0]].mean => Vector[0.5,0.5]
+  #  [V2D[0.0,0.0], V2D[1.0,1.0]].mean => V2D[0.5,0.5]
   def mean
     return self.sum / self.size
   end
@@ -342,6 +342,10 @@ class Float #:nodoc:
     return ( max - ( self.to_f - min ) )
   end
 
+  def fequal?( other )
+    return ((self - other).abs < 0.0000000001)
+  end
+
   def randsplit(minsize=0.0)
     v = self.to_f
     rand = minsize + Kernel::rand * (1.0 - minsize )

data/lib/xrvg.rb

@@ -3,7 +3,7 @@
 # Please refer to README for XRVG introduction
 
 # XRVG version (used in rakefile)
-XRVG_VERSION = "0.0.2"
+XRVG_VERSION = "0.0.3"
 
 # Standard Ruby extensions
 require 'enumerator'

data/test/test_bezier.rb

@@ -30,8 +30,19 @@ class BezierTest < Test::Unit::TestCase
     assert_equal( V2D[0.0, 1.0], b.firstpoint )
   end
 
+  def test_builder2
+    b = Bezier.raws( V2D[0.0, 1.0], V2D[1.0, 1.0], V2D[1.0, 0.0], V2D[2.0, 0.0] )
+    assert_equal( V2D[0.0, 1.0], b.firstpoint )
+    assert( V2D.vequal?( @@bezier.point( 0.1, nil, :parameter ), b.point( 0.1, nil, :parameter ) ) )
+
+    b = Bezier.vectors( V2D[0.0, 1.0], V2D[1.0, 0.0], V2D[1.0, 0.0], V2D[1.0, 0.0] )
+    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_O
     assert_equal( [V2D::O, V2D::O, V2D::O, V2D::O], Bezier::O.pointlist )
+    assert_equal( V2D::O, Bezier::O.sample(0.5) )
   end
   
   def test_piece
@@ -144,6 +155,17 @@ class BezierTest < Test::Unit::TestCase
     assert_equal( [(0.0..1.0), (1.0..2.0)],  @@multibezier.ranges )
   end
 
+  def test_split1
+    assert( V2D.vequal?( V2D[0.5, 0.5], @@beziersym.split(0.0,0.5).lastpoint ) )
+    assert( V2D.vequal?( V2D[0.5, 0.5], @@beziersym.split(0.5,1.0).firstpoint ) )
+  end
+
+  def test_split2
+    assert( V2D.vequal?( V2D::O, Bezier::O.split( 0.0,0.5 ).firstpoint ) )
+    assert( V2D.vequal?( V2D::O, Bezier::O.split( 0.5,0.8 ).lastpoint ) )
+  end
+
+
 end
 
   

data/test/test_color.rb

@@ -38,7 +38,7 @@ end
 class PaletteTest < Test::Unit::TestCase
 
   def test_palette
-    palette = Palette.new( :colorlist, [ Color.black, 0.0, Color.white, 1.0 ] )
+    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 ) )
   end
 end
@@ -46,7 +46,7 @@ end
 class GradientTest < Test::Unit::TestCase
 
   def test_gradient
-    gradient = LinearGradient.new( :colorlist, [Color.black, 0.0, Color.white, 1.0] )
+    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>")
 	
@@ -57,7 +57,7 @@ class GradientTest < Test::Unit::TestCase
     require 'render'
     require 'shape'
     render = SVGRender.new( :filename, "gradient1.svg" )
-    render.add( Circle.new, Style.new( :stroke, "none", :fill, LinearGradient.new( :colorlist, [Color.black, 0.0, Color.white, 1.0] ) ) )
+    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
@@ -69,7 +69,7 @@ class GradientTest < Test::Unit::TestCase
     require 'shape'
     render = SVGRender.new( :filename, "gradient2.svg" )
     circle = Circle.new
-    style = Style.new( :stroke, "none", :fill, CircularGradient.new( :colorlist, [Color.black(1.0), 0.0, Color.black(0.0), 1.0], :circle, circle ) )
+    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" ) )

data/test/test_frame.rb

@@ -5,8 +5,8 @@ require 'geometry2D'
 class FrameTest < Test::Unit::TestCase
   
   def test_frame1
-    frame = Frame[ :center, Vector[0.0,0.0], :vector, Vector[1.0,0.0], :rotation, 0.0, :scale, 1.0 ]
-    assert_equal( 0.0, frame.center[0] )
+    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 )
   end
 
 end

data/test/test_geometry2D.rb

@@ -45,6 +45,11 @@ class V2DTest < Test::Unit::TestCase
 
   end
 
+  def test_norm
+    assert_equal( V2D[0.0,1.0], V2D[0.0,2.0].norm )
+    assert_equal( V2D[0.0,0.0], V2D[0.0,0.0].norm )
+  end
+
   def test_ortho
     assert_equal(V2D[-0.6,0.5],
 		 V2D[0.5,0.6].ortho)

data/test/test_interpolation.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'interpolation'
+
+class InterpolatorTest < Test::Unit::TestCase
+  
+  def test_quadtree
+    quad = QuadTree.new( [0.0,1.0, 0.2,0.0, 0.6,1.0,  0.8,0.0, 1.0,1.0]  )
+    assert_equal( [0.2,0.0,0.6,1.0], quad.range( 0.5 ) )
+    assert_equal( [0.0,1.0, 0.2,0.0], quad.range( 0.0 ) )
+    assert_equal( [0.8,0.0, 1.0,1.0], quad.range( 1.0 ) )
+  end
+end

data/test/test_shape.rb

@@ -64,4 +64,12 @@ class CircleTest < Test::Unit::TestCase
       assert( V2D.vequal?( v1, v2 ) )
     end
   end
+
+  def test_diameter
+    cd = Circle.diameter( V2D[0.0,1.0], V2D[0.0,-1.0] )
+    c2 = Circle[ :center, V2D::O, :radius, 1.0 ]
+    assert( V2D.vequal?( cd.center, c2.center ) )
+    assert_equal( cd.radius, c2.radius )
+    assert( V2D.vequal?( V2D[0.0,1.0], cd.point( 0.0 ) ) )
+  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.2
-date: 2008-02-10 00:00:00 +01:00
+  version: 0.0.3
+date: 2008-02-17 00:00:00 +01:00
 summary: Ruby vector graphics library
 require_paths: 
 - lib
@@ -72,6 +72,7 @@ test_files:
 - test/test_color.rb
 - test/test_frame.rb
 - test/test_geometry2D.rb
+- test/test_interpolation.rb
 - test/test_render.rb
 - test/test_shape.rb
 - test/test_style.rb