rubyvis 0.1.2 → 0.1.3

data/lib/rubyvis/mark/bar.rb

@@ -8,9 +8,9 @@ module Rubyvis
     end
 
     @properties=Mark.properties.dup
-    attr_accessor_dsl :width, :height, :line_width, :stroke_style, :fill_style
+    attr_accessor_dsl :width, :height, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}]
     def self.defaults
-      Bar.new.extend(Mark.defaults).line_width(1.5).fill_style(Rubyvis.Colors.category20().by(Rubyvis.parent))
+      Bar.new.extend(Mark.defaults).line_width(1.5).fill_style( lambda {Rubyvis.Colors.category20().scale(self.parent.index)})
     end
   end
 end

data/lib/rubyvis/mark/dot.rb

@@ -0,0 +1,85 @@
+module Rubyvis
+  def self.Dot
+    Rubyvis::Dot
+  end
+  class Dot < Mark
+    def type
+      "dot"
+    end
+
+    @properties=Mark.properties.dup
+    
+    attr_accessor_dsl :shape, :shape_angle, :shape_radius, :shape_size, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}]
+    
+    def self.defaults()
+      Dot.new().extend(Mark.defaults).shape("circle"). line_width(1.5). stroke_style(lambda {pv.Colors.category10().scale(self.parent.index)})
+    end
+    
+    def anchor(name)
+      
+      
+      mark_anchor(name).left(lambda {
+          s=scene.target[self.index]
+          case self.name
+          when 'bottom' then s.left;
+          when 'top' then s.left;
+          when 'center' then s.left;
+          when 'left' then nil;
+          else
+            s.left+s.shape_radius
+          end
+      }).right(lambda {
+          s=scene.target[self.index]
+          self.name()=='left' ? s.right+s.shape_radius : nil
+        
+      }).top(lambda {
+        s=scene.target[self.index]
+          case self.name
+          when 'left' then  s.top;
+          when 'right' then s.top;
+          when 'center' then s.top;
+          when 'top' then nil;
+          else
+            s.top+s.shape_radius
+          end
+      }).bottom(lambda {
+         s=scene.target[self.index]
+          self.name()=='top' ? s.bottom+s.shape_radius : nil
+      }).text_align(lambda {
+       case self.name
+          when 'left' then  'right';
+          when 'bottom' then 'center';
+          when 'top' then 'center';
+          when 'center' then 'center';
+          else
+            'left'
+          end
+      }).text_baseline( lambda {
+       case self.name
+       when 'right' then  'middle';
+       when 'left' then 'middle';
+       when 'center' then 'middle';
+          when 'bottom' then 'top';
+          else
+            'bottom'
+          end
+      
+      })
+    end
+    def build_implied(s)
+      r = s.shape_radius
+      z = s.shape_size
+      if (r.nil?) 
+        if (z.nil?) 
+          s.shape_size = 20.25;
+          s.shape_radius = 4.5;
+        else
+          s.shape_radius = Math.sqrt(z)
+        end
+      elsif (z.nil?) 
+        s.shape_size = r * r;
+      end
+      mark_build_implied(s)
+    end
+  end
+end

data/lib/rubyvis/mark/label.rb

@@ -5,7 +5,7 @@ module Rubyvis
 
   class Label < Mark
     @properties=Mark.properties.dup
-    attr_accessor_dsl :text, :font, :text_angle, :text_style, :text_align, :text_baseline, :text_margin, :text_decoration, :text_shadow
+    attr_accessor_dsl :text, :font, :text_angle, [:text_style, lambda {|d| pv.color(d)}], :text_align, :text_baseline, :text_margin, :text_decoration, :text_shadow
     def type
       'label'
     end

data/lib/rubyvis/mark/line.rb

@@ -5,18 +5,19 @@ module Rubyvis
   module LinePrototype
     include AreaPrototype
     def line_anchor(name)
