xrvg 0.0.1 → 0.0.2

data/lib/bezierspline.rb

@@ -0,0 +1,266 @@
+# +BezierSpline+ source
+
+# BezierSpline class
+#
+# Internal class to represent a single-piece cubic bezier curve, defined by four points or two point + two vectors.
+# You may never have to use this class. Prefer the use of +Bezier+ class
+class BezierSpline #:nodoc:
+
+  def BezierSpline.[](*args)
+    return BezierSpline.new( *args )
+  end
+  
+  def initialize( type, v1, v2, v3, v4 )
+    self.checktype( type )
+    self.checkvalues( v1, v2, v3, v4 )
+    self.initdata( type, v1, v2, v3, v4 )
+  end
+  
+  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" )
+      end
+    end
+  end
+
+  def checktype( type )
+    if not type == :raw || type == :vector
+      Kernel::raise( "BezierSpline : type #{type.inspect} is not :raw or :vector" )
+    end
+  end
+
+  def data()
+    return [:raw] + self.pointlist
+  end
+  
+  def initdata( type, v1, v2, v3, v4 )
+    @rawpointlist      = nil
+    @vectorpointlist   = nil
+    if type == :raw
+      @rawpointlist       = [v1, v2, v3, v4]
+    elsif
+      @vectorpointlist    = [v1, v2, v3, v4]
+    end
+  end
+
+  def compute_rawpointlist
+    # Assert{ @vectorpointlist }
+    @rawpointlist = [@vectorpointlist[0], @vectorpointlist[0] +  @vectorpointlist[1], @vectorpointlist[2] +  @vectorpointlist[3], @vectorpointlist[2]]
+  end
+
+  def compute_vectorpointlist
+    # Assert{ @rawpointlist }
+    @vectorpointlist = [@rawpointlist[0], @rawpointlist[1] - @rawpointlist[0], @rawpointlist[3], @rawpointlist[2] - @rawpointlist[3]]
+  end
+
+  
+  def pointlist(type=:raw)
+    self.checktype( type )
+    if type == :raw
+      if not @rawpointlist
+	self.compute_rawpointlist
+      end
+      return @rawpointlist
+    elsif type == :vector
+      if not @vectorpointlist
+	self.compute_vectorpointlist
+      end
+      return @vectorpointlist
+    end
+  end
+
+  # shortcut method to get curve first point
+  def firstpoint
+    return self.pointlist()[0]
+  end
+
+  # shortcut method to get curve last point
+  def lastpoint
+    return self.pointlist()[-1]
+  end
+
+
+# -------------------------------------------------------------
+#  bezier formula
+# -------------------------------------------------------------
+
+  def compute_factors
+    p1, p2, p3, p4 = self.pointlist
+    @factors  = [-(p1 - p2 * 3.0 + p3 * 3.0 - p4), (p1 - p2 * 2.0 + p3) * 3.0, (p2 - p1) * 3.0, p1]
+    @tfactors = [@factors[0], @factors[1] * 2.0 / 3.0, @factors[2] / 3.0]
+    @afactors = [@tfactors[0] * 2.0, @tfactors[1]]
+  end
+
+  # get point from the bezier curve
+  # this method use the definition of the bezier curve
+  def point( t, result=nil )
+    t2 = t * t
+    t3 = t2 * t
+    if not result
+      result = V2D[0.0,0.0]
+    end
+    
+    if not @factors
+      compute_factors
+    end
+
+    # decomposed because avoid to build useless V2D
+    result.x = @factors[3].x + @factors[2].x * t + @factors[1].x * t2 + @factors[0].x * t3
+    result.y = @factors[3].y + @factors[2].y * t + @factors[1].y * t2 + @factors[0].y * t3
+
+    return result
+  end
+
+  # compute the bezier tangent vector
+  #
+  # Beware that what is actually computed here is 1/3 tangent !!
+  def tangent( t, result=nil )
+    t2 = t * t
+    if not result
+      result = V2D[0.0,0.0]
+    end
+
+    if not @factors
+      compute_factors
+    end
+
+    # decomposed because avoid to build useless V2D
+    result.x = @tfactors[2].x + @tfactors[1].x * t + @tfactors[0].x * t2
+    result.y = @tfactors[2].y + @tfactors[1].y * t + @tfactors[0].y * t2
+
+    return result
+  end
+
+  # compute the acc of bezier curve at t abscissa
+  def acc( t, result=nil )
+    if not result
+      result = V2D[0.0,0.0]
+    end
+
+    if not @factors
+      compute_factors
+    end
+
+    result.x = @afactors[1].x  + @afactors[0].x * t
+    result.y = @afactors[1].y  + @afactors[0].y * t
+
+    return result
+  end
+
+  # compute tangent vectors corresponding to the new subbezier
+  # very strange method, but effective
+  def subtangents (t1, t2 )
+    v1 = self.tangent( t1 ) * (t2 - t1)
+    v2 = self.tangent( t2 ) * (t1 - t2)
+    return [v1, v2]
+  end
+
+  # compute a subpiece of the current bezier
+  # t1 and t2 must correspond to the same atomic bezier
+  def subpiece (t1, t2)
+    tan1, tan2 = self.subtangents( t1, t2 )
+    return BezierSpline.new( :vector, self.point( t1 ), tan1, self.point( t2 ), tan2 )
+  end
+
+  def reverse()
+    return BezierSpline[ :raw, *self.pointlist().reverse ]
+  end
+
+  # simple translation operation : translate every point of the piece
+  # return a new Bezier
+  def translate( v )
+    newpoints = self.pointlist.map {|point| point + v}
+    return BezierSpline[ :raw, *newpoints ]
+  end
+
+  def gdebug(render)
+    p1, pc1, pc2, p2 = self.pointlist()
+    v1 = pc1 - p1
+    r1 = v1.r / 30.0
+    v2 = pc2 - p2
+    r2 = v2.r / 30.0
+    render.add( Circle[ :center, p1, :radius, r1  ],  Style[ :fill, "red" ])
+    render.add( Circle[ :center, pc1, :radius, r1 ],  Style[ :fill, "red" ])
+    render.add( Line[ :points, [p1, pc1]          ],  Style[ :stroke, "red", :strokewidth, (r1 / 10.0) ])
+    render.add( Circle[ :center, p2, :radius, r2  ],  Style[ :fill, "red" ])
+    render.add( Circle[ :center, pc2, :radius, r1 ],  Style[ :fill, "red" ])
+    render.add( Line[ :points, [p2, pc2]          ],  Style[ :stroke, "red", :strokewidth, (r2 / 10.0) ])
+  end
+
+# -------------------------------------------------------------
+#  length computation
+# -------------------------------------------------------------
+
+
+  # compute the length of the bezier curve defined by the points
+  #
+  # Algo : recursively approximate curve by lines, until length variation is under some epsilon
+  # 
+  # for the moment, just take a fix number of samples, and some it
+  def compute_length_interpolator() #:nodoc:
+    sum = 0.0
+    previous = nil
+    samplelist = [0.0, 0.0]
+    new      = V2D[0.0,0.0]
+    previous = nil
+    (0.0..1.0).samples( 100 ) do |abs|
+      self.point( abs, new )
+      if previous
+	sum+= (new - previous).r
+	samplelist += [abs, sum]
+      else
+	previous = V2D[0.0,0.0]
+      end
+      previous.x = new.x
+      previous.y = new.y
+    end
+    @length = samplelist[-1]
+
+    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]
+    else
+      newsamplelist = []
+      invsamplelist = []
+      samplelist.foreach do |abs, sum|
+	newsamplelist += [abs, sum / @length]
+	invsamplelist += [sum / @length, abs]
+      end
+      samplelist = newsamplelist
+    end
+    @abs_interpolator = Interpolator.new( :samplelist, invsamplelist )
+    return Interpolator.new( :samplelist, samplelist )
+  end
+
+  def length_interpolator() #:nodoc:
+    if @length_interpolator == nil
+      @length_interpolator = self.compute_length_interpolator()
+    end
+    return @length_interpolator
+  end
+
+  def length(t=nil)
+    if @length == nil
+      self.compute_length()
+    end
+    if not t
+      return @length
+    else
+      return @abs_interpolator.interpolate( t )
+    end
+  end
+
+  def compute_length() #:nodoc:
+    self.length_interpolator()
+    return @length
+  end
+
+  def parameterfromlength( l ) #:nodoc:
+    result = self.length_interpolator.interpolate( l )
+    return result
+  end
+
+
+end

