rubyvis 0.2.2 → 0.3.0

data/lib/rubyvis/layout.rb

@@ -4,6 +4,9 @@ module Rubyvis
   end
   class Layout < Rubyvis::Panel
     @properties=Panel.properties.dup
+    def build_properties(s,properties)
+      layout_build_properties(s,properties)
+    end
     def layout_build_properties(s,properties)
       mark_build_properties(s,properties)
     end
@@ -29,3 +32,8 @@ module Rubyvis
 end
 
 require 'rubyvis/layout/stack'
+require 'rubyvis/layout/network'
+require 'rubyvis/layout/hierarchy'
+require 'rubyvis/layout/treemap'
+
+

data/lib/rubyvis/layout/hierarchy.rb

@@ -0,0 +1,247 @@
+module Rubyvis
+  class Layout
+    # Alias for Rubyvis::Layout::Hierarchy
+    def self.Hierarchy
+      Rubyvis::Layout::Hierarchy
+    end
+    # Represents an abstract layout for hierarchy diagrams. This class is a
+    # specialization of Rubyvis::Layout::Network, providing the basic structure
+    # for both hierarchical node-link diagrams (such as Reingold-Tilford trees) and
+    # space-filling hierarchy diagrams (such as sunbursts and treemaps).
+    #
+    # <p>Unlike general network layouts, the +links+ property need not be
+    # defined explicitly. Instead, the links are computed implicitly from the
+    # +parent_node+ attribute of the node objects, as defined by the
+    # +nodes+ property. This implementation is also available as
+    # +Hierarchy.links, for reuse with non-hierarchical layouts; for example, to
+    # render a tree using force-directed layout.
+    #
+    # <p>Correspondingly, the +nodes+ property is represented as a union of
+    # Rubyvis::Layout::Network::Node} and Rubyvis::Dom::Node. To construct a node
+    # hierarchy from a simple JSON map, use the Rubyvis::Dom operator; this
+    # operator also provides an easy way to sort nodes before passing them to the
+    # layout.
+    #
+    # <p>For more details on how to use this layout, see
+    # Rubyvis::Layout::Network
+    #
+    # @see Rubyvis::Layout::Cluster
+    # @see Rubyvis::Layout::Partition
+    # @see Rubyvis::Layout::Tree
+    # @see Rubyvis::Layout::Treemap
+    # @see Rubyvis::Layout::Indent
+    # @see Rubyvis::Layout::Pack
+    class Hierarchy < Network
+      @properties=Network.properties.dup
+      def initialize
+        super
+        @link.stroke_style("#ccc")
+      end
+      def build_implied(s)
+        hierarchy_build_implied(s)
+      end
+      # @private Compute the implied links. (Links are null by default.) */
+      def hierarchy_build_implied(s)
+        s.links=self.links() if !s.links
+        network_build_implied(s)
+      end
+
+      # The implied links; computes links using the <tt>parent_node</tt> attribute.
+      def links
+        l=self.nodes().find_all {|n| n.parent_node}
+        l.map {|n|
+          OpenStruct.new({
+              :source_node=>n,
+              :target_node=>n.parent_node,
+              :link_value=>1
+        })}
+      end
+      def node_link
+        NodeLink.new(self)
+      end
+      def fill
+        Fill.new(self)
+      end
+    end
+    
+    class NodeLink
+      attr_accessor :ir, :_or, :orient, :w, :h
+      def initialize(obj)
+        @obj=obj
+      end
+      def build_implied(s)
+        nodes = s.nodes
+        orient= s.orient
+        orient=~/^(top|bottom)$/
+        
+        horizontal = $1
+        w = s.width
+        h = s.height
+        # /* Compute default inner and outer radius. */
+        if (orient == "radial") 
+          ir = s.inner_radius
+          _or = s.outer_radius
+          ir||=0
+          _or||=[w,h].min / 2.0
+        end
+        nodes.length.times {|i|
+          n = nodes[i]
+          n.mid_angle = (orient == "radial") ? mid_angle(n) : (horizontal ? Math::PI / 2.0 : 0)
+          n.x = x(n)
+          n.y = y(n)
+          n.mid_angle+=Math::PI if (n.first_child)
+        }      
+      end
+      def radius(n)
+        n.parent_node ? (n.depth * (_or-ir)+ir) : 0
+      end
+      def min_angle(n)
+        n.parent_node ? ((n.breadth - 0.25) * 2 * Math::PI ) : 0
+      end
+      def x(n)
+        case orient
+          when "left"
+            n.depth*w
+          when "right"
+            w-n.depth*w
+          when "top"
+            n.breadth*w
+          when "bottom"
+            w-n.breath*w
+          when "radial"
+            w/2.0+radius(n)*Math.cos(n.mid_angle)
+        end
+      end
+      def y(n)
+        case orient
+          when "left"
+            n.breadth*h
+          when "right"
+            h-n.depth*h
+          when "top"
+            n.depth*h            
+          when "bottom"
+            h-n.breath*h
+          when "radial"
+            h / 2.0 + radius(n) * Math.sin(n.mid_angle)
+        end # end case
+      end # end method
+    end # end class
+    
+    class Fill
+      attr_accessor :ir, :_or, :orient, :w, :h
+      def initialize(obj)
+        @obj=obj
+      end
+      def constructor
+        self.node.
+        stroke_style("#fff").
+        fill_style("#ccc").
+        width(lambda {|n| n.dx}).
+        height(lambda {|n| n.dy}).
+        inner_radius(lambda {|n| n.inner_radius}).
+        outer_radius(lambda {|n| n.outer_radius}).
+        start_angle(lambda {|n| n.start_angle}).
+        angle(lambda {return n.angle})
+      self.node_label.
+        text_align("center").
+        left(lambda {|n| n.x+ (n.dx / 2.0) })
+        top(lambda {|n| n.y+(n.dy / 0.2)})
+        # delete this.link
+      end
+      def build_implied(s)
+        nodes = s.nodes
+        orient= s.orient
+        orient=~/^(top|bottom)$/
+        horizontal = $1
+        w = s.width
+        h = s.height
+        depth = -nodes[0].min_depth
+        if (orient == "radial") 
+          ir = s.inner_radius
+          _or = s.outer_radius
+          ir||=0
+          depth = depth * 2 if ir!=0
+          _or||=[w,h].min / 2.0
+        end
+        nodes.each_with_index {|n,i|
+          n.x = x(n)
+          n.y = y(n)
+          if (orient == "radial") 
+            n.inner_radius = inner_radius(n);
+            n.outer_radius = outer_radius(n);
+            n.start_angle = start_angle(n);
+            n.angle = angle(n);
+            n.mid_Angle = n.start_angle + n.angle / 2.0;
+          else 
+            n.mid_angle = horizontal ? -Math::PI / 2.0 : 0;
+          end
+          n.dx = dx(n)
+          n.dy = dy(n)
+        }
+      end
+      
+      def scale(d, depth)
+        (d+depth) / (1.0+depth)
+      end
+      def x(n)
+        case orient
+          when "left"
+            scale(n.min_depth,depth)*w
+          when "right"
+            (1-scale(n.max_depth,depth))*w
+          when "top"
+            n.min_breadth*w
+          when "bottom"
+            (1-n.max_breath)*w
+          when "radial"
+            w / 2.0
+        end
+      end
+      def y(n)
+        case orient
+          when "left"
+            n.min_breadth*h
+          when "right"
+            (1-n.max_breadth)*h
+          when "top"
+            scale(n.min_depth, depth) * h            
+          when "bottom"
+            (1-scale(n.max_depth, depth)) * h
+          when "radial"
+            h / 2.0
+        end # end case
+      end # end method
+      def dx(n)
+        if orient=='left' or orient=='right'
+          (n.max_depth - n.min_depth) / (1.0 + depth) * w;
+        elsif orient=='top' or orient=='bottom'
+          (n.max_breadth - n.min_breadth) * w
+        elsif orient=='radial'
+          n.parent_node ? (n.inner_radius + n.outer_radius) * Math.cos(n.mid_angle) : 0
+        end          
+      end
+      def dy(n)
+        if orient=='left' or orient=='right'
+          (n.max_breadth - n.min_breadth) * h;
+        elsif orient=='top' or orient=='bottom'
+          (n.max_depth - n.min_depth) / (1.0 + depth) * h;
+        elsif orient=='radial'
+          n.parent_node ? (n.inner_radius + n.outer_radius) * Math.sin(n.mid_angle) : 0
+        end        
+      end
+      def inner_radius(n)
+        [0, scale(n.min_depth, depth/2.0)].max * (_or - _ir) + ir
+      end
+      def outer_radius(n)
+        scale(n.max_depth, depth / 2.0) * (_or - ir) + ir
+      end
+      def start_angle(n)
+        (n.parent_node ? n.min_breadth - 0.25 : 0) * 2 * Math::PI
+      end
+      def angle(n)
+        (n.parent_node ? n.max_breadt - n.min_breadth : 1 ) * 2 * Math::PI
+      end
+    end
+  end
+end

