Struct ScaleFillBinned 

pub struct ScaleFillBinned { /* private fields */ }

Binned fill/colour scale: n classes from n + 1 increasing edges, each with its own colour. See the module docs for how it relates to scale_fill_steps/::CLASSES.

Implementations

impl ScaleFillBinned

pub fn new( aesthetic: Aesthetic, breaks: Vec<f64>, colors: Vec<(u8, u8, u8)>, ) -> Self

n + 1 increasing breaks with an explicit colour per bin (colors.len() should be breaks.len() - 1; a mismatch falls back to the default two-colour ramp and is reported by validate).

pub fn two( aesthetic: Aesthetic, breaks: Vec<f64>, low: (u8, u8, u8), high: (u8, u8, u8), ) -> Self

n + 1 increasing breaks, coloured by interpolating low→high across the n bins (R’s scale_fill_steps(breaks = ...)).

pub fn na_color(self, color: (u8, u8, u8)) -> Self

Colour for Value::Na and the legend’s “no data” key (ggplot2’s na.value). Default grey50 (127, 127, 127). Overridden for drawing (not for the legend count) by na_pattern when that’s also set.

pub fn na_pattern(self, pattern: FillPattern) -> Self

A pattern fill for Value::Na and the legend’s “no data” key, drawn instead of the flat na_color — a classed choropleth’s no-data cells read as “no reading”, not a muted value (#206). FillPattern::stripe(fg, bg) is a reasonable default hatch; bg is what a pattern-less backend (plotters) falls back to.

pub fn na_label(self, label: &str) -> Self

Label for the “no data” legend key. Default "no data".

pub fn na_key(self, show: NaKey) -> Self

Whether the “no data” legend key is shown (#269). Default NaKey::Auto (today’s behaviour: shown only when at least one trained value was Value::Na). NaKey::Always keeps the key (with its count, down to "no data (0)") even when nothing is missing — a plot rendered once per animation frame needs a legend whose key count doesn’t change (and so doesn’t resize) just because one particular frame happens to have no missing values. NaKey::Never hides it even with Value::Na trained.

pub fn count_reserve(self, max_count: usize) -> Self

Lay the legend out — for auto-wrap sizing only, never for what’s drawn — as if every class’s trained count had max_count’s digit width (#271). Binned legend labels carry a count ("10–50 (12)"); across an animation’s frames the same scale’s counts change digit width while its breaks/colours stay fixed, which can change the legend’s measured pitch enough to flip an auto-wrapped (horizontal) legend’s row count and move the panel. max_count should be the largest count any frame can produce (e.g. the full dataset’s count per class). Default None: off, byte-identical to before this existed.

Trait Implementations

impl Clone for ScaleFillBinned

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScaleFillBinned

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Scale for ScaleFillBinned

fn map(&self, _value: &Value) -> f64

Not used for position — like super::steps::ScaleColorSteps, the legend looks a value’s colour up by its break label instead.

fn breaks_for_layout(&self) -> Vec<(f64, String)>

count_reserve (#271): pad every key’s trailing (count) to at least count_reserve’s digit width before measuring — the drawn labels from breaks are untouched. None (the default): identical to breaks().

fn na_fill_pattern(&self) -> Option<FillPattern>

This scale’s configured na_pattern, if any — the caller (a geom’s fill resolution, or the legend’s “no data” key) only consults this for a row/key that’s already otherwise headed for the flat na_color (Value::Na, or the “no data” legend-key label itself); every ordinary bin colour is unaffected (#206).

fn aesthetic(&self) -> Aesthetic

Which aesthetic this scale is for.

fn train(&mut self, values: &[Value])

Incorporate data values to determine domain.

fn breaks(&self) -> Vec<(f64, String)>

Generate break positions and labels for axis/legend.

fn name(&self) -> &str

Human-readable name (axis title).

fn set_name(&mut self, name: &str)

Set the scale name.

fn is_discrete(&self) -> bool

Whether this is a discrete scale.

fn map_to_color(&self, value: &Value) -> Option<(u8, u8, u8)>

Map a data value to an RGB color. Default returns None.

fn domain(&self) -> Option<(f64, f64)>

Return the trained data domain (min, max) for continuous scales. Used by the colorbar legend to pass data-space values to map_to_color().

fn is_na_break(&self, label: &str) -> bool

Whether label (a breaks label) is this scale’s “no data” legend key, so the legend draws that one key with na_fill_pattern instead of its ordinary flat swatch colour. Default false (no scale without an na key needs this). ScaleFillBinned overrides it.

fn validate(&self, warnings: &mut Vec<String>)

Validate this scale’s configuration once training is complete (e.g. a transform undefined at the domain’s own limits) and push a human-readable warning for each problem found. Called once per scale after the final training pass, with the plot’s warnings sink — map/map_to_size run per mark at draw time and have no such access, so a scale-level problem must be reported here instead. Default: no-op.

fn clone_box(&self) -> Box<dyn Scale>

Clone this scale into a boxed trait object.

fn reset_training(&mut self)

Reset training state so the scale can be retrained on new data.

fn transform(&self, value: &Value) -> Value

Apply transformation to raw data (e.g., log10).

fn map_to_shape(&self, _value: &Value) -> Option<PointShape>

Map a data value to a point shape. Default returns None.

fn map_to_linetype(&self, _value: &Value) -> Option<Linetype>

Map a data value to a linetype. Default returns None.

fn map_to_size(&self, _value: &Value) -> Option<f64>

Map a data value to a point size (radius in pixels). Default returns None.

fn map_to_alpha(&self, _value: &Value) -> Option<f64>

Map a data value to an alpha (opacity) value. Default returns None.

fn sec_axis(&self) -> Option<&SecAxis>

Get the secondary axis specification, if any.

fn set_default_locale(&mut self, _locale: &Locale)

Adopt a plot-level default Locale for the default break labels (number marks, month names, date formats), unless the scale already has its own. Called by the plot builder when GGPlot::locale is set. Default: ignored (scales without numeric/date labels).

fn locale(&self) -> Option<&Locale>

The locale this scale’s default labels are rendered with, if any.

fn format_value(&self, _value: &Value) -> Option<String>

Format a single raw (pre-scale-transform) data value for a per-mark attribute (data-fvalue/data-fx, B2-4) or a tooltip template placeholder — e.g. a de-DE currency string, or a datetime x’s ISO/locale date, independent of how the axis itself abbreviates its break labels. None for a missing/non-finite value, or a scale with nothing meaningful to format (default: every scale except continuous position/size/linewidth and datetime/colour-continuous, which override this).

fn set_limits(&mut self, _min: f64, _max: f64)

Override the trained domain limits (used by coord_cartesian zoom).

fn filter_limits(&self) -> Option<(f64, f64)>

Return OOB filter limits if this scale was created with explicit limits (e.g., via xlim/ylim). Data outside these limits should be removed before stats.

fn expanded_domain(&self) -> Option<(f64, f64)>

The data values at the panel edges (normalized 0 and 1) for a trained continuous position scale — the limits after expansion, in the scale’s transformed space. None for discrete / untrained / non-position scales.

fn axis_position_opposite(&self) -> bool

Whether this axis is drawn on the opposite side (x → top, y → right).

fn set_expand(&mut self, _mult: f64, _add: f64)

Set the expansion multiplier/additive constant (R’s expand = c(mult, add)), applied symmetrically to both ends. Used by CoordSf::train_scales (expand(false) passes (0.0, 0.0)) to pin an explicit xlim/ylim to the panel exactly. Default: no-op (discrete / non-position scales have no expansion to set).

fn map_fraction_to_size(&self, _fraction: f64) -> Option<f64>

Map an already-computed [0, 1] scale fraction (as returned alongside each label by breaks) directly to an output size, bypassing the round trip through map — a discrete-style legend key only has the break’s rendered label, not its original data value, so a continuous scale can’t recover the fraction by re-mapping the label text. Default: None.

fn map_fraction_to_alpha(&self, _fraction: f64) -> Option<f64>

Map an already-computed [0, 1] scale fraction directly to an output alpha (opacity), the map_fraction_to_size equivalent for a continuous alpha scale’s discrete-style legend keys — see that method’s doc for why the fraction, not the label, is the input. Default: None.