rubyvis 0.1.2 → 0.1.3

data/lib/rubyvis/scale.rb

@@ -12,6 +12,9 @@ module Rubyvis
     def self.ordinal(*args)
       Ordinal.new(*args)
     end
+    def self.log(*args)
+      Log.new(*args)
+    end
     def self.interpolator(start,_end)
       if start.is_a? Numeric
         return lambda {|t| t*(_end-start)+start}
@@ -32,3 +35,4 @@ end
 require 'rubyvis/scale/quantitative.rb'
 require 'rubyvis/scale/linear.rb'
 require 'rubyvis/scale/ordinal.rb'
+require 'rubyvis/scale/log.rb'

data/lib/rubyvis/scale/log.rb

@@ -0,0 +1,55 @@
+module Rubyvis
+  
+  class Scale::Log < Rubyvis::Scale::Quantitative
+    def initialize(*args)
+      super(*args)
+      @b=nil
+      @_p=nil
+      
+      base(10)
+    end
+    def log(x)
+      
+      Math.log(x+1e15) / @_p
+    end
+    def pow(y)
+      @b**y
+    end
+    def base(v=nil)
+      if v
+        @b=v
+        @_p=Math.log(@b)
+        transform(lambda {|x| log(x)}, lambda {|x| pow(x)})
+        return self
+      end
+      return @b
+    end
+    def ticks
+      d = domain
+      n = d[0] < 0,
+      i = (n ? -log(-d[0]) : log(d[0])).floor
+      j = (n ? -log(-d[1]) : log(d[1])).ceil
+      ticks = [];
+      if n 
+        ticks.push(-pow(-i))
+        (i..j).each {|ii|
+          ((b-1)...0).each {|k|
+            ticks.push(-pow(-ii) * k)
+          }
+        }
+      else
+        (i...j).each {|ii|
+          (1...b).each {|k|
+            ticks.push(pow(i) * k)
+          }
+        }
+        ticks.push(pow(i));
+      end
+      
+      #for (i = 0; ticks[i] < d[0]; i++); // strip small values
+      #for (j = ticks.length; ticks[j - 1] > d[1]; j--); // strip big values
+      #return ticks.slice(i, j);
+      ticks
+    end
+  end
+end

data/lib/rubyvis/scale/ordinal.rb

@@ -1,14 +1,19 @@
 module Rubyvis
   class Scale::Ordinal
-    include Rubyvis::Scale
-
+    #include Rubyvis::Scale
+    attr_reader :range_band
     def initialize(*args)
       @d=[] # domain
       @i={}
       @r=[]
+      @range_band=nil
       @band=0
       domain(*args)
     end
+    def to_proc
+      that=self
+      lambda {|*args| args[0] ? that.scale(args[0]) : nil }
+    end
     def scale(x)
       if @i[x].nil?
         @d.push(x)
@@ -17,15 +22,33 @@ module Rubyvis
       @r[@i[x] % @r.size]
     end
     def domain(*arguments)
-      array,f=arguments[0],arguments[1]
+      array, f=arguments[0],arguments[1]
       if(arguments.size>0)
-        array= (array.is_a? Array) ? ((arguments.size>1) ? array.map(&f) : array) : arguments.dup
+      array= (array.is_a? Array) ? ((arguments.size>1) ? pv.map(array,f) : array) : arguments.dup
         @d=array.uniq
-        i=pv.numerate(d)
+        @i=pv.numerate(@d)
         return self
       end
       @d
     end
+    def split_banded(*arguments)
+      min,max,band=arguments
+      band=1 if (arguments.size < 3)
+      if (band < 0) 
+        
+        n = self.domain().size
+        total = -band * n
+        remaining = max - min - total
+        padding = remaining / (n + 1).to_f
+        @r = pv.range(min + padding, max, padding - band);
+        @range_band = -band;
+      else
+        step = (max - min) / (self.domain().size + (1 - band))
+        @r = pv.range(min + step * (1 - band), max, step);
+        @range_band = step * band;
+      end
+      return self
+    end
     def range(*arguments)
       array, f = arguments[0],arguments[1]
       if(arguments.size>0)
