rubyplot 0.0.1 → 0.1.pre.a1

data/lib/rubyplot/artist/plot/bar.rb

@@ -0,0 +1,69 @@
+module Rubyplot
+  module Artist
+    module Plot
+      class Bar < Artist::Plot::Base
+        # Space between the columns.
+        attr_accessor :bar_spacing
+        # Width of each bar in pixels.
+        attr_accessor :bar_width
+        # Number between 0 and 1.0 denoting spacing between the bars.
+        # 0.0 means no spacing at all 1.0 means that each bars' width
+        # is nearly 0 (so each bar is a simple line with no X dimension).
+        # Denotes the total left + right side space.
+        attr_reader :spacing_ratio
+        # X co-ordinates of the lower left corner of the bar.
+        attr_accessor :abs_x_left
+        # Y co-ordinates of the lower left corner of the bar.
+        attr_accessor :abs_y_left
+
+        def initialize(*)
+          super
+          @spacing_ratio = 0.1
+          @abs_x_left = []
+          @abs_y_left = []
+          @rectangles = []
+        end
+
+        # Set the spacing factor for this bar plot.
+        def spacing_factor=(s_f)
+          raise ValueError, '@spacing_factor must be between 0.00 and 1.00' unless
+            (s_f >= 0) && (s_f <= 1)
+
+          @spacing_factor = s_f
+        end
+
+        # Set Bar plot data.
+        def data y_values
+          super(Array.new(y_values.size) { |i| i }, y_values)
+        end
+
+        # Number of bars in this Bar plot
+        def num_bars
+          @data[:y_values].size
+        end
+
+        def draw
+          setup_bar_rectangles
+          @rectangles.each(&:draw)
+        end
+
+        private
+
+        def setup_bar_rectangles
+          @normalized_data[:y_values].each_with_index do |iy, i|
+            height = iy * @axes.y_axis.length
+            @rectangles << Rubyplot::Artist::Rectangle.new(
+              self,
+              abs_x: @abs_x_left[i],
+              abs_y: @abs_y_left[i] - height,
+              width: @bar_width,
+              height: height,
+              border_color: @data[:color],
+              fill_color: @data[:color]
+            )
+          end
+        end
+      end # class Bar
+    end # module Plot
+  end # module Artist
+end # module Rubyplot

data/lib/rubyplot/artist/plot/bar_type.rb

@@ -0,0 +1,31 @@
+module Rubyplot
+  module Artist
+    module Plot
+      class BarType < Artist::Plot::Base
+        def initialize(*)
+          super
+          @spacing_ratio = 0.1
+          @abs_x_left = []
+          @abs_y_left = []
+          @rectangles = []
+        end
+
+        def data y_values
+          super(Array(0...(y_values.size)), y_values)
+        end
+
+        def num_bars
+          @data[:y_values].size
+        end
+
+        def draw
+          setup_bar_rectangles
+          @rectangles.each(&:draw)
+        end
+
+        protected
+
+      end # class BarType
+    end # module Plot
+  end # module Artist
+end # module Rubyplot

data/lib/rubyplot/artist/plot/base.rb

