rubyvis 0.3.6 → 0.4.0

data/lib/rubyvis/mark/area.rb

@@ -67,13 +67,15 @@ module Rubyvis
 
     def area_bind
       mark_bind
-      binds = self.binds
       
+      binds = self.binds
       required = binds.required
       optional = binds.optional
+      
       optional.size.times {|i|
         prop = optional[i]
-        prop.fixed = fixed.include? prop.name
+        prop.fixed = fixed.keys.include? prop.name
+        
         if (prop.name == "segmented")
           required.push(prop)
         end
@@ -95,7 +97,7 @@ module Rubyvis
       }).tension(lambda {
         self.scene.target[self.index].tension
       })
-      return anchor
+      anchor
     end
   end
   

data/lib/rubyvis/mark/line.rb

@@ -7,12 +7,13 @@ module Rubyvis
   module LinePrototype  # :nodoc:
     include AreaPrototype
     def line_anchor(name)
+      
       anchor=area_anchor(name).text_align(lambda {|d|
-          {'left'=>'right','bottom'=>'center', 'top'=>'center','center'=>'center','right'=>'left'}[self.name]
+          {'left'=>'right', 'bottom'=>'center', 'top'=>'center', 'center'=>'center','right'=>'left'}[self.name()]
       }).text_baseline(lambda{|d|
-        {'top'=>'bottom', 'right'=>'middle', 'left'=>'middle','center'=>'middle','bottom'=>'top'}[self.name]
+        {'top'=>'bottom', 'right'=>'middle', 'left'=>'middle','center'=>'middle', 'bottom'=>'top'}[self.name()]
       })
-      return anchor
+      anchor
     end
   end
   

data/lib/rubyvis/mark/panel.rb

@@ -96,18 +96,23 @@ module Rubyvis
           end
           if s.width.nil?
             w=Rubyvis.css(c,'width')
-            s.width=w-s.left-s.right
+            s.width=w - s.left - s.right
           end
           if s.height.nil?
             w=Rubyvis.css(c,'height')
-            s.height=h-s.top-s.bottom
+            s.height=h - s.top - s.bottom
           end
 
         else
           @_canvas||={}
           cache=@_canvas
           if(!(c=cache[self.index]))
-            c=cache[self.index]=Rubyvis.document.add_element('span')
+            document=REXML::Document.new
+            document.add_element("document")
+            cache[self.index]=document.root
+            c=cache[self.index]
+            
+            #c=cache[self.index]=Rubyvis.document.add_element('span')
           end
         end
         s.canvas=c

data/lib/rubyvis/mark/rule.rb

@@ -10,6 +10,7 @@ module Rubyvis
     def self.defaults
       Rule.new.mark_extend(Mark.defaults).line_width(1).stroke_style('black').antialias(false)
     end
+    
     def type
       'rule'
     end

data/lib/rubyvis/scene/svg_area.rb

@@ -4,7 +4,7 @@ module Rubyvis
       e = scenes._g.elements[1]
       return e if scenes.size==0
       s=scenes[0]
-      # segmented 
+      # segmented
       return self.area_segment(scenes) if (s.segmented) 
       # visible
       return e if (!s.visible)
@@ -63,8 +63,8 @@ module Rubyvis
         }
         
         if (s.interpolate == "basis") 
-          pathT = Rubyvis::SvgScene.curve_basis(pointsT);
-          pathB = Rubyvis::SvgScene.curve_basis(pointsB);
+          pathT = Rubyvis::SvgScene.curve_basis(pointsT)
+          pathB = Rubyvis::SvgScene.curve_basis(pointsB)
         elsif (s.interpolate == "cardinal") 
             pathT = Rubyvis::SvgScene.curve_cardinal(pointsT, s.tension);
             pathB = Rubyvis::SvgScene.curve_cardinal(pointsB, s.tension);
@@ -127,12 +127,10 @@ module Rubyvis
     end
         
     def self.area_segment(scenes)
-          
       e = scenes._g.elements[1]
       s = scenes[0]
