class Charty::Plotters::SizeMapper

Attributes

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

Public Instance Methods

lookup_single_value(key) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 327
def lookup_single_value(key)
  if @lookup_table.key?(key)
    @lookup_table[key]
  else
    normed = @norm.(key) || Float::NAN
    size_values = @lookup_table.values
    min, max = size_values.min, size_values.max
    min + normed * (max - min)
  end
end

Private Instance Methods

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

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

  when Array
    # nothing to do

  when Range, nil
    # Reverse values to use the largest size for the first category
    size_range = sizes || (0r .. 1r)
    sizes = Linspace.new(size_range, levels.length).reverse_each.to_a
  else
    raise ArgumentError,
      "Unable to recognize the value for `sizes`: %p" % sizes
  end

  lookup_table = categorical_lut_from_array(levels, sizes, :sizes)
  return levels, lookup_table
end
infer_map_type(sizes, norm, var_type) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 241
        def infer_map_type(sizes, norm, var_type)
  case
  when ! norm.nil?
    :numeric
  when sizes.is_a?(Hash),
       sizes.is_a?(Array)
    :categorical
  else
    var_type
  end
end
initialize_mapping(sizes, order, norm) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 219
        def initialize_mapping(sizes, order, norm)
  @sizes = sizes
  @order = order
  @norm = norm

  return unless plotter.variables.key?(:size)

  data = plotter.plot_data[:size]
  return unless data.notnull.any?

  @map_type = infer_map_type(sizes, norm, @plotter.var_types[:size])
  case @map_type
  when :numeric
    @levels, @lookup_table, @norm = numeric_mapping(data, sizes, norm)
  when :categorical
    @levels, @lookup_table = categorical_mapping(data, sizes, order)
  else
    raise NotImplementedError,
          "datetime color mapping is not supported"
  end
end
numeric_mapping(data, sizes, norm) click to toggle source
# File lib/charty/plotters/relational_plotter.rb, line 253
        def numeric_mapping(data, sizes, norm)
  case sizes
  when Hash
    # The presence of a norm object overrides a dictionary of sizes
    # in specifying a numeric mapping, so we need to process the
    # dictionary here
    levels = sizes.keys.sort
    size_values = sizes.values
    size_range = [size_values.min, size_values.max]
  else
    levels = Charty::Vector.new(data.unique_values).drop_na.to_a
    levels.sort!

    case sizes
    when Range
      size_range = [sizes.begin, sizes.end]
    when nil
      size_range = [0r, 1r]
    else
      raise ArgumentError,
            "Unable to recognize the value for `sizes`: %p" % sizes
    end
  end

  # Now we have the minimum and the maximum values of sizes
  case norm
  when nil
    norm = SimpleNormalizer.new
    sizes_scaled = norm.(levels)
  # when Colors::Normalize
  # TODO: Must support red-color's Normalize feature
  else
    raise ArgumentError,
          "Unable to recognize the value for `norm`: %p" % norm
  end

  case sizes
  when Hash
    # do nothing
  else
    lo, hi = size_range
    sizes = sizes_scaled.map {|x| lo + x * (hi - lo) }
    lookup_table = levels.zip(sizes).to_h
  end

  return levels, lookup_table, norm
end