🥮 mooncakes.io
    Sign in

    Lampese/mathplotlib/core/colors does not have a README file

    ColorError

    source
    pub(all) suberror ColorError {
      InvalidColor(String)
      ComponentOutOfRange(String)
      InvalidColorMap(String)
    }

    Errors raised while parsing a color specification.

    NormalizeError

    source
    pub(all) suberror NormalizeError {
      InvalidBounds(message~ : String)
      InvalidBase(message~ : String)
      InvalidValue(message~ : String)
      NoFiniteData
      NotScaled
      NotInvertible
    }

    Errors raised while constructing or applying a scalar color normalization.

    BoundaryNorm

    source
    pub struct BoundaryNorm {
      boundaries : Array[Double]
      ncolors : Int
      clip : Bool
      extend_mode : String
    }

    Map scalar values into discrete intervals defined by monotonically increasing boundaries.

    BoundaryNorm::autoscale_none

    source
    fn BoundaryNorm::autoscale_none(self : BoundaryNorm, values : Array[Double]) -> Unit

    Boundary normalizations already have fixed bounds; this is a no-op.

    BoundaryNorm::boundaries

    source
    fn BoundaryNorm::boundaries(self : BoundaryNorm) -> Array[Double]

    Return a copy of the boundary values.

    BoundaryNorm::clip

    source
    fn BoundaryNorm::clip(self : BoundaryNorm) -> Bool

    Return whether values outside the boundary range are clipped.

    BoundaryNorm::extend_mode

    source
    fn BoundaryNorm::extend_mode(self : BoundaryNorm) -> String

    Return the extension mode used by this normalization.

    BoundaryNorm::index

    source
    fn BoundaryNorm::index(self : BoundaryNorm, value : Double) -> Int raise NormalizeError

    Return the integer colormap index selected by a boundary normalization. Values below and above the boundaries return -1 and ncolors respectively when clipping is disabled, matching Matplotlib's under/over conventions.

    BoundaryNorm::inverse

    source
    fn BoundaryNorm::inverse(self : BoundaryNorm, value : Double) -> Double raise NormalizeError

    Boundary normalization is discrete and cannot be inverted.

    BoundaryNorm::is_valid

    source
    fn BoundaryNorm::is_valid(self : BoundaryNorm, value : Double) -> Bool

    Return whether a value is finite and can be normalized.

    BoundaryNorm::ncolors

    source
    fn BoundaryNorm::ncolors(self : BoundaryNorm) -> Int

    Return the number of color entries addressed by this normalization.

    BoundaryNorm::scaled

    source
    fn BoundaryNorm::scaled(self : BoundaryNorm) -> Bool

    Boundary normalizations are always ready to transform values.

    BoundaryNorm::transform

    source
    fn BoundaryNorm::transform(self : BoundaryNorm, value : Double) -> Double raise NormalizeError

    Transform a scalar to the normalized position of its discrete color index.

    CenteredNorm

    source
    pub struct CenteredNorm {
      vmin : Double?
      vmax : Double?
      halfrange : Double?
      clip : Bool
      vcenter : Double
    }

    Linear normalization centered on a value with a symmetric half-range.

    CenteredNorm::autoscale

    source
    fn CenteredNorm::autoscale(self : CenteredNorm, values : Array[Double]) -> Unit raise NormalizeError

    Set the half-range to the largest finite distance from the center.

    CenteredNorm::autoscale_none

    source
    fn CenteredNorm::autoscale_none(self : CenteredNorm, values : Array[Double]) -> Unit

    Fill an unset half-range from finite values.

    CenteredNorm::clip

    source
    fn CenteredNorm::clip(self : CenteredNorm) -> Bool

    Return the clipping mode.

    CenteredNorm::halfrange

    source
    fn CenteredNorm::halfrange(self : CenteredNorm) -> Double?

    Return the configured symmetric half-range, if one has been set.

    CenteredNorm::inverse

    source
    fn CenteredNorm::inverse(self : CenteredNorm, value : Double) -> Double raise NormalizeError

    Convert one normalized scalar back to centered data space.

    CenteredNorm::is_valid

    source
    fn CenteredNorm::is_valid(self : CenteredNorm, value : Double) -> Bool

    Return whether a value can be represented by this normalization.

    CenteredNorm::scaled

    source
    fn CenteredNorm::scaled(self : CenteredNorm) -> Bool

    Return whether both centered bounds are set.

    CenteredNorm::set_clip

    source
    fn CenteredNorm::set_clip(self : CenteredNorm, value : Bool) -> Unit

    Set the clipping mode.

    CenteredNorm::set_halfrange

    source
    fn CenteredNorm::set_halfrange(self : CenteredNorm, value : Double?) -> Unit raise NormalizeError

    Set the symmetric half-range and update both bounds.

    CenteredNorm::set_vcenter

    source
    fn CenteredNorm::set_vcenter(self : CenteredNorm, value : Double) -> Unit raise NormalizeError

    Set the center while preserving a configured half-range.

    CenteredNorm::transform

    source
    fn CenteredNorm::transform(self : CenteredNorm, value : Double) -> Double raise NormalizeError

    Transform one finite scalar using a symmetric center and half-range.

    CenteredNorm::transform_array

    source
    fn CenteredNorm::transform_array(self : CenteredNorm, values : Array[Double]) -> Array[Double] raise NormalizeError

    Fill a missing half-range and transform every finite value.

    CenteredNorm::vcenter

    source
    fn CenteredNorm::vcenter(self : CenteredNorm) -> Double

    Return the center value mapped to 0.5.

    CenteredNorm::vmax

    source
    fn CenteredNorm::vmax(self : CenteredNorm) -> Double?

    Return the upper data bound, if one has been set.

    CenteredNorm::vmin

    source
    fn CenteredNorm::vmin(self : CenteredNorm) -> Double?

    Return the lower data bound, if one has been set.

    ColorMap

    source
    pub struct ColorMap {
      name : String
      stops : Array[Rgba]
      discrete : Bool
      under : Rgba?
      over : Rgba?
      bad : Rgba?
    }

    A piecewise-linear scalar colormap.

    ColorMap::bad

    source
    fn ColorMap::bad(self : ColorMap) -> Rgba?

    Return the optional color for non-finite values.

    ColorMap::is_discrete

    source
    fn ColorMap::is_discrete(self : ColorMap) -> Bool

    Return whether this colormap selects a discrete entry for each sample.

    ColorMap::name

    source
    fn ColorMap::name(self : ColorMap) -> String

    Return the colormap name.

    ColorMap::over

    source
    fn ColorMap::over(self : ColorMap) -> Rgba?

    Return the optional over-range color.

    ColorMap::sample

    source
    fn ColorMap::sample(self : ColorMap, value : Double) -> Rgba

    Sample a colormap at a normalized scalar in [0, 1].

    ColorMap::sample_extended

    source
    fn ColorMap::sample_extended(self : ColorMap, value : Double) -> Rgba

    Sample a colormap while honoring configured under, over, and bad colors.

    ColorMap::set_bad

    source
    fn ColorMap::set_bad(self : ColorMap, color : Rgba) -> Unit

    Set the color used for non-finite (masked) values.

    ColorMap::set_over

    source
    fn ColorMap::set_over(self : ColorMap, color : Rgba) -> Unit

    Set the color used for normalized values above one.

    ColorMap::set_under

    source
    fn ColorMap::set_under(self : ColorMap, color : Rgba) -> Unit

    Set the color used for normalized values below zero.

    ColorMap::stops

    source
    fn ColorMap::stops(self : ColorMap) -> Array[Rgba]

    Return a copy of the interpolation stops.

    ColorMap::under

    source
    fn ColorMap::under(self : ColorMap) -> Rgba?

    Return the optional under-range color.

    ColorNorm

    source
    pub(all) enum ColorNorm {
      Linear(Normalize)
      Logarithmic(LogNorm)
      SymmetricLog(SymLogNorm)
      TwoSlope(TwoSlopeNorm)
      Power(PowerNorm)
      Centered(CenteredNorm)
      Boundary(BoundaryNorm)
    }

    A normalization that can be attached to a scalar image or colorbar.

    ColorNorm::autoscale

    source
    fn ColorNorm::autoscale(self : ColorNorm, values : Array[Double]) -> Unit raise NormalizeError

    Set both data bounds from finite values.

    ColorNorm::autoscale_none

    source
    fn ColorNorm::autoscale_none(self : ColorNorm, values : Array[Double]) -> Unit

    Fill missing bounds from an array of scalar values.

    ColorNorm::inverse

    source
    fn ColorNorm::inverse(self : ColorNorm, value : Double) -> Double raise NormalizeError

    Convert one normalized scalar back to data space.

    ColorNorm::is_valid

    source
    fn ColorNorm::is_valid(self : ColorNorm, value : Double) -> Bool

    Return whether a value is valid for this normalization.

    ColorNorm::scaled

    source
    fn ColorNorm::scaled(self : ColorNorm) -> Bool

    Return whether both bounds are set.

    ColorNorm::transform

    source
    fn ColorNorm::transform(self : ColorNorm, value : Double) -> Double raise NormalizeError

    Transform one scalar to normalized color space.

    ColorNorm::vmax

    source
    fn ColorNorm::vmax(self : ColorNorm) -> Double?

    Return the upper data bound, if one has been set.

    ColorNorm::vmin

    source
    fn ColorNorm::vmin(self : ColorNorm) -> Double?

    Return the lower data bound, if one has been set.

    LogNorm

    source
    pub struct LogNorm {
      vmin : Double?
      vmax : Double?
      clip : Bool
      base : Double
    }

    Logarithmically map positive scalar values to the interval [0, 1].

    LogNorm::autoscale

    source
    fn LogNorm::autoscale(self : LogNorm, values : Array[Double]) -> Unit raise NormalizeError

    Set both bounds to the positive finite minimum and maximum in values.

    LogNorm::autoscale_none

    source
    fn LogNorm::autoscale_none(self : LogNorm, values : Array[Double]) -> Unit

    Fill only bounds that are not already set from positive finite values.

    LogNorm::base

    source
    fn LogNorm::base(self : LogNorm) -> Double

    Return the logarithm base.

    LogNorm::clip

    source
    fn LogNorm::clip(self : LogNorm) -> Bool

    Return whether values outside the bounds are clipped.

    LogNorm::inverse

    source
    fn LogNorm::inverse(self : LogNorm, value : Double) -> Double raise NormalizeError

    Convert one normalized scalar back to data space.

    LogNorm::is_valid

    source
    fn LogNorm::is_valid(self : LogNorm, value : Double) -> Bool

    Return whether a value can be represented by this logarithmic norm.

    LogNorm::scaled

    source
    fn LogNorm::scaled(self : LogNorm) -> Bool

    Return whether both bounds are set.

    LogNorm::set_clip

    source
    fn LogNorm::set_clip(self : LogNorm, value : Bool) -> Unit

    Set the clipping mode.

    LogNorm::set_vmax

    source
    fn LogNorm::set_vmax(self : LogNorm, value : Double?) -> Unit raise NormalizeError

    Set the upper data bound.

    LogNorm::set_vmin

    source
    fn LogNorm::set_vmin(self : LogNorm, value : Double?) -> Unit raise NormalizeError

    Set the lower data bound.

    LogNorm::transform

    source
    fn LogNorm::transform(self : LogNorm, value : Double) -> Double raise NormalizeError

    Transform one positive finite scalar to logarithmic color space.

    LogNorm::transform_array

    source
    fn LogNorm::transform_array(self : LogNorm, values : Array[Double]) -> Array[Double] raise NormalizeError

    Fill missing bounds from values and transform positive values.

    LogNorm::vmax

    source
    fn LogNorm::vmax(self : LogNorm) -> Double?

    Return the upper data bound, if one has been set.

    LogNorm::vmin

    source
    fn LogNorm::vmin(self : LogNorm) -> Double?

    Return the lower data bound, if one has been set.

    Normalize

    source
    pub struct Normalize {
      vmin : Double?
      vmax : Double?
      clip : Bool
    }

    Linearly map scalar values to the interval [0, 1].

    Missing bounds are filled from the first finite data passed to autoscale_none or transform_array. Values outside the interval are preserved when clip is false and clamped when it is true.

    Normalize::autoscale

    source
    fn Normalize::autoscale(self : Normalize, values : Array[Double]) -> Unit raise NormalizeError

    Set both bounds to the finite minimum and maximum in values.

    Normalize::autoscale_none

    source
    fn Normalize::autoscale_none(self : Normalize, values : Array[Double]) -> Unit

    Fill only bounds that are not already set from finite values in values.

    Normalize::clip

    source
    fn Normalize::clip(self : Normalize) -> Bool

    Return whether values outside the bounds are clipped.

    Normalize::inverse

    source
    fn Normalize::inverse(self : Normalize, value : Double) -> Double raise NormalizeError

    Convert one normalized scalar back to data space.

    Normalize::scaled

    source
    fn Normalize::scaled(self : Normalize) -> Bool

    Return whether both bounds are set.

    Normalize::set_clip

    source
    fn Normalize::set_clip(self : Normalize, value : Bool) -> Unit

    Set the clipping mode.

    Normalize::set_vmax

    source
    fn Normalize::set_vmax(self : Normalize, value : Double?) -> Unit raise NormalizeError

    Set the upper data bound.

    Normalize::set_vmin

    source
    fn Normalize::set_vmin(self : Normalize, value : Double?) -> Unit raise NormalizeError

    Set the lower data bound.

    Normalize::transform

    source
    fn Normalize::transform(self : Normalize, value : Double) -> Double raise NormalizeError

    Transform one finite scalar to normalized color space.

    Normalize::transform_array

    source
    fn Normalize::transform_array(self : Normalize, values : Array[Double]) -> Array[Double] raise NormalizeError

    Fill missing bounds from values and transform every value.

    Normalize::vmax

    source
    fn Normalize::vmax(self : Normalize) -> Double?

    Return the upper data bound, if one has been set.

    Normalize::vmin

    source
    fn Normalize::vmin(self : Normalize) -> Double?

    Return the lower data bound, if one has been set.

    PowerNorm

    source
    pub struct PowerNorm {
      vmin : Double?
      vmax : Double?
      clip : Bool
      gamma : Double
    }

    Power-law normalization of non-negative distances from the lower bound.

    PowerNorm::autoscale

    source
    fn PowerNorm::autoscale(self : PowerNorm, values : Array[Double]) -> Unit raise NormalizeError

    Set both bounds to the finite minimum and maximum in values.

    PowerNorm::autoscale_none

    source
    fn PowerNorm::autoscale_none(self : PowerNorm, values : Array[Double]) -> Unit

    Fill only missing power-law bounds from finite values.

    PowerNorm::clip

    source
    fn PowerNorm::clip(self : PowerNorm) -> Bool

    Return whether values outside the bounds are clipped.

    PowerNorm::gamma

    source
    fn PowerNorm::gamma(self : PowerNorm) -> Double

    Return the exponent used by the power-law normalization.

    PowerNorm::inverse

    source
    fn PowerNorm::inverse(self : PowerNorm, value : Double) -> Double raise NormalizeError

    Convert one normalized value back to power-law data space.

    PowerNorm::is_valid

    source
    fn PowerNorm::is_valid(self : PowerNorm, value : Double) -> Bool

    Return whether a value can be represented by this normalization.

    PowerNorm::scaled

    source
    fn PowerNorm::scaled(self : PowerNorm) -> Bool

    Return whether both power-law bounds are set.

    PowerNorm::set_clip

    source
    fn PowerNorm::set_clip(self : PowerNorm, value : Bool) -> Unit

    Set the clipping mode.

    PowerNorm::set_vmax

    source
    fn PowerNorm::set_vmax(self : PowerNorm, value : Double?) -> Unit raise NormalizeError

    Set the upper data bound.

    PowerNorm::set_vmin

    source
    fn PowerNorm::set_vmin(self : PowerNorm, value : Double?) -> Unit raise NormalizeError

    Set the lower data bound.

    PowerNorm::transform

    source
    fn PowerNorm::transform(self : PowerNorm, value : Double) -> Double raise NormalizeError

    Transform one finite scalar with a power-law color scale.

    PowerNorm::transform_array

    source
    fn PowerNorm::transform_array(self : PowerNorm, values : Array[Double]) -> Array[Double] raise NormalizeError

    Fill missing bounds and transform every finite value.

    PowerNorm::vmax

    source
    fn PowerNorm::vmax(self : PowerNorm) -> Double?

    Return the upper data bound, if one has been set.

    PowerNorm::vmin

    source
    fn PowerNorm::vmin(self : PowerNorm) -> Double?

    Return the lower data bound, if one has been set.

    Rgb

    source
    pub struct Rgb {
      red : Double
      green : Double
      blue : Double
    }

    An opaque RGB color with components normalized to the interval [0, 1].

    RGB image inputs are converted to RGBA at the scene boundary with an implicit alpha value of one. Keeping the opaque form separate makes the channel count explicit in typed APIs while retaining one backend color representation.

    Rgb::blue

    source
    fn Rgb::blue(self : Rgb) -> Double

    Rgb::green

    source
    fn Rgb::green(self : Rgb) -> Double

    Rgb::red

    source
    fn Rgb::red(self : Rgb) -> Double

    Rgb::to_rgba

    source
    fn Rgb::to_rgba(self : Rgb) -> Rgba

    Convert an opaque RGB value to the common RGBA backend representation.

    Rgba

    source
    pub struct Rgba {
      red : Double
      green : Double
      blue : Double
      alpha : Double
    }

    An RGBA color with components normalized to the interval [0, 1].

    Rgba::alpha

    source
    fn Rgba::alpha(self : Rgba) -> Double

    Rgba::blue

    source
    fn Rgba::blue(self : Rgba) -> Double

    Rgba::green

    source
    fn Rgba::green(self : Rgba) -> Double

    Rgba::red

    source
    fn Rgba::red(self : Rgba) -> Double

    Rgba::scale_alpha

    source
    fn Rgba::scale_alpha(self : Rgba, factor : Double) -> Rgba raise ColorError

    Scale the opacity of a color by a validated global image alpha.

    The RGB components and the existing per-pixel alpha are preserved while the resulting opacity is multiplied by factor.

    Rgba::to_css

    source
    fn Rgba::to_css(self : Rgba) -> String

    Return an opaque color as #rrggbb, or an rgba() string when translucent.

    SymLogNorm

    source
    pub struct SymLogNorm {
      vmin : Double?
      vmax : Double?
      clip : Bool
      linthresh : Double
      linscale : Double
      base : Double
    }

    Symmetrically logarithmic normalization around zero.

    SymLogNorm::autoscale

    source
    fn SymLogNorm::autoscale(self : SymLogNorm, values : Array[Double]) -> Unit raise NormalizeError

    Set both bounds to the finite minimum and maximum in values.

    SymLogNorm::autoscale_none

    source
    fn SymLogNorm::autoscale_none(self : SymLogNorm, values : Array[Double]) -> Unit

    Fill only missing symmetric-log bounds from finite values.

    SymLogNorm::base

    source
    fn SymLogNorm::base(self : SymLogNorm) -> Double

    Return the logarithm base used by the symmetric-log transform.

    SymLogNorm::clip

    source
    fn SymLogNorm::clip(self : SymLogNorm) -> Bool

    Return whether values outside the bounds are clipped.

    SymLogNorm::inverse

    source
    fn SymLogNorm::inverse(self : SymLogNorm, value : Double) -> Double raise NormalizeError

    Convert one normalized value back to symmetric-log data space.

    SymLogNorm::is_valid

    source
    fn SymLogNorm::is_valid(self : SymLogNorm, value : Double) -> Bool

    Return whether a value can be represented by this normalization.

    SymLogNorm::linscale

    source
    fn SymLogNorm::linscale(self : SymLogNorm) -> Double

    Return the linear-region scale used by the symmetric-log transform.

    SymLogNorm::linthresh

    source
    fn SymLogNorm::linthresh(self : SymLogNorm) -> Double

    Return the linear threshold used by the symmetric-log transform.

    SymLogNorm::scaled

    source
    fn SymLogNorm::scaled(self : SymLogNorm) -> Bool

    Return whether both symmetric-log bounds are set.

    SymLogNorm::set_clip

    source
    fn SymLogNorm::set_clip(self : SymLogNorm, value : Bool) -> Unit

    Set the clipping mode.

    SymLogNorm::set_vmax

    source
    fn SymLogNorm::set_vmax(self : SymLogNorm, value : Double?) -> Unit raise NormalizeError

    Set the upper data bound.

    SymLogNorm::set_vmin

    source
    fn SymLogNorm::set_vmin(self : SymLogNorm, value : Double?) -> Unit raise NormalizeError

    Set the lower data bound.

    SymLogNorm::transform

    source
    fn SymLogNorm::transform(self : SymLogNorm, value : Double) -> Double raise NormalizeError

    Transform one finite scalar to symmetric-log color space.

    SymLogNorm::transform_array

    source
    fn SymLogNorm::transform_array(self : SymLogNorm, values : Array[Double]) -> Array[Double] raise NormalizeError

    Fill missing bounds and transform every finite value.

    SymLogNorm::vmax

    source
    fn SymLogNorm::vmax(self : SymLogNorm) -> Double?

    Return the upper data bound, if one has been set.

    SymLogNorm::vmin

    source
    fn SymLogNorm::vmin(self : SymLogNorm) -> Double?

    Return the lower data bound, if one has been set.

    TwoSlopeNorm

    source
    pub struct TwoSlopeNorm {
      vmin : Double?
      vmax : Double?
      vcenter : Double
    }

    Linear normalization with a distinguished value mapped to 0.5.

    TwoSlopeNorm::autoscale

    source
    fn TwoSlopeNorm::autoscale(self : TwoSlopeNorm, values : Array[Double]) -> Unit raise NormalizeError

    Set both bounds to finite data bounds, including the center when needed.

    TwoSlopeNorm::autoscale_none

    source
    fn TwoSlopeNorm::autoscale_none(self : TwoSlopeNorm, values : Array[Double]) -> Unit

    Fill missing two-slope bounds from finite values and include the center.

    TwoSlopeNorm::inverse

    source
    fn TwoSlopeNorm::inverse(self : TwoSlopeNorm, value : Double) -> Double raise NormalizeError

    Convert one normalized value back to two-slope data space.

    TwoSlopeNorm::is_valid

    source
    fn TwoSlopeNorm::is_valid(self : TwoSlopeNorm, value : Double) -> Bool

    Return whether a value can be represented by this normalization.

    TwoSlopeNorm::scaled

    source
    fn TwoSlopeNorm::scaled(self : TwoSlopeNorm) -> Bool

    Return whether both two-slope bounds are set.

    TwoSlopeNorm::set_vmax

    source
    fn TwoSlopeNorm::set_vmax(self : TwoSlopeNorm, value : Double?) -> Unit raise NormalizeError

    Set the upper data bound while preserving the center ordering.

    TwoSlopeNorm::set_vmin

    source
    fn TwoSlopeNorm::set_vmin(self : TwoSlopeNorm, value : Double?) -> Unit raise NormalizeError

    Set the lower data bound while preserving the center ordering.

    TwoSlopeNorm::transform

    source
    fn TwoSlopeNorm::transform(self : TwoSlopeNorm, value : Double) -> Double raise NormalizeError

    Transform one finite scalar with the center at 0.5.

    TwoSlopeNorm::transform_array

    source
    fn TwoSlopeNorm::transform_array(self : TwoSlopeNorm, values : Array[Double]) -> Array[Double] raise NormalizeError

    Fill missing bounds and transform every finite value.

    TwoSlopeNorm::vcenter

    source
    fn TwoSlopeNorm::vcenter(self : TwoSlopeNorm) -> Double

    Return the center value mapped to 0.5.

    TwoSlopeNorm::vmax

    source
    fn TwoSlopeNorm::vmax(self : TwoSlopeNorm) -> Double?

    Return the upper data bound, if one has been set.

    TwoSlopeNorm::vmin

    source
    fn TwoSlopeNorm::vmin(self : TwoSlopeNorm) -> Double?

    Return the lower data bound, if one has been set.

    boundary_color_norm

    source
    fn boundary_color_norm(value : BoundaryNorm) -> ColorNorm

    Wrap a boundary normalization as a polymorphic color normalization.

    boundary_norm

    source
    fn boundary_norm(boundaries : Array[Double], ncolors : Int, clip? : Bool, extend_mode? : String) -> BoundaryNorm raise NormalizeError

    Construct a discrete boundary normalization. extend_mode maps Matplotlib's extend parameter, avoiding a MoonBit keyword.

    centered_color_norm

    source
    fn centered_color_norm(value : CenteredNorm) -> ColorNorm

    Wrap a centered normalization as a polymorphic color normalization.

    centered_norm

    source
    fn centered_norm(vcenter? : Double, halfrange? : Double, clip? : Bool) -> CenteredNorm raise NormalizeError

    Construct a centered normalization around vcenter.

    colormap

    source
    fn colormap(name : String) -> ColorMap raise ColorError

    Return a named builtin colormap.

    custom_colormap

    source
    fn custom_colormap(name : String, stops : Array[Rgba]) -> ColorMap raise ColorError

    Construct a named colormap from at least one color stop.

    find_colormap

    source
    fn find_colormap(name : String) -> ColorMap?

    Return a named builtin colormap, if it exists.

    linear_color_norm

    source
    fn linear_color_norm(value : Normalize) -> ColorNorm

    Wrap a linear normalization as a polymorphic color normalization.

    listed_colormap

    source
    fn listed_colormap(name : String, colors : Array[Rgba]) -> ColorMap raise ColorError

    Construct a colormap whose entries are selected without interpolation.

    log_color_norm

    source
    fn log_color_norm(value : LogNorm) -> ColorNorm

    Wrap a logarithmic normalization as a polymorphic color normalization.

    log_norm

    source
    fn log_norm(vmin? : Double, vmax? : Double, clip? : Bool, base? : Double) -> LogNorm raise NormalizeError

    Construct a logarithmic normalization with the given logarithm base.

    normalize

    source
    fn normalize(vmin? : Double, vmax? : Double, clip? : Bool) -> Normalize raise NormalizeError

    Construct a linear normalization.

    parse_color

    source
    fn parse_color(value : String) -> Rgba raise ColorError

    Parse a small CSS-compatible color vocabulary and hexadecimal colors.

    power_color_norm

    source
    fn power_color_norm(value : PowerNorm) -> ColorNorm

    Wrap a power-law normalization as a polymorphic color normalization.

    power_norm

    source
    fn power_norm(gamma : Double, vmin? : Double, vmax? : Double, clip? : Bool) -> PowerNorm raise NormalizeError

    Construct a power-law normalization.

    rgb

    source
    fn rgb(red : Double, green : Double, blue : Double) -> Rgb raise ColorError

    Construct an opaque RGB value after validating all components.

    rgba

    source
    fn rgba(red : Double, green : Double, blue : Double, alpha? : Double) -> Rgba raise ColorError

    Construct an RGBA value after validating all components.

    symlog_color_norm

    source
    fn symlog_color_norm(value : SymLogNorm) -> ColorNorm

    Wrap a symmetric-log normalization as a polymorphic color normalization.

    symlog_norm

    source
    fn symlog_norm(linthresh : Double, linscale? : Double, vmin? : Double, vmax? : Double, clip? : Bool, base? : Double) -> SymLogNorm raise NormalizeError

    Construct a symmetric-log normalization around zero.

    linthresh controls the linear region around zero. linscale controls the visual width of that region and base controls the logarithmic decades outside it. Missing bounds are filled by autoscale_none.

    two_slope_color_norm

    source
    fn two_slope_color_norm(value : TwoSlopeNorm) -> ColorNorm

    Wrap a two-slope normalization as a polymorphic color normalization.

    two_slope_norm

    source
    fn two_slope_norm(vcenter : Double, vmin? : Double, vmax? : Double) -> TwoSlopeNorm raise NormalizeError

    Construct a two-slope normalization with vcenter mapped to 0.5.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io