-      area_anchor(name).text_align(lambda {|d|
-        {'left'=>'right','bottom'=>'center', 'top'=>'center','center'=>'center','right'=>'left'}[d]
+      anchor=area_anchor(name).text_align(lambda {|d|
+          {'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'}[d]
+        {'top'=>'bottom', 'right'=>'middle', 'left'=>'middle','center'=>'middle','bottom'=>'top'}[self.name]
       })
+      return anchor
     end
   end
   class Line < Mark
     include AreaPrototype
     include LinePrototype
     @properties=Mark.properties.dup
-    attr_accessor_dsl :line_width, :line_join, :stroke_style, :fill_style, :segmented, :interpolate, :eccentricity, :tension
+    attr_accessor_dsl :line_width, :line_join, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}], :segmented, :interpolate, :eccentricity, :tension
     def type
       "line"
     end
@@ -29,8 +30,8 @@ module Rubyvis
     def build_instance(*args)
       area_build_instance(*args)
     end
-    def defaults
-      Line.new.extend(Rubyvis::Mark).line_join('miter').line_width(1.5).stroke_style(RubyVis::Color.category10().by(pv.parent)).interpolate('linear').eccentricity(0).tension(7)
+    def self.defaults
+      Line.new.extend(Mark.defaults).line_join('miter').line_width(1.5).stroke_style( lambda {return Rubyvis::Colors.category10().scale(self.parent.index)}).interpolate('linear').eccentricity(0).tension(7)
     end
   end
 end

data/lib/rubyvis/mark/panel.rb

@@ -74,7 +74,6 @@ module Rubyvis
         bar = REXML::Formatters::Default.new
         out = String.new
         bar.write(v[1].elements[1], out)
-        out
       }.join
     end
     def build_implied(s)

data/lib/rubyvis/mark/rule.rb

@@ -5,9 +5,9 @@ module Rubyvis
   class Rule < Mark
     include LinePrototype
     @properties=Mark.properties.dup
-    attr_accessor_dsl :width, :height, :line_width, :stroke_style
+    attr_accessor_dsl :width, :height, :line_width, [:stroke_style, lambda {|d| pv.color(d)}]
     def self.defaults
-      Rule.new.extend(Mark.defaults).line_width(1).stroke_style(pv.color('black')).antialias(false)
+      Rule.new.extend(Mark.defaults).line_width(1).stroke_style('black').antialias(false)
     end
     def type
       'rule'
@@ -21,12 +21,13 @@ module Rubyvis
       r=s.right
       t=s.top
       b=s.bottom
-      if((!s.width.nil?) or ((l.nil?) and (r.nil?)) or ((!r.nil?) or (!l.nil?)))
+      
+      if((!s.width.nil?) or ((l.nil?) and (r.nil?)) or ((!r.nil?) and (!l.nil?)))
         s.height=0
       else
         s.width=0
       end
-      super(s)
+      mark_build_implied(s)
     end
   end
 end

data/lib/rubyvis/mark/wedge.rb

