xrvg 0.0.6 → 0.0.7

data/lib/beziertools.rb

@@ -1,245 +0,0 @@
-# Some BezierBuilder implementations
-# - old-fashioned SimpleBezier
-# - useful BezierLevel
-# - powerful Offset
-# - interesting Ondulation
-# - simple ClosureBezier
-
-require 'bezierbuilders'
-
-module XRVG
-# = SimpleBezier
-# == Content
-# Simple Bezier interpolator, that builds a multipiece "regular" bezier curve from a list of points
-# == Algo
-# For each point triplet :
-# - tangent vector of the middle point is the vector mean of vector from first to middle and vector frommiddle to last.
-# First and last tangents are computed by symetry
-# == Note
-# FittingBezier is a better class for point bezier interpolation. However, this class is kept mainly for historical reasons.
-class SimpleBezier < BezierBuilder
-  attribute :support, nil, Array
-
-  # BezierBuilder overloading: see SimpleBezier description for algorithm
-  def compute( )
-    points = @support
-    if points.length < 2
-      Kernel::raise("SimpleBezier support must have at least two points")
-    elsif points.length == 2
-      return LinearBezier.build( :support, points).data
-    end
-    
-    result = Array.new
-    p1      = points[0]
-    v1      = V2D::O
-    cpiece = [:vector, p1, v1]
-    
-    points.triplets do |p1, p2, p3|
-      v = ((p2 - p1)..( p3 - p2 )).middle * 1.0 / 3.0
-      result.push( cpiece + [p2, v.reverse] )
-      cpiece = [:vector, p2, v]
-    end
-
-    pr2 = points[-1]
-    vr2 = V2D::O
-    result.push( cpiece + [pr2, vr2] )
-
-    # compute first and last piece again, by symetry
-    piece0 = Bezier.single( *result[0] )
-    p1, v1, p2, v2 = piece0.pointlist(:vector)
-    pv     = (p2 - p1)
-    angle  = v2.angle - pv.angle 
-    v1     = (-v2).rotate( -2.0 * angle )
-    result[0] = [:vector, p1, v1, p2, v2]
-
-    piecel = Bezier.single( *result[-1] )
-    p1, v1, p2, v2 = piecel.pointlist(:vector)
-    pv     = (p2 - p1)
-    angle  = v1.angle - pv.angle 
-    v2     = (-v1).rotate(  -2.0 * angle )
-    result[-1] = [:vector, p1, v1, p2, v2]
-
-    return result
-  end
-end
-
-#
-# Interpolation extension with SimpleBezier
-#
-module Interpolation
-
-  def compute_simplebezier
-    points = self.samplelist.foreach(2).map { |index, value| V2D[index,value] }
-    @simplebezier = SimpleBezier[ :support, points ]
-  end
-  
-  def getcurve
-    if not @simplebezier
-      self.compute_simplebezier
-    end
-    return @simplebezier
-  end
-
-  def simplebezier( dindex )
-    return self.getcurve.sample( dindex ).y
-  end
-
-end
-
-
-# = Offset bezier builder
-# == Content
-# Generic offset bezier builder.
-# == Attributes
-#  attribute :support, nil, Curve
-#  attribute :abscissasampler, (0.0..1.0), Samplable
-#  attribute :ampl, 0.5, :samplable
-#  attribute :nsamples, 100
-class Offset < FitBezierBuilder
-  attribute :support, nil, Curve
-  attribute :abscissasampler, (0.0..1.0), Samplable
-  attribute :ampl, 0.5, :samplable
-  attribute :nsamples, 100
-
-  # overload FitBezierBuilder.points to compute Offset points
-  #
-  # Algo: for each sample, compute point, normal and amp, and newpoint = point + normal.norm * ampl
-  def points
-    result = []
-    [self.abscissasampler, self.ampl].samples( self.nsamples) do |abscissa, amplsample|
-      frame = self.support.frame( abscissa )
-      result << frame.center + frame.vector.ortho.norm * amplsample
-    end
-    return result
-  end
-end
-
-# = Fuseau bezier builder
-# == Content
-# Just shortcut class for Offset with :ampl = (1.0..0.0)
-# == Attributes
-#    attribute :maxwidth, 0.1
-class Fuseau < Offset
-  attribute :maxwidth, 0.1
-
-  # overload Offset.ampl method by returning (self.maxwidth..0.0)
-  def ampl
-    return (self.maxwidth..0.0)
-  end
-end
-
-
-
-# = BezierLevel bezier builder
-# == Content
-# Compute "roller coaster" bezier curves
-#
-# Can be used as a x-progressing curve, that is as an interpolation curve
-# == Attributes
-#  attribute :samplelist, [], Array
-# :samplelist must contain pairs of cartesien coords [x1,y1,x2,y2,...], x between 0.0 and 1.0 (as for interpolator)
-class BezierLevel < BezierBuilder
-  attribute :samplelist, [], Array
-
-  # Overload BezierBuilder build method
-  #
-  # Algo: simply interpolate [x,y] couples as V2D, with SimpleBezier bezier builder
-  def BezierLevel.build( *args )
-    builder = BezierLevel.new( *args )
-    points = []
-    builder.samplelist.foreach do |x,y|
-      points << V2D[x,y]
-    end
-    return SimpleBezier[ :support, points ]
-  end
-end
-
-# = ClosureBezier bezier builder
-# == Content
-# Simple bezier operator that take a list of beziers and produce a concatenate multipieces closed bezier curve.
-# Missing segments are completed with lines
-class ClosureBezier < BezierBuilder
-  attribute :bezierlist
-
-  # BezierBuilder compute overloading
-  def compute
-    result = []
-    result += self.bezierlist[0].pieces
-    self.bezierlist[1..-1].each do |bezier|
-      lastpoint = result[-1].lastpoint
-      newpoint  = bezier.firstpoint
-      if not V2D.vequal?( lastpoint, newpoint )
-	result += LinearBezier[ :support, [lastpoint, newpoint]].pieces
-      end
-      result += bezier.pieces
-    end
-    lastpoint = result[-1].lastpoint
-    newpoint  = result[0].firstpoint
-    if not V2D.vequal?( lastpoint, newpoint )
-      result += LinearBezier[ :support, [lastpoint, newpoint]].pieces
-    end
-    result = result.map {|piece| piece.data}
-    # Trace("result #{result.inspect}")
-    return result
-  end
-end
-
-# = Ondulation bezier builder
-# == Content
-# Generic ondulation bezier builder.
-# == Attributes
-#  attribute :support, nil, Curve
-#  attribute :ampl, 0.5, :samplable
-#  attribute :abscissasampler, (0.0..1.0), Samplable
-#  attribute :freq, 10
-# :support is a Curve
-# :abscissas must be a Float Samplable, as (0.0..1.0).geo(3.0)
-# :ampl can be a constant or a sampler
-# :freq is the number of oscillations to be computed
-class Ondulation < BezierBuilder
-  attribute :support, nil, Curve
-  attribute :ampl, 0.5, :samplable
-  attribute :abscissasampler, (0.0..1.0), Samplable
-  attribute :freq, 10
-
-  # atomic pattern computation
-  # 
-  def compute_arc( abs1, abs2, amplitude, sens )
-    mabs = (abs1 + abs2)/2.0
-    p1, halfpoint, p2 = self.support.points( [abs1, mabs, abs2] )
-    # Trace("mabs #{mabs} abs1 #{abs1} abs2 #{abs2} halfpoint #{halfpoint.inspect} p1 #{p1.inspect} p2 #{p2.inspect}")
-    # Trace("normal #{@support.normal( mabs )}")
-    halfnormal = self.support.normal( mabs ).norm * ( sens * amplitude * (p2 - p1).length)
-    # Trace("halfnormal #{halfnormal.inspect}")
-    newpoint = halfpoint + halfnormal
-    tpoint = halfpoint + halfnormal * 3.0
-    t1 = (tpoint - p1 ) / 6.0
-    t2 = (tpoint - p2 ) / 6.0
-    # Trace("newpoint #{newpoint.inspect} p1 #{p1.inspect} (newpoint - p1) #{(newpoint - p1).inspect}")
-    halftangent = self.support.tangent( mabs ).norm * (newpoint - p1).length / 3.0
-    # halftangent = self.support.tangent( mabs ).norm * (p2 - p1).length / 3.0
-    return [[:vector, p1, t1, newpoint, -halftangent], [:vector, newpoint, halftangent, p2, t2]]
-  end
-  
-  def compute_interpol( abs1, abs2, amplitude, sens )
-    arc = Bezier.multi( self.compute_arc( abs1, abs2, 1.0, sens ) )
-    subsupport = self.support.subbezier( abs1, abs2 )
-    return InterBezier[ :bezierlist, [0.0, subsupport, 1.0, arc] ].sample( amplitude ).data
-  end
-
-  # algo : for each abscissa, 0.0 of the curve (given the normal)
-  #    and for each mean abscissa, :amp normal
-  def compute
-    abscissas = self.abscissasampler.samples( self.freq + 1 )
-    sens = 1.0
-    pieces = []
-    [abscissas.pairs, self.ampl.samples( self.freq )].forzip do |abspair, amplitude|
-      abs1, abs2 = abspair
-      pieces += self.compute_interpol( abs1, abs2, amplitude, sens )
-      sens *= -1.0
-    end
-    return pieces
-  end
-end
-
-end # XRVG

