Struct gnuplot::Axes2D

pub struct Axes2D { /* fields omitted */ }

2D axes that is used for drawing 2D plots

Methods

impl Axes2D

pub fn set_border<'l>(
    &'l mut self,
    front: bool,
    locations: &[BorderLocation2D],
    options: &[PlotOption<&str>]
) -> &'l mut Self

Sets the properties of the plot border

Arguments

• front - Whether or not to draw the border above or below the plot contents
• locations - Which locations of the border to draw
• options - Array of PlotOption controlling the appearance of the border. Relevant options are:
  • Color - Specifies the color of the border
  • LineStyle - Specifies the style of the border
  • LineWidth - Specifies the width of the border

pub fn set_x_axis<'l>(
    &'l mut self,
    show: bool,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Sets the properties of x axis.

Arguments

• show - Whether or not draw the axis
• options - Array of PlotOption<&str> controlling the appearance of the axis. Relevant options are:
  • Color - Specifies the color of the border
  • LineStyle - Specifies the style of the border
  • LineWidth - Specifies the width of the border

pub fn set_y_axis<'l>(
    &'l mut self,
    show: bool,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Like set_x_axis but for the y axis.

pub fn arrow<'l>(
    &'l mut self,
    x1: Coordinate,
    y1: Coordinate,
    x2: Coordinate,
    y2: Coordinate,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Adds an arrow to the plot. The arrow is drawn from (x1, y1) to (x2, y2) with the arrow point towards (x2, y2).

Arguments

• x1 - X coordinate of the arrow start
• y1 - Y coordinate of the arrow start
• x2 - X coordinate of the arrow end
• y2 - Y coordinate of the arrow end
• options - Array of PlotOption<&str> controlling the appearance of the arrowhead and arrow shaft. Relevant options are:
  • ArrowType - Specifies the style of the arrow head (or an option to omit it)
  • ArrowSize - Sets the size of the arrow head (in graph units)
  • Color - Specifies the color of the arrow
  • LineStyle - Specifies the style of the arrow shaft
  • LineWidth - Specifies the width of the arrow shaft

pub fn set_legend<'l>(
    &'l mut self,
    x: Coordinate,
    y: Coordinate,
    legend_options: &[LegendOption<&str>],
    text_options: &[LabelOption<&str>]
) -> &'l mut Self

Specifies the location and other properties of the legend

Arguments

• x - X coordinate of the legend
• y - Y coordinate of the legend
• legend_options - Array of LegendOption options
• text_options - Array of LabelOption options specifying the appearance of the plot titles. Valid options are:
  • Font
  • TextColor
  • TextAlign(AlignLeft)
  • TextAlign(AlignRight)

