xrvg 0.0.1

data/lib/color.rb

@@ -0,0 +1,295 @@
+# Color functionalities file. See 
+# - +Color+
+# - +Palette+
+# - +Gradient+
+
+require 'geometry2D'; # for vector extension
+require 'interpolation'
+require 'attributable'
+require 'utils'
+require 'shape'; # for gradient
+
+#
+# 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
+# = 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
+
+  # Color builder
+  #
+  # only allows to build 4D vector, with composants between 0.0 and 1.0
+  def initialize( *args )
+    # TODO : check args number
+    super( *args )
+  end
+
+  # return the red composant
+  #  Color[0.1,0.2,0.3,0.4].r => 0.1
+  def r
+    return self[0]
+  end
+
+  # return the green composant
+  #  Color[0.1,0.2,0.3,0.4].r => 0.2
+  def g
+    return self[1]
+  end
+
+  # return the blue composant
+  #  Color[0.1,0.2,0.3,0.4].r => 0.3
+  def b
+    return self[2]
+  end
+
+  # return the opacity composant
+  #  Color[0.1,0.2,0.3,0.4].r => 0.4
+  def a
+    return self[3]
+  end
+
+  # set the red composant
+  #  Color[0.1,0.2,0.3,0.4].r = 0.5 => Color[0.5,0.2,0.3,0.4]
+  def r=(n)
+    self[0]= n
+  end
+
+  # set the green composant
+  #  Color[0.1,0.2,0.3,0.4].g = 0.5 => Color[0.1,0.5,0.3,0.4]
+  def g=(n)
+    self[1] = n
+  end
+
+  # set the blue composant
+  #  Color[0.1,0.2,0.3,0.4].b = 0.5 => Color[0.1,0.2,0.5,0.4]
+  def b=(n)
+    self[2] = n
+  end
+
+  # set the opacity composant
+  #  Color[0.1,0.2,0.3,0.4].a = 0.5 => Color[0.1,0.2,0.3,0.5]
+  def a=(n)
+    self[3] = n
+  end
+
+  # return an array containing colors on 255 integer format
+  #  Color[0.0,1.0,0.0,1.0].format255 => [0,255,0,255]
+  def format255()
+    return self.map {|v| (v * 255.0).to_i}
+  end
+
+  # return a random color vector, with 1.0 opacity !!
+  #  Color.rand => Color[0.2345, 0.987623, 0.4123, 1.0]
+  def Color.rand
+    return Color[Kernel::rand,Kernel::rand,Kernel::rand,1.0] 
+  end
+
+  # return a black color vector
+  def Color.black(opacity=1.0)
+    return Color[0.0, 0.0, 0.0, opacity]
+  end
+
+  # return a blue color vector
+  def Color.blue(opacity=1.0)
+    return Color[0.0, 0.0, 1.0, opacity]
+  end
+
+  # return a red color vector
+  def Color.red(opacity=1.0)
+    return Color[1.0, 0.0, 0.0, opacity]
+  end
+
+  # return a yellow color vector
+  def Color.yellow(opacity=1.0)
+    return Color[1.0, 1.0, 0.0, opacity]
+  end
+
+  # return a orange color vector
+  def Color.orange(opacity=1.0)
+    return Color[1.0, 0.5, 0.0, opacity]
+  end
+
+  # return a green color vector
+  def Color.green(opacity=1.0)
+    return Color[0.0, 1.0, 0.0, opacity]
+  end
+
+  # return a white color vector
+  def Color.white(opacity=1.0)
+    return Color[1.0, 1.0, 1.0, opacity]
+  end
+
+  # build a color vector from hsv parametrization (convert from hsv to rgb) h, s, v being between 0.0 and 1.0
+  # taken from wikipedia[http://en.wikipedia.org/wiki/HSV_color_space]
+  def Color.hsv( h, s, v, a)
+    if s == 0.0
+      return Color[v, v, v, a]
+    end
+    h *= 360.0
+    hi = (h/60.0).floor
+    f  = (h/60.0) - hi
+    p  = v * ( 1 -             s )
+    q  = v * ( 1 -       f   * s )
+    t  = v * ( 1 - ( 1 - f ) * s )
+    if hi == 0 
+      return Color[ v, t, p, a] 
+    end
+    if hi == 1 
+      return Color[ q, v, p, a] 
+    end
+    if hi == 2 
+      return Color[ p, v, t, a] 
+    end
+    if hi == 3 
+      return Color[ p, q, v, a] 
+    end
+    if hi == 4 
+      return Color[ t, p, v, a] 
+    end
+    if hi == 5 
+      return Color[ v, p, q, a] 
+    end
+  end
+
+  def Color.getHSLcomponent( tC, p, q ) #:nodoc:
+    while tC < 0.0
+      tC = tC + 1.0
+    end
+    while tC > 1.0
+      tC = tC - 1.0
+    end
+
+    if tC < (1.0 / 6.0)
+      tC = p + ( (q-p) * 6.0 * tC )
+    elsif tC >=(1.0 / 6.0) and tC < 0.5
+      tC = q
+    elsif tC >= 0.5 and tC < (2.0 / 3.0)
+      tC = p + ( (q-p) * 6.0 * ((2.0 / 3.0) - tC) )
+    else
+      tC = p
+    end
+    return tC
+  end
+
+  # build a color vector from hsl parametrization (convert from hsl to rgb) h, s, l being between 0.0 and 1.0
+  # taken from [[http://en.wikipedia.org/wiki/HSV_color_space]]
+  # h, s, l must be between 0.0 and 1.0
+  def Color.hsl( h, s, l, a)
+    h *= 360.0
+    if l < 0.5
+      q = l * (1.0 + s)
+    else
+      q = l+ s - (l * s)
+    end
+    p = 2 * l - q
+    hk = h / 360.0
+    tR = hk + 1.0 / 3.0
+    tG = hk
+    tB = hk - 1.0 / 3.0
+
+    tR = self.getHSLcomponent( tR, p, q )
+    tG = self.getHSLcomponent( tG, p, q )
+    tB = self.getHSLcomponent( tB, p, q )
+    return Color[tR, tG, tB, a]
+  end
+
+  # get svg description of a color
+  def svg
+    values = self[0..2].map {|v| (255.0 * v).to_i }
+    return "rgb(#{values.join(",")})"
+  end
+
+end
+
+# class Palette
+# = Intro
+# 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.rand( 10 )   # => return 10 random colors in palette
+#  palette.color( 0.5 ) # => Color.orange
+class Palette
+  include Attributable
+  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]
+  # "sample" method as defined in Samplable module
+  def color(dindex)
+    result = self.interpolate(dindex)
+    return Color.elements(result[0..-1],false)
+  end
+
+  # 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 )]
+    end
+    return Palette[ :colorlist, newcolorlist ]
+  end
+  
+
+  include Samplable
+  include Interpolation
+
+  def apply_sample( abs ) #:nodoc:
+    # Trace("Palette#apply_sample abs #{abs}")
+    return self.color( abs )
+  end
+
+  # alias apply_sample color
+  # alias apply_split ? => TODO
+  alias samplelist colorlist
+  alias colors samples
+end
+
+class Gradient < Palette #:nodoc:
+  def defsvg()
+    Kernel::raise("Gradient::defsvg must be redefined in subclasses")
+  end
+end
+
+
+class LinearGradient < Gradient #:nodoc:
+
+  def svgdef
+    template     = '<linearGradient id="%ID%" x1="0%" y1="0%" x2="0%" y2="100%">%stops%</linearGradient>'
+    stoptemplate = '<stop offset="%offset%" stop-color="%color%" stop-opacity="%opacity%"/>'
+    
+    stops = "\n"
+    self.colorlist.foreach do |color, index|
+      stops += stoptemplate.subreplace( {"%offset%" => index, "%color%" => color.svg, "%opacity%" => color.a} )
+      stops += "\n"
+    end
+
+    return template.subreplace( {"%stops%" => stops} )
+  end
+end
+
+class CircularGradient < Gradient #:nodoc:
+  attribute :circle, nil, Circle
+  
+  def svgdef
+    template     = '<radialGradient id="%ID%" gradientUnits="userSpaceOnUse" cx="%cx%" cy="%cy%" r="%r%">%stops%</radialGradient>'
+    stoptemplate = '<stop offset="%offset%" stop-color="%color%" stop-opacity="%opacity%"/>'
+    
+    stops = "\n"
+    self.colorlist.foreach do |color, index|
+      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} )
+  end
+end