@@ -33,7 +56,7 @@ module Rubyvis
         if @r[0].is_a? String
           @r=@r.map {|i| pv.color(i)}
         end
-        self
+        return self
       end
       @r
     end
@@ -42,11 +65,11 @@ module Rubyvis
       @r=pv.range(min+step.quo(2),max,step)
       self
     end
-    def by(*arguments)
-      f,dummy=arguments
-      t=self
-      by=lambda {t.scale(f.js_apply(self,arguments))}
-      by
+    def by(f)
+      that=self
+      lambda {|*args|
+        that.scale(f.js_apply(self,args))
+      }
     end
   end
 end

data/lib/rubyvis/scale/quantitative.rb

@@ -11,13 +11,22 @@ module Rubyvis
       @n=false
       @f=Rubyvis.identity # default forward transformation
       @g=Rubyvis.identity
-      @tick_format=lambda {|x| x.to_f}
+      @tick_format=lambda {|x|
+        if x.is_a? Numeric
+          (x.to_f-x.to_i==0) ? x.to_i : x.to_f
+        else
+          ""
+        end
+      }
       domain(*args)
     end
     def new_date(x=nil)
       x.nil? ? Time.new() : Time.at(x)
     end
-  
+    def to_proc
+      that=self
+      lambda {|*args|  args[0] ? that.scale(args[0]) : nil }
+    end
     def scale(x)
       x=x.to_f
       j=Rubyvis.search(@d, x)
@@ -251,10 +260,15 @@ module Rubyvis
       end
       start = (min.quo(step)).ceil * step
       _end = (max.quo(step)).floor * step
-      @tick_format= pv.Format.number().fraction_digits([0, -(pv.log(step, 10) + 0.01).floor].max);
+      @tick_format= pv.Format.number.fraction_digits([0, -(pv.log(step, 10) + 0.01).floor].max)
       ticks = pv.range(start, _end + step, step);
       return reverse ? ticks.reverse() : ticks;
     end
+    
+    def tick_format
+      @tick_format
+    end
+    
     def nice
       if (@d.size!=2)
         return self;

data/lib/rubyvis/scene/svg_area.rb