pub fn lines<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>>(
    &'l mut self,
    x: X,
    y: Y,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot with lines connecting each data point

Arguments

• x - x values
• y - y values
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • LineWidth - Sets the width of the line
  • LineStyle - Sets the style of the line
  • Color - Sets the color

pub fn points<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>>(
    &'l mut self,
    x: X,
    y: Y,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot with a point standing in for each data point

Arguments

• x - x values
• y - y values
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • PointSymbol - Sets symbol for each point
  • PointSize - Sets the size of each point
  • Color - Sets the color

pub fn lines_points<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>>(
    &'l mut self,
    x: X,
    y: Y,
    options: &[PlotOption<&str>]
) -> &'l mut Self

A combination of lines and points methods (drawn in that order).

Arguments

• x - x values
• y - y values
• options - Array of PlotOption<&str> controlling the appearance of the plot element

pub fn x_error_bars<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>, Txe: DataType, XE: IntoIterator<Item = Txe>>(
    &'l mut self,
    x: X,
    y: Y,
    x_error: XE,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot with a point standing in for each data point. Additionally, error bars are attached to each data point in the X direction.

Arguments

• x - x values
• y - y values
• x_error - Errors associated with the x value
• options - Array of PlotOption controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • PointSymbol - Sets symbol for each point
  • PointSize - Sets the size of each point
  • Color - Sets the color

pub fn y_error_bars<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>, Tye: DataType, YE: IntoIterator<Item = Tye>>(
    &'l mut self,
    x: X,
    y: Y,
    y_error: YE,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot with a point standing in for each data point. Additionally, error bars are attached to each data point in the Y direction.

Arguments

• x - x values
• y - y values
• y_error - Errors associated with the y values
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • PointSymbol - Sets symbol for each point
  • PointSize - Sets the size of each point
  • Color - Sets the color

pub fn x_error_lines<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>, Txe: DataType, XE: IntoIterator<Item = Txe>>(
    &'l mut self,
    x: X,
    y: Y,
    x_error: XE,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot with a point standing in for each data point and lines connecting each data point. Additionally, error bars are attached to each data point in the X direction.

Arguments

• x - x values
• y - y values
• x_error - Errors associated with the x value
• options - Array of PlotOption controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • PointSymbol - Sets symbol for each point
  • PointSize - Sets the size of each point
  • LineWidth - Sets the width of the line
  • LineStyle - Sets the style of the line
  • Color - Sets the color

pub fn y_error_lines<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>, Tye: DataType, YE: IntoIterator<Item = Tye>>(
    &'l mut self,
    x: X,
    y: Y,
    y_error: YE,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot with a point standing in for each data point and lines connecting each data point. Additionally, error bars are attached to each data point in the Y direction.

Arguments

• x - x values
• y - y values
• y_error - Errors associated with the y values
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • PointSymbol - Sets symbol for each point
  • PointSize - Sets the size of each point
  • LineWidth - Sets the width of the line
  • LineStyle - Sets the style of the line
  • Color - Sets the color

pub fn fill_between<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Tyl: DataType, YL: IntoIterator<Item = Tyl>, Tyh: DataType, YH: IntoIterator<Item = Tyh>>(
    &'l mut self,
    x: X,
    y_lo: YL,
    y_hi: YH,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot of two curves (bound by y_lo and y_hi) with a filled region between them. FillRegion plot option can be used to control what happens when the curves intersect. If set to Above, then the y_lo < y_hi region is filled. If set to Below, then the y_lo > y_hi region is filled. Otherwise both regions are filled.

Arguments

• x - x values
• y_lo - Bottom y values
• y_hi - Top y values
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • FillRegion - Specifies the region between the two curves to fill
  • Color - Sets the color of the filled region
  • FillAlpha - Sets the transparency of the filled region

pub fn boxes<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>>(
    &'l mut self,
    x: X,
    y: Y,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot using boxes of automatic width. Box widths are set so that there are no gaps between successive boxes (i.e. each box may have a different width). Boxes start at the x-axis and go towards the y value of the datapoint.

Arguments

• x - x values (center of the box)
• y - y values
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • LineWidth - Sets the width of the border
  • LineStyle - Sets the style of the border
  • BorderColor - Sets the color of the border
  • Color - Sets the color of the box fill
  • FillAlpha - Sets the transparency of the box fill

pub fn boxes_set_width<'l, Tx: DataType, X: IntoIterator<Item = Tx>, Ty: DataType, Y: IntoIterator<Item = Ty>, Tw: DataType, W: IntoIterator<Item = Tw>>(
    &'l mut self,
    x: X,
    y: Y,
    w: W,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D scatter-plot using boxes of set (per box) width. Boxes start at the x-axis and go towards the y value of the datapoint.

Arguments

• x - x values (center of the box)
• y - y values
• w - Box width values
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • LineWidth - Sets the width of the border
  • LineStyle - Sets the style of the border
  • BorderColor - Sets the color of the border
  • Color - Sets the color of the box fill
  • FillAlpha - Sets the transparency of the box fill

pub fn box_and_whisker<'l, Tx: DataType, X: IntoIterator<Item = Tx>, TBoxMin: DataType, BoxMin: IntoIterator<Item = TBoxMin>, TWhiskerMin: DataType, WhiskerMin: IntoIterator<Item = TWhiskerMin>, TWhiskerMax: DataType, WhiskerMax: IntoIterator<Item = TWhiskerMax>, TBoxMax: DataType, BoxMax: IntoIterator<Item = TBoxMax>>(
    &'l mut self,
    x: X,
    box_min: BoxMin,
    whisker_min: WhiskerMin,
    whisker_max: WhiskerMax,
    box_max: BoxMax,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D box-and-whisker plot using boxes of automatic width.

Arguments

• x - x values (center of the box)
• box_min - minimum box y value
• whisker_min - minimum whisker y value
• whisker_max - maximum whisker y value
• box_max - maximum box y value
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • LineWidth - Sets the width of the border
  • LineStyle - Sets the style of the border
  • BorderColor - Sets the color of the border
  • Color - Sets the color of the box fill
  • FillAlpha - Sets the transparency of the box fill
  • WhiskerBars - Sets the width of the whisker bars

pub fn box_and_whisker_set_width<'l, Tx: DataType, X: IntoIterator<Item = Tx>, TBoxMin: DataType, BoxMin: IntoIterator<Item = TBoxMin>, TWhiskerMin: DataType, WhiskerMin: IntoIterator<Item = TWhiskerMin>, TWhiskerMax: DataType, WhiskerMax: IntoIterator<Item = TWhiskerMax>, TBoxMax: DataType, BoxMax: IntoIterator<Item = TBoxMax>, TBoxWidth: DataType, BoxWidth: IntoIterator<Item = TBoxWidth>>(
    &'l mut self,
    x: X,
    box_min: BoxMin,
    whisker_min: WhiskerMin,
    whisker_max: WhiskerMax,
    box_max: BoxMax,
    box_width: BoxWidth,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Plot a 2D box-and-whisker plot using boxes of set width.

Arguments

• x - x values (center of the box)
• box_min - minimum box y value
• whisker_min - minimum whisker y value
• whisker_max - maximum whisker y value
• box_max - maximum box y value
• box_width - width of the box (in x axis units)
• options - Array of PlotOption<&str> controlling the appearance of the plot element. The relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).
  • LineWidth - Sets the width of the border
  • LineStyle - Sets the style of the border
  • BorderColor - Sets the color of the border
  • Color - Sets the color of the box fill
  • FillAlpha - Sets the transparency of the box fill
  • WhiskerBars - Sets the width of the whisker bars

pub fn image<'l, T: DataType, X: IntoIterator<Item = T>>(
    &'l mut self,
    mat: X,
    num_rows: usize,
    num_cols: usize,
    dimensions: Option<(f64, f64, f64, f64)>,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Draws an image from a rectangular array of data by connecting the individual datapoints with polygons.

#Arguments:

• mat - Row-major 2D array signifying the value of the datapoints. The X and Y coordinates of the datapoints are determined automatically, and optionally scaled using the dimensions argument.
• num_rows - Number of rows in the data array
• num_cols - Number of columns in the data array
• dimensions - Optional X and Y coordinates of the first and last data points (with the rest of the coordinates spaced evenly between). By default this will be (0, 0) and (num_rows - 1, num_cols - 1).
• options - Array of PlotOption<&str> controlling the appearance of the surface. Relevant options are:
  • Caption - Specifies the caption for this dataset. Use an empty string to hide it (default).

Trait Implementations

impl AxesCommon for Axes2D

fn set_pos_grid<'l>(
    &'l mut self,
    nrow: u32,
    ncol: u32,
    pos: u32
) -> &'l mut Self

Set the position of the axes on the figure using grid coordinates. # Arguments * nrow - Number of rows in the grid. Must be greater than 0. * ncol - Number of columns in the grid. Must be greater than 0. * pos - Which grid cell to place this axes in, counting from top-left corner, going left and then down, starting at 0.

fn set_pos<'l>(&'l mut self, x: f64, y: f64) -> &'l mut Self

Set the position of the axes on the figure using screen coordinates. The coordinates refer to the bottom-left corner of the axes # Arguments * x - X position. Ranges from 0 to 1 * y - Y position. Ranges from 0 to 1

fn set_size<'l>(&'l mut self, w: f64, h: f64) -> &'l mut Self

Set the size of the axes # Arguments * w - Width. Ranges from 0 to 1 * h - Height. Ranges from 0 to 1

fn set_aspect_ratio<'l>(&'l mut self, ratio: AutoOption<f64>) -> &'l mut Self

Set the aspect ratio of the axes # Arguments * ratio - The aspect ratio. Set to Auto to return the ratio to default

fn set_x_label<'l>(
    &'l mut self,
    text: &str,
    options: &[LabelOption<&str>]
) -> &'l mut Self

Set the label for the X axis # Arguments * text - Text of the label. Pass an empty string to hide the label * options - Array of LabelOption controlling the appearance of the label. Relevant options are: * Offset - Specifies the offset of the label * Font - Specifies the font of the label * TextColor - Specifies the color of the label * Rotate - Specifies the rotation of the label * Align - Specifies how to align the label

fn set_y_label<'l>(
    &'l mut self,
    text: &str,
    options: &[LabelOption<&str>]
) -> &'l mut Self

Like set_x_label, but for the Y axis

fn set_cb_label<'l>(
    &'l mut self,
    text: &str,
    options: &[LabelOption<&str>]
) -> &'l mut Self

