Module ranged1d

The one-dimensional coordinate system abstraction.

Plotters build complex coordinate system with a combinator pattern and all the coordinate system is built from the one dimensional coordinate system. This module defines the fundamental types used by the one-dimensional coordinate system.

The key trait for a one dimensional coordinate is Ranged. This trait describes a set of values which served as the 1D coordinate system in Plotters. In order to extend the coordinate system, the new coordinate spec must implement this trait.

The following example demonstrate how to make a customized coordinate specification

use plotters::coord::ranged1d::{Ranged, DefaultFormatting, KeyPointHint};
use std::ops::Range;

struct ZeroToOne;

impl Ranged for ZeroToOne {
  type ValueType = f64;
  type FormatOption = DefaultFormatting;

  fn map(&self, &v: &f64, pixel_range: (i32, i32)) -> i32 {
     let size = pixel_range.1 - pixel_range.0;
     let v = v.min(1.0).max(0.0);
     ((size as f64) * v).round() as i32
  }

  fn key_points<Hint:KeyPointHint>(&self, hint: Hint) -> Vec<f64> {
      if hint.max_num_points() < 3 {
          vec![]
      } else {
          vec![0.0, 0.5, 1.0]
      }
  }

  fn range(&self) -> Range<f64> {
      0.0..1.0
  }
}

use plotters::prelude::*;

let mut buffer = vec![0; 1024 * 768 * 3];
let root = BitMapBackend::with_buffer(&mut buffer, (1024, 768)).into_drawing_area();

let chart = ChartBuilder::on(&root)
  .build_cartesian_2d(ZeroToOne, ZeroToOne)
  .unwrap();

Structs

• BoldPoints
  The key point hint indicates we only need key point for the bold grid lines
• DefaultFormatting
  This makes the ranged coord uses the default Debug based formatting
• LightPoints
  The key point hint indicates that we are using the key points for the light grid lines
• NoDefaultFormatting
  This markers prevent Plotters to implement the default Debug based formatting
• SegmentedCoord
  A SegmentedCoord is a decorator on any discrete coordinate specification. This decorator will convert the discrete coordinate in two ways:

Enums

• KeyPointWeight
  Specify the weight of key points.
• SegmentValue
  The value that used by the segmented coordinate.

Traits

• AsRangedCoord
  The trait for the type that can be converted into a ranged coordinate axis
• DefaultValueFormatOption
  Since stable Rust doesn’t have specialization, it’s very hard to make our own trait that automatically implemented the value formatter. This trait uses as a marker indicates if we should automatically implement the default value formatter based on it’s Debug trait
• DiscreteRanged
  The trait indicates the coordinate is discrete This means we can bidirectionally map the range value to 0 to N in which N is the number of distinct values of the range.
• IntoSegmentedCoord
  The trait for types that can decorated by SegmentedCoord decorator.
• KeyPointHint
  The trait for a hint provided to the key point algorithm used by the coordinate specs. The most important constraint is the max_num_points which means the algorithm could emit no more than specific number of key points weight is used to determine if this is used as a bold grid line or light grid line bold_points returns the max number of corresponding bold grid lines
• Ranged
  The trait that indicates we have a ordered and ranged value Which is used to describe any 1D axis.
• ReversibleRanged
  The trait indicates the ranged value can be map reversely, which means an pixel-based coordinate is given, it’s possible to figure out the underlying logic value.
• ValueFormatter
  Determine how we can format a value in a coordinate system by default