data/lib/frame.rb

@@ -0,0 +1,32 @@
+# frame.rb file
+# 
+# See +Frame+
+require 'attributable'
+
+#
+# Frame class
+# = Intro
+# Defines a local geometry. Used by +Curve+ interface.
+# = Attributes
+#   attribute :center
+#   attribute :vector
+#   attribute :rotation
+#   attribute :scale
+class Frame
+  include Attributable
+  attribute :center
+  attribute :vector
+  attribute :rotation
+  attribute :scale
+
+  def ==(other)
+    if self.center == other.center and
+	self.vector == other.vector and
+	self.rotation == other.rotation and
+	self.scale == other.scale
+      return true
+    end
+    return false
+  end
+end
+

data/lib/geometry2D.rb

@@ -0,0 +1,207 @@
+#
+# Contains Ruby Vector class extension. 
+# See :
+# - +Vector+
+# - +Point+
+
+require 'matrix'
+
+# 
+# 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.
+#
+# Another thing is to make this class C extension, to speed up computation.
+class Vector
+  include Comparable
+
+  X = Vector[1.0, 0.0]
+  Y = Vector[0.0, 1.0]
+  O = Vector[0.0, 0.0]
+
+  # to optimize for 2D
+  if nil
+  def *( scalar )
+    return Vector[ self[0] * scalar, self[1] * scalar ]
+  end
+  
+  def +(other)
+    return Vector[ self[0] + other[0], self[1] + other[1] ]
+  end
+  end
+
+
+  # method necessary to make Vector Ranges
+  #
+  # make <=> on x, then on y
+  def <=>( other )
+    first = self.x <=> other.x 
+    if first != 0
+      return first
+    else
+      return self.y <=> other.y
+    end
+  end
+
+  # method necessary to make Vector Ranges
+  # 
+  # simply call succ on each coord
+  def succ()
+    return Vector[ self.x.succ, self.y.succ ]
+  end
+
+  # compute the normalized vector given the current vector
+  #  Vector[0.0,2.0].norm => Vector[0.0,1.0]
+  def norm
+    r = r()
+    if r != 0.0
+      return self / r
+    else
+      return Vector::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
+  def angle
+    r = self.r()
+    if r == 0
+      return 0
+    else
+      unitary = self/r
+      cos, sin = unitary[0], unitary[1]
+      angle = Math.acos( cos )
+      if sin < 0.0
+	angle = -angle
+      end
+      return angle
+    end
+  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 )
+    return v1.angle - v2.angle
+  end
+
+  # 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
+  def scale( scaler )
+    return Vector[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]
+  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 ]
+  end
+  
+  # compute the orthogonal vector. Equiv to .rotate( Math::PI/2.0 )
+  #  Vector[1.0,0.0].ortho => Vector[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]
+  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]
+  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]
+  def coords(type=:cartesien)
+    if type == :cartesien
+      return [self.x, self.y]
+    elsif type == :polar
+      if @polarcoords == nil
+	@polarcoords = [self.r, self.angle]
+      end
+      return @polarcoords
+    else
+      Kernel.raise( "Unknown coord type #{type}" )      
+    end
+  end
+  
+  # build a vector from polar coords
+  def Vector.polar( r, angle )
+    x = r * Math.cos( angle )
+    y = r * Math.sin( angle )
+    return Vector[x,y]
+  end
+
+  alias length r
+  alias translate +
+end
+
+#
+# Point class just to have some more meaningful notation, as Point::O
+#
+class Point < Vector
+
+  O = Point[0.0, 0.0]
+
+  # 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)
+    if pointlist.size == 0
+      return [0.0, 0.0, 0.0, 0.0]
+    end
+
+    xs = pointlist.map {|p| p.x}
+    ys = pointlist.map {|p| p.y}
+
+    return [xs.min, ys.min, xs.max, ys.max]
+  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]
+  # use +viewvox+
+  def Point.size (pointlist)
+    xmin, ymin, xmax, ymax = viewbox( pointlist )
+    return [xmax - xmin, ymax - ymin]
+  end
+
+end
+
+
+
+

