mtah-ruby-treemap 0.0.3.1

data/lib/treemap/image_output.rb

@@ -0,0 +1,77 @@
+#
+# image_output.rb - RubyTreemap
+#
+# Copyright (c) 2006 by Andrew Bruno <aeb@qnot.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+#
+
+require 'RMagick'
+require File.dirname(__FILE__) + "/output_base"
+
+class Treemap::ImageOutput < Treemap::OutputBase
+    def initialize
+        super
+
+        # default options for ImageOutput
+
+        yield self if block_given?
+    end
+
+    def setup_draw
+        draw = Magick::Draw.new
+        draw.stroke_width(1)
+        draw.stroke("#000000")
+        draw.stroke_opacity(1)
+        draw.fill_opacity(1)
+        draw.font_family = "Verdana"
+        draw.pointsize = 12
+        draw.gravity = Magick::WestGravity
+
+        return draw
+    end
+
+    def new_image
+        Magick::Image.new(@width, @height) {self.background_color = "white"}
+    end
+
+    def to_png(node, filename="treemap.png")
+        #
+        # XXX Need to flesh out this method. Add in label drawing.
+        #
+
+        image = self.new_image
+        draw = self.setup_draw
+
+        @bounds = self.bounds
+
+        # Pad for root border
+        @bounds.x2 -= 1
+        @bounds.y2 -= 1
+
+        @layout.process(node, @bounds)
+
+        draw_map(node, draw, image)
+
+        # render image
+        draw.draw(image)
+        image.write(filename)
+    end
+
+    def draw_map(node, draw, image)
+        return "" if node.nil?
+        if(node.color.nil?)
+            draw.fill("#CCCCCC")
+        else
+            draw.fill("#" + @color.get_hex_color(node.color))
+        end
+        draw.rectangle(node.bounds.x1, node.bounds.y1, node.bounds.x2, node.bounds.y2)
+        node.children.each do |c|
+            draw_map(c, draw, image)
+        end
+    end
+end

data/lib/treemap/layout_base.rb

@@ -0,0 +1,30 @@
+#--
+# layout_base.rb - RubyTreemap
+#
+# Copyright (c) 2006 by Andrew Bruno <aeb@qnot.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+#++
+
+module Treemap
+    class LayoutBase
+        attr_accessor :position, :color
+
+        def initialize
+            # Similar to the css style position. If set to :fixed x,y bounds calculations
+            # should be computed relative to the root bounds. If set to :absolute then they
+            # should be computed relative to the parent bounds.
+            # See http://www.w3.org/TR/CSS2/visuren.html#positioning-scheme
+            @position = :fixed
+            yield self if block_given?
+        end
+
+        # Subclasses will override
+        def process(node, bounds)
+        end
+    end
+end

data/lib/treemap/node.rb

@@ -0,0 +1,141 @@
+#
+# node.rb - RubyTreemap
+#
+# Copyright (c) 2006 by Andrew Bruno <aeb@qnot.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+#
+
+require "md5"
+
+module Treemap
+    #
+    # A generic tree node class which is used to represent the data to be
+    # treemap'ed. The Layout and Output classes expect an object of this
+    # type to perform the treemap calculations on.
+    #
+    # Create a simple tree:
+    #    root = Treemap::Node.new
+    #    root.new_child(:size => 6)
+    #    root.new_child(:size => 6)
+    #    root.new_child(:size => 4)
+    #    root.new_child(:size => 3)
+    #    root.new_child(:size => 2)
+    #    root.new_child(:size => 2)
+    #    root.new_child(:size => 1)
+    #
+    # Initialize values:
+    #    root = Treemap::Node.new(:label => "All", :size => 100, :color => "#FFCCFF")
+    #    child1 = Treemap::Node.new(:label => "Child 1", :size => 50)
+    #    child2 = Treemap::Node.new(:label => "Child 2", :size => 50)
+    #    root.add_child(child1)
+    #    root.add_child(child2)
+    #
+    #
+    class Treemap::Node
+        attr_accessor :id, :label, :color, :size, :bounds, :parent, :object
+        attr_reader :children
+
+        #
+        # Create a new Node. You can initialize the node by passing in
+        # a hash with any of the following keys:
+        #
+        # * :size - The size that this node represents. For non-leaf nodes the 
+        #   size must be equal to the sum of the sizes of it's children. If size
+        #   is nil then the value will be calculated by recursing the children.
+        # * :label - The label for this node. Used when displaying. Defaults to "node"
+        # * :color - The background fill color in hex to render when drawing the 
+        #   square. If the value is a number a color will be calculated. An example
+        #   string color would be: ##FFFFFF (white)
+        # * :id - A unique id to assign to this node. Default id will be generated if
+        #   one is not provided.
+        # * :object - An object, that this node might contain.
+        #
+        #
+        def initialize(opts = {})
+            @size = opts[:size]
+            @label = opts[:label]
+            @color = opts[:color]
+            @id = opts[:id]
+            @object = opts[:object]
+            @children = []
+
+            if(@id.nil?)
+                make_id
+            end
+        end
+
+        #
+        # Returns the depth of the node. 0 for root.
+        #
+        def depth
+            return 0 if parent.nil?
+            1 + self.parent.depth
+        end
+
+        def add_child(node)
+            # XXX check to see that a node with the same label doesn't already exist.
+            #     having 2 nodes with the same label at the same depth 
+            #     doesn't seem to make sense
+            node.parent = self
+            @children.push(node)
+        end
+
+        #
+        # Creates a new node and adds it as a child. See new method.
+        #
+        def new_child(*args)
+            node = Treemap::Node.new(*args)
+            self.add_child(node)
+        end
+
+        def find
+            @children.find { |c| yield(c) }
+        end
+
+        def to_s
+            str = "[:id => " + id + " :label => " + label
+            str += " :size => " + size.to_s + " :color => " + color.to_s
+            if(not(bounds.nil?))
+                str += " :bounds => " + bounds.to_s
+            end
+            str += "]"
+            str
+        end
+
+        def size
+            return @size if !@size.nil?
+            sum = 0
+            @children.each do |c|
+                sum += c.size
+            end
+
+            sum
+        end
+        
+        # Unscientific formula to calculate the font size depending on the node's area
+        def font_size(base_size)
+            (base_size * Math.sqrt(self.bounds.width * self.bounds.height) / 125).to_i
+        end
+
+        def label
+            return @label if !@label.nil?
+            "node - " + size.to_s
+        end
+
+        def leaf?
+            return true if @children.nil?
+            !(@children.size > 0)
+        end
+
+    private
+        def make_id
+            #XXX prob should change this. Create a better way to generate unique id's
+            @id = MD5.new([self.label, rand(100000000)].join("-")).hexdigest
+        end
+    end
+end