Like set_x_label, but for the color bar

fn set_title<'l>(
    &'l mut self,
    text: &str,
    options: &[LabelOption<&str>]
) -> &'l mut Self

Set the title for the axes # Arguments * text - Text of the title. Pass an empty string to hide the title * options - Array of LabelOption<&str> controlling the appearance of the title. Relevant options are: * Offset - Specifies the offset of the label * Font - Specifies the font of the label * TextColor - Specifies the color of the label * Rotate - Specifies the rotation of the label * Align - Specifies how to align the label

fn label<'l>(
    &'l mut self,
    text: &str,
    x: Coordinate,
    y: Coordinate,
    options: &[LabelOption<&str>]
) -> &'l mut Self

Adds a label to the plot, with an optional marker. # Arguments * text - Text of the label * x - X coordinate of the label * y - Y coordinate of the label * options - Array of LabelOption<&str> controlling the appearance of the label. Relevant options are: * Offset - Specifies the offset of the label * Font - Specifies the font of the label * TextColor - Specifies the color of the label * Rotate - Specifies the rotation of the label * Align - Specifies how to align the label * MarkerSymbol - Specifies the symbol for the marker. Omit to hide the marker * MarkerSize - Specifies the size for the marker * MarkerColor - Specifies the color for the marker

fn set_x_ticks<'l>(
    &'l mut self,
    tick_placement: Option<(AutoOption<f64>, u32)>,
    tick_options: &[TickOption<&str>],
    label_options: &[LabelOption<&str>]
) -> &'l mut Self

