rubyvis 0.3.4 → 0.3.5

data/lib/rubyvis.rb

@@ -30,7 +30,7 @@ require 'rubyvis/mark/shorcut_methods'
 module Rubyvis
   @document=nil
   # Rubyvis version
-  VERSION = '0.3.4' 
+  VERSION = '0.3.5' 
   # 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/color/color.rb

@@ -27,24 +27,24 @@ module Rubyvis
   def self.color(format)
     return format.rgb if format.respond_to? :rgb
     if (format =~/([a-z]+)\((.*)\)/)
-      m2 = $2.split(",")
+      color_type,color_data=$1,$2
+      m2 = color_data.split(",")
       a = 1
-      if ['hsla','rgba'].include? $1
+      if ['hsla','rgba'].include? color_type
         a = m2[3].to_f
         return Color.transparent if (a==0)
       end
 
-      if ['hsla','hsl'].include? $1
-        h=m2[0].to_f
-        s=m2[0].to_f.quo(100)
-        l=m2[0].to_f.quo(100)
-        return Color::Hsl.new(h,s,l,a).rgb()
+      if ['hsla','hsl'].include? color_type
+        h=m2[0].to_i
+        s=m2[1].to_f / 100
+        l=m2[2].to_f / 100
+        return Color::Hsl.new(h,s,l,a).rgb
       end
-
-      if ['rgba','rgb'].include? $1
+     
+      if ['rgba','rgb'].include? color_type
         parse=lambda {|c|
-          f=c.to_f
-          return (c[c.size-1]=='%') ? (f*2.55).round : f
+          (c[c.size-1,1]=='%') ? (c.to_f*2.55).round : c.to_i
         }
         r=parse.call(m2[0])
         g=parse.call(m2[1])
@@ -69,7 +69,7 @@ module Rubyvis
         g = format[3,2]
         b = format[5,2]
       end
-      return Rubyvis.rgb(r.to_i(16), g.to_i(16), b.to_i(16), 1);
+      return Rubyvis.rgb(r.to_i(16), g.to_i(16), b.to_i(16), 1)
     end
 
     # Otherwise, pass-through unsupported colors. */
@@ -292,14 +292,10 @@ module Rubyvis
         @g=g
         @a=a
         @opacity=a
-        if @a>0
-          @color="rgb(#{r.to_i},#{g.to_i},#{b.to_i})"
-        else
-          @color="none"
-        end
+        @color= @a > 0 ? "rgb(#{r.to_i},#{g.to_i},#{b.to_i})" : "none"
       end
       def ==(v)
-        self.class==v.class and @r==v.r and @b==v.b and @g=v.g and @a=v.a
+        self.class==v.class and @r==v.r and @b==v.b and @g==v.g and @a==v.a
       end
       
       # Constructs a new RGB color with the same green, blue and alpha channels
@@ -333,20 +329,20 @@ module Rubyvis
       # darker are inverse operations, the results of a series of invocations of
       # these two methods might be inconsistent because of rounding errors.
       def lighter(k=1)
-          k = 0.7**k
-          i = 30
-          r=self.r
-          g=self.g
-          b=self.b
-          return Rubyvis.rgb(i, i, i, a) if (!r and !g and !b) 
-          r = i if (r and (r < i)) 
-          g = i if (g and (g < i)) 
-          b = i if (b and (b < i))
-          Rubyvis.rgb(
-            [255, (r/k).floor].min,
-            [255, (g/k).floor].min,
-            [255, (b/k).floor].min,
-            a)
+        k = 0.7**k
+        i = 30
+        r=self.r
+        g=self.g
+        b=self.b
+        return Rubyvis.rgb(i, i, i, a) if (!r and !g and !b) 
+        r = i if (r and (r < i)) 
+        g = i if (g and (g < i)) 
+        b = i if (b and (b < i))
+        Rubyvis.rgb(
+          [255, (r/k).floor].min,
+          [255, (g/k).floor].min,
+          [255, (b/k).floor].min,
+        a)
       end
       # Returns a new color that is a darker version of this color. This method
       # applies an arbitrary scale factor to each of the three RGB components of this
@@ -368,7 +364,6 @@ module Rubyvis
     end
     # Represents a color in HSL space.
     class Hsl < Color
-      
       # The hue, an integer in [0, 360].
       attr_accessor :h
       # The saturation, a float in [0, 1].
@@ -386,6 +381,9 @@ module Rubyvis
         @l=l
         @a=a
       end
+      def ==(v)
+        self.class==v.class and @h==v.h and @s==v.s and @l==v.l and @a==v.a
+      end
       
       # Returns the RGB color equivalent to this HSL color.
       def rgb
