xrvg 0.0.8 → 0.0.81

data/CHANGES

@@ -1,6 +1,12 @@
 = CHANGES
 
-== 0.0.8 (2008.08.26)
+== 0.0.81 (2008.08.26)
+=== Content
+- tutorials updated with the new SyncS
+- spiral class considered as curve, to redefine point and tangent computation, and to provide access to parameters
+- debug unitary tests
+
+== 0.0.8 (2008.08.25)
 === Content
 - unitary tests completion
 - new spiral builder from tangent (spiral refactoring to be committed soon...)

data/Rakefile

@@ -212,6 +212,7 @@ task "gen-website" do
   Rake::Task["muse"].invoke
   Rake::Task["examples"].invoke
   Rake::Task["rdoc"].invoke
+  Rake::Task["coverage"].invoke
   Rake::Task["finish"].invoke
 end
 
@@ -292,6 +293,17 @@ task "muse" do
   sh "emacs -u \"\" g:/emacs/emacs/plans/xrvgwebsite.muse -l g:/emacs/emacs/perso/xrvg-publish-exe.el -kill", :verbose => true
 end
 
+#---
+# The "coverage" task generates html coverage testing
+desc "Do test coverage, and copy it into web directory for uploading"
+task "coverage" do
+  system %{rcov test_*.rb}
+  remove_dir "#{WEBSITE_DIR}/coverage"
+  mkdir "#{WEBSITE_DIR}/coverage"
+  FileList["coverage/*.html"].to_a.each {|fn| cp( fn, "#{WEBSITE_DIR}/coverage" ) }
+end
+
+
 #---
 # The "finish" task removes some generated files
 task "finish" do

data/lib/parametriclength.rb

@@ -33,6 +33,7 @@ module ParametricLength
     previous = nil
     self.parameter_range.samples( ParametricLength::NSAMPLES ) do |abs|
       self.pointfromparameter( abs, new )
+      # Trace("compute_length_interpolator: abs #{abs} point #{new.inspect}")
       if previous
 	sum+= (new - previous).r
 	samplelist += [sum, abs]
@@ -44,6 +45,7 @@ module ParametricLength
     end
     @length = samplelist[-2]
 
+    # Trace("compute_length_interpolator: samplelist #{samplelist.inspect}")
     length_interpolator = nil
     if @length == 0.0
       newsamplelist = [0.0,0.0,0.0,1.0]
@@ -82,6 +84,7 @@ module ParametricLength
 
   def parameterfromlength( lvalue ) #:nodoc:
     result = self.length_interpolator.interpolate( lvalue )
+    # Trace("parameterfromlength lvalue #{lvalue} result #{result}")
     return result
   end
 end

data/lib/samplation.rb

@@ -201,6 +201,15 @@ module Samplable
     return self.apply( self.modify( [abs], type ), type ).pop
   end
 
+  def rand(nsamples=1,&block)#:nodoc:
+    self.random()
+    if nsamples == 1
+      return sample( 0.0 )
+    else
+      return samples( nsamples, &block )
+    end
+  end
+
   # alias for sample( 0.5 )
   def mean()
     return self.sample( 0.5 )
@@ -504,7 +513,7 @@ class ShuffleFilter < Filter
   end
 
   def transforms( inputs, type )  #:nodoc:
-    return inputs.sort_by { rand }
+    return inputs.shuffle
   end
 end
 
@@ -549,11 +558,6 @@ class Roller
     return result
   end
 
-  # TODO : must be generalized
-  def rand()  #:nodoc:
-    return @items.choice
-  end
-
   def next()
     return transform( 0.0 )
   end

data/lib/spiral.rb

@@ -10,39 +10,111 @@ module XRVG
 # abstract class to define spiral types
 # 
 # use compute_radius to compute nsamples reference points, before interpolating with SimpleBezier
-class GSpiral < BezierBuilder
+class GSpiral < Curve
+  extend Forwardable
+
   attribute :center, V2D::O, V2D
   attribute :ext,    V2D::O + V2D::X, V2D
   attribute :curvature, 1.0
   attribute :nsamples, 100
   attribute :sens, 1.0
+
+  attr_accessor :angle0, :r0, :maxangle
+
+  # setup prefered interface, enq() and deq()...
+  # def_delegator :@q, :push, :enq
+
+  # delegate interfaces unknown for spiral to bezier
+  # :length is computed by ParametricLength
+  def_delegators :bezier, :contour, :svg, :viewbox, :acc
+
+  def initialize( *args )
+    super( *args )
+    @r0, @angle0 = (@ext - @center).coords(:polar)
+  end
+
+  include ParametricLength
+  def parameter_range
+    return (self.angle0..self.sens * self.maxangle)
+  end
+
+  def maxangle
+    if not @maxangle
+      @maxangle = self.compute_maxangle( @r0, @angle0, @curvature )
+    end
+    return @maxangle
+  end
+
+  def pointfromparameter( parameter, container )
+    r = self.compute_radius( @r0, @angle0, @curvature, parameter )
+    if not container
+      container = V2D[ 0.0, 0.0]
+    end
+    container.xy = V2D.polar( r, parameter ).coords
+    # Trace("parameter #{parameter} container #{container.inspect}")
+    return container
+  end
+
+  # compute a point at curviligne abscissa
+  #
+  # curve method redefinition
+  def point( l, container=nil )
+    # Trace("point parameter #{l}")
+    return pointfromparameter( parameterfromlength(l), container )
+  end
   