data/lib/rubyvis/layout/network.rb

@@ -0,0 +1,228 @@
+module Rubyvis
+  class Layout
+    # Alias for Rubyvis::Layout::Network 
+    def self.Network
+      Rubyvis::Layout::Network
+    end
+
+    # Represents an abstract layout for network diagrams. This class
+    # provides the basic structure for both node-link diagrams (such as
+    # force-directed graph layout) and space-filling network diagrams (such as
+    # sunbursts and treemaps). Note that "network" here is a general term that
+    # includes hierarchical structures; a tree is represented using links from
+    # child to parent.
+    #
+    # <p>Network layouts require the graph data structure to be defined using two
+    # properties:<ul>
+    #
+    # <li><tt>nodes</tt> - an array of objects representing nodes. Objects in this
+    # array must conform to the {@link pv.Layout.Network.Node} interface; which is
+    # to say, be careful to avoid naming collisions with automatic attributes such
+    # as <tt>index</tt> and <tt>linkDegree</tt>. If the nodes property is defined
+    # as an array of primitives, such as numbers or strings, these primitives are
+    # automatically wrapped in an object; the resulting object's <tt>nodeValue</tt>
+    # attribute points to the original primitive value.
+    #
+    # <p><li><tt>links</tt> - an array of objects representing links. Objects in
+    # this array must conform to the {@link pv.Layout.Network.Link} interface; at a
+    # minimum, either <tt>source</tt> and <tt>target</tt> indexes or
+    # <tt>sourceNode</tt> and <tt>targetNode</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>this.nodes()</tt>.
+    #
+    # </ul>
+    #
+    # <p>Three standard mark prototypes are provided:<ul>
+    #
+    # <li><tt>node</tt> - for rendering nodes; typically a {@link pv.Dot}. The node
+    # mark is added directly to the layout, with the data property defined via the
+    # layout's <tt>nodes</tt> property. Properties such as <tt>strokeStyle</tt> and
+    # <tt>fillStyle</tt> can be overridden to compute properties from node data
+    # dynamically.
+    #
+    # <p><li><tt>link</tt> - for rendering links; typically a {@link pv.Line}. The
+    # link mark is added to a child panel, whose data property is defined as
+    # layout's <tt>links</tt> property. The link's data property is then a
+    # two-element array of the source node and target node. Thus, poperties such as
+    # <tt>strokeStyle</tt> and <tt>fillStyle</tt> can be overridden to compute
+    # properties from either the node data (the first argument) or the link data
+    # (the second argument; the parent panel data) dynamically.
+    #
+    # <p><li><tt>label</tt> - for rendering node labels; typically a
+    # {@link pv.Label}. The label mark is added directly to the layout, with the
+    # data property defined via the layout's <tt>nodes</tt> property. Properties
+    # such as <tt>strokeStyle</tt> and <tt>fillStyle</tt> can be overridden to
+    # compute properties from node data dynamically.
+    #
+    # </ul>Note that some network implementations may not support all three
+    # standard mark prototypes; for example, space-filling hierarchical layouts
+    # typically do not use a <tt>link</tt> prototype, as the parent-child links are
+    # implied by the structure of the space-filling <tt>node</tt> marks.  Check the
+    # specific network layout for implementation details.
+    #
+    # <p>Network layout properties, including <tt>nodes</tt> and <tt>links</tt>,
+    # are typically cached rather than re-evaluated with every call to render. This
+    # is a performance optimization, as network layout algorithms can be
+    # expensive. If the network structure changes, call {@link #reset} to clear the
+    # cache before rendering. Note that although the network layout properties are
+    # cached, child mark properties, such as the marks used to render the nodes and
+    # links, <i>are not</i>. Therefore, non-structural changes to the network
+    # layout, such as changing the color of a mark on mouseover, do not need to
+    # reset the layout.
+    #
+    # @see Rubyvis::Layout::Hierarchy
+    # @see Rubyvis::Layout::Force
+    # @see Rubyvis::Layout::Matrix
+    # @see Rubyvis::Layout::Arc
+    # @see Rubyvis::Layout::Rollup
+    class Network < Rubyvis::Layout
+      @properties=Layout.properties.dup
+      attr_accessor :node, :link, :node_label
+      attr_accessor :_id
+      def initialize
+        super
+        @_id=Rubyvis.id()
+        @node=_node
+        @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
+        that=self        
+        m=Mark.new().
+          data(lambda {that.nodes}).
+          stroke_style("#1f77b4").
+          fill_style("#fff").
+          left(lambda {|n| n.x }).
+          top(lambda {|n| n.y })
+        m.parent = self
+        m 
+      end
+      module LinkAdd
+        attr_accessor :that
+        def add(type)
+          that=@that
+          return that.add(Rubyvis::Panel).
+          data(lambda {that.links}).
+          add(type).
+          mark_extend(self)
+        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
+        that=self
+        l=Mark.new().
+          mark_extend(@node).
+          data(lambda {|_p| [_p.source_node, p.target_node] }).
+          fill_style(nil).
+          line_width(lambda {|d,_p| p.link_value * 1.5 }).
+          stroke_style("rgba(0,0,0,.2)")
+        l.extend LinkAdd
+        l.that=self
+        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
+        that=self
+        nl=Mark.new.mark_extend(@node).
+          text_margin(7).
+          text_baseline("middle").
+          text(lambda {|n| n.node_name ? n.node_name : n.node_value }).
+          text_angle(lambda {|n| 
+            a = n.mid_angle
+            Rubyvis::Wedge.upright(a) ? a : (a + Math::PI)
+          }).
+          text_align(lambda {|n| 
+            Rubyvis::Wedge.upright(n.mid_angle) ? "left" : "right"
+          })
+        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_accessor_dsl [:nodes, lambda {|v|
+        out=[]
+        v.each_with_index {|d,i|
+          d=OpenStruct.new({:node_value=>d}) unless d.respond_to? :node_value
+          d.index=i
+          out.push(d)
+        }
+        out
+      }]
+      attr_accessor_dsl [:links, lambda {|v|
+        out=[]
+        v.map {|d|
+          if !d.link_value.is_a? Numeric
+            d.link_value = !d.value.is_a?(Numeric) ? 1 : d.value
+          end
+          d
+        }
+      }]
+
+      # Resets the cache, such that changes to layout property definitions will be
+      # visible on subsequent render. Unlike normal marks (and normal layouts),
+      # properties associated with network layouts are not automatically re-evaluated
+      # on render; the properties are cached, and any expensive layout algorithms are
+      # only run after the layout is explicitly reset.
+      #
+      # (@returns Rubyvis::Layout::Network) self
+      def reset
+        self._id=Rubyvis.id()
+        self
+      end
+      
+      # @private Skip evaluating properties if cached. */
+      
+      def build_properties(s, properties)
+        s_id=s._id
+        s_id||=0
+        if (s_id < self._id)
+          layout_build_properties(s,properties)
+        end
+      end
+      
+      def build_implied(s)
+        network_build_implied(s)
+      end
+      def network_build_implied(s)
+        layout_build_implied(s)
+        return true if (!s._id.nil? and s._id >= self._id)
+        s._id= self._id
+        s.nodes.each do |d|
+          d.link_degree=0
+        end
+        
+        s.links.each do |d|
+          v=d.link_value
+          if !d.source_node
+            d.source_node=s.nodes[d.source]
+          end
+          d.source_node.link_degree+=v
+          if !d.target_node
+            d.target_node=s.nodes[d.target]
+          end
+          d.target_node.link_degree+=v
+          
+        end
+        false
+      end
+    end
+  end
+end