rubyvis 0.3.2 → 0.3.3

data/History.txt

@@ -1,3 +1,10 @@
+=== 0.3.3 / 2010-11-23
+
+* Implemented Rubyvis::Layout::Pack, Rubyvis::Layout::Indent and Rubyvis::Flatten
+* Implemeted Rubyvis::Mark.title()
+* New examples: bubble charts and circle packing
+* Better documentation for Network
+
 === 0.3.2 / 2010-11-23
 
 * Updated examples

data/Manifest.txt

@@ -10,8 +10,10 @@ examples/area_interpolation.rb
 examples/bar_column_chart.rb
 examples/barley/barley.rb
 examples/barley/barley_data.rb
+examples/bubble_charts.rb
 examples/cars/cars.rb
 examples/cars/cars_data.rb
+examples/circle_packing.rb
 examples/crimea/crimea_data.rb
 examples/crimea/crimea_grouped_bar.rb
 examples/crimea/crimea_line.rb
@@ -23,6 +25,7 @@ examples/fixtures/tipsy.gif
 examples/grouped_charts.rb
 examples/icicle.rb
 examples/image.rb
+examples/indent.rb
 examples/line.rb
 examples/line_and_step.rb
 examples/line_interpolation.rb
@@ -39,6 +42,7 @@ lib/rubyvis.rb
 lib/rubyvis/color/color.rb
 lib/rubyvis/color/colors.rb
 lib/rubyvis/dom.rb
+lib/rubyvis/flatten.rb
 lib/rubyvis/format.rb
 lib/rubyvis/format/date.rb
 lib/rubyvis/format/number.rb
@@ -48,7 +52,9 @@ lib/rubyvis/javascript_behaviour.rb
 lib/rubyvis/layout.rb
 lib/rubyvis/layout/cluster.rb
 lib/rubyvis/layout/hierarchy.rb
+lib/rubyvis/layout/indent.rb
 lib/rubyvis/layout/network.rb
+lib/rubyvis/layout/pack.rb
 lib/rubyvis/layout/partition.rb
 lib/rubyvis/layout/stack.rb
 lib/rubyvis/layout/treemap.rb

data/examples/bubble_charts.rb

@@ -0,0 +1,60 @@
+# Bubble charts, such as those provided by "Many Eyes":http://manyeyes.alphaworks.ibm.com/manyeyes/page/Bubble_Chart.html, encode data in the area of circles. Although less perceptually accurate than bar charts, they can pack hundreds of values into a small space. A similar technique is the Dorling cartogram, where circles are positioned according to geography rather than arbitrarily. Here we compare the file sizes of the Rubyvis library files
+$:.unshift(File.dirname(__FILE__)+"/../lib")
+require 'rubyvis'
+
+
+def get_files(path)
+  h={}
+  Dir.glob("#{path}/*").each {|e|
+    next if File.expand_path(e)=~/pkg|web|vendor|doc|~/
+    pa=File.expand_path(e) 
+    if File.stat(pa).directory?
+      h[File.basename(pa)]=get_files(pa)
+    else
+      h[File.basename(pa)]=File.stat(pa).size
+    end
+  }
+  h
+end
+
+files=get_files(File.dirname(__FILE__)+"/../lib")
+
+classes = Rubyvis.nodes(Rubyvis.flatten(files).leaf(lambda {|v| v.is_a? Numeric}).array)
+
+
+classes[1,classes.size-1].each {|d|
+  #p d.node_value.keys
+  d.node_name = "/" + d.node_value[:keys].join("/")
+  i = d.node_name.rindex("/")
+  class << d
+    attr_accessor :class_name, :package_name
+  end
+  d.class_name = d.node_name[i+1,d.node_name.size-(i+1)].gsub(".rb","")
+  d.package_name = d.node_name[0,i]
+  d.node_value = d.node_value[:value]
+}
+# For pretty number formatting.
+format = Rubyvis.Format.number
+
+vis = Rubyvis::Panel.new.
+  width(600)
+    .height(600)
+c20=Rubyvis::Colors.category20()
+vis.add(pv.Layout.Pack)
+    .top(-50)
+    .bottom(-50)
+    .nodes(classes)
+    .size(lambda {|d| d.node_value})
+    .spacing(0)
+    .order(nil)
+  .node.add(Rubyvis::Dot)
+    .fill_style(lambda {|d| c20.scale(d.package_name)})
+    .stroke_style(lambda {|d| c20.scale(d.package_name).darker})
+    .visible(lambda {|d| d.parent_node})
+    .title(lambda {|d| d.node_name + ": " + format.format(d.node_value)})
+  .anchor("center").add(pv.Label)
+  .text(lambda {|d| d.class_name[0, Math.sqrt(d.node_value).to_i / 8]})
+
+vis.render();
+puts vis.to_svg
+

data/examples/circle_packing.rb

