xrvg 0.0.5 → 0.0.6

data/lib/beziertools.rb

@@ -63,6 +63,29 @@ class SimpleBezier < BezierBuilder
   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
@@ -179,7 +202,31 @@ class Ondulation < BezierBuilder
   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
@@ -188,20 +235,7 @@ class Ondulation < BezierBuilder
     pieces = []
     [abscissas.pairs, self.ampl.samples( self.freq )].forzip do |abspair, amplitude|
       abs1, abs2 = abspair
-      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
-      pieces += [[:vector, p1, t1, newpoint, -halftangent], [:vector, newpoint, halftangent, p2, t2]]
+      pieces += self.compute_interpol( abs1, abs2, amplitude, sens )
       sens *= -1.0
     end
     return pieces

data/lib/color.rb

@@ -3,10 +3,8 @@
 # - +Palette+
 # - +Gradient+
 
-require 'geometry2D'; # for vector extension
-require 'interpolation'
-require 'attributable'
 require 'utils'
+require 'interpolation'
 require 'shape'; # for gradient
 
 module XRVG
@@ -130,7 +128,7 @@ class Color
 
   # return a random color vector, with 1.0 opacity !!
   #  Color.rand => Color[0.2345, 0.987623, 0.4123, 1.0]
-  def Color.rand( opacity )
+  def Color.rand( opacity=1.0 )
     return Color[Kernel::rand,Kernel::rand,Kernel::rand,opacity] 
   end
 
@@ -169,6 +167,12 @@ class Color
     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]
@@ -259,7 +263,10 @@ class Color
 
   # get svg description of a color
   def svg
-    values = self[0..2].map {|v| (255.0 * v).to_i }
+    values = self[0..2].map do |v|
+      v = Range.O.trim( v )
+      (255.0 * v).to_i 
+    end
     return "rgb(#{values.join(",")})"
   end
 
@@ -275,7 +282,47 @@ end
 #  palette.color( 0.5 ) # => Color.orange
 class Palette
   include Attributable
-  attribute :colorlist
+  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]
@@ -295,14 +342,14 @@ class Palette
   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

data/lib/fitting.rb

@@ -145,13 +145,13 @@ class Fitting
     maxerror = 0.0
     container = V2D[]
     [pointlist, parameters].forzip do |point, parameter|
-      Trace("point #{point.inspect} parameter #{parameter}")
+      # Trace("point #{point.inspect} parameter #{parameter}")
       error = (point - bezier.point( parameter, container, :parameter )).r
       if error > maxerror
 	maxerror = error
       end
     end
-    Trace("Fitting.error #{maxerror}")
+    # Trace("Fitting.error #{maxerror}")
     return maxerror
   end
 

data/lib/geometry2D.rb

@@ -3,7 +3,7 @@
 # See :
 # - +V2D+
 
-require 'Attributable'
+require 'attributable'
 
 module XRVG
 #
@@ -127,8 +127,8 @@ class V2D
   #  V2D[0.0,2.0].angle => 0.0
   def angle
     r = self.r()
-    if r == 0
-      return 0
+    if r == 0.0
+      return 0.0
     else
       unitary = self/r
       cos, sin = unitary.x, unitary.y
@@ -176,6 +176,13 @@ class V2D
     return self * 2.0 - other
   end
 
+  # compute the symetric of point "self" considering (point,v) as symetry axis
+  def axesym( point, axev )
+    v = self - point
+    angle = V2D.angle( v, axev )
+    return point + v.rotate( -2.0 * angle )
+  end
+
   # coords management between different coord systems (for the moment only euclidian and polar)
   #  V2D[0.0,1.0].coords         => [0.0,1.0]
   #  V2D[0.0,1.0].coords(:polar) => [1.0,Math::PI/2.0]

data/lib/geovariety.rb