data/lib/treemap/output_base.rb

@@ -0,0 +1,39 @@
+#
+# output_base.rb - RubyTreemap
+#
+# Copyright (c) 2006 by Andrew Bruno <aeb@qnot.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+#
+
+require 'rexml/document'
+
+module Treemap
+    class OutputBase
+        attr_accessor(:width, :height, :layout, :color, :margin_top, :margin_left)
+
+        def initialize
+            @width = 800
+            @height = 600
+            @margin_top = 0
+            @margin_left = 0
+            @layout = Treemap::SquarifiedLayout.new
+            @color = Treemap::GradientColor.new
+            yield self if block_given?
+        end
+
+    protected
+        def bounds
+            x1 = self.margin_left
+            y1 = self.margin_top
+            x2 = self.width + self.margin_left
+            y2 = self.height + self.margin_top
+            bounds = Treemap::Rectangle.new(x1, y1, x2, y2)
+            return bounds
+        end
+    end
+end

data/lib/treemap/rectangle.rb

@@ -0,0 +1,38 @@
+#
+# rectangle.rb - RubyTreemap
+#
+# Copyright (c) 2006 by Andrew Bruno <aeb@qnot.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+#
+
+module Treemap
+    class Rectangle
+        attr_accessor :x1, :y1, :x2, :y2
+
+        def initialize(x1, y1, x2, y2)
+            @x1 = x1
+            @y1 = y1
+            @x2 = x2
+            @y2 = y2
+
+            yield self if block_given?
+        end
+
+        def to_s
+            "[" + [@x1, @y1, @x2, @y2].join(",") + "]"
+        end
+
+        def width
+            @x2 - @x1
+        end
+
+        def height
+            @y2 - @y1
+        end
+    end
+end

data/lib/treemap/slice_layout.rb

@@ -0,0 +1,97 @@
+#
+# slice_layout.rb - RubyTreemap
+#
+# Copyright (c) 2006 by Andrew Bruno <aeb@qnot.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+#
+
+require File.dirname(__FILE__) + "/layout_base"
+
+class Treemap::SliceLayout < Treemap::LayoutBase
+    Vertical = 1
+    Horizontal = 2
+
+    def process(node, bounds, axis=nil)
+        bounds = bounds.clone
+
+        node.bounds = bounds.clone
+
+        if(@position == :absolute) 
+            bounds.x2 = bounds.width
+            bounds.y2 = bounds.height
+            bounds.x1 = 0
+            bounds.y1 = 0
+        end
+
+        if(!node.leaf?)
+            process_children(node.children, bounds, axis)
+        end
+    end
+
+    def sum(children)
+        sum = 0
+        children.each do |c|
+            sum += c.size
+        end
+        sum
+    end
+
+    def process_children(children, bounds, axis=nil)
+        parent_bounds = bounds.clone
+        bounds = bounds.clone
+
+        axis = axis(bounds) if(axis.nil?)
+
+        width = axis == Vertical ? bounds.width : bounds.height
+
+        sum = sum(children)
+
+        # XXX should we sort? seems to produce better map but not tested on 
+        # larger data sets
+        # children.sort {|c1,c2| c2.size <=> c1.size}.each do |c|
+        children.each do |c|
+            size = ((c.size.to_f / sum.to_f)*width).round
+
+            if(axis == Vertical) 
+                bounds.x2 = bounds.x1 + size
+            else
+                bounds.y2 = bounds.y1 + size
+            end
+
+            process(c, bounds, flip(axis))
+
+            axis == Vertical ? bounds.x1 = bounds.x2 : bounds.y1 = bounds.y2
+        end
+
+        last = children.last
+        if(axis == Vertical)
+            last.bounds.x2 = parent_bounds.x2
+        else
+           last.bounds.y2 = parent_bounds.y2
+        end
+
+    end
+
+    def flip(axis)
+        return Horizontal if axis == Vertical
+        Vertical
+    end
+    
+    def vertical?(bounds)
+        bounds.width > bounds.height
+    end
+
+    def horizontal?(bounds)
+        bounds.width < bounds.height
+    end
+
+    def axis(bounds)
+        return Horizontal if horizontal?(bounds)
+        Vertical
+    end
+end