@@ -0,0 +1,54 @@
+# = Circle Packing
+# Enclosure diagrams are also space-filling, using containment rather than adjacency to represent the hierarchy. As with adjacency diagrams, the size of any node in the tree is quickly revealed. Although circle packing does not use space as efficiently as a treemap, the “wasted” space effectively reveals the hierarchy. At the same time, node sizes can be rapidly compared using area judgments.
+# By flattening the hierarchy, the pack layout can also be used to create "bubble charts":bubble_charts.html.
+# This example uses RBP API.
+
+
+$:.unshift(File.dirname(__FILE__)+"/../lib")
+require 'rubyvis'
+
+
+def get_files(path)
+  h={}
+  Dir.glob("#{path}/*").each {|e|
+    next if File.expand_path(e)=~/pkg|web|vendor|doc|~/
+    pa=File.expand_path(e) 
+    if File.stat(pa).directory?
+      h[File.basename(pa)]=get_files(pa)
+    else
+      h[File.basename(pa)]=File.stat(pa).size
+    end
+  }
+  h
+end
+
+files=get_files(File.dirname(__FILE__)+"/../lib/")
+
+format = Rubyvis::Format.number();
+
+vis = Rubyvis::Panel.new do
+  width 600
+  height 796
+  margin 2
+  layout_pack do
+    nodes Rubyvis.dom(files).root("Rubyvis").nodes
+    size(lambda {|d| d.node_value})
+    node.dot do 
+      fill_style {|d| 
+        d.first_child ? "rgba(31, 119, 180, 0.25)" : "#ff7f0e"
+      }
+      title {|d| 
+        d.node_name.to_s + (d.first_child ? "" : ": " + format.format(d.node_value))}
+        
+      line_width 1
+    end
+    node_label.label do
+      visible {|d| !d.first_child}
+      text {|d| d.node_name[0, Math.sqrt(d.node_value) / 10]}
+    end
+  end
+end
+
+vis.render()
+puts vis.to_svg
+

data/examples/indent.rb

@@ -0,0 +1,71 @@
+# = Indented Tree
+# Indented trees are widely-used to represent file systems, among other applications. Although indented trees require much vertical space and do not easily facilitate multiscale inference, they do allow efficient interactive exploration of the tree to find a specific node.
+# In addition, the indent layout allows rapid scanning of node labels, and multivariate data such as file size can be displayed adjacent to the hierarchy.
+#
+# Uses Protovis API
+$:.unshift(File.dirname(__FILE__)+"/../lib")
+require 'rubyvis'
+
+
+def get_files(path)
+  h={}
+  Dir.glob("#{path}/*").each {|e|
+    next if File.expand_path(e)=~/pkg|web|vendor|doc|~/
+    pa=File.expand_path(e) 
+    if File.stat(pa).directory?
+      h[File.basename(pa)]=get_files(pa)
+    else
+      h[File.basename(pa)]=File.stat(pa).size
+    end
+  }
+  h
+end
+
+files=get_files(File.dirname(__FILE__)+"/../")
+
+
+root = Rubyvis.dom(files)
+    .root("rubyvis")
+    .sort(lambda {|a,b| a.node_name<=>b.node_name})
+
+#/* Recursively compute the package sizes. */
+root.visit_after {|n,i| 
+  if (n.first_child)
+    n.node_value= Rubyvis.sum(n.child_nodes , lambda {|nn|  nn.node_value})
+  end
+}
+
+def t(d)
+  d.parent_node ? (t(d.parent_node) + "." + d.node_name) : d.node_name
+end
+
+vis = Rubyvis::Panel.new()
+    .width(260)
+    .height((root.nodes.size + 1)* 12)
+    .margin(5)
+
+layout = vis.add(pv.Layout.Indent)
+.nodes(lambda {root.nodes})
+    .depth(12)
+    .breadth(12)
+
+layout.link.add(pv.Line)
+
+node = layout.node.add(pv.Panel)
+.top(lambda {|n| n.y - 6})
+    .height(12)
+    .right(6)
+    .strokeStyle(nil)
+    
+node.anchor("left").add(pv.Dot)
+    .strokeStyle("#1f77b4")
+    .fillStyle(lambda {|n| n.first_child ? "#aec7e8" : "#ff7f0e"})
+    .title(lambda {|d| t(d)})
+  .anchor("right").add(pv.Label)
+  .text(lambda {|n| n.node_name})
+
+node.anchor("right").add(pv.Label)
+.text(lambda {|n| (n.node_value >> 10).to_s + "KB"})
+
+vis.render()
+puts vis.to_svg

data/lib/rubyvis.rb

@@ -8,6 +8,7 @@ require 'rubyvis/internals'
 require 'rubyvis/sceneelement'
 require 'rubyvis/property'
 require 'rubyvis/nest'
+require 'rubyvis/flatten'
 
 require 'rubyvis/javascript_behaviour'
 require 'rubyvis/format'
@@ -29,7 +30,7 @@ require 'rubyvis/mark/shorcut_methods'
 module Rubyvis
   @document=nil
   # Rubyvis version
-  VERSION = '0.3.2' 
+  VERSION = '0.3.3' 
   # Protovis API on which current Rubyvis is based
   PROTOVIS_API_VERSION='3.3'
   # You actually can do it! http://snipplr.com/view/2137/uses-for-infinity-in-ruby/

data/lib/rubyvis/dom.rb

@@ -110,8 +110,10 @@ module Rubyvis
       attr_accessor :angle
       attr_accessor :start_angle
       attr_accessor :outer_radius
-      attr_accessor :inner_radius      
-      
+      attr_accessor :inner_radius
+      attr_accessor :radius      
+      attr_accessor :_p
+      attr_accessor :n
 
       # Constructs a DOM node for the specified value. Instances of this class are
       # not typically created directly; instead they are generated from a JavaScript 

data/lib/rubyvis/flatten.rb