@@ -0,0 +1,128 @@
+# File for GeoVariety
+# See (also):
+# - InterBezier
+# - Offsetvariety
+# - FuseauVariety
+
+require 'interbezier'
+
+module XRVG
+
+# = GeoVariety abstract module
+# == Principle
+# Base module to define geometrical spaces or canvas different from simple euclidean one to draw curves on.
+# It provides three different services:
+# - point computation
+# - geodesic computation
+# - arbitrary bezier computation, this one by computing sampling of euclidean curve on the variety, and then fitting point
+#   sequence with FitBezierBuilder
+module GeoVariety
+  
+  # must be overriden
+  def point( point )
+    raise NotImplementedError.new("#{self.class.name}#point is an abstract method.")
+  end
+  
+  # must be overriden
+  def line( x1, x2, y )
+    raise NotImplementedError.new("#{self.class.name}#line is an abstract method.")
+  end
+
+  # see GeoVariety module description for algorithm
+  def bezier( pointrange, bezier )
+    bezier = bezier.similar( pointrange )
+    points = bezier.samples( 20 )
+    points = points.map {|point| self.point( point )}
+    return FitBezierBuilder[ :points, points ]
+  end
+end
+
+# = InterBezier GeoVariety implementation
+# == Principle
+# InterBezier defines a surface by the set of every possible curve sample from one interpolated curve to the other.
+# Geodesic corresponds then to one interpolated result, and point to a point of this curve
+class InterBezier
+  include GeoVariety
+  
+  # Compute the geodesic curve by doing self.sample with y coord, and then compute point of this curve with length "x"
+  def point( point )
+    curve = self.sample( point.y )
+    return curve.point( point.x )
+  end
+
+  # Compute the geodesic subcurve with y coord between x1 and x2
+  def line( x1, x2, y )
+    # Trace("interbezier line x1 #{x1} x2 #{x2} y #{y}")
+    curve = self.sample( y )
+    result = curve.apply_split( x1, x2 )
+    # Trace("interbezier line result #{result.inspect}")
+    return result
+  end
+
+end
+
+# = OffsetVariety implementation
+# == Principle
+# Geovariety is defined by the set of offset curves from -ampl to +ampl
+# == Extension
+# Parameter could be a :samplable parameter : in that case, ampl will vary
+#
+# Another extension would be to parametrize range straightforwardly
+#
+# Finally, the two previous remarks must be synthetized :-)
+class OffsetVariety
+  include Attributable
+  attribute :support
+  attribute :ampl, nil, Float
+
+  include GeoVariety
+
+  # builder: init static offset range with (-self.ampl..self.ampl)
+  def initialize( *args )
+    super( *args )
+    @range = (-self.ampl..self.ampl)
+  end
+
+  # point computed by computing offset curve with ampl y coord mapped onto offset range, and then sampling the curve with x coord
+  def point( point )
+    curve = Offset[ :support, @support, :ampl, @range.sample( point.y ) ]
+    return curve.point( point.x )
+  end
+
+  # subgeodesic computed by computing offset curve with ampl y coord
+  def line( x1, x2, y )
+    curve = Offset[ :support, @support, :ampl, @range.sample( y ) ]
+    return curve.apply_split( x1, x2 )
+  end
+  
+end  
+
+# = FuseauVariety implementation
+# == Principle
+# Same as OffsetVariety, with Fuseau shape, that is with linearly varying ampl range
+class FuseauVariety
+  include Attributable
+  attribute :support
+  attribute :ampl, nil, Float
+
+  include GeoVariety
+
+  def initialize( *args )
+    super( *args )
+    @range = (-self.ampl..self.ampl)
+  end
+
+  def point( point )
+    curve = Offset[ :support, @support, :ampl, (0.0..@range.sample( point.y ))]
+    return curve.point( point.x )
+  end
+
+  def line( x1, x2, y )
+    curve = Offset[ :support, @support, :ampl, (0.0..@range.sample( y ))]
+    return curve.apply_split( x1, x2 )
+  end
+end
+
+end # XRVG
+
+# see geovariety_test to see tests

data/lib/interbezier.rb

@@ -24,12 +24,12 @@ class InterBezier
     alllengths = []
     beziers.each do |bezier|
       lengths = bezier.piecelengths
-      # Trace("bezier lengths #{lengths.inspect}")
+      Trace("bezier lengths #{lengths.inspect}")
       lengthH[ bezier ] = lengths
       alllengths += lengths
     end
     alllengths = Float.sort_float_list( alllengths )
-    # Trace("alllengths #{alllengths.inspect}")
+    Trace("alllengths #{alllengths.inspect}")
     
     newbezierlist = []
     beziers.each do |bezier|
@@ -42,10 +42,10 @@ class InterBezier
       newbezierlist << newbezier
     end
 
-    # Trace("newbezierlist #{newbezierlist.inspect}")
+    Trace("newbezierlist #{newbezierlist.length}")
     beziers = newbezierlist
     bezierpointlists = beziers.map {|bezier| bezier.pointlist(:vector) }
-    # Trace("bezierpointlists #{bezierpointlists.map {|list| list.length}.inspect}")
+    Trace("bezierpointlists #{bezierpointlists.map {|list| list.length}.inspect}")
     pointsequencelist = bezierpointlists.forzip
     @interpolatorlist = []
     pointsequencelist.foreach(beziers.size) do |pointsequence|

data/lib/interpolation.rb

@@ -3,11 +3,9 @@
 # See
 # - +Interpolation+
 # - +Interpolator+
-# - +InterpolatorQuad+
+# - +InterpolatorBinaryTree+
 
 require 'utils'
-require 'attributable'
-require 'samplation'
 
 module XRVG
 # Interpolation module
@@ -29,12 +27,26 @@ module Interpolation
     raise NotImplementedError.new("#{self.class.name}#samplelist is an abstract method.")
   end
 
