xrvg 0.0.6 → 0.0.7

data/lib/fitting.rb

@@ -1,203 +0,0 @@
-#
-# Fitting file. See +Fitting+
-#
-
-require 'matrix'; # for matrix inversion
-require 'bezier.rb'; # for error computation
-
-module XRVG
-#
-# = Fitting computation class
-# == Intro
-# Used to compute cubic curve fitting on a list of points (that is sampling inverse operation). Only 2D.
-# == Example
-# Compute the most fitting single piece bezier curve given list of points
-#  bezier    = Fitting.compute( points )
-# Compute multipieces bezier curve given list of points
-#  bezier    = Fitting.adaptative_compute( points )
-class Fitting
-
-  # compute first parameter t estimated values from length between consecutive points
-  def Fitting.initparameters( pointlist, parameters=nil ) #:nodoc:
-    lengths = [0.0]
-    pointlist.pairs do |p1, p2|
-      lengths.push( lengths[-1] + (p1-p2).r )
-    end
-    tlength = lengths[-1]
-    if not parameters
-      if not tlength == 0.0
-	parameters = lengths.map {|length| length / tlength}
-      else
-	parameters = [0.0] * pointlist.length
-      end
-    end
-    return [parameters, tlength]
-  end
-
-  # compute control points from polynomial bezier representation
-  #
-  # a, b, c, d are such as 
-  #  piece( t ) = at3 + bt2 + ct + d
-  def Fitting.bezierpiece( a, b, c, d )
-    p0 = d
-    p1 = p0 + c / 3.0
-    p2 = p1 + c / 3.0 + b / 3.0
-    p3 = p0 + c + b + a
-    return [p0, p1, p2, p3]
-  end
-
-
-  # Base method
-  # 
-  # Given a pointlist, compute the closest matching cubic bezier curve
-  #
-  # Result is in the form [p1, pc1, pc2, p2], with [p1, pc1, pc2, p2] V2D
-  #
-  # maxerror is normalized with curve length. In case of good match (that is pointlist can be modelized by cubic bezier curve), 
-  # result error will be under maxerror. If not, result may be above maxerror. In that case, computation is stopped because error
-  # no longer decrease, or because iteration is too long.
-  def Fitting.compute( pointlist, maxerror=0.01, maxiter=100 )
-    parameters, tlength = Fitting.initparameters( pointlist )
-    perror = 1.0
-    niter = 0
-    while true
-      bezier, coeffs = Fitting.iterate( pointlist, parameters )
-      error = Fitting.error( bezier, pointlist, parameters ) / tlength
-      parameters = Fitting.renormalize( bezier, coeffs, pointlist, parameters )
-      if (error < maxerror || (error-perror).abs < 0.00001 || niter > maxiter )
-	break
-      end
-      niter += 1
-    end
-    return bezier
-  end
-
-  # adaptative computation with automatic splitting if error not low enough, or if convergence is not fast enough
-  #
-  #
-  def Fitting.adaptative_compute( pointlist, maxerror=0.0001, maxiter=10, tlength=nil )
-    parameters, tlengthtmp = Fitting.initparameters( pointlist )
-    if parameters == [0] * pointlist.length
-      return [Bezier.single(:vector, pointlist[0], V2D::O, pointlist[0], V2D::O),0.0]
-    end
-    tlength ||= tlengthtmp
-    niter = 0
-    bezier = nil
-    while true
-      bezier, coeffs = Fitting.iterate( pointlist, parameters )
-      error = Fitting.error( bezier, pointlist, parameters ) / tlength
-      parameters = Fitting.renormalize( bezier, coeffs, pointlist, parameters )
-
-      # pointlist.length > 8 because matching with a bezier needs at least 4 points
-      if (niter > maxiter and error > maxerror and pointlist.length > 8)
-	pointlists = [pointlist[0..pointlist.length/2 - 1], pointlist[pointlist.length/2 - 1 ..-1]]
-	beziers = []
-	errors  = []
-	pointlists.each do |subpointlist|
-	  subbezier, suberror = Fitting.adaptative_compute( subpointlist, maxerror, maxiter, tlength )
-	  beziers << subbezier
-	  errors  << suberror
-	end
-	bezier = beziers.sum
-	error  = errors.max
-	break
-      elsif (error < maxerror || niter > maxiter)
-	break
-      end
-      perror = error
-      niter += 1
-    end
-    return [bezier, error]
-  end
-
-  # algo comes from http://www.tinaja.com/glib/bezdist.pdf
-  def Fitting.renormalize( bezier, coeffs, pointlist, parameters )
-    a3, a2, a1, a0 = coeffs
-    dxdu = Proc.new {|u| 3.0*a3.x*u**2 + 2.0*a2.x*u + a1.x}
-    dydu = Proc.new {|u| 3.0*a3.y*u**2 + 2.0*a2.y*u + a1.y}
-    container = V2D[]
-    z    = Proc.new {|u,p4| p = bezier.point( u, container, :parameter ); (p.x - p4.x) * dxdu.call( u ) + (p.y - p4.y) * dydu.call( u )}
-    newparameters = []
-    [pointlist, parameters].forzip do |point, parameter|
-      u1 = parameter
-      if parameter < 0.99
-	u2 = parameter + 0.01
-      else
-	u2 = parameter - 0.01
-      end
-      z1 = z.call(u1,point)
-      z2 = z.call(u2,point)
-      if z1 == z2
-	u2 += 0.01
-	z2 = z.call(u2,point)
-      end
-      if z1 == z2
-	u2 -= 0.01
-	z2 = z.call(u2,point)
-      end
-      newparameters << (z2 * u1 - z1 * u2)/(z2-z1)
-    end
-    return newparameters
-  end
-  
-  # error is max error  between points in pointlist and points sampled from bezier with parameters
-  def Fitting.error( bezier, pointlist, parameters )
-    maxerror = 0.0
-    container = V2D[]
-    [pointlist, parameters].forzip do |point, 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}")
-    return maxerror
-  end
-
-  # iterate method compute new bezier parameters from pointlist and previous bezier parameters
-  # 
-  # Algo comes from http://www.tinaja.com/glib/bezdist.pdf
-  #
-  # TODO : optimized
-  def Fitting.iterate( pointlist, parameters )
-    p0 = pointlist[0]
-    p1 = pointlist[-1]
-
-    sumt0 = parameters.map{ |t| t**0.0 }.sum
-    sumt1 = parameters.map{ |t| t**1.0 }.sum
-    sumt2 = parameters.map{ |t| t**2.0 }.sum
-    sumt3 = parameters.map{ |t| t**3.0 }.sum
-    sumt4 = parameters.map{ |t| t**4.0 }.sum
-    sumt5 = parameters.map{ |t| t**5.0 }.sum
-    sumt6 = parameters.map{ |t| t**6.0 }.sum
-
-    psumt1 = [pointlist, parameters].forzip.foreach(2).map {|point, t| point * (t**1.0) }.inject(V2D::O){|sum, item| sum + item}
-    psumt2 = [pointlist, parameters].forzip.foreach(2).map {|point, t| point * (t**2.0) }.inject(V2D::O){|sum, item| sum + item}
-    psumt3 = [pointlist, parameters].forzip.foreach(2).map {|point, t| point * (t**3.0) }.inject(V2D::O){|sum, item| sum + item}
-
-    coeff11 = sumt6 - 2 * sumt4 + sumt2
-    coeff12 = sumt5 - sumt4 - sumt3 + sumt2
-
-    coeff21 = coeff12
-    coeff22 = sumt4 - 2 * sumt3 + sumt2
-
-    result1 = (p0 - p1) * (sumt4 - sumt2) - p0 * (sumt3 - sumt1) + psumt3 - psumt1
-    result2 = (p0 - p1) * (sumt3 - sumt2) - p0 * (sumt2 - sumt1) + psumt2 - psumt1
-    
-    matrix = Matrix[ [coeff11, coeff12], [coeff21, coeff22] ]
-    matrixinv = matrix.inverse
-    ax, bx = (matrixinv * Vector[result1.x, result2.x])[0..-1]
-    ay, by = (matrixinv * Vector[result1.y, result2.y])[0..-1]
-
-    a = V2D[ax, ay]
-    b = V2D[bx, by]
-    d = p0
-    c = p1- (a + b + p0)
-
-    piece = Fitting.bezierpiece( a, b, c, d )
-    return [Bezier.raw( *piece ), [a, b, c, d] ]
-  end    
-end
-
-end # end XRVG