@@ -0,0 +1,128 @@
+module Rubyvis
+  # Returns a {@link pv.Flatten} operator for the specified map. This is a
+  # convenience factory method, equivalent to <tt>new pv.Flatten(map)</tt>.  
+  def self.flatten(map)
+    Flatten.new(map)
+  end
+  # Represents a flatten operator for the specified array. Flattening
+  # allows hierarchical maps to be flattened into an array. The levels in the
+  # input tree are specified by <i>key</i> functions.
+  #
+  # <p>For example, consider the following hierarchical data structure of Barley
+  # yields, from various sites in Minnesota during 1931-2:
+  #
+  # <pre>{ 1931: {
+  #     Manchuria: {
+  #       "University Farm": 27.00,
+  #       "Waseca": 48.87,
+  #       "Morris": 27.43,
+  #       ... },
+  #     Glabron: {
+  #       "University Farm": 43.07,
+  #       "Waseca": 55.20,
+  #       ... } },
+  #   1932: {
+  #     ... } }</pre>
+  #
+  # To facilitate visualization, it may be useful to flatten the tree into a
+  # tabular array:
+  #
+  # <pre>var array = pv.flatten(yields)
+  #     .key("year")
+  #     .key("variety")
+  #     .key("site")
+  #     .key("yield")
+  #     .array();</pre>
+  #
+  # This returns an array of object elements. Each element in the array has
+  # attributes corresponding to this flatten operator's keys:
+  #
+  # <pre>{ site: "University Farm", variety: "Manchuria", year: 1931, yield: 27 },
+  # { site: "Waseca", variety: "Manchuria", year: 1931, yield: 48.87 },
+  # { site: "Morris", variety: "Manchuria", year: 1931, yield: 27.43 },
+  # { site: "University Farm", variety: "Glabron", year: 1931, yield: 43.07 },
+  # { site: "Waseca", variety: "Glabron", year: 1931, yield: 55.2 }, ...</pre>
+  #
+  # <p>The flatten operator is roughly the inverse of the {@link pv.Nest} and
+  # {@link pv.Tree} operators.
+  #
+  class Flatten
+    def initialize(map)
+      @map=map
+      @keys=[]
+      @leaf=nil
+    end
+    # Flattens using the specified key function. Multiple keys may be added to the
+    # flatten; the tiers of the underlying tree must correspond to the specified
+    # keys, in order. The order of the returned array is undefined; however, you
+    # can easily sort it.
+    #
+    # @param {string} key the key name.
+    # @param {function} [f] an optional value map function.
+    # @returns {pv.Nest} this.
+    
+    def key(k, f=nil)
+      @keys.push(OpenStruct.new({:name=>key,:value=>f}))
+      @leaf=nil
+      self
+    end
+
+    # Flattens using the specified leaf function. This is an alternative to
+    # specifying an explicit set of keys; the tiers of the underlying tree will be
+    # determined dynamically by recursing on the values, and the resulting keys
+    # will be stored in the entries <tt>keys</tt> attribute. The leaf function must
+    # return true for leaves, and false for internal nodes.
+    #
+    # @param {function} f a leaf function.
+    # @returns {pv.Nest} this.
+    def leaf(f)
+      @keys.clear
+      @leaf=f
+      self
+    end
+    def recurse(value,i)
+      if @leaf.call(value)
+        @entries.push({:keys=>@stack.dup, :value=>value})
+      else
+        value.each {|key,v|
+          @stack.push(key)
+          recurse(v, i+1)
+          @stack.pop
+        }
+      end
+    end
+    def visit(value,i)
+      if (i < @keys.size - 1)
+        value.each {|key,v|
+          @stack.push(key)
+          visit(v,i+1)
+          @stack.pop
+        }
+      else 
+        @entries.push(@stack+value)
+      end
+    end
+    # Returns the flattened array. Each entry in the array is an object; each
+    # object has attributes corresponding to this flatten operator's keys.
+    #
+    # @returns an array of elements from the flattened map.
+    def array
+      @entries=[]
+      @stack=[]
+      if @leaf
+        recurse(@map,0)
+        return @entries
+      end
+      visit(@map,0)
+      @entries.map {|stack|
+        m={}
+        @keys.each_with_index {|k,i|
+          v=@stack[i]
+          m[k.name]=k.value ? k.value.js_call(self,v) : v
+        }
+        m
+      }
+    end
+    alias :to_a :array
+  end
+end

data/lib/rubyvis/layout.rb

@@ -37,5 +37,7 @@ require 'rubyvis/layout/hierarchy'
 require 'rubyvis/layout/treemap'
 require 'rubyvis/layout/partition'
 require 'rubyvis/layout/cluster'
+require 'rubyvis/layout/indent'
+require 'rubyvis/layout/pack'
 
 

data/lib/rubyvis/layout/indent.rb