data/lib/interpolation.rb

@@ -0,0 +1,59 @@
+# Interpolation file.
+#
+# See
+# - +Interpolation+
+# - +Interpolator+
+
+require 'utils'
+require 'attributable'
+
+# Interpolation module
+# = Intro
+# Defines an interpolation service from a samplelist that must be a list [value1, index1, value2, index2, ..., valueN, indexN],
+# with index between 0.0 and 1.0 and in increasing order.
+# value must be an object with + and * scalar operators defined
+# = Uses
+# Used for example by Palette
+# = Future
+# Must be extended for all kinds of interpolation (bezier, ...)
+module Interpolation
+  
+  # must be the overloaded method to adapt Interpolation
+  #
+  # for example, Palette redefines samplelist as
+  #  alias samplelist colorlist
+  def samplelist()
+    return [0.0, 0.0, 1.0, 1.0]
+  end
+
+  # computing method
+  #
+  # from an input between 0.0 and 1.0, returns linear interpolated value
+  def interpolate( dindex )
+    result = nil
+    pvalue, pindex = self.samplelist[0..1]
+    self.samplelist.foreach do |value, index|
+      if dindex <= index
+	if dindex == index
+	  return value
+	end
+	result = pvalue + ((value - pvalue ) * ((dindex - pindex) / (index - pindex )))
+	break
+      end
+      pvalue, pindex = value, index
+    end
+    if not result
+      result = self.samplelist[-2]
+    end
+    return result
+  end
+end
+
+# Buildable interpolator
+# 
+# Simply instanciated module in a class
+class Interpolator
+  include Attributable
+  attribute :samplelist
+  include Interpolation
+end