data/lib/frame.rb

@@ -1,33 +0,0 @@
-# frame.rb file
-# 
-# See +Frame+
-require 'attributable'
-
-module XRVG
-#
-# 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
-end

data/lib/geovariety.rb

@@ -1,128 +0,0 @@
-# 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

@@ -1,87 +0,0 @@
-require 'bezier'
-
-module XRVG
-class InterBezier
-  include Attributable
-  attribute :bezierlist
-
-  include Interpolation
-
-  def initialize( *args )
-    super( *args )
-    self.init_interpolation_structures
-  end
-
-  def init_interpolation_structures
-    beziers = []
-    indexes = []
-    @bezierlist.foreach do |index, bezier| 
-      beziers.push( bezier )
-      indexes.push( index )
-    end
-
-    lengthH = {}
-    alllengths = []
-    beziers.each do |bezier|
-      lengths = bezier.piecelengths
-      Trace("bezier lengths #{lengths.inspect}")
-      lengthH[ bezier ] = lengths
-      alllengths += lengths
-    end
-    alllengths = Float.sort_float_list( alllengths )
-    Trace("alllengths #{alllengths.inspect}")
-    
-    newbezierlist = []
-    beziers.each do |bezier|
-      newpieces = []
-      initlengths = lengthH[ bezier ]
-      alllengths.pairs do |l1, l2| 
-	newpieces += bezier.subbezier( l1, l2 ).pieces
-      end
-      newbezier = Bezier[ :pieces, newpieces ]
-      newbezierlist << newbezier
-    end
-
-    Trace("newbezierlist #{newbezierlist.length}")
-    beziers = newbezierlist
-    bezierpointlists = beziers.map {|bezier| bezier.pointlist(:vector) }
-    Trace("bezierpointlists #{bezierpointlists.map {|list| list.length}.inspect}")
-    pointsequencelist = bezierpointlists.forzip
-    @interpolatorlist = []
-    pointsequencelist.foreach(beziers.size) do |pointsequence|
-      interlist = [indexes, pointsequence].forzip
-      @interpolatorlist.push( Interpolator.new( :samplelist, interlist ) )
-    end
-  end
-
-  def interpolate( abs, container=nil )
-    pieces = []
-    @interpolatorlist.foreach(4) do |interpiece|
-      piece = interpiece.map {|inter| inter.interpolate( abs )}
-      pieces.push( [:vector] + piece )
-    end
-    return Bezier.multi( pieces )    
-  end
-
-  include Samplable
-  alias apply_sample interpolate
-
-end
-
-class GradientBezier < InterBezier
-
-  # TODO : does not work !!
-  def samples( nsamples, &block )
-    return super( nsamples + 1, &block )
-  end
-
-  def apply_samples( samples )
-    samples = super( samples )
-    result = []
-    samples.pairs do |bezier1, bezier2|
-      result.push( ClosureBezier.build( :bezierlist, [bezier1, bezier2.reverse]) )
-    end
-    return result
-  end
-end
-end # XRVG  

