rubyvis 0.3.3 → 0.3.4

data/lib/rubyvis/layout/tree.rb

@@ -0,0 +1,267 @@
+module Rubyvis
+  class Layout
+    # Alias for Rubyvis::Layout::Tree 
+    def self.Tree
+      Rubyvis::Layout::Tree
+    end
+    # Implements a node-link tree diagram using the Reingold-Tilford "tidy"
+    # tree layout algorithm. The specific algorithm used by this layout is based on
+    # <a href="http://citeseer.ist.psu.edu/buchheim02improving.html">"Improving
+    # Walker's Algorithm to Run in Linear Time"</A> by C. Buchheim, M. J&uuml;nger
+    # &amp; S. Leipert, Graph Drawing 2002. This layout supports both cartesian and
+    # radial orientations orientations for node-link diagrams.
+    #
+    # <p>The tree layout supports a "group" property, which if true causes siblings
+    # to be positioned closer together than unrelated nodes at the same depth. The
+    # layout can be configured using the <tt>depth</tt> and <tt>breadth</tt>
+    # properties, which control the increments in pixel space between nodes in both
+    # dimensions, similar to the indent layout.
+    #
+    # <p>For more details on how to use this layout, see
+    # {@link pv.Layout.Hierarchy}
+    class Tree < Hierarchy
+      @properties=Hierarchy.properties.dup
+      def initialize
+        super
+      end
+      
+      ##
+      # :attr: breadth
+      # The offset between siblings nodes; defaults to 15.
+            
+      ##
+      # :attr: depth
+      # The offset between parent and child nodes; defaults to 60.
+      #
+      
+      ##
+      # :attr: orient
+      # The orientation. The default orientation is "top", which means that the root
+      # node is placed on the top edge, leaf nodes appear at the bottom, and internal
+      # nodes are in-between. The following orientations are supported:<ul>
+      #
+      # <li>left - left-to-right.
+      # <li>right - right-to-left.
+      # <li>top - top-to-bottom.
+      # <li>bottom - bottom-to-top.
+      # <li>radial - radially, with the root at the center.</ul>
+      #
+      
+      ##
+      # :group:
+      # The sibling grouping, i.e., whether differentiating space is placed between
+      # sibling groups. The default is 1 (or true), causing sibling leaves to be
+      # separated by one breadth offset. Setting this to false (or 0) causes
+      # non-siblings to be adjacent.
+      
+      attr_accessor_dsl :group, :breadth, :depth, :orient
+      
+      # Default properties for tree layouts. The default orientation is "top",
+      # the default group parameter is 1, and the default breadth and depth
+      # offsets are 15 and 60 respectively.
+      def self.defaults
+        Rubyvis::Layout::Tree.new.mark_extend(Rubyvis::Layout::Hierarchy.defaults).
+        group(1).
+        breadth(15).
+        depth(60).
+        orient("top")
+      end
+      
+      def first_walk(v)
+        l,r,a=nil,nil,nil
+        if (!v.first_child)
+          l= v.previous_sibling
+          v.prelim = l.prelim + distance(v.depth, true)  if l
+        else    
+          l = v.first_child
+          r = v.last_child
+          a = l # default ancestor
+          v.each_child {|c| 
+            first_walk(c)
+            a = apportion(c, a)
+          }
+          execute_shifts(v)
+          midpoint = 0.5 * (l.prelim + r.prelim)
+          l = v.previous_sibling
+          if l
+            v.prelim = l.prelim + distance(v.depth, true)
+            v.mod = v.prelim - midpoint
+          else
+            v.prelim = midpoint
+          end
+        end
+      end
+      def second_walk(v,m,depth)
+        v.breadth = v.prelim + m
+        m += v.mod
+        v.each_child {|c|
+          second_walk(c, m, depth)
+        }
+      end
+      def apportion(v,a)
+        w = v.previous_sibling
+        if w
+          vip = v
+          vop = v
+          vim = w
+          vom = v.parent_node.first_child
+          sip = vip.mod
+          sop = vop.mod
+          sim = vim.mod
+          som = vom.mod
+          nr = next_right(vim)
+          nl = next_left(vip)
+          while (nr and nl) do
+            vim = nr
+            vip = nl
+            vom = next_left(vom)
+            vop = next_right(vop)
+            vop.ancestor = v
+            shift = (vim.prelim + sim) - (vip.prelim + sip) + distance(vim.depth, false)
+            if (shift > 0)
+              move_subtree(ancestor(vim, v, a), v, shift)
+              sip += shift
+              sop += shift
+            end
+            sim += vim.mod
+            sip += vip.mod
+            som += vom.mod
+            sop += vop.mod
+            nr = next_right(vim)
+            nl = next_left(vip)
+          end
+          
+          if (nr and !next_right(vop))
+            vop.thread = nr
+            vop.mod += sim - sop
+          end
+          if (nl and !next_left(vom))
+            vom.thread = nl
+            vom.mod += sip - som
+            a = v
+          end
+        end
+        a
+      end
+      
+      def next_left(v)
+        v.first_child ? v.first_child : v.thread
+      end
+      def next_right(v)
+        v.last_child ? v.last_child : v.thread
+      end
+      
+      def move_subtree(wm, wp, shift) 
+        subtrees = wp.number - wm.number
+        wp.change -= shift / subtrees.to_f
+        wp.shift += shift
+        wm.change += shift / subtrees.to_f
+        wp.prelim += shift
+        wp.mod += shift
+      end
+      
+      def execute_shifts(v) 
+        shift = 0
+        change = 0
+        c=v.last_child
+        while c        
+          c.prelim += shift
+          c.mod += shift
+          change += c.change
+          shift += c.shift + change
+          c = c.previous_sibling          
+        end
+      end
+      def ancestor(vim, v, a) 
+        (vim.ancestor.parent_node == v.parent_node) ? vim.ancestor : a
+      end
+
+      def distance(depth, siblings) 
+        (siblings ? 1 : (@_group + 1)).to_f / ((@_orient == "radial") ? depth : 1)
+      end
+
+      
+      def mid_angle(n)
+        (@_orient == "radial") ? n.breadth.to_f / depth : 0;
+      end
+      
+      #/** @private */
+      def x(n)
+        case @_orient
+          when "left"
+            n.depth;
+          when "right"
+            @_w - n.depth;
+          when "top"
+            n.breadth + @_w / 2.0
+          when "bottom"
+            n.breadth + @_w / 2.0
+          when "radial"
+            @_w / 2.0 + n.depth * Math.cos(mid_angle(n))
+        end
+      end
+      
+      #/** @private */
+      def y(n)
+        case @_orient
+          when "left"
+            n.breadth + @_h / 2.0
+          when "right"
+            n.breadth + @_h / 2.0
+          when "top"
+            n.depth;
+          when "bottom"
+            @_h - n.depth
+          when "radial"
+            @_h / 2.0 + n.depth * Math.sin(mid_angle(n))
+        end
+      end
+
+      
+      
+      def build_implied(s)
+        return nil if hierarchy_build_implied(s)        
+        @_nodes = s.nodes
+        @_orient = s.orient
+        @_depth = s.depth
+        @_breadth = s.breadth
+        @_group = s.group
+        @_w = s.width
+        @_h = s.height
+        root=@_nodes[0]
+        root.visit_after {|v,i|
+          v.ancestor = v
+          v.prelim = 0
+          v.mod = 0
+          v.change = 0
+          v.shift = 0
+          v.number = v.previous_sibling ? (v.previous_sibling.number + 1) : 0
+          v.depth = i
+        }
+        #/* Compute the layout using Buchheim et al.'s algorithm. */
+        first_walk(root)
+        second_walk(root, -root.prelim, 0)
+        
+        root.visit_after {|v,i|
+          v.breadth *= breadth
+          v.depth *= depth
+          v.mid_angle = mid_angle(v)
+          v.x = x(v)
+          v.y = y(v)
+          v.mid_angle += Math::PI if (v.first_child)
+          v.breadth=nil
+          v.depth=nil
+          v.ancestor=nil
+          v.prelim=nil
+          v.mod=nil
+          v.change=nil
+          v.shift=nil
+          v.number=nil
+          v.thread=nil
+        }
+        
+        
+      end
+    end
+  end
+end

