charty 0.2.0 → 0.2.1

data/lib/charty/backends/pyplot.rb

@@ -12,7 +12,7 @@ module Charty
       end
 
       def initialize
-        @plot = ::Matplotlib::Pyplot
+        @pyplot = ::Matplotlib::Pyplot
       end
 
       def self.activate_iruby_integration
@@ -28,91 +28,221 @@ module Charty
       end
 
       def render_layout(layout)
-        _fig, axes = @plot.subplots(nrows: layout.num_rows, ncols: layout.num_cols)
+        _fig, axes = @pyplot.subplots(nrows: layout.num_rows, ncols: layout.num_cols)
         layout.rows.each_with_index do |row, y|
           row.each_with_index do |cel, x|
-            plot = layout.num_rows > 1 ? axes[y][x] : axes[x]
-            plot(plot, cel, subplot: true)
+            ax = layout.num_rows > 1 ? axes[y][x] : axes[x]
+            plot(ax, cel, subplot: true)
           end
         end
-        @plot.show
+        @pyplot.show
       end
 
       def render(context, filename)
-        plot(@plot, context)
+        plot(@pyplot, context)
         if filename
           FileUtils.mkdir_p(File.dirname(filename))
-          @plot.savefig(filename)
+          @pyplot.savefig(filename)
         end
-        @plot.show
+        @pyplot.show
       end
 
-      def save(context, filename)
-        plot(@plot, context)
+      def save(context, filename, finish: true)
+        plot(context)
         if filename
           FileUtils.mkdir_p(File.dirname(filename))
-          @plot.savefig(filename)
+          @pyplot.savefig(filename)
         end
+        @pyplot.clf if finish
       end
 
-      def plot(plot, context, subplot: false)
+      def plot(ax, context, subplot: false)
         # TODO: Since it is not required, research and change conditions.
         # case
-        # when plot.respond_to?(:xlim)
-        #   plot.xlim(context.range_x.begin, context.range_x.end)
-        #   plot.ylim(context.range_y.begin, context.range_y.end)
-        # when plot.respond_to?(:set_xlim)
-        #   plot.set_xlim(context.range_x.begin, context.range_x.end)
-        #   plot.set_ylim(context.range_y.begin, context.range_y.end)
+        # when @pyplot.respond_to?(:xlim)
+        #   @pyplot.xlim(context.range_x.begin, context.range_x.end)
+        #   @pyplot.ylim(context.range_y.begin, context.range_y.end)
+        # when @pyplot.respond_to?(:set_xlim)
+        #   @pyplot.set_xlim(context.range_x.begin, context.range_x.end)
+        #   @pyplot.set_ylim(context.range_y.begin, context.range_y.end)
         # end
 
-        plot.title(context.title) if context.title
+        ax.title(context.title) if context.title
         if !subplot
-          plot.xlabel(context.xlabel) if context.xlabel
-          plot.ylabel(context.ylabel) if context.ylabel
+          ax.xlabel(context.xlabel) if context.xlabel
+          ax.ylabel(context.ylabel) if context.ylabel
         end
 
+        palette = Charty::Palette.default
+        colors = palette.colors.map {|c| c.to_rgb.to_hex_string }.cycle
         case context.method
         when :bar
           context.series.each do |data|
-            plot.bar(data.xs.to_a.map(&:to_s), data.ys.to_a, label: data.label)
+            ax.bar(data.xs.to_a.map(&:to_s), data.ys.to_a, label: data.label,
+                   color: colors.next)
           end
-          plot.legend()
+          ax.legend()
         when :barh
           context.series.each do |data|
-            plot.barh(data.xs.to_a.map(&:to_s), data.ys.to_a)
+            ax.barh(data.xs.to_a.map(&:to_s), data.ys.to_a, color: colors.next)
           end
         when :box_plot
-          plot.boxplot(context.data.to_a, labels: context.labels)
+          min_l = palette.colors.map {|c| c.to_rgb.to_hsl.l }.min
+          lum = min_l*0.6
+          gray = Colors::RGB.new(lum, lum, lum).to_hex_string
+          draw_box_plot(context, subplot, colors, gray)
         when :bubble
           context.series.each do |data|
-            plot.scatter(data.xs.to_a, data.ys.to_a, s: data.zs.to_a, alpha: 0.5, label: data.label)
+            ax.scatter(data.xs.to_a, data.ys.to_a, s: data.zs.to_a, alpha: 0.5,
+                       color: colors.next, label: data.label)
           end
-          plot.legend()
+          ax.legend()
         when :curve
           context.series.each do |data|
-            plot.plot(data.xs.to_a, data.ys.to_a)
+            ax.plot(data.xs.to_a, data.ys.to_a, color: colors.next)
           end
         when :scatter
           context.series.each do |data|