Sets the properties of the ticks on the X axis.

fn set_y_ticks<'l>(
    &'l mut self,
    tick_placement: Option<(AutoOption<f64>, u32)>,
    tick_options: &[TickOption<&str>],
    label_options: &[LabelOption<&str>]
) -> &'l mut Self

Like set_x_ticks but for the Y axis.

fn set_cb_ticks<'l>(
    &'l mut self,
    tick_placement: Option<(AutoOption<f64>, u32)>,
    tick_options: &[TickOption<&str>],
    label_options: &[LabelOption<&str>]
) -> &'l mut Self

Like set_x_ticks but for the color bar axis.

fn set_x_ticks_custom<'l, T: DataType, S: ToString, TickT: Borrow<Tick<T, S>>, TL: IntoIterator<Item = TickT>>(
    &'l mut self,
    ticks: TL,
    tick_options: &[TickOption<&str>],
    label_options: &[LabelOption<&str>]
) -> &'l mut Self

Sets ticks on the X axis with specified labels at specified positions.

fn set_y_ticks_custom<'l, T: DataType, S: ToString, TickT: Borrow<Tick<T, S>>, TL: IntoIterator<Item = TickT>>(
    &'l mut self,
    ticks: TL,
    tick_options: &[TickOption<&str>],
    label_options: &[LabelOption<&str>]
) -> &'l mut Self