@@ -0,0 +1,81 @@
+module Rubyvis
+  class Layout
+    # Alias for Rubyvis::Layout::Indent 
+    def self.Indent
+      Rubyvis::Layout::Indent
+    end
+    # Implements a hierarchical layout using the indent algorithm. This
+    # layout implements a node-link diagram where the nodes are presented in
+    # preorder traversal, and nodes are indented based on their depth from the
+    # root. This technique is used ubiquitously by operating systems to represent
+    # file directories; although it requires much vertical space, indented trees
+    # allow efficient <i>interactive</i> exploration of trees to find a specific
+    # node. In addition they allow rapid scanning of node labels, and multivariate
+    # data such as file sizes can be displayed adjacent to the hierarchy.
+    #
+    # <p>The indent layout can be configured using the <tt>depth</tt> and
+    # <tt>breadth</tt> properties, which control the increments in pixel space for
+    # each indent and row in the layout. This layout does not support multiple
+    # orientations; the root node is rendered in the top-left, while
+    # <tt>breadth</tt> is a vertical offset from the top, and <tt>depth</tt> is a
+    # horizontal offset from the left.
+    #
+    # <p>For more details on how to use this layout, see
+    # Rubyvis::Layout::Hierarchy
+    class Indent < Hierarchy
+      @properties=Hierarchy.properties.dup 
+      # Constructs a new, empty indent layout. Layouts are not typically constructed
+      # directly; instead, they are added to an existing panel via
+      # Rubyvis::Mark.add
+      def initialize
+        super
+        @link.interpolate("step-after")
+      end
+      
+      ##
+      # :attr: depth
+      # The horizontal offset between different levels of the tree; defaults to 15.
+      #
+      
+      ##
+      # :attr: breadth
+      # The vertical offset between nodes; defaults to 15.
+      #
+      
+      attr_accessor_dsl :depth, :breadth
+      
+      # Default properties for indent layouts. By default the depth and breadth
+      # offsets are 15 pixels.
+      def self.defaults
+        Rubyvis::Layout::Indent.new.mark_extend(Rubyvis::Layout::Hierarchy.defaults).
+          depth(15).
+          breadth(15)
+      end
+      
+      def position(n, breadth, depth)
+        n.x = @ax + depth * @dspace
+        depth+=1
+        n.y = @ay + breadth * @bspace
+        breadth+=1
+        n.mid_angle = 0
+        c=n.first_child
+        while c
+          breadth=position(c,breadth,depth)
+          c=c.next_sibling
+        end
+        breadth;
+      end
+      private :position
+      def build_implied(s)
+        return nil if hierarchy_build_implied(s)
+        nodes = s.nodes
+        @bspace = s.breadth
+        @dspace = s.depth
+        @ax = 0
+        @ay = 0
+        position(nodes[0], 1, 1)
+      end
+      
+    end
+  end
+end

data/lib/rubyvis/layout/network.rb

@@ -75,7 +75,22 @@ module Rubyvis
     # @see Rubyvis::Layout::Rollup
     class Network < Rubyvis::Layout
       @properties=Layout.properties.dup
-      attr_accessor :node, :link, :node_label
+      # The node prototype. This prototype is intended to be used with a 
+      # Dot mark in conjunction with the link prototype.
+      attr_accessor :node
+      # The link prototype, which renders edges between source nodes and target
+      # nodes. This prototype is intended to be used with a Line mark in
+      # conjunction with the node prototype.      
+      attr_accessor :link
+      # The node label prototype, which renders the node name adjacent to the node.
+      # This prototype is provided as an alternative to using the anchor on the
+      # node mark; it is primarily intended to be used with radial node-link
+      # layouts, since it provides a convenient mechanism to set the text angle.
+      #
+      # NOTE FOR PROTOVIS USERS: The original name of method was +label+
+      # but it was replaced to not conflict with rubyvis shortcut
+      # method Mark.label()       
+      attr_accessor :node_label
       attr_accessor :_id
       def initialize
         super
@@ -84,9 +99,8 @@ module Rubyvis
         @link=_link
         @node_label=_node_label
       end
-      # The node prototype. This prototype is intended to be used with a 
-      # Dot mark in conjunction with the link prototype.      
-      def _node
+           
+      def _node #:nodoc:
         that=self        
         m=Mark.new().
           data(lambda {that.nodes}).
@@ -97,7 +111,7 @@ module Rubyvis
         m.parent = self
         m 
       end
-      module LinkAdd
+      module LinkAdd # :nodoc:
         attr_accessor :that
         def add(type)
           that=@that
@@ -108,11 +122,9 @@ module Rubyvis
         end
       end
       
-     # The link prototype, which renders edges between source nodes and target
-     # nodes. This prototype is intended to be used with a Line mark in
-     # conjunction with the node prototype.
+    
       
-      def _link
+      def _link # :nodoc:
         that=self
         l=Mark.new().
           mark_extend(@node).
@@ -125,14 +137,8 @@ module Rubyvis
         l
       end
 
-      # The node label prototype, which renders the node name adjacent to the node.
-      # This prototype is provided as an alternative to using the anchor on the
-      # node mark; it is primarily intended to be used with radial node-link
-      # layouts, since it provides a convenient mechanism to set the text angle.
-      #
-      # NOTE FOR PROTOVIS USERS: The original name of method was +label+
-      # but it was replaced to not conflict with Mark.label() 
-      def _node_label
+     
+      def _node_label #:nodoc:
         that=self
         nl=Mark.new().
           mark_extend(@node).
@@ -149,12 +155,17 @@ module Rubyvis
         nl.parent = self
         nl
       end
+      
       ##
-      # :class: Node
-      # Represents a node in a network layout. There is no explicit
-      # constructor; this class merely serves to document the attributes that are
-      # used on nodes in network layouts. (Note that hierarchical nodes place
-      # additional requirements on node representation, vis Rubyvis::Dom::Node
+      # :attr: nodes
+      #
+      # an array of objects representing nodes. Objects in this  array must conform to the Rubyvis::Layout::Network::Node interface; which is
+      # to say, be careful to avoid naming collisions with automatic attributes such
+      # as <tt>index</tt> and <tt>link_degree</tt>. If the nodes property is defined
+      # as an array of 'primitives' (objects which doesn't respond to node_value)
+      # these primitives are automatically wrapped in an OpenStruct object; 
+      # the resulting object's <tt>node_value</tt>
+      # attribute points to the original primitive value.
       
       attr_accessor_dsl [:nodes, lambda {|v|
         out=[]
@@ -165,6 +176,18 @@ module Rubyvis
         }
         out
       }]