+  # compute tangent at curviligne abscissa
+  #
+  # curve method redefinition
+  def tangent ( l, container=nil )
+    raise NotImplementedError.new("#{self.class.name}#tangent is an abstract method.")
+  end
+
   def compute_radius( r0, angle0, curvature, angle )
     raise NotImplementedError.new("#{self.class.name}#compute_radius is an abstract method.")
   end
   
-  def maxangle( r0, angle0, curvature )
-    raise NotImplementedError.new("#{self.class.name}#maxangle is an abstract method.")
+  def compute_maxangle( r0, angle0, curvature )
+    raise NotImplementedError.new("#{self.class.name}#compute_maxangle is an abstract method.")
+  end
+
+  def compute_bezier()
+    return SimpleBezier.build( :support, self.refpoints )
+  end
+
+  def bezier
+    if not @bezier
+      @bezier = self.compute_bezier
+    end
+    return @bezier
   end
 
-  def compute()
+  def refpoints
     points = []
-    r0, angle0 = (@ext - @center).coords(:polar)
-    maxangle = self.maxangle( r0, angle0, @curvature )
-    SyncS[(r0..0.0), (angle0..self.sens * maxangle)].samples( self.nsamples ) do |radius, angle|
+    self.parameter_range.samples( self.nsamples ) do |angle|
       r = self.compute_radius( r0, angle0, @curvature, angle )
       point = V2D.polar( r, angle )
       points.push( @center + point )
     end
-    return SimpleBezier.build( :support, points ).data
+    return points
   end
+
+  # -------------------------------------------------------------
+  #  sampler computation
+  # -------------------------------------------------------------
+  include Samplable
+  include Splittable
+
+  alias apply_sample point
+
+
 end  
 
 # at angle angle0,             r = r0
 # at angle angle0 + curvature, r = 0.0
 class SpiralLinear < GSpiral
 
-  def maxangle( r0, angle0, curvature )
+  def compute_maxangle( r0, angle0, curvature )
     return (angle0 + curvature)
   end
 
@@ -57,17 +129,22 @@ end
 class SpiralLog < GSpiral
 
   def nsamples
-    return (curvature * 15.0).to_i
+    return (self.curvature * 15.0).to_i
   end
 
   def compute_radius( r0, angle0, curvature, angle )
     return r0 * Math.exp( - self.sens * (angle - angle0) / curvature )
   end
 
-  def maxangle( r0, angle0, curvature )
+  def compute_maxangle( r0, angle0, curvature )
     return angle0 - curvature * Math.log( 0.001 )
   end
 
+  # method redefinition from GSpiral from Curve
+  def tangent( length, container=nil )
+    container = SpiralLog.tangent( self.center, self.point( length ), self.curvature )
+  end
+
   def SpiralLog.tangent( center, ext, curvature )
     return (center - ext).rotate( -Math.atan( curvature ) ) 
   end

data/lib/xrvg.rb

@@ -3,7 +3,7 @@
 # Please refer to README for XRVG introduction
 
 # XRVG version (used in rakefile)
-XRVG_VERSION = "0.0.8"
+XRVG_VERSION = "0.0.81"
 
 # XRVG namespace
 module XRVG

data/test/test_sample.rb

@@ -44,8 +44,13 @@ class RollerTest < Test::Unit::TestCase
   def test_roller
     assert_equal( ["a", "b", "a"], Roller["a","b"].samples(3))
 
-    rand = Roller["a","b"].rand
-    assert( ["a","b"].include?( rand ) )
+    randresult = Roller["a","b"].rand
+    assert( ["a","b"].include?( randresult ) )
+
+    randresult = Roller["a","b"].rand(2)
+    randresult.each do |value|
+      assert( ["a","b"].include?( value ) )
+    end
   end
 
   def test_next

data/test/test_spiral.rb

@@ -4,9 +4,20 @@ require 'test/unit'
 
 class SpiralTest < Test::Unit::TestCase
 
-  def test_abstract
+  def test_abstract1
     assert_raise(NotImplementedError) {GSpiral.new.compute_radius( 0.0,0.0,0.0,0.0)}
   end
+
+  def test_abstract2
+    assert_raise(NotImplementedError) {GSpiral.new.tangent( 0.0 )}
+  end
+
+  def test_bezier
+    spiral = SpiralLog[]
+    assert_equal( spiral.point( 0.0 ), spiral.bezier.point( 0.0 ) )
+    assert_equal( spiral.point( 1.0 ), spiral.bezier.point( 1.0 ) )
+  end
+
   
   def test_all
     spiral = SpiralLog[]
@@ -15,13 +26,13 @@ class SpiralTest < Test::Unit::TestCase
     spiral = SpiralLinear[]
     assert_equal( V2D::X, spiral.point( 0.0 ) )
     
-    assert_raise(NotImplementedError) {GSpiral.new.maxangle( 0.0,0.0,0.0)}
+    assert_raise(NotImplementedError) {GSpiral.new.compute_maxangle( 0.0,0.0,0.0)}
   end
 
   def test_tangent
     spiral    = SpiralLog[]
-    tangent   = SpiralLog.tangent( V2D::O, V2D::X, 1.0 )
-    newspiral = SpiralLog.fromtangent( tangent, V2D::X, 1.0 )
+    tangent   = spiral.tangent( 0.0 )
+    newspiral = SpiralLog.fromtangent( tangent, spiral.ext, spiral.curvature )
     assert_equal( spiral.point( 0.0 ), newspiral.point( 0.0 ) )
     assert_equal( spiral.point( 1.0 ), newspiral.point( 1.0 ) )
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: xrvg
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
-date: 2008-08-25 00:00:00 +02:00
+  version: 0.0.81
+date: 2008-08-26 00:00:00 +02:00
 summary: Ruby vector graphics library
 require_paths: 
 - lib