data/lib/color.rb

@@ -8,26 +8,65 @@ require 'interpolation'
 require 'attributable'
 require 'utils'
 require 'shape'; # for gradient
+require 'matrix'
 
 #
 # Color class
 #
 # = Basics
-# Class Color derives from Vector, and consists in a 4D vector of (0.0..1.0) values, for red, blue, green, and opacity
+# Class Color consists in a 4D vector of (0.0..1.0) values, for red, blue, green, and opacity
 # = Utilities
 # Conversion from hsv and hsl color spaces available (see this link[http://en.wikipedia.org/wiki/HSV_color_space])
 # = Future
 # - Must use this library[https://rubyforge.org/projects/color/], to avoid effort duplication
 # - Must add relative color operations as Nodebox wants to
 # - Must optimize 4D vector operations (as C extension ?)
-class Color < Vector
+class Color
 
   # Color builder
   #
   # only allows to build 4D vector, with composants between 0.0 and 1.0
-  def initialize( *args )
+  def Color.[]( *args )
     # TODO : check args number
-    super( *args )
+    Color.new( *args )
+  end
+
+  # builder
+  #
+  # r, g, b, a must be between 0.0 and 1.0
+  def initialize( r, g, b, a)
+    @items = [r,g,b,a]
+  end
+
+  # delegation componant indexation method
+  def [](index)
+    return @items[index]
+  end
+
+  # define addition operation, for interpolation
+  def +( other )
+    return Color[ self.r + other.r,
+                  self.g + other.g,
+                  self.b + other.b,
+                  self.a + other.a ]
+  end
+
+  # define scalar multiplication, for interpolation
+  def *( scalar )
+    return Color[ self.r * scalar,
+                  self.g * scalar,
+                  self.b * scalar,
+                  self.a * scalar ]
+  end
+
+  # return [r,g,b,a]
+  def composants
+    return @items
+  end
+
+  # equality operator
+  def ==( other )
+    return (self.composants == other.composants)
   end
 
   # return the red composant