@@ -0,0 +1,124 @@
+module Rubyvis
+  def self.Wedge
+    Rubyvis::Wedge
+  end
+  class Wedge < Mark
+    def type
+      "wedge"
+    end
+    @properties=Mark.properties.dup
+    attr_accessor_dsl :start_angle, :end_angle, :angle, :inner_radius, :outer_radius, :line_width, [:stroke_style, lambda {|d| pv.color(d)}], [:fill_style, lambda {|d| pv.color(d)}]
+    def self.defaults
+      Wedge.new.extend(Mark.defaults).start_angle(lambda  {s=self.sibling; s ? s.end_angle: -Math::PI.quo(2) } ).inner_radius( 0 ).line_width( 1.5 ).stroke_style( nil ).fill_style( lambda {Rubyvis.Colors.category20().scale(self.parent.index)})
+    end
+    def mid_radius
+      (inner_radius+outer_radius) / 2.0
+    end
+    def mid_angle
+      (start_angle+end_angle) / 2.0
+    end
+    
+    def anchor(name)
+      partial=lambda {|s| s.inner_radius!=0 ? true : s.angle<2*Math.PI}
+      mid_radius=lambda {|s| (s.inner_radius+s.outer_radius) / 2.0}
+      mid_angle=lambda {|s| (s.start_angle+s.end_angle) / 2.0 }
+      
+      mark_anchor(name).left(lambda {
+        s = self.scene.target[self.index];
+        if (partial.call(s))
+          
+          case (self.name()) 
+          when "outer"
+            return s.left + s.outer_radius * Math.cos(mid_angle.call(s))
+          when "inner"
+            return s.left + s.inner_radius * Math.cos(mid_angle.call(s))
+          when "start"
+            return s.left + mid_radius.call(s) * Math.cos(s.start_angle)
+          when "center"
+            return s.left + mid_radius.call(s) * Math.cos(mid_angle.call(s))
+          when "end"
+            return s.left + mid_radius.call(s) * Math.cos(s.end_angle)
+          end
+        end
+        return s.left;
+      }).top(lambda {
+        s = self.scene.target[self.index];
+        if (partial.call(s))
+          case (self.name()) 
+          when "outer"
+            return s.top + s.outer_radius * Math.sin(mid_angle.call(s))
+          when "inner"
+            return s.top + s.inner_radius * Math.sin(mid_angle.call(s))
+          when "start"
+            return s.top + mid_radius.call(s) * Math.sin(s.start_angle)
+          when "center"
+            return s.top + mid_radius.call(s) * Math.sin(mid_angle.call(s))
+          when "end"
+            return s.top + mid_radius.call(s) * Math.sin(s.end_angle)
+          end
+        end
+        return s.top;
+          
+      }).text_align(lambda {
+      s = self.scene.target[self.index];
+        if (partial.call(s))
+          case (self.name()) 
+          when 'outer'
+            return self.upright(mid_angle.call(s)) ? 'right':'left'
+          when 'inner'
+            return self.upright(mid_angle.call(s)) ? 'left':'right'
+            
+          end
+        end
+        return 'center'
+      }).text_baseline(lambda {
+      s = self.scene.target[self.index];
+        if (partial.call(s))
+          case (self.name()) 
+          when 'start'
+            return self.upright(s.start_angle) ? 'top':'bottom'
+          when 'end'
+            return self.upright(s.end_angle) ? 'bottom':'top'
+            
+          end
+        end
+        return 'middle'
+      }).text_angle(lambda {
+        s = self.scene.target[self.index];
+        a=0
+        if (partial.call(s))
+          case (self.name()) 
+          when 'center'
+            a=mid_angle.call(s)
+          when 'inner'
+            a=mid_angle.call(s)
+          when 'outer'
+            a=mid_angle.call(s)
+          when 'start'
+            a=s.start_angle
+          when 'end'
+            a=s.end_angle
+          end
+        end
+        self.upright(a) ? a: (a+Math::PI) 
+      })
+      
+    end
+    
+    
+    def self.upright(angle)
+      angle=angle % (2*Math::PI)
+      angle=(angle<0) ? (2*Math::PI+angle) : angle
+      (angle < Math::PI/2.0) or (angle>=3*Math::PI / 2.0)
+      
+    end
+    def build_implied(s)
+      if (s.angle.nil?)
+        s.angle= s.end_angle-s.start_angle 
+      elsif s.end_angle.nil?
+        s.end_angle=s.start_angle+s.angle
+      end
+      mark_build_implied(s)
+    end
+  end
+end

data/lib/rubyvis/nest.rb