@@ -0,0 +1,67 @@
+module Rubyplot
+  module Artist
+    module Plot
+      class Base < Artist::Base
+        attr_reader :axes, :data, :x_max, :x_min, :y_min, :y_max
+        attr_writer :stroke_width, :stroke_opacity
+
+        def initialize axes
+          super(axes.abs_x, axes.abs_y)
+          @axes = axes
+          @data = {
+            label: '',
+            color: :default
+          }
+          @normalized_data = {
+            y_values: nil,
+            x_values: nil
+          }
+          @stroke_width = 4.0
+          @stroke_opacity = 0.0
+        end
+
+        def label
+          @data[:label]
+        end
+
+        def color
+          @data[:color]
+        end
+
+        def label=(label)
+          @data[:label] = label
+        end
+
+        def color= color
+          @data[:color] = color
+        end
+
+        def data(x_values, y_values)
+          @data[:x_values] = x_values
+          @data[:y_values] = y_values
+          @y_min = @data[:y_values].min
+          @y_max = @data[:y_values].max
+          @x_min = @data[:x_values].min
+          @x_max = @data[:x_values].max
+        end
+
+        # Normalize original data to values between 0-1. Used for obtaining relative
+        # values of the data.
+        def normalize
+          x_spread = @axes.x_range[1] - @axes.x_range[0]
+          y_spread = @axes.y_range[1] - @axes.y_range[0]
+          if @data[:x_values]
+            @normalized_data[:x_values] = @data[:x_values].map do |x|
+              (x.to_f - @axes.x_range[0]) / x_spread
+            end
+          end
+          if @data[:y_values]
+            @normalized_data[:y_values] = @data[:y_values].map do |y|
+              (y.to_f - @axes.y_range[0]) / y_spread
+            end
+          end
+        end
+      end # class Base
+    end # module Plot
+  end # module Artist
+end # module Rubyplot

data/lib/rubyplot/artist/plot/bubble.rb

@@ -0,0 +1,41 @@
+module Rubyplot
+  module Artist
+    module Plot
+      class Bubble < Artist::Plot::Base
+        # Width in pixels of the border of each bubble.
+        attr_reader :stroke_width
+        attr_reader :z_max, :z_min
+        def initialize(*)
+          super
+          @bubbles = []
+          @stroke_width = 1.0
+        end
+
+        def data x_values, y_values, z_values
+          super(x_values, y_values)
+          @data[:z_values] = z_values
+          @z_max = @data[:z_values].max
+          @z_min = @data[:z_values].min
+        end
+
+        def draw
+          @normalized_data[:y_values].each_with_index do |iy, idx_y|
+            ix = @normalized_data[:x_values][idx_y]
+            iz = @data[:z_values][idx_y]
+            abs_x = ix * @axes.x_axis.length + @axes.abs_x + @axes.y_axis_margin
+            abs_y = (@axes.y_axis.length - iy * @axes.y_axis.length) + @axes.abs_y
+            @bubbles << Rubyplot::Artist::Circle.new(
+              self,
+              abs_x: abs_x,
+              abs_y: abs_y,
+              radius: iz,
+              color: @data[:color],
+              stroke_width: @stroke_width
+            )
+          end
+          @bubbles.each(&:draw)
+        end
+      end # class Bubble
+    end # module Plot
+  end # module Artist
+end # module Rubyplot

data/lib/rubyplot/artist/plot/line.rb

@@ -0,0 +1,61 @@
+module Rubyplot
+  module Artist
+    module Plot
+      class Line < Artist::Plot::Base
+        # Set true if you want to see only the vertices of the line plot.
+        attr_writer :hide_lines
+
+        def initialize(*)
+          super
+          @hide_lines = false
+        end
+
+        def data(x_values, y_values=[])
+          y_values = Array.new(x_values.size) { |i| i } if y_values.empty?
+          super x_values, y_values
+        end
+
+        def draw
+          if @normalized_data[:x_values].size == 1
+            draw_single_point
+          else
+            draw_lines
+          end
+        end
+
+        private
+
+        # FIXME: make this edge case happen.
+        def draw_single_point
+          # Rubyplot::Artist::Circle.new()
+        end
+
+        def draw_lines
+          prev_x = prev_y = nil
+          @normalized_data[:x_values].each_with_index do |ix, idx_ix|
+            iy = @normalized_data[:y_values][idx_ix]
+            next if ix.nil? || iy.nil?
+
+            new_x = ix * (@axes.x_axis.abs_x2 - @axes.x_axis.abs_x1).abs + @axes.abs_x +
+                    @axes.y_axis_margin
+            new_y = (@axes.y_axis.length - iy * @axes.y_axis.length) + @axes.abs_y
+
+            unless prev_x.nil? && prev_y.nil?
+              Rubyplot::Artist::Line2D.new(
+                self,
+                abs_x1: prev_x,
+                abs_y1: prev_y,
+                abs_x2: new_x,
+                abs_y2: new_y,
+                stroke_opacity: @stroke_opacity,
+                stroke_width: @stroke_width
+              ).draw
+            end
+            prev_x = new_x
+            prev_y = new_y
+          end
+        end
+      end # class Line
+    end # module Plot
+  end # module Artist
+end # module Rubyplot