@@ -224,7 +263,7 @@ class Palette
   # "sample" method as defined in Samplable module
   def color(dindex)
     result = self.interpolate(dindex)
-    return Color.elements(result[0..-1],false)
+    return result
   end
 
   # return a new palette by reversing the current one

data/lib/geometry2D.rb

@@ -1,45 +1,90 @@
 #
-# Contains Ruby Vector class extension. 
+# Contains Ruby geometric Vector 2D class. 
 # See :
-# - +Vector+
-# - +Point+
+# - +V2D+
 
-require 'matrix'
+require 'Attributable'
 
-# 
-# Vector class extension, to provide several useful "geometrical" services
-# 
-# For example :
-#   Vector[0.0,2.0].norm               => Vector[0.0,1.0]
-#   Vector[0.0,2.0].angle              => 0.0
-#   Vector[0.0,2.0].ortho              => Vector[-2.0,0.0]
-#   Vector[0.0,2.0].rotate( Math::PI ) => Vector[0.0,-2.0]
 #
-# It could be efficient to define specific 2D vector, to speed up computation.
-# It is however not compatible with Color definition, as Vector 4D, and prevent from using this lib in 3D or 4D (with time).
-# Must be checked though.
+# 2D vector
 #
-# Another thing is to make this class C extension, to speed up computation.
-class Vector
+# V2D class definition, to provide several useful "geometrical" services
+#
+# Extends and somehow redefines Vector class, to speed up computation, as less generic
+# 
+# For example :
+#   V2D[0.0,2.0].norm               => V2D[0.0,1.0]
+#   V2D[0.0,2.0].angle              => 0.0
+#   V2D[0.0,2.0].ortho              => V2D[-2.0,0.0]
+#   V2D[0.0,2.0].rotate( Math::PI ) => V2D[0.0,-2.0]
+class V2D
   include Comparable
+  include Attributable 
+  attribute :x, 0.0, Float
+  attribute :y, 0.0, Float
+
+  # create a new 2D vector
+  #  v = V2D[0.0,0.0]
+  def V2D.[](x=0.0,y=0.0)
+    return V2D.new(x,y)
+  end
+
+  # set coords
+  def xy=(other)
+    if other.is_a? Array
+      self.x = other[0]
+      self.y = other[1]
+    else
+      self.x = other.x
+      self.y = other.y
+    end
+  end
 
-  X = Vector[1.0, 0.0]
-  Y = Vector[0.0, 1.0]
-  O = Vector[0.0, 0.0]
+  # initialize overloading on Attributable to speed up
+  def initialize(x,y) #:nodoc:
+    self.x = x
+    self.y = y
+  end
+
+  X = V2D[1.0, 0.0]
+  Y = V2D[0.0, 1.0]
+  O = V2D[0.0, 0.0]
 
-  # to optimize for 2D
-  if nil
+  # scalar multiplication
+  #   V2D[1.0,2.0] * 2.0; #=> V2D[2.0,4.0]
   def *( scalar )
-    return Vector[ self[0] * scalar, self[1] * scalar ]
+    return V2D[ self.x * scalar, self.y * scalar ]
+  end
+
+  # scalar division
+  #  V2D[1.0,2.0] / 2.0; #=> V2D[0.5,1.0]
+  # ruby checks for dividing by zero
+  def /( scalar )
+    return V2D[ self.x / scalar, self.y / scalar ]
   end
   