data/lib/rubyvis/layout/treemap.rb

@@ -174,6 +174,7 @@ module Rubyvis
             
       def size(f)
         @size=Rubyvis.functor(f)
+        self
       end
       
       

data/lib/rubyvis/mark.rb

@@ -699,7 +699,11 @@ module Rubyvis
       width=self.parent ? self.parent.width() : (w+(l.nil? ? 0 : l)+(r.nil? ? 0 : r))
       #puts (self.parent)? "parent width: #{self.parent.width}" : "no parent" if $DEBUG
       #p prop.sort if $DEBUG
-      puts "build implied #{type}: l:#{l},r:#{r},t:#{t},b:#{b}, w:#{prop[:width]} #{w},h: #{prop[:height]} #{h}, width:#{width}" if $DEBUG
+      
+      height=self.parent ? self.parent.height(): (h+(t.nil? ? 0 : t )+(b.nil? ? 0 : b))
+      
+      puts "build implied #{type}: l:#{l},r:#{r},t:#{t},b:#{b}, w:#{prop[:width]} #{w},h: #{prop[:height]} #{h}, width:#{width}, height:#{height}" if $DEBUG
+      
       if w.nil?
         r||=0
         l||=0
@@ -715,7 +719,7 @@ module Rubyvis
         l=width-w-r
       end
 