data/lib/treemap/squarified_layout.rb

@@ -0,0 +1,141 @@
+#
+# squarified_layout.rb - RubyTreemap
+#
+# Copyright (c) 2006 by Andrew Bruno <aeb@qnot.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+#
+
+require File.dirname(__FILE__) + "/layout_base"
+
+class Treemap::SquarifiedLayout < Treemap::SliceLayout
+
+    def process(node, bounds, axis=nil)
+
+        bounds = bounds.clone
+
+        node.bounds = bounds.clone
+
+        if(@position == :absolute) 
+            bounds.x2 = bounds.width
+            bounds.y2 = bounds.height
+            bounds.x1 = 0
+            bounds.y1 = 0
+        end
+
+        if(!node.leaf?)
+            squarify_children(node, bounds, flip(axis))
+        end
+    end
+
+    def squarify_children(node, bounds, axis)
+
+        parent_bounds = bounds.clone
+        bounds = bounds.clone
+
+        node.children.sort! {|a,b| b.size <=> a.size}
+
+        if(node.children.size < 2)
+            process_children(node.children, bounds, flip(axis))
+        end
+
+        parent_size = node.size
+        first_child = node.children.first
+
+        row_size = first_child.size
+        row_max = row_size.to_f / parent_size.to_f
+        total = row_max 
+
+        prev_aspect = aspect_ratio(bounds, first_child.size.to_f / row_size.to_f, total, axis)
+        row = [first_child]
+
+        node.children[1 .. node.children.size-1].each do |c|
+            child_prop = c.size.to_f / parent_size.to_f
+            aspect = aspect_ratio(bounds, c.size.to_f / row_size.to_f, total + child_prop, axis)
+
+            if(aspect > prev_aspect)
+                newb = bounds.clone
+                if(axis == Vertical)
+                    newb.x2 = bounds.x1 + ((bounds.width * total)).round
+                else 
+                    newb.y2 = bounds.y1 + ((bounds.height * total)).round
+                end
+
+                process_children(row, newb, flip(axis))
+
+                if(axis == Vertical)
+                    bounds.x1 = newb.x2
+                else 
+                    bounds.y1 = newb.y2
+                end
+
+                axis = flip(axis)
+                parent_size -= row_size
+                row_size = c.size
+                total = row_max = row_size.to_f / parent_size.to_f
+                prev_aspect = aspect_ratio(bounds, c.size.to_f / row_size.to_f, total, axis)
+                row = [c]
+            else
+                row_size += c.size
+                total += child_prop
+                prev_aspect = aspect
+                row.push(c)
+            end
+        end
+
+        process_children(row, bounds, flip(axis))
+    end
+
+    def aspect_ratio(bounds, node_prop, row_prop, axis)
+        height = bounds.height * row_prop
+        width = bounds.width * node_prop
+        if(axis == Vertical)
+            width = bounds.width * row_prop
+            height = bounds.height * node_prop
+        end 
+
+        return 0 if width == 0 and height == 0
+
+        a = 0;
+        b = 0;
+        if(width > 0)
+            a = height.to_f / width.to_f
+        end
+        if(height > 0)
+            b = width.to_f / height.to_f
+        end
+
+        ratio = [a, b].max
+
+        ratio
+    end
+
+    def axis(bounds)
+        # XXX experiment with switching
+        # axis = super(bounds)
+        # flip(axis)
+    end
+
+    # XXX another way of computing the aspect ratio
+    def aspect_ratio_method2(bounds, max, proportion, axis)
+
+        large = bounds.height
+        small = bounds.width
+        if(axis == Vertical)
+            large = bounds.width
+            small = bounds.height
+        end 
+
+        ratio = (large * proportion).to_f / ((small * max).to_f / proportion.to_f).to_f
+
+        if(ratio < 1)
+            ratio = 1.to_f / ratio.to_f
+        end
+
+        ratio
+    end
+end