+      
+      ##
+      # :attr: links
+      #
+      # an array of objects representing links. Objects in
+      # this array must conform to the Rubyvis::Layout::Network::Link interface; at a
+      # minimum, either <tt>source</tt> and <tt>target</tt> indexes or
+      # <tt>source_node</tt> and <tt>target_node</tt> references must be set. 
+      # Note that if the links property is defined after the nodes property, 
+      # the links can be defined in terms of <tt>self.nodes()</tt>.
+
+
       attr_accessor_dsl [:links, lambda {|v|
         out=[]
         v.map {|d|
@@ -189,7 +212,7 @@ module Rubyvis
       
       # @private Skip evaluating properties if cached. */
       
-      def build_properties(s, properties)
+      def build_properties(s, properties) # :nodoc:
         s_id=s._id
         s_id||=0
         if (s_id < self._id)
@@ -197,10 +220,10 @@ module Rubyvis
         end
       end
       
-      def build_implied(s)        
+      def build_implied(s) # :nodoc:
         network_build_implied(s)
       end
-      def network_build_implied(s)
+      def network_build_implied(s) # :nodoc:
         layout_build_implied(s)
         return true if (!s._id.nil? and s._id >= self._id)
         s._id= self._id
@@ -224,8 +247,8 @@ module Rubyvis
         false
       end
       
-      # Represents a node in a network layout. There is no explicit
-      # constructor; this class merely serves to document the attributes that are
+      # Represents a node in a network layout. 
+      # This class mostly  serves to document the attributes that are
       # used on nodes in network layouts. (Note that hierarchical nodes place
       # additional requirements on node representation, vis Rubyvis::Dom::Node.)
       #
@@ -245,23 +268,19 @@ module Rubyvis
         
         # The node name; optional. If present, this attribute will be used to provide
         # the text for node labels. If not present, the label text will fallback to the
-        # <tt>nodeValue</tt> attribute.
+        # <tt>node_value</tt> attribute.
         #
         # @type string
         attr_accessor :node_name
         
-        # The node value; optional. If present, and no <tt>nodeName</tt> attribute is
-        # present, the node value will be used as the label text. This attribute is
-        # also automatically populated if the nodes are specified as an array of
-        # primitives, such as strings or numbers.
-        #
-        # @type object
+        # The node value; optional. If present, and no <tt>node_name</tt> attribute is present, the node value will be used as the label text.
+        # This attribute is also automatically populated if the nodes are specified as an array of 'primitives', such as strings or numbers.
         attr_accessor :node_value
       end
     
       
-      # Represents a link in a network layout. There is no explicit
-      # constructor; this class merely serves to document the attributes that are
+      # Represents a link in a network layout. 
+      # This class mostly serves to document the attributes that are
       # used on links in network layouts. For hierarchical layouts, this class is
       # used to represent the parent-child links.
       #
@@ -277,21 +296,21 @@ module Rubyvis
         # default value of 1 is used.
         #
         # @type number
-        # @name pv.Layout.Network.Link.prototype.linkValue
-        #/
+
+
         attr_accessor :link_value
       
         # The link's source node. If not set, this value will be derived from the
         # <tt>source</tt> attribute index.
         #
         # @type pv.Layout.Network.Node
-        # @name pv.Layout.Network.Link.prototype.sourceNode
+
         attr_accessor :source_node
         # The link's target node. If not set, this value will be derived from the
         # <tt>target</tt> attribute index.
         #
         # @type pv.Layout.Network.Node
-        # @name pv.Layout.Network.Link.prototype.targetNode
+
         attr_accessor :target_node
         # Alias for <tt>sourceNode</tt>, as expressed by the index of the source node.
         # This attribute is not populated automatically, but may be used as a more
@@ -299,7 +318,7 @@ module Rubyvis
         # representation.
         #
         # @type number
-        # @name pv.Layout.Network.Link.prototype.source
+
         attr_accessor :source
         # Alias for <tt>targetNode</tt>, as expressed by the index of the target node.
         # This attribute is not populated automatically, but may be used as a more
@@ -307,7 +326,7 @@ module Rubyvis
         # representation.
         #
         # @type number
-        # @name pv.Layout.Network.Link.prototype.target
+
         attr_accessor :target
         # Alias for <tt>linkValue</tt>. This attribute is not populated automatically,
         # but may be used instead of the <tt>linkValue</tt> attribute when specifying

data/lib/rubyvis/layout/pack.rb

@@ -0,0 +1,333 @@
+module Rubyvis
+  class Layout
+    # Alias for Rubyvis::Layout::Indent 
+    def self.Pack
+      Rubyvis::Layout::Pack
+    end
+
+    # Implements a hierarchical layout using circle-packing. The meaning of
+    # the exported mark prototypes changes slightly in the space-filling
+    # implementation:<ul>
+    #
+    # <li><tt>node</tt> - for rendering nodes; typically a {@link pv.Dot}.
+    #
+    # <p><li><tt>link</tt> - unsupported; undefined. Links are encoded implicitly
+    # in the arrangement of the space-filling nodes.
+    #
+    # <p><li><tt>label</tt> - for rendering node labels; typically a
+    # {@link pv.Label}.
+    #
+    # </ul>The pack layout support dynamic sizing for leaf nodes, if a
+    # {@link #size} psuedo-property is specified. The default size function returns
+    # 1, causing all leaf nodes to be sized equally, and all internal nodes to be
+    # sized by the number of leaf nodes they have as descendants.
+    #
+    # <p>The size function can be used in conjunction with the order property,
+    # which allows the nodes to the sorted by the computed size. Note: for sorting
+    # based on other data attributes, simply use the default <tt>null</tt> for the
+    # order property, and sort the nodes beforehand using the {@link pv.Dom}
+    # operator.
+    #
+    # <p>For more details on how to use this layout, see
+    # {@link pv.Layout.Hierarchy}.
+    #
+    # @extends pv.Layout.Hierarchy
+    # @see <a href="http://portal.acm.org/citation.cfm?id=1124772.1124851"
+    # >"Visualization of large hierarchical data by circle packing"</a> by W. Wang,
+    # H. Wang, G. Dai, and H. Wang, ACM CHI 2006.
+    #/
+    class Pack < Hierarchy
+      @properties=Hierarchy.properties.dup 
+      def initialize
+        super
+        @node.
+        shape_radius(lambda {|n| n.radius }).
+        stroke_style("rgb(31, 119, 180)").
+        fill_style("rgba(31, 119, 180, 0.25)")
+
+      
+      @node_label.text_align("center")
+        
+        @link=nil
+        
+        @radius = lambda { 1 }
+      end
+      
+      
+      ##
+      # :attr: spacing
+      # The spacing parameter; defaults to 1, which provides a little bit of padding
+      # between sibling nodes and the enclosing circle. Larger values increase the
+      # spacing, by making the sibling nodes smaller; a value of zero makes the leaf
+      # nodes as large as possible, with no padding on enclosing circles.
+      #
+      # @type number
+      
+      ##
+      # :attr: order
+      # The sibling node order. The default order is <tt>null</tt>, which means to
+      # use the sibling order specified by the nodes property as-is. A value of
+      # "ascending" will sort siblings in ascending order of size, while "descending"
+      # will do the reverse. For sorting based on data attributes other than size,
+      # use the default <tt>null</tt> for the order property, and sort the nodes
+      # beforehand using the {@link pv.Dom} operator.
+      #
+      # @see pv.Dom.Node#sort
+      
+      
+      attr_accessor_dsl :spacing, :order
+      
+      ##
+      # Default properties for circle-packing layouts. The default spacing parameter
+      # is 1 and the default order is "ascending".
+      #
+      def self.defaults
+        Rubyvis::Layout::Pack.new.mark_extend(Rubyvis::Layout::Hierarchy.defaults).
+        spacing(1).
+        order("ascending")
+      end
+            
+      
+      # TODO is it possible for spacing to operate in pixel space?
+      # Right now it appears to be multiples of the smallest radius.
+      
+      ##
+      # Specifies the sizing function. By default, a sizing function is disabled and
+      # all nodes are given constant size. The sizing function is invoked for each
+      # leaf node in the tree (passed to the constructor).
+      #
+      # <p>For example, if the tree data structure represents a file system, with
+      # files as leaf nodes, and each file has a <tt>bytes</tt> attribute, you can
+      # specify a size function as:
+      #
+      # <pre>    .size(function(d) d.bytes)</pre>
+      #
+      # As with other properties, a size function may specify additional arguments to
+      # access the data associated with the layout and any enclosing panels.
+      #
+      # @param {function} f the new sizing function.
+      # @returns {pv.Layout.Pack} this.
+      def size(f)
+        if f.is_a? Proc
+          @radius=lambda {|*args| Math.sqrt(f.js_apply(self,args))} 
+        else
+          f=Math.sqrt(f)
+          @radius=lambda {f}
+        end
+        self
+      end
+      ## @private Compute the radii of the leaf nodes. #/
+      
+      def radii(nodes)
+        stack=Mark.stack
+        stack.unshift(nil)
+        nodes.each {|c|
+          if !c.first_child
+            stack[0]=c
+            c.radius = @radius.js_apply(self, stack)
+          end
+        }
+        stack.shift
+      end
+      def pack_tree(n)
+        nodes = []
+        c=n.first_child
+        while(c)
+          c.radius=pack_tree(c) if c.first_child
+          c.n=c._p=c
+          nodes.push(c)
+          c=c.next_sibling
+        end
+      
+        # Sort.
+        case @s.order
+        when "ascending"
+          nodes.sort {|a,b| a.radius<=>b.radius}
+        when 'descending'
+          nodes.sort {|a,b| b.radius<=>a.radius}
+        when 'reverse'
+          nodes.reverse
+        end
+        
+        return pack_circle(nodes)
+      end
+      def bound(n)
+        @x_min = [n.x - n.radius, @x_min].min
+        @x_max = [n.x + n.radius, @x_max].max
+        @y_min = [n.y - n.radius, @y_min].min
+        @y_max = [n.y + n.radius, @y_max].max
+      end
+      def insert(a,b)
+        c = a.n
+        a.n = b
+        b._p = a
+        b.n = c
+        c._p = b
+      end
+      def splice(a, b) 
+        a.n = b
+        b._p = a
+      end
+      def intersects(a, b)
+        dx = b.x - a.x
+        dy = b.y - a.y
+        dr = a.radius + b.radius
+        (dr * dr - dx * dx - dy * dy) > 0.001 # within epsilon
+      end
+      
+      ## @private #/
+      def place(a, b, c)
+        da = b.radius + c.radius
+        db = a.radius + c.radius
+        dx = b.x - a.x
+        dy = b.y - a.y
+        dc = Math.sqrt(dx * dx + dy * dy)
+        cos = (db * db + dc * dc - da * da) / (2.0 * db * dc)
+        
+        theta = Math.acos(cos)
+        x = cos * db
+        h = Math.sin(theta) * db
+        dx /= dc
+        dy /= dc
+        c.x = a.x + x * dx + h * dy
+        c.y = a.y + x * dy - h * dx
+      end
+      
+      # @private #/
+      def transform(n, x, y, k) 
+        c=n.first_child
+        while(c) do 
+          c.x += n.x
+          c.y += n.y
+          transform(c, x, y, k)
+          c=c.next_sibling
+        end
+        n.x = x + k * n.x
+        n.y = y + k * n.y
+        n.radius *= k
+        n.mid_angle=0 # Undefined on protovis
+      end
+      
+
+      def pack_circle(nodes) 
+        @x_min = Infinity
+        @x_max = -Infinity
+        @y_min = Infinity
+        @y_max = -Infinity
+        a=b=c=j=k=nil
+      
+      
+        # Create first node.
+        a = nodes[0];
+        a.x = -a.radius
+        a.y = 0
+        bound(a)
+      
+        # Create second node. #/
+        if (nodes.size > 1)
+          b = nodes[1]
+          b.x = b.radius
+          b.y = 0
+          bound(b)
+      
+          # Create third node and build chain.
+          if (nodes.size > 2)
+            c = nodes[2]
+            place(a, b, c)
+            bound(c)
+            insert(a, c)
+            a._p = c
+            insert(c, b)
+            b = a.n
+      
+            # Now iterate through the rest.
+            i=3
+            while(i<nodes.size) do
+              c=nodes[i]
+              place(a, b, c)
+              
+              # Search for the closest intersection. #/
+              isect = 0
+              s1 = 1
+              s2 = 1
+              
+              j=b.n
+              while(j!=b) do
+                if (intersects(j,c))
+                  isect=1;
+                  break;
+                end
+                j=j.n
+                s1+=1
+              end
+              
+              if isect==1
+                k=a._p
+                while(k!=k._p) do
+                  if(intersects(k,c))
+                    if(s2<s1)
+                      isect=-1
+                      k=j
+                    end
+                    break
+                  end
+                  k=k._p
+                  s2+=1
+                end
+              end
+              
+      
+              # Update node chain. #/
+              if (isect == 0) 
+                insert(a, c)
+                b = c
+                bound(c)
+              elsif (isect > 0)
+                splice(a, j)
+                b = j
+                i-=1
+              elsif (isect < 0)
+                splice(j, b)
+                a = j
+                i-=1
+              end
+              i+=1
+            end
+            
+            
+          end
+        end
+      
+        # Re-center the circles and return the encompassing radius. #/
+        cx = (@x_min + @x_max) / 2.0
+        cy = (@y_min + @y_max) / 2.0
+        cr = 0
+        nodes.each do |n|
+          n.x -= cx
+          n.y -= cy
+          cr = [cr, n.radius + Math.sqrt(n.x * n.x + n.y * n.y)].max
+        end
+        cr + @s.spacing
+      end
+      
+      
+      def build_implied(s)
+        return nil if hierarchy_build_implied(s)
+        @s=s
+        nodes = s.nodes
+        root = nodes[0]
+        radii(nodes)
+      
+        # Recursively compute the layout. #/
+        root.x = 0
+        root.y = 0
+        root.radius = pack_tree(root)
+        
+        w = self.width
+        h = self.height
+        k = 1.0 / [2.0 * root.radius / w, 2.0 * root.radius / h].max
+        transform(root, w / 2.0, h / 2.0, k)
+      end
+    end
+  end
+end

data/lib/rubyvis/mark.rb

@@ -460,8 +460,12 @@ module Rubyvis
       end
     end
     # Execute a block using this mark as a reference
+    # <b>Example</b>
+    #   bar.execute |b|
+    #     b.width 10
+    #     b.add(Rubyvis::Label)
+    #   end
     def execute(&block)
-      
       block.arity<1 ? self.instance_eval(&block) : block.call(self)      
     end
     # The mark type; a lower name. The type name controls rendering
@@ -486,7 +490,9 @@ module Rubyvis
     # or its prototype, and so on. The prototype mark need not be the same 
     # type of mark as this mark. (Note that for inheritance to be useful,
     # properties with the same name on different mark types should 
-    # have equivalent meaning.)
+    # have equivalent meaning).
+    # On protovis, this method is called +extend+, but it should be changed
+    # because clashed with native +extend+ method
     def mark_extend(proto)
       @proto=proto
       @target=proto.target

data/lib/rubyvis/mark/shorcut_methods.rb

@@ -212,5 +212,33 @@ class Rubyvis::Mark
   # See Mark for examples of use    
   mark_method :layout_cluster, Rubyvis::Layout::Cluster
   
+  ##
+  # :method: layout_indent(opts,&block)  
+  #
+  # Adds a Layout::Indent 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_indent, Rubyvis::Layout::Indent
+
+  ##
+  # :method: layout_pack(opts,&block)  
+  #
+  # Adds a Layout::Pack 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_pack, Rubyvis::Layout::Pack
+
   
 end

data/lib/rubyvis/scene/svg_scene.rb

@@ -86,14 +86,40 @@ module Rubyvis
 
     def self.append(e,scenes,index)
       e._scene=OpenStruct.new({:scenes=>scenes, :index=>index})
-      #e=self.title
+      e=self.title(e,scenes[index])
 
       if(!e.parent)
         scenes._g.add_element(e)
       end
       return e.next_sibling_node
     end
-
+    
+    # Applies a title tooltip to the specified element <tt>e</tt>, using the
+    # <tt>title</tt> property of the specified scene node <tt>s</tt>. Note that
+    # this implementation does not create an SVG <tt>title</tt> element as a child
+    # of <tt>e</tt>; although this is the recommended standard, it is only
+    # supported in Opera. Instead, an anchor element is created around the element
+    # <tt>e</tt>, and the <tt>xlink:title</tt> attribute is set accordingly.
+    #
+    # @param e an SVG element.
+    # @param s a scene node.
+    
+    def self.title(e,s)
+      a = e.parent
+      a=nil if (a and (a.tag_name != "a"))
+      if (s.title) 
+        if (!a) 
+          a = self.create("a")
+          e.parent.replace_child(a, e) if (e.parent)
+          a.add_element(e)
+        end
+        a.add_attribute('xlink:title',s.title)
+        return a;
+      end
+      a.parent_node.replace_child(e, a) if (a) 
+      e
+    end
+    
     def self.expect(e, type, attributes, style=nil)
 
       if (e)

data/lib/rubyvis/sceneelement.rb

@@ -8,7 +8,7 @@ module Rubyvis
     end
     include Enumerable
     attr_accessor :visible
-    attr_accessor :mark, :type, :child_index, :parent, :parent_index, :target, :defs, :data,  :antialias, :line_width, :fill_style, :overflow, :width, :height, :top, :bottom, :left, :right, :title, :reverse, :stroke_style, :transform, :canvas, :_g, :events, :cursor, :children, :id, :segmented, :interpolate, :tension, :name, :text_baseline, :text_align, :text, :font, :text_angle, :text_style, :text_margin, :text_decoration, :text_shadow, :line_join, :eccentricity, :shape_size, :shape, :shape_angle, :shape_radius, :start_angle, :end_angle, :angle, :inner_radius, :outer_radius, :layers, :orient, :offset, :order,:url, :image_width, :image_height, :image, :_id, :nodes, :round, :links, :padding_left, :padding_right, :padding_top, :padding_bottom, :mode, :group
+    attr_accessor :mark, :type, :child_index, :parent, :parent_index, :target, :defs, :data,  :antialias, :line_width, :fill_style, :overflow, :width, :height, :top, :bottom, :left, :right, :title, :reverse, :stroke_style, :transform, :canvas, :_g, :events, :cursor, :children, :id, :segmented, :interpolate, :tension, :name, :text_baseline, :text_align, :text, :font, :text_angle, :text_style, :text_margin, :text_decoration, :text_shadow, :line_join, :eccentricity, :shape_size, :shape, :shape_angle, :shape_radius, :start_angle, :end_angle, :angle, :inner_radius, :outer_radius, :layers, :orient, :offset, :order,:url, :image_width, :image_height, :image, :_id, :nodes, :round, :links, :padding_left, :padding_right, :padding_top, :padding_bottom, :mode, :group, :depth, :breadth, :spacing
     
     def []=(v,i)
       if v.is_a? Numeric

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rubyvis
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 3
-  - 2
-  version: 0.3.2
+  - 3
+  version: 0.3.3
 platform: ruby
 authors: 
 - Claudio Bustos
@@ -152,8 +152,10 @@ files:
 - examples/bar_column_chart.rb
 - examples/barley/barley.rb
 - examples/barley/barley_data.rb
+- examples/bubble_charts.rb
 - examples/cars/cars.rb
 - examples/cars/cars_data.rb
+- examples/circle_packing.rb
 - examples/crimea/crimea_data.rb
 - examples/crimea/crimea_grouped_bar.rb
 - examples/crimea/crimea_line.rb
@@ -165,6 +167,7 @@ files:
 - examples/grouped_charts.rb
 - examples/icicle.rb
 - examples/image.rb
+- examples/indent.rb
 - examples/line.rb
 - examples/line_and_step.rb
 - examples/line_interpolation.rb
@@ -181,6 +184,7 @@ files:
 - lib/rubyvis/color/color.rb
 - lib/rubyvis/color/colors.rb
 - lib/rubyvis/dom.rb
+- lib/rubyvis/flatten.rb
 - lib/rubyvis/format.rb
 - lib/rubyvis/format/date.rb
 - lib/rubyvis/format/number.rb
@@ -190,7 +194,9 @@ files:
 - lib/rubyvis/layout.rb
 - lib/rubyvis/layout/cluster.rb
 - lib/rubyvis/layout/hierarchy.rb
+- lib/rubyvis/layout/indent.rb
 - lib/rubyvis/layout/network.rb
+- lib/rubyvis/layout/pack.rb
 - lib/rubyvis/layout/partition.rb
 - lib/rubyvis/layout/stack.rb
 - lib/rubyvis/layout/treemap.rb