data/lib/rubyplot/artist/plot/multi_bars.rb

@@ -0,0 +1,75 @@
+module Rubyplot
+  module Artist
+    module Plot
+      # Class for holding multiple Bar plot objects.
+      # Terminoligies used:
+      #
+      # * A 'bar' is a single bar of a single bar plot.
+      # * A 'slot' is a box within which multiple bars can be plotted.
+      # * 'padding' is the total whitespace on the left and right of a slot.
+      class MultiBars < Artist::Plot::Base
+        # The max. width that each bar can occupy.
+        attr_reader :max_bar_width
+
+        def initialize(*args, bar_plots:)
+          super(args[0])
+          @bar_plots = bar_plots
+          @x_min = @bar_plots.map(&:x_min).min
+          @y_min = @bar_plots.map(&:y_min).min
+          @x_max = @bar_plots.map(&:x_max).max
+          @y_max = @bar_plots.map(&:y_max).max
+          configure_plot_geometry_data!
+          configure_x_ticks!
+        end
+
+        def normalize
+          @bar_plots.each(&:normalize)
+        end
+
+        def draw
+          @bar_plots.each(&:draw)
+        end
+
+        private
+
+        def configure_plot_geometry_data!
+          @num_max_slots = @bar_plots.map(&:num_bars).max
+          @max_slot_width = (@axes.x_axis.abs_x2 - @axes.x_axis.abs_x1).abs / @num_max_slots
+          # FIXME: figure out a way to specify inter-box space somehow.
+          @spacing_ratio = @bar_plots[0].spacing_ratio
+          @padding = @spacing_ratio * @max_slot_width
+          @max_bars_width = @max_slot_width - @padding
+          @bars_per_slot = @bar_plots.size
+          @bar_plots.each_with_index do |bar, index|
+            set_bar_dims bar, index
+          end
+        end
+
+        def configure_x_ticks!
+          @axes.num_x_ticks = @num_max_slots
+          labels = @axes.x_ticks || Array.new(@num_max_slots, &:to_s)
+          labels = labels[0...@axes.num_x_ticks] if labels.size != @axes.num_x_ticks
+          @axes.x_ticks = labels.map.with_index do |label, i|
+            Rubyplot::Artist::XTick.new(
+              @axes,
+              abs_x: @axes.abs_x + @axes.y_axis_margin + i * @max_slot_width + @max_slot_width / 2,
+              abs_y: @axes.origin[1],
+              label: label,
+              length: 6,
+              label_distance: 10
+            )
+          end
+        end
+
+        def set_bar_dims bar_plot, index
+          bar_plot.bar_width = @max_bars_width / @bars_per_slot
+          @num_max_slots.times do |i|
+            bar_plot.abs_x_left[i] = @axes.abs_x + @axes.y_axis_margin +
+                                     i * @max_slot_width + @padding / 2 + index * bar_plot.bar_width
+            bar_plot.abs_y_left[i] = @axes.origin[1] - @axes.x_axis.stroke_width
+          end
+        end
+      end # class MultiBars
+    end # module Plot
+  end # module Artist
+end # module Rubyplot

data/lib/rubyplot/artist/plot/multi_stacked_bar.rb