+  # 2D vector addition
+  #  V2D[1.0,2.0] + V2D[2.0,1.0]; #=> V2D[3.0,3.0]
   def +(other)
-    return Vector[ self[0] + other[0], self[1] + other[1] ]
+    return V2D[ self.x + other.x, self.y + other.y ]
+  end
+
+  # 2D vector substraction
+  #  V2D[1.0,2.0] - V2D[2.0,1.0]; #=> V2D[-1.0,1.0]
+  def -(other)
+    return V2D[ self.x - other.x, self.y - other.y ]
   end
+
+  # 2D vector negative
+  #  -V2D[1.0,2.0]  #=> V2D[-1.0,2.0]
+  def -@ ()
+    return V2D[ -self.x, -self.y ]
   end
 
+  # alias for 2D vector negative
+  alias reverse   -@
 
-  # method necessary to make Vector Ranges
+  # method necessary to make V2D Ranges
   #
   # make <=> on x, then on y
   def <=>( other )
@@ -51,34 +96,41 @@ class Vector
     end
   end
 
-  # method necessary to make Vector Ranges
+  # method necessary to make V2D Ranges
   # 
   # simply call succ on each coord
   def succ()
-    return Vector[ self.x.succ, self.y.succ ]
+    return V2D[ self.x.succ, self.y.succ ]
   end
 
+  # compute length of 2D vector (r notation to be compatible with Vector)
+  def r()
+    return Math.hypot( self.x, self.y )
+  end
+
+  # alias for computing 2D vector length
+  alias length    r
+
   # compute the normalized vector given the current vector
-  #  Vector[0.0,2.0].norm => Vector[0.0,1.0]
+  #  V2D[0.0,2.0].norm => V2D[0.0,1.0]
   def norm
     r = r()
     if r != 0.0
       return self / r
     else
-      return Vector::O
+      return V::O
     end
   end
 
   # compute the angle of a vector considering x axis.
-  #  Vector[0.0,2.0].angle => 0.0
-  # must be made in C extension, as expensive
+  #  V2D[0.0,2.0].angle => 0.0
   def angle
     r = self.r()
     if r == 0
       return 0
     else
       unitary = self/r
-      cos, sin = unitary[0], unitary[1]
+      cos, sin = unitary.x, unitary.y
       angle = Math.acos( cos )
       if sin < 0.0
 	angle = -angle
@@ -88,66 +140,44 @@ class Vector
   end
 
   # compute the angle between two vectors
-  #  Vector.angle( Vector[1.0,0.0], Vector[0.0,1.0] ) => Math::PI/2.0
-  def Vector.angle( v1, v2 )
+  #  V2D.angle( V2D[1.0,0.0], V2D[0.0,1.0] ) => Math::PI/2.0
+  def V2D.angle( v1, v2 )
     return v1.angle - v2.angle
   end
 
+  # 2D translation, simply defines as addition
+  alias translate +
+
   # scale a vector with another one
-  #  Vector[1.0,2.0].scale( Vector[3.0,4.0] ) => Vector[3.0,8.0]
-  #  v.scale( Vector[a,a] ) <=> v * a
+  #  V2D[1.0,2.0].scale( V2D[3.0,4.0] ) => V2D[3.0,8.0]
+  #  v.scale( V2D[a,a] ) <=> v * a
   def scale( scaler )
-    return Vector[self.x * scaler.x, self.y * scaler.y ]
+    return V2D[self.x * scaler.x, self.y * scaler.y ]
   end
 
   # rotate a 2D vector 
-  #  Vector[1.0,0.0].rotate( Math::PI/2.0 ) => Vector[0.0,1.0]
+  #  V2D[1.0,0.0].rotate( Math::PI/2.0 ) => V2D[0.0,1.0]
   def rotate( angle )
     newx = self.x * Math.cos( angle ) - self.y * Math.sin( angle )
     newy = self.x * Math.sin( angle ) + self.y * Math.cos( angle )
-    return Vector[ newx, newy ]
+    return V2D[ newx, newy ]
   end
   
   # compute the orthogonal vector. Equiv to .rotate( Math::PI/2.0 )
-  #  Vector[1.0,0.0].ortho => Vector[0.0,1.0]
+  #  V2D[1.0,0.0].ortho => V2D[0.0,1.0]
   def ortho
-    return Vector[ -self[1], self[0] ]
-  end
-  
-  # return first coord of a vector
-  #  Vector[1.0,2.0].x => 1.0
-  def x
-    return self[0]
+    return V2D[ -self.y, self.x ]
   end
 