-      pathsT=[]
-      pathsB=[]
-      
+      pathsT=nil
+      pathsB=nil
       if (s.interpolate == "basis" or s.interpolate == "cardinal" or s.interpolate == "monotone") 
         pointsT = []
         pointsB = []
@@ -144,16 +142,17 @@ module Rubyvis
         }
     
         if (s.interpolate == "basis") 
-          pathT = Rubyvis.SvgScene.curve_basis_segments(pointsT);
-          pathB = Rubyvis.SvgScene.curve_basis_segments(pointsB);
-        elsif (s.interpolate == "cardinal") 
-            pathT = Rubyvis.SvgScene.curve_cardinal_segments(pointsT, s.tension);
-            pathB = Rubyvis.SvgScene.curve_cardinal_segments(pointsB, s.tension);
+          pathsT = Rubyvis::SvgScene.curve_basis_segments(pointsT)
+          pathsB = Rubyvis::SvgScene.curve_basis_segments(pointsB)
+        elsif (s.interpolate == "cardinal")
+            pathsT = Rubyvis::SvgScene.curve_cardinal_segments(pointsT, s.tension);
+            pathsB = Rubyvis::SvgScene.curve_cardinal_segments(pointsB, s.tension);
         elsif # monotone
-          pathT = Rubyvis.SvgScene.curve_monotone_segments(pointsT);
-          pathB = Rubyvis.SvgScene.curve_monotone_segments(pointsB);
+          pathsT = Rubyvis::SvgScene.curve_monotone_segments(pointsT)
+          pathsB = Rubyvis::SvgScene.curve_monotone_segments(pointsB)
         end
       end