@@ -0,0 +1,78 @@
+module Rubyplot
+  module Artist
+    module Plot
+      class MultiStackedBar < Artist::Plot::Base
+        def initialize(*args, stacked_bars:)
+          super(args[0])
+          @stacked_bars = stacked_bars
+          @x_min = @stacked_bars.map(&:x_min).min
+          @y_min = @stacked_bars.map(&:y_min).min
+          @x_max = @stacked_bars.map(&:x_max).max
+          @y_max = @stacked_bars.map(&:y_max).max
+          reset_axes_ranges
+          renormalize_data
+          configure_plot_geometry_data
+          configure_x_ticks
+        end
+
+        def draw
+          @stacked_bars.each(&:draw)
+        end
+
+        private
+
+        def reset_axes_ranges
+          @axes.y_range[0] = 0
+          @axes.x_range[0] = 0
+        end
+
+        # Normalize data in the stacked bar plot w.r.t each other and new X & Y ranges.
+        def renormalize_data
+          @stacked_bars.each do |p|
+            p.normalize
+            p.renormalize @stacked_bars.size
+          end
+        end
+
+        def configure_plot_geometry_data
+          @num_max_slots = @stacked_bars.map(&:num_bars).max
+          @max_slot_width = @axes.x_axis.length / @num_max_slots
+          @spacing_ratio = @stacked_bars[0].spacing_ratio
+          @padding = @spacing_ratio * @max_slot_width
+          @max_bars_width = @max_slot_width - @padding
+          @num_max_stacks = @stacked_bars.size
+          @stacked_bars.each_with_index do |bar, index|
+            set_bar_dims bar, index
+          end
+        end
+
+        def configure_x_ticks
+          @axes.num_x_ticks = @num_max_slots
+          labels = @axes.x_ticks || Array.new(@num_max_slots, &:to_s)
+          labels = labels[0...@axes.num_x_ticks] if labels.size != @axes.num_x_ticks
+          @axes.x_ticks = labels.map.with_index do |label, i|
+            Rubyplot::Artist::XTick.new(
+              @axes,
+              abs_x: @axes.abs_x + @axes.y_axis_margin + i * @max_slot_width + @max_slot_width / 2,
+              abs_y: @axes.origin[1],
+              label: label,
+              length: 6,
+              label_distance: 10
+            )
+          end
+        end
+
+        def set_bar_dims bar, plot_index
+          bar.bar_width = @max_bars_width
+          plots_below = @stacked_bars[0...plot_index]
+          bar.num_bars.times do |i|
+            pedestal_height = plots_below.map { |p| p.member_height(i) }.inject(:+) || 0
+            bar.abs_x_left[i] = @axes.abs_x + @axes.y_axis_margin +
+                                i * @max_slot_width + @padding / 2
+            bar.abs_y_left[i] = (@axes.abs_y + @axes.y_axis.length) - pedestal_height
+          end
+        end
+      end # class StackedBar
+    end # module Plot
+  end # module Artist
+end # module Rubyplot

data/lib/rubyplot/artist/plot/scatter.rb

@@ -0,0 +1,29 @@
+module Rubyplot
+  module Artist
+    module Plot
+      class Scatter < Artist::Plot::Base
+        attr_writer :circle_radius
+
+        def initialize(*)
+          super
+          @circle_radius = 4.0
+        end
+
+        def draw
+          @normalized_data[:y_values].each_with_index do |iy, idx_y|
+            ix = @normalized_data[:x_values][idx_y]
+            next if iy.nil? || ix.nil?
+
+            abs_x = ix * @axes.x_axis.length + @axes.abs_x + @axes.y_axis_margin
+            abs_y = (@axes.y_axis.length - iy * @axes.y_axis.length) + @axes.abs_y
+            Rubyplot::Artist::Circle.new(
+              self, abs_x: abs_x, abs_y: abs_y, radius: @circle_radius,
+              stroke_opacity: @stroke_opacity,
+              stroke_width: @stroke_width
+            ).draw
+          end
+        end
+      end # class Scatter
+    end # module Plot
+  end # module Artist
+end # module Rubyplot