-  # return second coord of a vector
-  #  Vector[1.0,2.0].y => 2.0
-  def y
-    return self[1]
-  end
-  
-  # compute the symetric of vector considered as point, with center of symetrie being other considered as point
-  #  Vector[1.0,2.0].sym( Vector[0.0,0.0] ) => Vector[-1.0,-2.0]
+  # compute the symetric of vector considered as point, with center of symetrie being "other" considered as point
+  #  V2D[1.0,2.0].sym( V2D[0.0,0.0] ) => V2D[-1.0,-2.0]
   def sym( other )
     return self * 2.0 - other
   end
 
-  # shortcut method to do 
-  #  vector * (1.0 / scalar)
-  def /( scalar )
-    return self * (1.0 / scalar)
-  end
-
-  # more efficient that self * -1.0
-  def -@ ()
-    return Vector[ -self[0], -self[1] ]
-  end
-
-  alias reverse -@
-
   # coords management between different coord systems (for the moment only euclidian and polar)
-  #  Vector[0.0,1.0].coords         => [0.0,1.0]
-  #  Vector[0.0,1.0].coords(:polar) => [1.0,Math::PI/2.0]
+  #  V2D[0.0,1.0].coords         => [0.0,1.0]
+  #  V2D[0.0,1.0].coords(:polar) => [1.0,Math::PI/2.0]
   def coords(type=:cartesien)
     if type == :cartesien
       return [self.x, self.y]
@@ -162,26 +192,26 @@ class Vector
   end
   
   # build a vector from polar coords
-  def Vector.polar( r, angle )
+  def V2D.polar( r, angle )
     x = r * Math.cos( angle )
     y = r * Math.sin( angle )
-    return Vector[x,y]
+    return V2D[x,y]
   end
 
-  alias length r
-  alias translate +
-end
-
-#
-# Point class just to have some more meaningful notation, as Point::O
-#
-class Point < Vector
+  # compute 2D inner_product as v1.x * v2.x + v1.y * v2.y
+  #  V2D[ 1.0, 2.0 ].inner_product( V2D[3.0,4.0] ); #=> 11.0 
+  def inner_product( other )
+    return self.x * other.x + self.y * other.y
+  end
 
-  O = Point[0.0, 0.0]
+  # specific method to test vector equality with specified precision
+  def V2D.vequal?( v1, v2, epsilon=0.000000001 )
+    return ((v2-v1).r < epsilon)
+  end
 
   # compute the coord box enclosing every 2D elements considered as points
-  #  Point.viewbox( [Vector[1.0,2.0], Vector[2.0,1.0]] ) => [1.0, 1.0, 2.0, 2.0]
-  def Point.viewbox (pointlist)
+  #  Vector.viewbox( [Vector[1.0,2.0], Vector[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]
     end
@@ -193,15 +223,11 @@ class Point < Vector
   end
 
   # compute dimension of the box enclosing 2D elemnts considered as points
-  #   Point.viewbox( [Vector[1.0,2.0], Vector[10.0,1.0]] ) => [9.0, 1.0]
+  #   Vector.viewbox( [Vector[1.0,2.0], Vector[10.0,1.0]] ) => [9.0, 1.0]
   # use +viewvox+
-  def Point.size (pointlist)
-    xmin, ymin, xmax, ymax = viewbox( pointlist )
+  def V2D.size (pointlist)
+    xmin, ymin, xmax, ymax = V2D.viewbox( pointlist )
     return [xmax - xmin, ymax - ymin]
   end
-
 end
 
-
-
-

data/lib/interpolation.rb

@@ -23,12 +23,14 @@ module Interpolation
   # for example, Palette redefines samplelist as
   #  alias samplelist colorlist
   def samplelist()
-    return [0.0, 0.0, 1.0, 1.0]
+    Kernel::raise("Interpolation::samplelist method must be redefined in subclasses")
   end
 
   # computing method
   #
   # from an input between 0.0 and 1.0, returns linear interpolated value
+  #
+  # interpolate uses + and * scalar operators on interpolation values
   def interpolate( dindex )
     result = nil
     pvalue, pindex = self.samplelist[0..1]
@@ -37,7 +39,7 @@ module Interpolation
 	if dindex == index
 	  return value
 	end
-	result = pvalue + ((value - pvalue ) * ((dindex - pindex) / (index - pindex )))
+	result = pvalue + ((value + pvalue * (-1.0) ) * ((dindex - pindex) / (index - pindex )))
 	break
       end
       pvalue, pindex = value, index