Struct audio_processor_testing_helpers::charts::ChartContext

pub struct ChartContext<'a, DB, CT> where
    DB: DrawingBackend,
    CT: CoordTranslate,  { /* private fields */ }

The context of the chart. This is the core object of Plotters. Any plot/chart is abstracted as this type, and any data series can be placed to the chart context.

• To draw a series on a chart context, use ChartContext::draw_series
• To draw a single element to the chart, you may want to use ChartContext::plotting_area

Implementations

impl<'a, DB, XT, YT, X, Y> ChartContext<'a, DB, Cartesian2d<X, Y>> where
    DB: DrawingBackend,
    X: Ranged<ValueType = XT> + ValueFormatter<XT>,
    Y: Ranged<ValueType = YT> + ValueFormatter<YT>, 

pub fn configure_mesh(&mut self) -> MeshStyle<'a, '_, X, Y, DB>

Initialize a mesh configuration object and mesh drawing can be finalized by calling the function MeshStyle::draw.

impl<'a, DB, CT> ChartContext<'a, DB, CT> where
    DB: DrawingBackend,
    CT: ReverseCoordTranslate, 

pub fn into_coord_trans(self) -> impl Fn((i32, i32))

Convert the chart context into an closure that can be used for coordinate translation

impl<'a, DB, CT> ChartContext<'a, DB, CT> where
    DB: DrawingBackend,
    CT: CoordTranslate, 

pub fn configure_series_labels(&'b mut self) -> SeriesLabelStyle<'a, 'b, DB, CT> where
    DB: 'a, 

Configure the styles for drawing series labels in the chart

pub fn plotting_area(&self) -> &DrawingArea<DB, CT>

Get a reference of underlying plotting area

pub fn as_coord_spec(&self) -> &CT

Cast the reference to a chart context to a reference to underlying coordinate specification.

pub fn draw_series<B, E, R, S>(
    &mut self,
    series: S
) -> Result<&mut SeriesAnno<'a, DB>, DrawingAreaErrorKind<<DB as DrawingBackend>::ErrorType>> where
    B: CoordMapper,
    E: Drawable<DB, B>,
    R: Borrow<E>,
    S: IntoIterator<Item = R>,
    &'b E: for<'b> PointCollection<'b, <CT as CoordTranslate>::From, B>, 

Draw a data series. A data series in Plotters is abstracted as an iterator of elements

impl<'a, DB, X, Y> ChartContext<'a, DB, Cartesian2d<X, Y>> where
    DB: DrawingBackend,
    X: Ranged,
    Y: Ranged, 

pub fn x_range(&self) -> Range<<X as Ranged>::ValueType>

Get the range of X axis

pub fn y_range(&self) -> Range<<Y as Ranged>::ValueType>

Get range of the Y axis

pub fn backend_coord(
    &self,
    coord: &(<X as Ranged>::ValueType, <Y as Ranged>::ValueType)
) -> (i32, i32)

Maps the coordinate to the backend coordinate. This is typically used with an interactive chart.

pub fn set_secondary_coord<SX, SY>(
    self,
    x_coord: SX,
    y_coord: SY
) -> DualCoordChartContext<'a, DB, Cartesian2d<X, Y>, Cartesian2d<<SX as AsRangedCoord>::CoordDescType, <SY as AsRangedCoord>::CoordDescType>> where
    SX: AsRangedCoord,
    SY: AsRangedCoord, 

Convert this chart context into a dual axis chart context and attach a second coordinate spec on the chart context. For more detailed information, see documentation for struct DualCoordChartContext

• x_coord: The coordinate spec for the X axis
• y_coord: The coordinate spec for the Y axis
• returns The newly created dual spec chart context

impl<'a, DB, X, Y, Z, XT, YT, ZT> ChartContext<'a, DB, Cartesian3d<X, Y, Z>> where
    DB: DrawingBackend,
    X: Ranged<ValueType = XT> + ValueFormatter<XT>,
    Y: Ranged<ValueType = YT> + ValueFormatter<YT>,
    Z: Ranged<ValueType = ZT> + ValueFormatter<ZT>, 

pub fn configure_axes(&mut self) -> Axes3dStyle<'a, '_, X, Y, Z, DB>

impl<'a, DB, X, Y, Z> ChartContext<'a, DB, Cartesian3d<X, Y, Z>> where
    X: Ranged,
    Y: Ranged,
    Z: Ranged,
    DB: DrawingBackend, 

pub fn with_projection<P>(
    &mut self,
    pf: P
) -> &mut ChartContext<'a, DB, Cartesian3d<X, Y, Z>> where
    P: FnOnce(ProjectionMatrixBuilder) -> ProjectionMatrix, 

Override the 3D projection matrix. This function allows to override the default projection matrix.

• pf: A function that takes the default projection matrix configuration and returns the projection matrix. This function will allow you to adjust the pitch, yaw angle and the centeral point of the projection, etc. You can also build a projection matrix which is not relies on the default configuration as well.

pub fn set_3d_pixel_range(
    &mut self,
    size: (i32, i32, i32)
) -> &mut ChartContext<'a, DB, Cartesian3d<X, Y, Z>>

impl<'a, DB, CT> ChartContext<'a, DB, CT> where
    DB: DrawingBackend,
    CT: CoordTranslate, 

pub fn into_chart_state(self) -> ChartState<CT>

Convert a chart context into a chart state, by doing so, the chart context is consumed and a saved chart state is created for later use. This is typically used in incrmental rendering. See documentation of ChartState for more detailed example.

pub fn into_shared_chart_state(self) -> ChartState<Arc<CT>>

Convert the chart context into a sharable chart state. Normally a chart state can not be clone, since the coordinate spec may not be able to be cloned. In this case, we can use an Arc get the coordinate wrapped thus the state can be cloned and shared by multiple chart context

impl<'a, DB, CT> ChartContext<'a, DB, CT> where
    DB: DrawingBackend,
    CT: CoordTranslate + Clone, 

pub fn to_chart_state(&self) -> ChartState<CT>

Make the chart context, do not consume the chart context and clone the coordinate spec