@@ -416,7 +414,7 @@ module Rubyvis
           return m1
         }
         vv=lambda {|h1|
-          (v(h1) * 255).round
+          (v.call(h1) * 255).round
         }
         
         Rubyvis.rgb(vv.call(h + 120), vv.call(h), vv.call(h - 120), a)

data/lib/rubyvis/format/number.rb

@@ -46,7 +46,7 @@ module Rubyvis
           i = Array.new(mins - i.size + 1).join(@padi) + i.to_s
         end
         
-        s[0] = x < 0 ? np + i + ns : i
+        s[0] = x < 0 ? @np + i + @ns : i
         
         #/* Pad the fractional part. */
         f = s[1].nil? ? "" : s[1]

data/lib/rubyvis/layout.rb

@@ -23,7 +23,7 @@ module Rubyvis
         end
         @properties[name]=true
         self.property_method(name,false, func, self)        
-        define_method(name.to_s+"=") {|v|
+        define_method(name.to_s + "=") {|v|
           self.send(name,v)
         }
       end
@@ -32,6 +32,7 @@ module Rubyvis
 end
 
 require 'rubyvis/layout/stack'
+require 'rubyvis/layout/horizon'
 require 'rubyvis/layout/grid'
 require 'rubyvis/layout/network'
 require 'rubyvis/layout/hierarchy'
@@ -41,5 +42,5 @@ require 'rubyvis/layout/partition'
 require 'rubyvis/layout/cluster'
 require 'rubyvis/layout/indent'
 require 'rubyvis/layout/pack'
-
+require 'rubyvis/layout/arc'
 

data/lib/rubyvis/layout/arc.rb

@@ -0,0 +1,188 @@
+module Rubyvis
+  class Layout
+    # Alias for Rubyvis::Layout::Arc
+    def self.Arc
+      Rubyvis::Layout::Arc
+    end
+    
+    # @class Implements a layout for arc diagrams. An arc diagram is a network
+    # visualization with a one-dimensional layout of nodes, using circular arcs to
+    # render links between nodes. For undirected networks, arcs are rendering on a
+    # single side; this makes arc diagrams useful as annotations to other
+    # two-dimensional network layouts, such as rollup, matrix or table layouts. For
+    # directed networks, links in opposite directions can be rendered on opposite
+    # sides using <tt>directed(true)</tt>.
+    #
+    # <p>Arc layouts are particularly sensitive to node ordering; for best results,
+    # order the nodes such that related nodes are close to each other. A poor
+    # (e.g., random) order may result in large arcs with crossovers that impede
+    # visual processing. A future improvement to this layout may include automatic
+    # reordering using, e.g., spectral graph layout or simulated annealing.
+    #
+    # <p>This visualization technique is related to that developed by
+    # M. Wattenberg, <a
+    # href="http://www.research.ibm.com/visual/papers/arc-diagrams.pdf">"Arc
+    # Diagrams: Visualizing Structure in Strings"</a> in <i>IEEE InfoVis</i>, 2002.
+    # However, this implementation is limited to simple node-link networks, as
+    # opposed to structures with hierarchical self-similarity (such as strings).
+    #
+    # <p>As with other network layouts, three mark prototypes are provided:<ul>
+    #
+    # <li><tt>node</tt> - for rendering nodes; typically a {@link pv.Dot}.
+    # <li><tt>link</tt> - for rendering links; typically a {@link pv.Line}.
+    # <li><tt>label</tt> - for rendering node labels; typically a {@link pv.Label}.
+    #
+    # </ul>For more details on how this layout is structured and can be customized,
+    # see {@link pv.Layout.Network}.
+    
+    class Arc < Network
+      @properties=Network.properties.dup      
+      attr_accessor :_interpolate, :_directed, :_reverse
+      def initialize
+        super
+        @_interpolate=nil # cached interpolate
+        @_directed=nil # cached directed
+        @_reverse=nil # cached reverse
+        @_sort=nil
+        that=self
+        @link.data(lambda {|_p|
+            s=_p.source_node;t=_p.target_node
+            that._reverse != (that._directed or (s.breadth < t.breadth)) ? [s, t] : [t, s]
+        }).interpolate(lambda{ that._interpolate})
+      end
+      
+      def build_implied(s)
+        return true if network_build_implied(s)
+        # Cached
+        
+        nodes = s.nodes
+        orient = s.orient
+        sort = @_sort
+        index = Rubyvis.range(nodes.size)
+        w = s.width
+        h = s.height
+        r = [w,h].min / 2.0 
+        # /* Sort the nodes. */
+        if (sort)
+          index.sort! {|a,b| sort.call(nodes[a],nodes[b])}
+        end
+        
+        
+        
+        #/** @private Returns the mid-angle, given the breadth. */
+        mid_angle=lambda do |b| 
+          case orient 
+            when "top"
+              -Math::PI / 2.0
+            when "bottom"
+              Math::PI / 2.0
+            when "left"
+              Math::PI
+            when "right"
+              0
+            when "radial"
+              (b - 0.25) * 2.0 * Math::PI
+          end
+        end
+        
+        # /** @private Returns the x-position, given the breadth. */
+        x= lambda do |b|
+        case orient 
+          when "top"
+            b * w
+          when "bottom"
+           b * w
+          when "left"
+          0;
+          when "right"
+          w;
+          when "radial"
+            w / 2.0 + r * Math.cos(mid_angle.call(b))
+          end
+        end
+        
+        # /** @private Returns the y-position, given the breadth. */
+        y=lambda do |b| 
+          case orient 
+          when "top"
+            0;
+          when "bottom"
+            h;
+          when "left"
+            b* h
+          when "right"
+            b * h
+          when "radial"
+            h / 2.0 + r * Math.sin(mid_angle.call(b))
+          end
+        end
+        
+        #/* Populate the x, y and mid-angle attributes. */
+        nodes.each_with_index do |nod, i|
+          n=nodes[index[i]]
+          n.breadth=(i+0.5) / nodes.size
+          b=n.breadth
+          n.x=x[b]
+          n.y=y[b]
+          n.mid_angle=mid_angle[b]
+        end        
+        
+        @_directed = s.directed
+        @_interpolate = s.orient == "radial" ? "linear" : "polar"
+        @_reverse = s.orient == "right" or s.orient == "top"
+        
+      end
+      
+      ##
+      # :attr: orient
+      # The orientation. The default orientation is "left", which means that nodes
+      # will be positioned from left-to-right in the order they are specified in the
+      # <tt>nodes</tt> property. 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, starting at 12 o'clock and proceeding clockwise.</ul>
+      
+      ##
+      # :attr: directed
+      # Whether this arc digram is directed (bidirectional); only applies to
+      # non-radial orientations. By default, arc digrams are undirected, such that
+      # all arcs appear on one side. If the arc digram is directed, then forward
+      # links are drawn on the conventional side (the same as as undirected
+      # links--right, left, bottom and top for left, right, top and bottom,
+      # respectively), while reverse links are drawn on the opposite side.
+      
+      attr_accessor_dsl :orient, :directed
+      
+      def self.defaults
+        Arc.new.mark_extend(Network.defaults).
+          orient("bottom")
+      end
+      
+      # Specifies an optional sort function. The sort function follows the same
+      # comparator contract required by {@link pv.Dom.Node#sort}. Specifying a sort
+      # function provides an alternative to sort the nodes as they are specified by
+      # the <tt>nodes</tt> property; the main advantage of doing this is that the
+      # comparator function can access implicit fields populated by the network
+      # layout, such as the <tt>linkDegree</tt>.
+      #
+      # <p>Note that arc diagrams are particularly sensitive to order. This is
+      # referred to as the seriation problem, and many different techniques exist to
+      # find good node orders that emphasize clusters, such as spectral layout and
+      # simulated annealing.
+      #
+      # @param {function} f comparator function for nodes.
+      # @returns {pv.Layout.Arc} this.
+      def sort(f=nil,&block)
+        f||=block
+        @_sort=f
+        self
+      end
+      
+      
+    end
+  end
+end
+

data/lib/rubyvis/layout/horizon.rb

@@ -0,0 +1,153 @@
+module Rubyvis
+  class Layout
+    # Alias for Rubyvis::Layout::Horizon
+    def self.Horizon
+      Rubyvis::Layout::Horizon
+    end
+    
+    # Implements a horizon layout, which is a variation of a single-series
+    # area chart where the area is folded into multiple bands. Color is used to
+    # encode band, allowing the size of the chart to be reduced significantly
+    # without impeding readability. This layout algorithm is based on the work of
+    # J. Heer, N. Kong and M. Agrawala in <a  href="http://hci.stanford.edu/publications/2009/heer-horizon-chi09.pdf">"Sizing
+    # the Horizon: The Effects of Chart Size and Layering on the Graphical
+    # Perception of Time Series Visualizations"</a>, CHI 2009.
+    #
+    # <p>This layout exports a single <tt>band</tt> mark prototype, which is
+    # intended to be used with an area mark. The band mark is contained in a panel
+    # which is replicated per band (and for negative/positive bands). For example,
+    # to create a simple horizon graph given an array of numbers:
+    #
+    #   vis.add(Rubyvis::Layout::Horizon)
+    #     .bands(n)
+    #   .band.add(Rubyvis::Area)
+    #     .data(data)
+    #     .left(lambda { index * 35})
+    #     .height(lambda {|d| d * 40})
+    #
+    # The layout can be further customized by changing the number of bands, and
+    # toggling whether the negative bands are mirrored or offset. (See the
+    # above-referenced paper for guidance.)
+    #
+    # <p>The <tt>fill_style</tt> of the area can be overridden, though typically it
+    # is easier to customize the layout's behavior through the custom
+    # <tt>background_style</tt>, <tt>positive_style</tt> and <tt>negative_style</tt>
+    # properties. By default, the background is white, positive bands are blue, and
+    # negative bands are red. For the most accurate presentation, use fully-opaque
+    # colors of equal intensity for the negative and positive bands.
+    class Horizon < Layout
+      @properties=Layout.properties.dup      
+      # The band prototype. This prototype is intended to be used with an Area
+      # mark to render the horizon bands.
+      attr_accessor :band
+      attr_accessor :_bands, :_mode, :_size, :_fill, :_red, :_blue
+      def initialize
+        super
+        @_bands=nil
+        @_mode=nil # cached mode
+        @_size=nil # cached height
+        @_fill=nil # cached background style
+        @_red=nil # cached negative color (ramp)
+        @_blue=nil # cached positive color (ramp)
+        @_bands_panel=_bands_panel
+        @band=_band
+      end
+      def build_implied(s)
+        layout_build_implied(s) 
+        @_bands=s.bands
+        @_mode=s.mode
+        @_size=((@_mode == "color" ? 0.5 : 1) * s.height).round
+        @_fill=s.background_style
+        @_red=Rubyvis.ramp(@_fill, s.negative_style).domain(0,@_bands)
+        @_blue=Rubyvis.ramp(@_fill, s.positive_style).domain(0,@_bands)
+        
+      end
+      def _bands_panel
+        that=self
+        Rubyvis::Panel.new().
+          data(lambda {Rubyvis.range(that._bands.to_f * 2)}).
+          overflow("hidden").
+          height(lambda {that._size}).
+          top(lambda {|i| that._mode=='color' ? (i & 1) * that._size : 0 }).
+          fill_style(lambda {|i| i!=0 ? nil : that._fill})
+      end
+      
+      def _band
+        that=self
+        m=Rubyvis::Mark.new().
+        top(lambda  {|d,i|
+          (that._mode == "mirror" and (i & 1)!=0) ? (i + 1 >> 1) * that._size : nil
+        }).
+        bottom(lambda {|d,i|
+            crit= (i & 1)!= 0 ? i & 1 : -1
+          (that._mode == "mirror") ? ((i & 1)!=0 ? nil : (i + 1 >> 1) * -that._size) : (crit * (i + 1 >> 1) * that._size)
+        }).
+        fill_style(lambda {|d,i|
+            ((i & 1)!=0 ? that._red : that._blue).scale((i >> 1) + 1)
+        })
+        
+        class << m # :nodoc:
+          def that_and_bands(that,bands)
+            @that = that
+            @bands=bands
+          end
+          def add(type)
+            bands=@bands
+            that = @that
+            that.add( Rubyvis.Panel ).mark_extend(bands). add(type). mark_extend(self)
+          end
+        end
+        
+        m.that_and_bands(self, @_bands_panel)
+        m
+      end
+      
+      ##
+      # :attr: mode
+      # The horizon mode: offset, mirror, or color. The default is "offset".
+      
+      ##
+      # :attr: bands
+      # The number of bands. Must be at least one. The default value is two.
+      #
+      
+      ##
+      # :attr: positive_style
+      # The positive band color; if non-null, the interior of positive bands are
+      # filled with the specified color. The default value of this property is blue.
+      # For accurate blending, this color should be fully opaque.
+      #
+      
+      ##
+      # :attr: negative_style
+      # The negative band color; if non-null, the interior of negative bands are
+      # filled with the specified color. The default value of this property is red.
+      # For accurate blending, this color should be fully opaque.
+      #
+      
+      ##
+      # :attr: background_style
+      # The background color. The panel background is filled with the specified
+      # color, and the negative and positive bands are filled with an interpolated
+      # color between this color and the respective band color. The default value of
+      # this property is white. For accurate blending, this color should be fully
+      # opaque.
+      #
+      
+      attr_accessor_dsl :bands, :mode, :background_style, [:background_style, lambda {|d| Rubyvis.color(d)}], [:positive_style, lambda {|d| Rubyvis.color(d)}], [:negative_style, lambda {|d| Rubyvis.color(d)}]
+
+      # Default properties for horizon layouts. By default, there are two bands, the
+      # mode is "offset", the background style is "white", the positive style is
+      # blue, negative style is red.
+      def self.defaults
+        Horizon.new.mark_extend(Layout.defaults).
+          bands(2).
+          mode('offset').
+          background_style('white').
+          positive_style('#1f77b4').
+          negative_style('#d62728')
+      end
+    end
+  end
+end
+