class Charty::Plotters::ColorMapper

Attributes

levels[R]
lookup_table[R]
map_type[R]
norm[R]
palette[R]

Public Instance Methods

inverse_lookup_table() click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 195
def inverse_lookup_table
  lookup_table.invert
end
lookup_single_value(key) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 199
def lookup_single_value(key)
  if @lookup_table.key?(key)
    @lookup_table[key]
  elsif @norm
    # Use the colormap to interpolate between existing datapoints
    begin
      normed = @norm.(key)
      @cmap[normed]
    rescue ArgumentError, TypeError => err
      if Util.nan?(key)
        return "#000000"
      else
        raise err
      end
    end
  end
end

Private Instance Methods

categorical_mapping(data, palette, order) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 149
        def categorical_mapping(data, palette, order)
  levels = data.categorical_order(order)
  n_colors = levels.length

  case palette
  when Hash
    lookup_table = categorical_lut_from_hash(levels, palette, :palette)
    return levels, lookup_table

  when nil
    current_palette = Palette.default
    if n_colors <= current_palette.n_colors
      colors = Palette.new(current_palette.colors, n_colors).colors
    else
      colors = Palette.husl_colors(n_colors)
    end

  when Array
    colors = palette

  else
    colors = Palette.new(palette, n_colors).colors
  end

  lookup_table = categorical_lut_from_array(levels, colors, :palette)
  return levels, lookup_table
end
infer_map_type(palette, norm, input_format, var_type) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 177
        def infer_map_type(palette, norm, input_format, var_type)
  case
  when false # palette is qualitative_palette
    :categorical
  when ! norm.nil?
    :numeric
  when palette.is_a?(Array),
       palette.is_a?(Hash)
    :categorical
  when input_format == :wide
    :categorical
  else
    var_type
  end
end
initialize_mapping(palette, order, norm) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 79
        def initialize_mapping(palette, order, norm)
  @palette = palette
  @order = order

  if plotter.variables.key?(:color)
    data = plotter.plot_data[:color]
  end

  if data && data.notnull.any?
    @map_type = infer_map_type(palette, norm, @plotter.input_format, @plotter.var_types[:color])

    case @map_type
    when :numeric
      @levels, @lookup_table, @norm, @cmap = numeric_mapping(data, palette, norm)
    when :categorical
      @cmap = nil
      @norm = nil
      @levels, @lookup_table = categorical_mapping(data, palette, order)
    else
      raise NotImplementedError,
            "datetime color mapping is not supported"
    end
  end
end
numeric_mapping(data, palette, norm) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 104
        def numeric_mapping(data, palette, norm)
  case palette
  when Hash
    levels = palette.keys.sort
    colors = palette.values_at(*levels)
    cmap = Colors::ListedColormap.new(colors)
    lookup_table = palette.dup
  else
    levels = data.drop_na.unique_values
    levels.sort!

    palette ||= "ch:"
    cmap = case palette
           when Colors::Colormap
             palette
           else
             Palette.new(palette, 256).to_colormap
           end

    case norm
    when nil
      norm = SimpleNormalizer.new
    when Array
      norm = SimpleNormalizer.new(*norm)
    #when Colors::Normalizer
    # TODO: Must support red-color's Normalize feature
    else
      raise ArgumentError,
            "`color_norm` must be nil, Array, or Normalizer object"
    end

    # initialize norm
    norm.(data.drop_na.to_a)

    lookup_table = levels.map { |level|
      [
        level,
        cmap[norm.(level)]
      ]
    }.to_h
  end

  return levels, lookup_table, norm, cmap
end