-            plot.scatter(data.xs.to_a, data.ys.to_a, label: data.label)
+            ax.scatter(data.xs.to_a, data.ys.to_a, label: data.label,
+                       color: colors.next)
           end
-          plot.legend()
+          ax.legend()
         when :error_bar
           context.series.each do |data|
-            plot.errorbar(
+            ax.errorbar(
               data.xs.to_a,
               data.ys.to_a,
               data.xerr,
               data.yerr,
               label: data.label,
+              color: colors.next
             )
           end
-          plot.legend()
+          ax.legend()
         when :hist
-          plot.hist(context.data.to_a)
+          data = Array(context.data)
+          ax.hist(data, color: colors.take(data.length), alpha: 0.4)
         end
       end
+
+      private def draw_box_plot(context, subplot, colors, gray)
+        Array(context.data).each_with_index do |group_data, i|
+          next if group_data.empty?
+
+          box_data = group_data.compact
+          next if box_data.empty?
+
+          artist_dict = @pyplot.boxplot(box_data, vert: "v", patch_artist: true,
+                                        positions: [i], widths: 0.8)
+
+          color = colors.next
+          artist_dict["boxes"].each do |box|
+            box.update({facecolor: color, zorder: 0.9, edgecolor: gray}, {})
+          end
+          artist_dict["whiskers"].each do |whisker|
+            whisker.update({color: gray, linestyle: "-"}, {})
+          end
+          artist_dict["caps"].each do |cap|
+            cap.update({color: gray}, {})
+          end
+          artist_dict["medians"].each do |median|
+            median.update({color: gray}, {})
+          end
+          artist_dict["fliers"].each do |flier|
+            flier.update({
+              markerfacecolor: gray,
+              marker: "d",
+              markeredgecolor: gray,
+              markersize: 5
+            }, {})
+          end
+        end
+      end
+
+      # ==== NEW PLOTTING API ====
+
+      def begin_figure
+        # do nothing
+      end
+
+      def bar(bar_pos, values, color: nil, width: 0.8r, align: :center, orient: :v)
+        bar_pos = Array(bar_pos)
+        values = Array(values)
+        color = Array(color).map(&:to_hex_string)
+        width = Float(width)
+        if orient == :v
+          @pyplot.bar(bar_pos, values, width: width, color: color, align: align)
+        else
+          @pyplot.barh(bar_pos, values, width: width, color: color, align: align)
+        end
+      end
+
+      def box_plot(plot_data, positions, color:, gray:,
+                   width: 0.8r, flier_size: 5, whisker: 1.5, notch: false)
+        color = Array(color).map(&:to_hex_string)
+        gray = gray.to_hex_string
+        width = Float(width)
+        flier_size = Float(flier_size)
+        whisker = Float(whisker)
+        plot_data.each_with_index do |group_data, i|
+          next if group_data.nil? || group_data.empty?
+
+          artist_dict = @pyplot.boxplot(group_data, vert: :v,
+                                        patch_artist: true,
+                                        positions: [i],
+                                        widths: width,
+                                        whis: whisker, )
+
+          artist_dict["boxes"].each do |box|
+            box.update({facecolor: color[i], zorder: 0.9, edgecolor: gray}, {})
+          end
+          artist_dict["whiskers"].each do |whisker|
+            whisker.update({color: gray, linestyle: "-"}, {})
+          end
+          artist_dict["caps"].each do |cap|
+            cap.update({color: gray}, {})
+          end
+          artist_dict["medians"].each do |median|
+            median.update({color: gray}, {})
+          end
+          artist_dict["fliers"].each do |flier|
+            flier.update({
+              markerfacecolor: gray,
+              marker: "d",
+              markeredgecolor: gray,
+              markersize: flier_size
+            }, {})
+          end
+        end
+      end
+
+      def set_xlabel(label)
+        @pyplot.gca.set_xlabel(String(label))
+      end
+
+      def set_ylabel(label)
+        @pyplot.gca.set_ylabel(String(label))
+      end
+
+      def set_xticks(values)
+        @pyplot.gca.set_xticks(Array(values))
+      end
+
+      def set_xtick_labels(labels)
+        @pyplot.gca.set_xticklabels(Array(labels).map(&method(:String)))
+      end
+
+      def set_xlim(min, max)
+        @pyplot.gca.set_xlim(Float(min), Float(max))
+      end
+
+      def disable_xaxis_grid
+        @pyplot.gca.xaxis.grid(false)
+      end
+
+      def show
+        @pyplot.show
+      end
     end
   end
 end

data/lib/charty/backends/rubyplot.rb

@@ -23,7 +23,7 @@ module Charty
       end
 
       def render_layout(layout)
-        (fig, axes) = *@plot.subplots(nrows: layout.num_rows, ncols: layout.num_cols)
+        (_fig, axes) = *@plot.subplots(nrows: layout.num_rows, ncols: layout.num_cols)
         layout.rows.each_with_index do |row, y|
           row.each_with_index do |cel, x|
             plot = layout.num_rows > 1 ? axes[y][x] : axes[x]

data/lib/charty/palette.rb

@@ -0,0 +1,235 @@
+require "numo/narray"
+
+module Charty
+  class Palette
+    SEABORN_PALETTES = {
+      "deep" => ["#4C72B0", "#DD8452", "#55A868", "#C44E52", "#8172B3",
+                 "#937860", "#DA8BC3", "#8C8C8C", "#CCB974", "#64B5CD"].freeze,
+      "deep6" => ["#4C72B0", "#55A868", "#C44E52",
+                  "#8172B3", "#CCB974", "#64B5CD"].freeze,
+      "muted" => ["#4878D0", "#EE854A", "#6ACC64", "#D65F5F", "#956CB4",
+                  "#8C613C", "#DC7EC0", "#797979", "#D5BB67", "#82C6E2"].freeze,
+      "muted6" => ["#4878D0", "#6ACC64", "#D65F5F",
+                   "#956CB4", "#D5BB67", "#82C6E2"].freeze,
+      "pastel" => ["#A1C9F4", "#FFB482", "#8DE5A1", "#FF9F9B", "#D0BBFF",
+                   "#DEBB9B", "#FAB0E4", "#CFCFCF", "#FFFEA3", "#B9F2F0"].freeze,
+      "pastel6" => ["#A1C9F4", "#8DE5A1", "#FF9F9B",
+                    "#D0BBFF", "#FFFEA3", "#B9F2F0"].freeze,
+      "bright" => ["#023EFF", "#FF7C00", "#1AC938", "#E8000B", "#8B2BE2",
+                   "#9F4800", "#F14CC1", "#A3A3A3", "#FFC400", "#00D7FF"].freeze,
+      "bright6" => ["#023EFF", "#1AC938", "#E8000B",
+                    "#8B2BE2", "#FFC400", "#00D7FF"].freeze,
+      "dark" => ["#001C7F", "#B1400D", "#12711C", "#8C0800", "#591E71",
+                 "#592F0D", "#A23582", "#3C3C3C", "#B8850A", "#006374"].freeze,
+      "dark6" => ["#001C7F", "#12711C", "#8C0800",
+                  "#591E71", "#B8850A", "#006374"].freeze,
+      "colorblind" => ["#0173B2", "#DE8F05", "#029E73", "#D55E00", "#CC78BC",
+                       "#CA9161", "#FBAFE4", "#949494", "#ECE133", "#56B4E9"].freeze,
+      "colorblind6" => ["#0173B2", "#029E73", "#D55E00",
+                        "#CC78BC", "#ECE133", "#56B4E9"].freeze
+    }.freeze
+
+    MPL_QUAL_PALS = {
+      "tab10" => 10,
+      "tab20" => 20,
+      "tab20b" => 20,
+      "tab20c" => 20,
+      "Set1" => 9,
+      "Set2" => 8,
+      "Set3" => 12,
+      "Accent" => 8,
+      "Paired" => 12,
+      "Pastel1" => 9,
+      "Pastel2" => 8,
+      "Dark2" => 8,
+    }.freeze
+
+    QUAL_PALETTE_SIZES = MPL_QUAL_PALS.dup
+    SEABORN_PALETTES.each do |k, v|
+      QUAL_PALETTE_SIZES[k] = v.length
+    end
+    QUAL_PALETTE_SIZES.freeze
+
+    def self.seaborn_colors(name)
+      SEABORN_PALETTES[name].map do |hex_string|
+        Colors::RGB.parse(hex_string)
+      end
+    end
+
+    # Get a set of evenly spaced colors in HSL hue space.
+    #
+    # @param n_colors [Integer]
+    #   The number of colors in the palette
+    # @param h [Numeric]
+    #   The hue value of the first color in degree
+    # @param s [Numeric]
+    #   The saturation value of the first color (between 0 and 1)
+    # @param l [Numeric]
+    #   The lightness value of the first color (between 0 and 1)
+    #
+    # @return [Array<Colors::HSL>]
+    #   The array of colors
+    def self.hsl_colors(n_colors=6, h: 3.6r, s: 0.65r, l: 0.6r)
+      hues = Numo::DFloat.linspace(0, 1, n_colors + 1)[0...-1]
+      hues.inplace + (h/360r).to_f
+      hues.inplace % 1
+      hues.inplace - Numo::Int32.cast(hues)
+      (0...n_colors).map {|i| Colors::HSL.new(hues[i]*360r, s, l) }
+    end
+
+    # Get a set of evenly spaced colors in HUSL hue space.
+    #
+    # @param n_colors [Integer]
+    #   The number of colors in the palette
+    # @param h [Numeric]
+    #   The hue value of the first color in degree
+    # @param s [Numeric]
+    #   The saturation value of the first color (between 0 and 1)
+    # @param l [Numeric]
+    #   The lightness value of the first color (between 0 and 1)
+    #
+    # @return [Array<Colors::HSL>]
+    #   The array of colors
+    def self.husl_colors(n_colors=6, h: 3.6r, s: 0.9r, l: 0.65r)
+      hues = Numo::DFloat.linspace(0, 1, n_colors + 1)[0...-1]
+      hues.inplace + (h/360r).to_f
+      hues.inplace % 1
+      hues.inplace * 359
+      (0...n_colors).map {|i| Colors::HUSL.new(hues[i], s, l) }
+    end
+
+    def self.cubehelix_colors(n_colors, start=0, rot=0.4r, gamma=1.0r, hue=0.8r,
+                               light=0.85r, dark=0.15r, reverse=false, as_cmap: false)
+      raise NotImplementedError,
+            "Cubehelix palette has not been implemented"
+    end
+
+    def self.matplotlib_colors(name, n_colors=6)
+      raise NotImplementedError,
+            "Matplotlib's colormap emulation has not been implemented"
+    end
+
+    # Return a list of colors defining a color palette
+    #
+    # @param palette [nil, String, Palette]
+    #   Name of palette or nil to return current palette.
+    #   If a Palette is given, input colors are used but
+    #   possibly cycled and desaturated.
+    # @param n_colors [Integer, nil]
+    #   Number of colors in the palette.
+    #   If `nil`, the default will depend on how `palette` is specified.
+    #   Named palettes default to 6 colors, but grabbing the current palette
+    #   or passing in a list of colors will not change the number of colors
+    #   unless this is specified.  Asking for more colors than exist in the
+    #   palette cause it to cycle.
+    # @param desaturate_factor [Float, nil]
+    #   Propotion to desaturate each color by.
+    #
+    # @return [Palette]
+    #   Color palette.  Behaves like a list.
+    def initialize(palette=nil, n_colors=nil, desaturate_factor: nil)
+      case
+      when palette.nil?
+        @name = nil
+        palette = Colors::ColorDate::DEFAULT_COLOR_CYCLE
+        n_colors ||= palette.length
+      else
+        palette = normalize_palette_name(palette)
+        case palette
+        when String
+          @name = palette
+          # Use all colors in a qualitative palette or 6 of another kind
+          n_colors ||= QUAL_PALETTE_SIZES.fetch(palette, 6)
+          case @name
+          when SEABORN_PALETTES.method(:has_key?)
+            palette = self.class.seaborn_colors(@name)
+          when "hls", "HLS", "hsl", "HSL"
+            palette = self.class.hsl_colors(n_colors)
+          when "husl", "HUSL"
+            palette = self.class.husl_colors(n_colors)
+          when /\Ach:/
+            # Cubehelix palette with params specified in string
+            args, kwargs = parse_cubehelix_args(palette)
+            palette = self.class.cubehelix_colors(n_colors, *args, **kwargs)
+          else
+            begin
+              palette = self.class.matplotlib_colors(palette, n_colors)
+            rescue ArgumentError
+              raise ArgumentError,
+                    "#{palette} is not a valid palette name"
+            end
+          end
+        else
+          n_colors ||= palette.length
+        end
+      end
+      if desaturate_factor
+        palette = palette.map {|c| Colors.desaturate(c, desaturate_factor) }
+      end
+
+      # Always return as many colors as we asked for
+      @colors = palette.cycle.take(n_colors).freeze
+      @desaturate_factor = desaturate_factor
+    end
+
+    attr_reader :name, :colors, :desaturate_factor
+
+    def n_colors
+      @colors.length
+    end
+
+    # Two palettes are equal if they have the same colors, even if they have
+    # the different names and different desaturate factors.
+    def ==(other)
+      case other
+      when Palette
+        colors == other.colors
+      else
+        super
+      end
+    end
+
+    def [](i)
+      @palette[i % n_colors]
+    end
+
+    def to_ary
+      @palette.dup
+    end
+
+    private def normalize_palette_name(palette)
+      case palette
+      when String
+        palette
+      when Symbol
+        palette.to_s
+      else
+        palette.to_str
+      end
+    rescue NoMethodError, TypeError
+      palette
+    end
+
+    class << self
+      attr_reader :default
+
+      def default=(args)
+        @default = case args
+                   when Palette
+                     args
+                   when Array
+                     case args[0]
+                     when Array
+                       Palette.new(*args)
+                     else
+                       Palette.new(args)
+                     end
+                   else
+                     Palette.new(args)
+                   end
+      end
+    end
+
+    self.default = Palette.new("deep").freeze
+  end
+end