@@ -0,0 +1,158 @@
+module Rubyvis
+  ##
+  # Returns a {@link pv.Nest} operator for the specified array. This is a
+  # convenience factory method, equivalent to <tt>new pv.Nest(array)</tt>.
+  #
+  # @see pv.Nest
+  # @param {array} array an array of elements to nest.
+  # @returns {Nest} a nest operator for the specified array.
+  ##
+  def self.nest(array)
+    Nest.new(array)
+  end
+  class NestedArray
+    attr_accessor :key, :values
+    def initialize(opts)
+      @key=opts[:key]
+      @values=opts[:values]
+    end
+    def ==(var)
+      key==var.key and values=var.values
+    end
+  end
+  ##
+  # Constructs a nest operator for the specified array. This constructor should
+  # not be invoked directly; use {@link pv.nest} instead.
+  #
+  # @class Represents a {@link Nest} operator for the specified array. Nesting
+  # allows elements in an array to be grouped into a hierarchical tree
+  # structure. The levels in the tree are specified by <i>key</i> functions. The
+  # leaf nodes of the tree can be sorted by value, while the internal nodes can
+  # be sorted by key. Finally, the tree can be returned either has a
+  # multidimensional array via {@link #entries}, or as a hierarchical map via
+  # {@link #map}. The {@link #rollup} routine similarly returns a map, collapsing
+  # the elements in each leaf node using a summary function.
+  #
+  # <p>For example, consider the following tabular data structure of Barley
+  # yields, from various sites in Minnesota during 1931-2:
+  #
+  #   { yield: 27.00, variety: "Manchuria", year: 1931, site: "University Farm" },
+  #   { yield: 48.87, variety: "Manchuria", year: 1931, site: "Waseca" },
+  #   { yield: 27.43, variety: "Manchuria", year: 1931, site: "Morris" }
+  #
+  # To facilitate visualization, it may be useful to nest the elements first by
+  # year, and then by variety, as follows:
+  #
+  # <pre>var nest = pv.nest(yields)
+  #     .key(function(d) d.year)
+  #     .key(function(d) d.variety)
+  #     .entries();</pre>
+  #
+  # This returns a nested array. Each element of the outer array is a key-values
+  # pair, listing the values for each distinct key:
+  #
+  # <pre>{ key: 1931, values: [
+  #   { key: "Manchuria", values: [
+  #       { yield: 27.00, variety: "Manchuria", year: 1931, site: "University Farm" },
+  #       { yield: 48.87, variety: "Manchuria", year: 1931, site: "Waseca" },
+  #       { yield: 27.43, variety: "Manchuria", year: 1931, site: "Morris" },
+  #       ...
+  #     ] },
+  #   { key: "Glabron", values: [
+  #       { yield: 43.07, variety: "Glabron", year: 1931, site: "University Farm" },
+  #       { yield: 55.20, variety: "Glabron", year: 1931, site: "Waseca" },
+  #       ...
+  #     ] },
+  #   ] },
+  # { key: 1932, values: ... }</pre>
+  #
+  # Further details, including sorting and rollup, is provided below on the
+  # corresponding methods.
+  #
+  # @param {array} array an array of elements to nest.
+  #/
+  class Nest
+    attr_accessor :array, :keys, :order
+    def initialize(array)
+      @array=array
+      @keys=[]
+      @order=nil
+    end
+    def key(k)
+      @keys.push(k)
+      return self
+    end
+    def sort_keys(order=nil)
+      #keys[keys.size-1].order = order.nil? ? pv.natural_order : order
+      return self
+    end
+    def sort_values(order=nil)
+      @order = order.nil? ? pv.natural_order : order
+      return self
+    end
+    def map
+      i=0
+      map={} 
+      values=[]
+      @array.each_with_index {|x,j|
+        m=map
+        (@keys.size-1).times {|i|
+          k=@keys[i].call(x)
+          m[k]={} if (!m[k])
+          m=m[k]
+        }
+        k=@keys.last.call(x)
+        if(!m[k])
+          a=[]
+          values.push(a)
+          m[k]=a
+        end
+        m[k].push(x)
+      }
+      if(self.order)
+        values.each_with_index {|v,vi|
+          values[vi].sort(&self.order)
+        }
+      end
+      map
+    end
+    def entries()
+      entries_sort(entries_entries(map),0)
+    end
+    def entries_entries(map)
+      array=[]
+      map.each_pair {|k,v|
+        array.push(NestedArray.new({:key=>k, :values=>(v.is_a? Array) ? v: entries_entries(v)}))
+      }
+      array
+    end
+    def entries_sort(array,i)
+      o=keys[i].order
+      if o
+        array.sort {|a,b| o(a.key, b.key)}
+      end
+      i+=1
+      if (i<keys.size)
+        array.each {|v|
+          entries_sort(v, i)
+        }
+        
+      end
+      return array
+      
+    end
+    def rollup_rollup(map,f)
+      map.each_pair {|key,value|
+        if value.is_a? Array
+          map[key]=f.call(value)
+        else
+          rollup_rollup(value)
+        end
+      }
+      return map;
+    end
+    def rollup(f)
+      rollup_rollup(self.map,f)
+    end
+  end
+end