@@ -0,0 +1,197 @@
+module Rubyvis
+  module SvgScene
+    def self.area(scenes)
+      e = scenes._g.elements[1]
+      return e if scenes.size==0
+      s=scenes[0]
+      # segmented */
+      return self.area_segment(scenes) if (s.segmented) 
+      # visible
+      # 
+      return e if (!s.visible)
+      
+      fill = s.fill_style
+      stroke = s.stroke_style
+      
+      return e if (fill.opacity==0 and stroke.opacity==0) 
+      # /** @private Computes the straight path for the range [i, j]. */
+      path=lambda {|i,j|
+        p1 = []
+        p2 = [];
+        k=j
+        (i..k).each {|i|
+          si = scenes[i]
+          sj = scenes[j]
+          pi = "#{si.left},#{si.top}"
+          pj = "#{(sj.left + sj.width)},#{(sj.top + sj.height)}"
+    
+          #/* interpolate */
+          if (i < k) 
+            sk = scenes[i + 1]
+            sl = scenes[j - 1]
+            case (s.interpolate) 
+              when "step-before"
+                pi = pi+"V#{sk.top}"
+                pj = pj+"H#{sl.left + sl.width}"
+              
+              when "step-after"
+                pi = pi+"H#{sk.left}"
+                pj = pj+"V#{sl.top + sl.height}"
+            end
+          end
+    
+          p1.push(pi);
+          p2.push(pj);
+          j=j-1
+        }
+        (p1+p2).join("L");
+      }
+        
+      # @private Computes the curved path for the range [i, j]. */
+      path_curve=lambda {|i, j|
+        pointsT = []
+        pointsB = []
+        pathT=nil
+        pathB=nil
+        
+        
+        k=j
+        (i..k).each {|i|
+          sj = scenes[j];
+          pointsT.push(scenes[i])
+          pointsB.push(OpenStruct.new({:left=> sj.left + sj.width, :top=> sj.top + sj.height}))
+          j=j-1
+        }
+    
+        if (s.interpolate == "basis") 
+          pathT = pv.SvgScene.curve_basis(pointsT);
+          pathB = pv.SvgScene.curve_basis(pointsB);
+        elsif (s.interpolate == "cardinal") 
+            pathT = pv.SvgScene.curve_cardinal(pointsT, s.tension);
+            pathB = pv.SvgScene.curve_cardinal(pointsB, s.tension);
+        elsif # monotone
+          pathT = pv.SvgScene.curve_monotone(pointsT);
+          pathB = pv.SvgScene.curve_monotone(pointsB);
+        end
+    
+        "#{pointsT[0].left },#{ pointsT[0].top }#{ pathT }L#{ pointsB[0].left},#{pointsB[0].top}#{pathB}"
+          }
+        
+          #/* points */
+          d = []
+          si=nil
+          sj=nil
+          i=0
+          while(i<scenes.size) 
+            si = scenes[i]
+            continue if (si.width==0 and si.height==0)
+            j=0
+            (i+1).upto(scenes.size-1) {|jj|
+              j=jj; sj = scenes[jj];
+              break if (si.width==0 and si.height==0)
+            }
+            
+            i=i-1 if (i!=0 and (s.interpolate != "step-after"))
+            j=j+1 if ((j < scenes.size) and (s.interpolate != "step-before"))
+            d.push(((j - i > 2 and (s.interpolate == "basis" or s.interpolate == "cardinal" or s.interpolate == "monotone")) ? path_curve : path).call(i, j - 1))
+            i = j - 1
+            i+=1
+          end
+          
+          return e if d.size==0
+        
+          e = self.expect(e, "path", {
+              "shape-rendering"=> s.antialias ? nil : "crispEdges",
+              "pointer-events"=> s.events,
+              "cursor"=> s.cursor,
+              "d"=> "M" + d.join("ZM") + "Z",
+              "fill"=> fill.color,
+              "fill-opacity"=> fill.opacity==0 ? nil : fill.opacity,
+              "stroke"=> stroke.color,
+              "stroke-opacity"=> stroke.opacity==0 ? nil : stroke.opacity,
+              "stroke-width"=> stroke.opacity!=0 ? s.line_width / self.scale : nil
+            });
+          return self.append(e, scenes, 0);
+        end
+        
+        def self.area_segment(scenes)
+          
+          e = scenes._g.elements[1]
+          s = scenes[0]
+          pathsT=[]
+          pathsB=[]
+          
+          if (s.interpolate == "basis" or s.interpolate == "cardinal" or s.interpolate == "monotone") 
+            pointsT = []
+            pointsB = []
+            n=scenes.size
+            n.times {|i|
+              sj = scenes[n - i - 1]
+              pointsT.push(scenes[i])
+              pointsB.push(OpenStruct.new({:left=> sj.left + sj.width, :top=> sj.top + sj.height}));
+            }
+        
+            if (s.interpolate == "basis") 
+              pathT = pv.SvgScene.curve_basis_segments(pointsT);
+              pathB = pv.SvgScene.curve_basis_segments(pointsB);
+            elsif (s.interpolate == "cardinal") 
+                pathT = pv.SvgScene.curve_cardinal_segments(pointsT, s.tension);
+                pathB = pv.SvgScene.curve_cardinal_segments(pointsB, s.tension);
+            elsif # monotone
+              pathT = pv.SvgScene.curve_monotone_segments(pointsT);
+              pathB = pv.SvgScene.curve_monotone_segments(pointsB);
+            end
+          end
+          n=scenes.size-1
+          n.times {|i|
+            
+            s1 = scenes[i]
+            s2 = scenes[i + 1]
+        
+            # /* 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) 
+            d=nil
+            if (pathsT) 
+              pathT = pathsT[i]
+              pb=pathsB[n - i - 1]
+              pathB = "L" + pb[1,pb.size-1]
+              d = pathT + pathB + "Z";
+            else 
+              #/* interpolate */
+              si = s1
+              sj = s2
+              
+              case (s1.interpolate) 
+                when "step-before"
+                  si = s2
+                when "step-after"
+                  sj = s1
+              end
+              
+        
+              #/* path */
+              d = "M#{s1.left},#{si.top}L#{s2.left},#{sj.top }L#{s2.left + s2.width},#{sj.top + sj.height}L#{s1.left + s1.width},#{si.top + si.height}Z"
+            end
+        
+            e = self.expect(e, "path", {
+                "shape-rendering"=> s1.antialias ? null : "crispEdges",
+                "pointer-events"=> s1.events,
+                "cursor"=> s1.cursor,
+                "d"=> d,
+                "fill"=> fill.color,
+                "fill-opacity"=> fill.opacity==0 ? nil : fill.opacity,
+              "stroke"=> stroke.color,
+              "stroke-opacity"=> stroke.opacity==0 ? nil : stroke.opacity,
+              "stroke-width"=> stroke.opacity!=0 ? s1.line_width / self.scale : nil
+              });
+            e = self.append(e, scenes, i);
+          }
+          return e;
+        end
+      end
+end
+