-      height=self.parent ? self.parent.height(): (h+(t.nil? ? 0 : t )+(b.nil? ? 0 : b))
+      
 
       if h.nil?
         t||=0
@@ -739,11 +743,9 @@ module Rubyvis
       s.top=t
       s.bottom=b
 
-      puts "Post->left: #{l},right:#{r},top:#{t},bottom:#{b}, width:#{w}, height:#{h}" if $DEBUG
-
-      s.width=w if prop[:width]
-      #puts "width:#{s.width}" if $DEBUG
-      s.height=h if prop[:height]
+      puts "Post->left: #{l},right:#{r},top:#{t},bottom:#{b}, width:#{w}, height:#{h}\n\n" if $DEBUG
+      s.width  = w if prop[:width]
+      s.height = h if prop[:height]
       s.text_style=Rubyvis::Color.transparent if prop[:text_style] and !s.text_style
       s.fill_style=Rubyvis::Color.transparent if prop[:fill_style] and !s.fill_style
       s.stroke_style=Rubyvis::Color.transparent if prop[:stroke_style] and !s.stroke_style
@@ -874,7 +876,7 @@ module Rubyvis
             @types[2].push(@seen[name])
           end
         }
-      end while(mark=mark.proto)
+      end while(mark = mark.proto)
       @binds=OpenStruct.new({:properties=>@seen, :data=>@_data, :required=>@_required, :optional=>@types[1]+@types[2]+@types[3]
       })
     end

data/lib/rubyvis/mark/area.rb

@@ -55,9 +55,9 @@ module Rubyvis
         #    p binds.fixed
         #/* Evaluate all properties on the first instance. */
       else
-        binds.required = binds._required;
-        binds.optional = binds._optional;
-        binds.fixed = nil;
+        binds.required = binds._required
+        binds.optional = binds._optional
+        binds.fixed = nil
       end
       # pp binds
       mark_build_instance(s)
@@ -66,7 +66,7 @@ module Rubyvis
 
 
     def area_bind
-      mark_bind()
+      mark_bind
       binds = self.binds
       
       required = binds.required
@@ -80,8 +80,8 @@ module Rubyvis
       }
       optional.delete_if {|v| v.name=='segmented'}
       # Cache the original arrays so they can be restored on build. */
-      @binds._required = required;
-      @binds._optional = optional;
+      @binds._required = required
+      @binds._optional = optional
     end
 
 

data/lib/rubyvis/mark/dot.rb

@@ -21,7 +21,7 @@ module Rubyvis
     # :attr: shape_size
     # The size of the shape, in square pixels. Square pixels are used such that the
     # area of the shape is linearly proportional to the value of the
-    # <tt>shapeSize</tt> property, facilitating representative encodings. This is
+    # <tt>shape_size</tt> property, facilitating representative encodings. This is
     # an alternative to using shape_radius
     #
     

data/lib/rubyvis/mark/shorcut_methods.rb