+      
       n=scenes.size-1
       n.times {|i|
         
@@ -163,9 +162,10 @@ module Rubyvis
         # /* visible */
         next if (!s1.visible or !s2.visible)
         
-        fill = s.fill_style
-        stroke = s.stroke_style            
-        next e if (fill.opacity==0 and stroke.opacity==0) 
+        fill = s1.fill_style
+        stroke = s1.stroke_style            
+        next if (fill.opacity==0 and stroke.opacity==0)
+        
         d=nil
         if (pathsT) 
           pathT = pathsT[i]

data/lib/rubyvis/scene/svg_curve.rb

@@ -102,7 +102,7 @@ module Rubyvis::SvgScene
     p1 = p2;
     p2 = p3;
     p3 = points[2];
-    paths.push(firstPath + self.path_basis(p0, p1, p2, p3)); # merge first & second path
+    paths.push(firstPath + self.path_basis(p0, p1, p2, p3).to_s) # merge first & second path
     3.upto(points.size-1) {|i|
       p0 = p1;
       p1 = p2;
@@ -112,7 +112,7 @@ module Rubyvis::SvgScene
     }
     
     # merge last & second-to-last path
-    paths.push(path_basis(p1, p2, p3, p3).segment + path_basis(p2, p3, p3, p3))
+    paths.push(path_basis(p1, p2, p3, p3).segment + path_basis(p2, p3, p3, p3).to_s)
     paths
   end
 
@@ -258,11 +258,14 @@ module Rubyvis::SvgScene
     d = []
     m = []
     dx = []
+    k=0
     
     #/* Compute the slopes of the secant lines between successive points. */
-    (points.size-1).times {|k|
+    
+    while(k < points.size-1) do 
       d[k] = (points[k+1].top - points[k].top) / (points[k+1].left - points[k].left).to_f
-    }
+      k+=1
+    end
     
     #/* Initialize the tangents at every point as the average of the secants. */
     m[0] = d[0]
@@ -320,7 +323,7 @@ module Rubyvis::SvgScene
   # * @param points the array of points.
   #/
   def self.curve_monotone_segments(points) 
-     return "" if (points.length <= 2)
+    return "" if (points.size <= 2)
      self.curve_hermite_segments(points, self.monotone_tangents(points))
   end
 

data/lib/rubyvis/scene/svg_line.rb

@@ -15,7 +15,7 @@ module Rubyvis
       return e if (fill.opacity==0.0 and  stroke.opacity==0.0)
       #/* points */
 
-      d = "M" + s.left.to_s + "," + s.top.to_s
+      d = "M#{s.left},#{s.top}"
 
       if (scenes.size > 2 and (['basis', 'cardinal', 'monotone'].include? s.interpolate))
         case (s.interpolate)
@@ -55,37 +55,40 @@ module Rubyvis
       s = scenes[0];
       paths=nil
       case s.interpolate
-      when "basis"
-        paths = curve_basis_segments(scenes)
-      when "cardinal"
-        paths=curve_cardinal_segments(scenes, s.tension)
-      when "monotone"
-        paths = curve_monotone_segments(scenes)
+        when "basis"
+          paths = curve_basis_segments(scenes)
+        when "cardinal"
+          paths=curve_cardinal_segments(scenes, s.tension)
+        when "monotone"
+          paths = curve_monotone_segments(scenes)
       end
 
-      (scenes.length-1).times {|i|
+      (0...(scenes.size-1)).each {|i|
 
         s1 = scenes[i]
         s2 = scenes[i + 1];
-
+        #p "#{s1.top} #{s1.left} #{s1.line_width} #{s1.interpolate} #{s1.line_join}"
         # visible 
-        next if (!s1.visible and !s2.visible)
+        next if (!s1.visible or !s2.visible)
 
         stroke = s1.stroke_style
-        fill = Rubyvis.Color.transparent
+        fill = Rubyvis::Color.transparent
 
         next if stroke.opacity==0.0
 
         # interpolate
         d=nil
-        if ((s1.interpolate == "linear") and (s1.lineJoin == "miter"))
-          fill = stroke;
-          stroke = Rubyvis.Color.transparent;
-          d = path_join(scenes[i - 1], s1, s2, scenes[i + 2]);
+        if ((s1.interpolate == "linear") and (s1.line_join == "miter"))
+          fill = stroke
+          stroke = Rubyvis::Color.transparent
+          s0=((i-1) < 0) ? nil : scenes[i-1]
+          s3=((i+2) >= scenes.size) ? nil : scenes[i+2]
+          
+          d = path_join(s0, s1, s2, s3)
         elsif(paths)
           d = paths[i]
         else
-          d = "M" + s1.left + "," + s1.top + path_segment(s1, s2);
+          d = "M#{s1.left},#{s1.top}#{path_segment(s1, s2)}"
         end
 
         e = SvgScene.expect(e, "path", {
@@ -102,7 +105,7 @@ module Rubyvis
         });
         e = SvgScene.append(e, scenes, i);
       }
-      return e
+      e
     end
 
     # Returns the path segment for the specified points. */
@@ -148,17 +151,16 @@ module Rubyvis
 
       p2 = Rubyvis.vector(s2.left, s2.top)
 
-      p = p2.minus(p1)
-
-      v = p.perp().norm()
+      _p = p2.minus(p1)
 
-      w = v.times(s1.lineWidth / (2 * this.scale))
+      v = _p.perp().norm()
+      
+      w = v.times(s1.line_width / (2.0 * self.scale))
 
       a = p1.plus(w)
       b = p2.plus(w)
       c = p2.minus(w)
       d = p1.minus(w)
-
       #/*
       # * Start join. P0 is the previous line segment's start point. We define the
       # * cutting plane as the average of the vector perpendicular to P0-P1, and
@@ -167,19 +169,20 @@ module Rubyvis
       # * Note that we don't implement miter limits, so these can get wild.
       # */
       if (s0 and s0.visible)
-        v1 = p1.minus(s0.left, s0.top).perp().norm().plus(v);
-        d = line_intersect(p1, v1, d, p);
-        a = line_intersect(p1, v1, a, p);
+        v1 = p1.minus(s0.left, s0.top).perp().norm().plus(v)
+        d = line_intersect(p1, v1, d, _p)
+        a = line_intersect(p1, v1, a, _p)
       end
 
       #/* Similarly, for end join. */
-      if (s3 && s3.visible)
+      if (s3 and s3.visible)
         v2 = Rubyvis.vector(s3.left, s3.top).minus(p2).perp().norm().plus(v);
-        c = line_intersect(p2, v2, c, p);
-        b = line_intersect(p2, v2, b, p);
+        c = line_intersect(p2, v2, c, _p);
+        b = line_intersect(p2, v2, b, _p);
       end
 
-      return "M" + a.x + "," + a.y+ "L" + b.x + "," + b.y+ " " + c.x + "," + c.y+ " " + d.x + "," + d.y
+      d="M#{a.x},#{a.y}L#{b.x},#{b.y} #{c.x},#{c.y} #{d.x},#{d.y}"
+      d
     end
   end
 end

data/lib/rubyvis/scene/svg_scene.rb

@@ -9,7 +9,7 @@ require 'rubyvis/scene/svg_wedge'
 require 'rubyvis/scene/svg_image'
 require 'rubyvis/scene/svg_curve'
 
-class REXML::Element # :nodoc:
+class REXML::Element #:nodoc:
   attr_accessor :_scene
 end
 
@@ -58,7 +58,6 @@ module Rubyvis
 
       {:svg=>svg,:css=>css}
     end
-
     def self.update_all(scenes)
       puts "update_all: #{scenes.inspect}" if $DEBUG
       if (scenes.size>0 and scenes[0].reverse and scenes.type!='line' and scenes.type!='area')
@@ -85,12 +84,11 @@ module Rubyvis
 
     def self.append(e,scenes,index)
       e._scene=OpenStruct.new({:scenes=>scenes, :index=>index})
-      e=self.title(e,scenes[index])
-
+      e=self.title(e, scenes[index])
       if(!e.parent)
         scenes._g.add_element(e)
       end
-      return e.next_sibling_node
+      e.next_sibling_node
     end
     
     # Applies a title tooltip to the specified element <tt>e</tt>, using the

data/lib/rubyvis/scene/svg_wedge.rb

@@ -11,11 +11,12 @@ module Rubyvis
         
         r1 = s.inner_radius
         r2 = s.outer_radius
+
         a = (s.angle).abs
         _p=nil
         
         if (a >= 2 * Math::PI) 
-          if (r1) 
+          if (r1!=0) 
             _p = "M0,#{r2 }A#{r2},#{r2} 0 1,1 0,#{-r2}A#{r2 },#{r2 } 0 1,1 0,#{r2}M0,#{r1}A#{r1},#{r1} 0 1,1 0,#{-r1}A#{r1},#{r1} 0 1,1 0,#{r1 }Z"
           else 
             _p = "M0,#{r2}A#{r2},#{r2} 0 1,1 0,#{-r2}A#{r2},#{r2} 0 1,1 0,#{r2 }Z"
@@ -27,10 +28,10 @@ module Rubyvis
           c2 = Math.cos(ea)
           s1 = Math.sin(sa)
           s2 = Math.sin(ea)
-          if (r1)
+          if (r1!=0)
             _p = "M#{r2 * c1},#{r2 * s1}A#{r2},#{r2} 0 #{((a < Math::PI) ? "0" : "1")},1 #{r2 * c2},#{r2 * s2}L#{r1 * c2},#{r1 * s2}A#{r1},#{r1} 0 #{((a < Math::PI) ? "0" : "1")},0 #{r1 * c1},#{r1 * s1}Z"
           else 
-            _p = "M#{r2 * c1},#{r2 * s1}A#{r2},#{r2} 0 #{((a < Math.PI) ? "0" : "1")},1 #{r2 * c2},#{r2 * s2}L0,0Z"
+            _p = "M#{r2 * c1},#{r2 * s1}A#{r2},#{r2} 0 #{((a < Math::PI) ? "0" : "1")},1 #{r2 * c2},#{r2 * s2}L0,0Z"
           end
         end
         

data/lib/rubyvis/vector.rb

@@ -0,0 +1,104 @@
+module Rubyvis
+  # Returns a {@link pv.Vector} for the specified <i>x</i> and <i>y</i>
+  # coordinate. This is a convenience factory method, equivalent to <tt>new
+  # pv.Vector(x, y)</tt>.
+  #
+  # @see pv.Vector
+  # @param {number} x the <i>x</i> coordinate.
+  # @param {number} y the <i>y</i> coordinate.
+  # @returns {pv.Vector} a vector for the specified coordinates.
+  
+  def self.vector(x,y) 
+    Rubyvis::Vector.new(x,y)
+  end
+  class Vector
+    attr_accessor :x,:y
+    # Constructs a {@link pv.Vector} for the specified <i>x</i> and <i>y</i>
+    # coordinate. This constructor should not be invoked directly; use
+    # {@link pv.vector} instead.
+    #
+    # @class Represents a two-dimensional vector; a 2-tuple <i>&#x27e8;x,
+    # y&#x27e9;</i>. The intent of this class is to simplify vector math. Note that
+    # in performance-sensitive cases it may be more efficient to represent 2D
+    # vectors as simple objects with <tt>x</tt> and <tt>y</tt> attributes, rather
+    # than using instances of this class.
+    #
+    # @param {number} x the <i>x</i> coordinate.
+    # @param {number} y the <i>y</i> coordinate.
+    def initialize(x,y) 
+      @x=x
+      @y=y
+    end
+    def ==(v)
+      @x==v.x and @y==v.y
+    end
+    # Returns a vector perpendicular to this vector: <i>&#x27e8;-y, x&#x27e9;</i>.
+    #
+    # @returns {pv.Vector} a perpendicular vector.
+    #/
+    def perp
+      Rubyvis::Vector.new(-@y,@x)
+    end
+    # Returns a normalized copy of this vector: a vector with the same direction,
+    # but unit length. If this vector has zero length this method returns a copy of
+    # this vector.
+    #
+    # @returns {pv.Vector} a unit vector.
+    def norm 
+      l=length()
+      times(l!=0 ? (1.0 / l) : 1.0)
+    end
+    
+    # Returns the magnitude of this vector, defined as <i>sqrt(x * x + y * y)</i>.
+    #
+    # @returns {number} a length.
+    def length
+      Math.sqrt(@x**2 + @y**2)
+    end
+
+    # Returns a scaled copy of this vector: <i>&#x27e8;x * k, y * k&#x27e9;</i>.
+    # To perform the equivalent divide operation, use <i>1 / k</i>.
+    #
+    # @param {number} k the scale factor.
+    # @returns {pv.Vector} a scaled vector.
+    def times(k)
+      Rubyvis::Vector.new(@x * k, @y * k)
+    end
+    # Returns this vector plus the vector <i>v</i>: <i>&#x27e8;x + v.x, y +
+    # v.y&#x27e9;</i>. If only one argument is specified, it is interpreted as the
+    # vector <i>v</i>.
+    #
+    # @param {number} x the <i>x</i> coordinate to add.
+    # @param {number} y the <i>y</i> coordinate to add.
+    # @returns {pv.Vector} a new vector.
+    def plus(x,y=nil)
+      
+      return (y.nil?) ? Rubyvis::Vector.new(@x + x.x, @y + x.y) : Rubyvis::Vector.new(@x + x, @y + y)
+    end
+    
+    # Returns this vector minus the vector <i>v</i>: <i>&#x27e8;x - v.x, y -
+    # v.y&#x27e9;</i>. If only one argument is specified, it is interpreted as the
+    # vector <i>v</i>.
+    #
+    # @param {number} x the <i>x</i> coordinate to subtract.
+    # @param {number} y the <i>y</i> coordinate to subtract.
+    # @returns {pv.Vector} a new vector.
+    
+    def minus(x,y=nil)
+      
+      return (y.nil?) ? Rubyvis::Vector.new(@x - x.x, @y - x.y) : Rubyvis::Vector.new(@x - x, @y - y)
+    end
+
+    # Returns the dot product of this vector and the vector <i>v</i>: <i>x * v.x +
+    # y * v.y</i>. If only one argument is specified, it is interpreted as the
+    # vector <i>v</i>.
+    #
+    # @param {number} x the <i>x</i> coordinate to dot.
+    # @param {number} y the <i>y</i> coordinate to dot.
+    # @returns {number} a dot product.
+    def dot(x, y=nil) 
+      (y.nil?) ? @x * x.x + @y * x.y : @x * x + @y * y
+    end
+  end
+end
+