data/lib/rubyvis/scene/svg_dot.rb

@@ -0,0 +1,67 @@
+module Rubyvis
+  module SvgScene
+    def self.dot(scenes)
+      e = scenes._g.elements[1]
+      scenes.each_with_index {|s,i|
+      s = scenes[i];
+      
+      # visible */
+      next if !s.visible
+      fill = s.fill_style
+      stroke = s.stroke_style
+      next if (fill.opacity==0 and stroke.opacity==0)
+      
+      #/* points */
+      radius = s.shape_radius
+      path = nil
+      case s.shape
+      when 'cross'
+        path = "M#{-radius},#{-radius}L#{radius},#{radius}M#{radius},#{ -radius}L#{ -radius},#{radius}"
+      when "triangle"
+        h = radius
+        w = radius * 1.1547; # // 2 / Math.sqrt(3)
+        path = "M0,#{h}L#{w},#{-h} #{-w},#{-h}Z"
+      when  "diamond"
+        radius=radius* Math::sqrt(2)
+        path = "M0,#{-radius}L#{radius},0 0,#{radius} #{-radius},0Z";
+      when  "square"
+        path = "M#{-radius},#{-radius}L#{radius},#{-radius} #{radius},#{radius} #{-radius},#{radius}Z"
+      when  "tick"
+        path = "M0,0L0,#{-s.shapeSize}"
+      when  "bar"
+        path = "M0,#{s.shape_size / 2.0}L0,#{-(s.shapeSize / 2.0)}"
+
+      end
+      
+      #/* Use <circle> for circles, <path> for everything else. */
+      svg = {
+      "shape-rendering"=> s.antialias ? nil : "crispEdges",
+      "pointer-events"=> s.events,
+      "cursor"=> s.cursor,
+      "fill"=> fill.color,
+      "fill-opacity"=> (fill.opacity==0) ? nil :fill.opacity,
+      "stroke"=> stroke.color,
+      "stroke-opacity"=> (stroke.opacity==0) ? nil : stroke.opacity,
+      "stroke-width"=> (stroke.opacity!=0) ? s.line_width / self.scale : nil
+      }
+      
+      if (path) 
+          svg["transform"] = "translate(#{s.left},#{s.top})"
+          if (s.shape_angle) 
+            svg["transform"] += " rotate(#{180 * s.shape_angle / Math.PI})";
+          end
+        svg["d"] = path
+        e = self.expect(e, "path", svg);
+      else 
+        svg["cx"] = s.left;
+        svg["cy"] = s.top;
+        svg["r"] = radius;
+        e = self.expect(e, "circle", svg);
+      end
+      e = self.append(e, scenes, i);
+      }
+      return e
+    end
+  end
+end
+