@@ -1,9 +1,9 @@
 class Rubyvis::Mark
   ##
-  # :section: Ruby API
+  # :section: RBP Api
   ##
   
-  # Create 
+  # Create a new Mark method shorcut.
   def self.mark_method(name, mark) #:nodoc:
     define_method(name) do |*args,&block|
       opts=args[0]
@@ -240,5 +240,32 @@ class Rubyvis::Mark
   # See Mark for examples of use    
   mark_method :layout_pack, Rubyvis::Layout::Pack
 
+  ##
+  # :method: layout_grid(opts,&block)
+  #
+  # Adds a Layout::Grid to current mark. 
+  # 
+  # If a block is provided, the context will be defined differently if 
+  # parameter is provided
+  # * Without parameter: block executed inside context of new mark
+  # * With paramenter: block executed inside context of current mark. 
+  #   Paramenter references new mark
+  # 
+  # See Mark for examples of use    
+  mark_method :layout_grid, Rubyvis::Layout::Grid
+
+  ##
+  # :method: tree_grid(opts,&block)
+  #
+  # Adds a Layout::Tree to current mark. 
+  # 
+  # If a block is provided, the context will be defined differently if 
+  # parameter is provided
+  # * Without parameter: block executed inside context of new mark
+  # * With paramenter: block executed inside context of current mark. 
+  #   Paramenter references new mark
+  # 
+  # See Mark for examples of use    
+  mark_method :layout_tree, Rubyvis::Layout::Tree
   
 end

data/lib/rubyvis/nest.rb

@@ -90,6 +90,22 @@ module Rubyvis
       @order = order.nil? ? Rubyvis.natural_order : order
       return self
     end
+    
+    # Returns a hierarchical map of values. Each key adds one level to the
+    # hierarchy. With only a single key, the returned map will have a key for each
+    # distinct value of the key function; the correspond value with be an array of
+    # elements with that key value. If a second key is added, this will be a nested
+    # map. For example:
+    #
+    # <pre>Rubyvis.nest(yields)
+    #     .key(function(d) d.variety)
+    #     .key(function(d) d.site)
+    #     .map()</pre>
+    #
+    # returns a map <tt>m</tt> such that <tt>m[variety][site]</tt> is an array, a subset of
+    # <tt>yields</tt>, with each element having the given variety and site.
+    #
+    # @returns a hierarchical map of values    
     def map
       #i=0
       map={} 
@@ -116,6 +132,19 @@ module Rubyvis
       end
       map
     end
+    
+    # Returns a hierarchical nested array. This method is similar to
+    # {@link pv.entries}, but works recursively on the entire hierarchy. Rather
+    # than returning a map like {@link #map}, this method returns a nested
+    # array. Each element of the array has a <tt>key</tt> and <tt>values</tt>
+    # field. For leaf nodes, the <tt>values</tt> array will be a subset of the
+    # underlying elements array; for non-leaf nodes, the <tt>values</tt> array will
+    # contain more key-values pairs.
+    #
+    # <p>For an example usage, see the {@link Nest} constructor.
+    #
+    # @returns a hierarchical nested array.
+    
     def entries()
       entries_sort(entries_entries(map),0)
     end
@@ -145,13 +174,30 @@ module Rubyvis
         if value.is_a? Array
           map[key]=f.call(value)
         else
-          rollup_rollup(value)
+          rollup_rollup(value,f)
         end
       }
       return map;
     end
+    
+    # Returns a rollup map. The behavior of this method is the same as
+    # {@link #map}, except that the leaf values are replaced with the return value
+    # of the specified rollup function <tt>f</tt>. For example,
+    #
+    # <pre>pv.nest(yields)
+    #      .key(function(d) d.site)
+    #      .rollup(function(v) pv.median(v, function(d) d.yield))</pre>
+    #
+    # first groups yield data by site, and then returns a map from site to median
+    # yield for the given site.
+    #
+    # @see #map
+    # @param {function} f a rollup function.
+    # @returns a hierarchical map, with the leaf values computed by <tt>f</tt>.
+
+    
     def rollup(f)
-      rollup_rollup(self.map,f)
+      rollup_rollup(self.map, f)
     end
   end
 end