data/lib/render.rb

@@ -1,266 +0,0 @@
-# 
-# Render file. See
-# - +Render+ for render "abstraction"
-# - +SVGRender+ for effective SVG render 
-
-require 'color'
-require 'style'
-
-module XRVG
-# Render abstract class
-#
-# Is pretty useless for the moment
-class Render
-  include Attributable
-  attr_accessor :width
-  attr_accessor :height
-end
-
-# SVG Render class
-#
-# In charge of generating a svg output file from different object passed to it
-# = Use
-# Canonical use of the class
-#  render = SVGRender[ :filename, "essai.svg" ]
-#  render.add( Circle[] )
-#  render.end
-# = Improvements
-# Allows also the "with" syntax
-# = Attributes
-#  attribute :filename, "", String
-#  attribute :imagesize, "2cm", String
-#  attribute :background, Color.white, [Color, String]
-class SVGRender < Render
-  attribute :filename, "", String
-  attribute :imagesize, "2cm", String
-  attribute :background, "white", [Color, String]
-  attr_reader :viewbox
-
-  # SVGRender builder
-  #
-  # Allows to pass a block, to avoid using .end
-  #  SVGRender.[] do |render|
-  #    render.add( Circle[] )
-  #  end
-  def SVGRender.[](*args,&block)
-    result = self.new( *args )
-    if block
-      yield result
-      result.end
-    end
-    return result
-  end
-
-  
-  def initialize ( *args, &block ) #:nodoc:
-    super( *args )
-    @layers  = {}
-    @defs    = ""
-    @ngradients = 0
-    if @filename.length == 0
-      @filename = $0.split(".")[0..-2].join(".") + ".svg"
-      Trace("filename is #{filename}")
-    end
-  end
-
-  def layers=( backtofront ) #:nodoc:
-    @sortlayers = backtofront
-    @sortlayers.each do |key|
-      @layers[ key ] = ""
-    end
-  end
-  
-  def add_content (string, layer) #:nodoc:
-    if not @layers.key? layer
-      @layers[ layer ] = ""
-    end
-    @layers[ layer ] += string
-  end
-
-  def svg_template #:nodoc:
-    return '<?xml version="1.0" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg width="%SIZE%" height="%SIZE%" %VIEWBOX% version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    %DEFS%
-    %BACKGROUND%
-    %CONTENT%
-</svg>'
-  end
-  
-  def add_def (object) #:nodoc:
-    @defs += object
-  end
-
-  def add_gradient( gradient ) #:nodoc:
-    id = "gradient#{@ngradients}"
-    add_def( gradient.svgdef.subreplace( {"%ID%" => id} ) )
-    @ngradients += 1
-    return id
-  end
-
-  # render fundamental method
-  # 
-  # used to render an object, with a particular style, on an optional layer.
-  #  render.add( Circle[], Style[ :fill, Color.black ], 1 )
-  # If style is not provided, render asked to object its default_style, if any
-  def add(object, style=nil, layer=0, type=:object)
-    add_content( render( object, style ), layer)
-    refresh_viewbox( object )
-  end
-  
-  def render (object, style=nil) #:nodoc:
-    owidth, oheight = object.size
-
-    res     = 0.0000001
-    if owidth < res and oheight < res
-      return ""
-    end
-
-    if not style
-      style = object.default_style
-    end
-
-    result  = "<g #{style.svgline}>\n"
-    result += object.svg + "\n"
-    result += "</g>\n"
-
-    # puts "result #{result}"
-
-    if style.fill.is_a? Gradient
-      gradientID = add_gradient( style.fill )
-      result = result.subreplace( {"%fillgradient%" => "url(##{gradientID})"} )
-    end
-    
-    if style.stroke.is_a? Gradient
-      gradientID = add_gradient( style.stroke )
-      result = result.subreplace( {"%strokegradient%" => "url(##{gradientID})"} )
-    end
-    return result
-  end
-
-  def viewbox #:nodoc:
-    return @viewbox
-  end
-
-  def size #:nodoc:
-    xmin, ymin, xmax, ymax  = viewbox
-    return [xmax - xmin, ymax - ymin]
-  end
-
-  def refresh_viewbox (object) #:nodoc:
-    newviewbox = object.viewbox
-    if newviewbox.length > 0
-      if @viewbox == nil
-	@viewbox = newviewbox
-      else
-	newxmin, newymin, newxmax, newymax = newviewbox
-	xmin, ymin, xmax, ymax = viewbox
-	
-	if newxmin < xmin 
-	  xmin = newxmin
-	end
-	if newymin < ymin 
-	  ymin = newymin
-	end
-	if newxmax > xmax
-	  xmax = newxmax
-	end
-	if newymax > ymax
-	  ymax = newymax
-	end
-
-	@viewbox = [xmin, ymin, xmax, ymax]
-      end
-    end
-  end
-  
-  def get_background_svg #:nodoc:
-    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.respond_to? :svg
-      bg = bg.svg
-    end
-    return template.subreplace( {"%x%"      => xmin,
-				 "%y%"      => ymin,
-				 "%width%"  => width,
-				 "%height%" => height,
-				 "%fill%"   => bg} )
-  end
-
-  def get_final_viewbox #:nodoc:
-    marginfactor = 0.2
-    xmin, ymin, xmax, ymax = viewbox()
-    width, height          = size()
-    
-    xcenter = (xmin + xmax)/2.0
-    ycenter = (ymin + ymax)/2.0
-    
-    width  *= 1.0 + marginfactor
-    height *= 1.0 + marginfactor
-    
-    if width == 0.0
-      width = 1.0
-    end
-    if height == 0.0
-      height = 1.0
-    end
-
-    xmin = xcenter - width  / 2.0
-    ymin = ycenter - height / 2.0
-									
-    return xmin, ymin, width, height
-  end
-
-  def get_viewbox_svg #:nodoc:
-    return viewbox_svg( get_final_viewbox() )
-  end
-
-  def get_carre_viewbox( viewbox ) #:nodoc:
-    xmin, ymin, width, height = viewbox
-    xcenter = xmin + width  / 2.0
-    ycenter = ymin + height / 2.0
-    maxsize = width < height ? height : width
-    return [xcenter - maxsize/2.0, ycenter - maxsize/2.0, maxsize, maxsize]
-  end
-
-  def viewbox_svg( viewbox ) #:nodoc:
-    xmin, ymin, width, height = viewbox
-    return "viewBox=\"#{xmin} #{ymin} #{width} #{height}\""
-  end
-
-  def content #:nodoc:
-    keys = @sortlayers ? @sortlayers : @layers.keys.sort
-    return keys.inject("") {|result,key| result += @layers[key]}
-  end
-
-  def svgdef #:nodoc:
-    return "<defs>\n#{@defs}\n</defs>\n"
-  end
-
-  def end () #:nodoc:
-    svgcontent    = content()
-    svgviewbox    = get_viewbox_svg()
-    svgbackground = get_background_svg()
-
-    content = svg_template().subreplace( {"%VIEWBOX%"    => svgviewbox,
-					  "%SIZE%"       => @imagesize,
-					  "%DEFS%"       => svgdef,
-					  "%BACKGROUND%" => svgbackground,
-					  "%CONTENT%"    => svgcontent})
-    
-    File.open(filename(), "w") do |f|
-      f << content
-    end
-   
-    puts "render #{filename()} OK"; # necessary for Emacs to get output name !!!!
-  end
-  
-  def raster () #:nodoc:
-    # bg = background.format255
-
-    # Kernel.system( "ruby", "svg2png.rb", filename(), "2.0" )
-    # Kernel.system( "i_view32", filename().subreplace( ".svg" => ".png" ), "/fs" )
-  end
-end
-end