Struct LineChart 

pub struct LineChart<C: PixelColor> { /* private fields */ }

Line chart implementation for displaying continuous data series.

A line chart connects data points with straight lines (or smooth curves when enabled), making it ideal for showing trends over time or continuous relationships between variables. This implementation is optimized for embedded systems with static memory allocation and efficient rendering.

Features

• Configurable line styling (color, width, smoothing)
• Optional markers at data points with various shapes
• Area filling under the line
• Integration with grid systems and axes
• Support for animations and real-time data streaming

Memory Usage

The line chart uses static allocation with a maximum of 256 data points per series. Additional memory is used for:

• Screen coordinate transformation (256 points)
• Area fill polygon vertices (258 points maximum)
• Grid and axis rendering buffers

Examples

Basic line chart:

use embedded_charts::prelude::*;
use embedded_graphics::pixelcolor::Rgb565;

let chart: LineChart<Rgb565> = LineChart::new();
let mut data: StaticDataSeries<Point2D, 256> = StaticDataSeries::new();
data.push(Point2D::new(0.0, 10.0))?;
data.push(Point2D::new(1.0, 20.0))?;

Styled line chart with markers:

use embedded_charts::prelude::*;
use embedded_graphics::pixelcolor::Rgb565;

let chart = LineChart::builder()
    .line_color(Rgb565::BLUE)
    .line_width(2)
    .with_markers(MarkerStyle {
        shape: MarkerShape::Circle,
        size: 6,
        color: Rgb565::RED,
        visible: true,
    })
    .build()?;

Implementations

impl<C> LineChart<C>

where C: From<Rgb565> + PixelColor,

pub fn new() -> Self

Create a new line chart with default styling.

This creates a line chart with:

• Blue line color
• 1-pixel line width
• No area fill
• No markers
• No smoothing
• Default margins (10 pixels on all sides)

Examples

use embedded_charts::prelude::*;
use embedded_graphics::pixelcolor::Rgb565;

let chart: LineChart<Rgb565> = LineChart::new();

pub fn builder() -> LineChartBuilder<C>

Create a builder for configuring the line chart.

The builder pattern provides a fluent interface for configuring all aspects of the line chart before creation.

Examples

use embedded_charts::prelude::*;
use embedded_graphics::pixelcolor::Rgb565;

let chart = LineChart::builder()
    .line_color(Rgb565::BLUE)
    .line_width(2)
    .with_markers(MarkerStyle::default())
    .build()?;

pub fn set_style(&mut self, style: LineChartStyle<C>)

Set the line style configuration.

This replaces the entire style configuration with the provided one. Use the builder pattern for more granular control.

Arguments

• style - The new line chart style configuration

Examples

use embedded_charts::prelude::*;
use embedded_graphics::pixelcolor::Rgb565;

let mut chart = LineChart::new();
let style = LineChartStyle {
    line_color: Rgb565::RED,
    line_width: 3,
    fill_area: true,
    fill_color: Some(Rgb565::CSS_LIGHT_CORAL),
    markers: None,
    smooth: false,
    smooth_subdivisions: 8,
};
chart.set_style(style);

pub fn style(&self) -> &LineChartStyle<C>

Get the current line style configuration.

Returns a reference to the current style configuration, allowing inspection of current settings.

Returns

A reference to the current LineChartStyle

pub fn set_config(&mut self, config: ChartConfig<C>)

Set the chart configuration.

This includes general chart settings like title, background color, margins, and grid visibility.

Arguments

• config - The new chart configuration

pub fn config(&self) -> &ChartConfig<C>

Get the current chart configuration.

Returns

A reference to the current ChartConfig

pub fn set_grid(&mut self, grid: Option<GridSystem<C>>)

Set the grid system for the chart.

The grid system draws background grid lines to help with data reading. Pass None to disable the grid.

Arguments

• grid - Optional grid system configuration

Examples

use embedded_charts::prelude::*;
use embedded_graphics::pixelcolor::Rgb565;

let mut chart: LineChart<Rgb565> = LineChart::new();
// Grid configuration is simplified in this example
let grid: LinearGrid<Rgb565> = LinearGrid::new(GridOrientation::Horizontal, GridSpacing::DataUnits(10.0));
// chart.set_grid(Some(grid)); // Grid system API still evolving

pub fn grid(&self) -> Option<&GridSystem<C>>

Get the current grid system configuration.

Returns

An optional reference to the current grid system

Trait Implementations

impl<C> AxisChart<C> for LineChart<C>

where C: From<Rgb565> + PixelColor + 'static,

type XAxis = LinearAxis<f32, C>

X-axis type

type YAxis = LinearAxis<f32, C>

Y-axis type

fn set_x_axis(&mut self, axis: LinearAxis<f32, C>)

Set the X-axis configuration

fn set_y_axis(&mut self, axis: LinearAxis<f32, C>)

Set the Y-axis configuration

fn x_axis(&self) -> ChartResult<&LinearAxis<f32, C>>

Get the X-axis configuration

fn y_axis(&self) -> ChartResult<&LinearAxis<f32, C>>

Get the Y-axis configuration

impl<C> Chart<C> for LineChart<C>

where C: From<Rgb565> + PixelColor + 'static,

type Data = StaticDataSeries<Point2D, 256>

The type of data this chart can render

type Config = ChartConfig<C>

Configuration type for this chart

fn draw<D>( &self, data: &Self::Data, config: &Self::Config, viewport: Rectangle, target: &mut D, ) -> ChartResult<()>

where D: DrawTarget<Color = C>, Self::Data: DataSeries, <Self::Data as DataSeries>::Item: DataPoint, <<Self::Data as DataSeries>::Item as DataPoint>::X: Into<f32> + Copy + PartialOrd, <<Self::Data as DataSeries>::Item as DataPoint>::Y: Into<f32> + Copy + PartialOrd,

Draw the chart to the target display

fn data_bounds(&self, _data: &Self::Data) -> ChartResult<()>

Get the data bounds for this chart

impl<C: Debug + PixelColor> Debug for LineChart<C>

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

Formats the value using the given formatter.

impl<C> Default for LineChart<C>

where C: From<Rgb565> + PixelColor,

fn default() -> Self

Returns the “default value” for a type.