data/lib/color.rb

@@ -1,401 +0,0 @@
-# Color functionalities file. See 
-# - +Color+
-# - +Palette+
-# - +Gradient+
-
-require 'utils'
-require 'interpolation'
-require 'shape'; # for gradient
-
-module XRVG
-#
-# Color class
-#
-# = Basics
-# 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
-
-  # Color builder
-  #
-  # only allows to build 4D vector, with composants between 0.0 and 1.0
-  def Color.[]( *args )
-    # TODO : check args number
-    Color.new( *args )
-  end
-
-  # builder
-  #
-  # r, g, b, a must be between 0.0 and 1.0
-  def initialize( r, g, b, a)
-    # cannot trim because otherwise color interpolation cannot be right !!
-    # r = Range.O.trim( r )
-    # g = Range.O.trim( g )
-    # b = Range.O.trim( b )
-    # a = Range.O.trim( 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
-  #  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)
-    @items[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)
-    @items[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)
-    @items[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)
-    @items[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 @items.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( opacity=1.0 )
-    return Color[Kernel::rand,Kernel::rand,Kernel::rand,opacity] 
-  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
-
-  # return a grey color vector
-  def Color.grey(light,opacity=1.0)
-    return Color[light, light, light, 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]
-  #
-  # error on algo with h = 1.0 => hi == 6 mustbe taken into account
-  def Color.hsv( h, s, v, a)
-    h = Range.O.trim( h )
-    s = Range.O.trim( s )
-    v = Range.O.trim( v )
-    a = Range.O.trim( a )
-    if s == 0.0
-      return Color[v, v, v, a]
-    end
-    h *= 360.0
-    hi = (h/60.0).floor
-    if hi == 6
-      hi = 5
-    end
-    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 = Range.O.trim( h )
-    s = Range.O.trim( s )
-    l = Range.O.trim( l )
-    a = Range.O.trim( 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 do |v|
-      v = Range.O.trim( v )
-      (255.0 * v).to_i 
-    end
-    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, [ 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
-  include Attributable
-  attribute :colorlist, nil, Array
-  attribute :interpoltype, :linear
-
-  include Samplable
-  include Interpolation
-
-  def initialize( *args )
-    super( *args )
-    build_interpolators
-  end
-
-  # build an interpolator by color componant
-  def build_interpolators()
-    vlists = [[],[],[],[]]
-    self.colorlist.foreach do |index, color|
-      vlists[0] += [index, color.r ]
-      vlists[1] += [index, color.g ]
-      vlists[2] += [index, color.b ]
-      vlists[3] += [index, color.a ]
-    end
-    @interpolators = vlists.map {|samplelist| Interpolator[ :samplelist, samplelist, :interpoltype, self.interpoltype]}
-  end
-
-  # interpolators accessor (for debugging)
-  def interpolators()
-    return @interpolators
-  end
-
-  # overloading to reset interpolators if interpoltype changes
-  def interpoltype=(value)
-    @interpoltype = value
-    if @interpolators
-      self.build_interpolators
-    end
-  end
-
-  # method overloading to delegate computation to componant interpolators
-  def interpolate( dindex )
-    vs = self.interpolators.map {|inter| inter.interpolate( dindex )}
-    return Color[ *vs ]
-  end
-
-  # compute color given float pourcentage.
-  #  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)
-    return result
-  end
-
-  # return a new palette by reversing the current one
-  def reverse()
-    newcolorlist = []
-    self.colorlist.reverse.foreach do |color, index|
-      newcolorlist += [(0.0..1.0).complement( index ), color]
-    end
-    return Palette[ :colorlist, newcolorlist ]
-  end
-  
-
-
-  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()
-    raise NotImplementedError.new("#{self.class.name}#defsvg is an abstract method.")
-  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 |index, color|
-      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 |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} )
-  end
-end
-end