Like set_x_ticks_custom but for the the Y axis.

fn set_cb_ticks_custom<'l, T: DataType, S: ToString, TickT: Borrow<Tick<T, S>>, TL: IntoIterator<Item = TickT>>(
    &'l mut self,
    ticks: TL,
    tick_options: &[TickOption<&str>],
    label_options: &[LabelOption<&str>]
) -> &'l mut Self

Like set_x_ticks_custom but for the the color bar axis.

fn set_x_range<'l>(
    &'l mut self,
    min: AutoOption<f64>,
    max: AutoOption<f64>
) -> &'l mut Self

Set the range of values for the X axis.

fn set_y_range<'l>(
    &'l mut self,
    min: AutoOption<f64>,
    max: AutoOption<f64>
) -> &'l mut Self

Set the range of values for the Y axis.

fn set_x_reverse<'l>(&'l mut self, reverse: bool) -> &'l mut Self

Sets X axis to reverse. # Arguments * reverse - Boolean, true to reverse axis, false will not reverse

fn set_y_reverse<'l>(&'l mut self, reverse: bool) -> &'l mut Self

Sets Y axis to reverse. # Arguments * reverse - Boolean, true to reverse axis, false will not reverse

fn set_cb_range<'l>(
    &'l mut self,
    min: AutoOption<f64>,
    max: AutoOption<f64>
) -> &'l mut Self

Set the range of values for the color bar axis.

fn set_x_log<'l>(&'l mut self, base: Option<f64>) -> &'l mut Self

Sets the X axis be logarithmic. Note that the range must be non-negative for this to be valid.

fn set_y_log<'l>(&'l mut self, base: Option<f64>) -> &'l mut Self

Sets the Y axis be logarithmic. Note that the range must be non-negative for this to be valid.

fn set_cb_log<'l>(&'l mut self, base: Option<f64>) -> &'l mut Self

Sets the color bar axis be logarithmic. Note that the range must be non-negative for this to be valid.

fn set_x_grid<'l>(&'l mut self, show: bool) -> &'l mut Self

Shows the grid on the X axis.

fn set_x_minor_grid<'l>(&'l mut self, show: bool) -> &'l mut Self

Shows the minor grid on the X axis.

fn set_y_grid<'l>(&'l mut self, show: bool) -> &'l mut Self

Shows the grid on the Y axis.

fn set_y_minor_grid<'l>(&'l mut self, show: bool) -> &'l mut Self

Shows the minor grid on the Y axis.

fn set_cb_grid<'l>(&'l mut self, show: bool) -> &'l mut Self

Shows the grid on the color bar axis.

fn set_grid_options<'l>(
    &'l mut self,
    front: bool,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Set the grid options.

fn set_minor_grid_options<'l>(
    &'l mut self,
    options: &[PlotOption<&str>]
) -> &'l mut Self

Set the minor grid options.

fn set_x_time<'l>(&'l mut self, is_time: bool) -> &'l mut Self

Sets the X axis be time.

fn set_y_time<'l>(&'l mut self, is_time: bool) -> &'l mut Self

Sets the Y axis be time. Note that the range must be non-negative for this to be valid.

fn set_cb_time<'l>(&'l mut self, is_time: bool) -> &'l mut Self

Sets the color bar axis be time. Note that the range must be non-negative for this to be valid.

fn set_margins<'l>(&'l mut self, margins: &[MarginSide]) -> &'l mut Self

Sets the margins of the plot.

fn set_palette(&mut self, palette: PaletteType) -> &mut Self

Sets the palette used for 3D surface and image plots