+  # must be the overloaded method to adapt Interpolation
+  #
+  # is usually provided by a side-effect of a :attribute declaration in including class
+  def interpoltype()
+    return :linear
+  end
+
+  # overall computation method
+  #
+  # from an input between 0.0 and 1.0, returns an interpolated value computed by interpolation method deduced from interpoltype
+  def interpolate( dindex )
+    return method( self.interpoltype ).call( dindex )
+  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 )
+  def linear( dindex )
     result = nil
     pindex, pvalue = self.samplelist[0..1]
     self.samplelist.foreach do |index, value|
@@ -43,7 +55,7 @@ module Interpolation
 	  return value
 	end
 	result = pvalue + ((value + (pvalue * (-1.0)) ) * ((dindex - pindex) / (index - pindex )))
-	Trace("pindex #{pindex} pvalue #{pvalue.inspect} index #{index} value #{value.inspect} dindex #{dindex} result #{result.inspect}")
+	# Trace("pindex #{pindex} pvalue #{pvalue.inspect} index #{index} value #{value.inspect} dindex #{dindex} result #{result.inspect}")
 	break
       end
       pvalue, pindex = value, index
@@ -61,12 +73,13 @@ end
 class Interpolator
   include Attributable
   attribute :samplelist
+  attribute :interpoltype, :linear
   include Interpolation
   include Samplable
   alias apply_sample interpolate
 end
 
-class QuadRange
+class BinaryTreeRange
 
   def initialize( limit, quadleft, quadright, range=nil )
     @limit     = limit
@@ -88,13 +101,13 @@ class QuadRange
   end
 end
 
-# QuadTree class
+# BinaryTree 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 = BinaryTree.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
+class BinaryTree
 
   def initialize( samplelist ) #:nodoc:
     quads = []
@@ -102,7 +115,7 @@ class QuadTree
     samplelist.foreach(2).pairs do |ppair, pair|
       pindex, pvalue = ppair
       index, value   = pair
-      quads << QuadRange.new( nil, nil, nil, [pindex, pvalue, index, value] )
+      quads << BinaryTreeRange.new( nil, nil, nil, [pindex, pvalue, index, value] )
       ends  << index
     end
     @root = build_quads( quads, ends )
@@ -113,7 +126,7 @@ class QuadTree
     newends  = []
     index = 0
     quads.foreach do |quad1, quad2|
-      newquads << QuadRange.new( ends[2*index], quad1, quad2, nil)
+      newquads << BinaryTreeRange.new( ends[2*index], quad1, quad2, nil)
       newends  << ends[2*index + 1]
       index += 1
     end
@@ -125,24 +138,24 @@ class QuadTree
   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]  
+  #  BinaryTree.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
+# Binary tree interpolator
 # 
-# Use QuadTree to retrieve range of values between linear interpolation.
+# Use BinaryTree to retrieve range of values between linear interpolation.
 #
 # Used in BezierSpline to compute parameter from length.
-class InterpolatorQuad < Interpolator
+class InterpolatorBinaryTree < Interpolator
 
   def compute_quad #:nodoc:
-    @quad = QuadTree.new( self.samplelist )
+    @quad = BinaryTree.new( self.samplelist )
   end
   
-  # - first use QuadTree range to retrieve range of dindex, 
+  # - first use BinaryTree range to retrieve range of dindex, 
   # - then linearly interpolate
   def interpolate( dindex )
     if not @quad

data/lib/parametriclength.rb

@@ -13,6 +13,7 @@ module ParametricLength
     raise NotImplementedError.new("#{self.class.name}#parameter_range is an abstract method.")
   end
 
+  # abstract method to compute point from parameter
   def pointfromparameter( parameter, container )
     raise NotImplementedError.new("#{self.class.name}#pointfromparameter is an abstract method.")
   end
@@ -56,8 +57,8 @@ module ParametricLength
       end
       samplelist = newsamplelist
     end
-    @abs_interpolator = InterpolatorQuad.new( :samplelist, invsamplelist )
-    return InterpolatorQuad.new( :samplelist, samplelist )
+    @abs_interpolator = InterpolatorBinaryTree.new( :samplelist, invsamplelist )
+    return InterpolatorBinaryTree.new( :samplelist, samplelist )
   end
 
   def length_interpolator() #:nodoc:

data/lib/render.rb

@@ -4,7 +4,6 @@
 # - +SVGRender+ for effective SVG render 
 
 require 'color'
-require 'attributable'
 require 'style'
 
 module XRVG
@@ -34,7 +33,7 @@ end
 class SVGRender < Render
   attribute :filename, "", String
   attribute :imagesize, "2cm", String
-  attribute :background, Color.white, [Color, String]
+  attribute :background, "white", [Color, String]
   attr_reader :viewbox
 
   # SVGRender builder