API
#
RecipesPipeline.Formatted
— Type
Represents data values with formatting that should apply to the tick labels.
#
RecipesPipeline.GroupBy
— Type
A special type that will break up incoming data into groups, and allow for easier creation of grouped plots
#
RecipesPipeline.Surface
— Type
represents a contour or surface mesh
#
RecipesBase.is_key_supported
— Method
is_key_supported(key)
Check if the plotting package natively supports the attribute key
#
RecipesPipeline._apply_type_recipe
— _Method
_apply_type_recipe(plotattributes, v::T, letter)
Apply the type recipe with signature (::Type{T}, ::T)
.
#
RecipesPipeline._process_plotrecipes!
— _Method
_process_plotrecipes!(plt, kw_list)
Grab the first in line to be processed and pass it through apply_recipe
to generate a list of RecipeData
objects. If we applied a "plot recipe" without error, then add the returned datalist’s KWs, otherwise we just add the original KW.
#
RecipesPipeline._process_seriesrecipes!
— _Method
_process_seriesrecipes!(plt, kw_list)
Recursively apply series recipes until the backend supports the seriestype
#
RecipesPipeline._process_userrecipes!
— _Method
_process_userrecipes(plt, plotattributes, args)
Wrap input arguments in a RecipeData' vector and recursively apply user recipes and type recipes on the first element. Prepend the returned
RecipeDatavector. If an element with empy
argsis returned pop it from the vector, finish up, and it to vector of
Dicts with processed series. When all arguments are processed return the series
Dict`.
#
RecipesPipeline.add_series!
— Method
add_series!(plt, kw)
Adds the series defined by kw
to the plot object. For example Plots updates the current subplot arguments, expands extrema and pushes the the series to the series_list of plt
.
#
RecipesPipeline.get_axis_limits
— Method
get_axis_limits(plt, letter)
Get the limits for the axis specified by letter
(:x
, :y
or :z
) in plt
. If it errors, tryrange
from PlotUtils is used.
#
RecipesPipeline.is3d
— Method
is3d(::Type{Val{:myseriestype}})
Returns true
if myseriestype
represents a 3D series, false
otherwise.
#
RecipesPipeline.is_axis_attribute
— Method
is_axis_attribute(plt, attr)
Returns true
if attr
is an axis attribute, i.e. it applies to xattr
, yattr
and zattr
, otherwise false
.
#
RecipesPipeline.is_seriestype_supported
— Method
is_seriestype_supported(plt, st)
Check if the plotting package natively supports the seriestype st
.
#
RecipesPipeline.is_subplot_attribute
— Method
is_subplot_attribute(plt, attr)
Returns true
if attr
is a subplot attribute, otherwise false
.
#
RecipesPipeline.is_surface
— Method
is_surface(::Type{Val{:myseriestype}})
Returns true
if myseriestype
represents a surface series, false
otherwise.
#
RecipesPipeline.needs_3d_axes
— Method
needs_3d_axes(::Type{Val{:myseriestype}})
Returns true
if myseriestype
needs 3d axes, false
otherwise.
#
RecipesPipeline.plot_setup!
— Method
plot_setup!(plt, plotattributes, kw_list)
Setup plot, subplots and layouts. For example, Plots creates the backend figure, initializes subplots, expands extrema and links subplot axes.
#
RecipesPipeline.postprocess_axis_args!
— Method
postprocess_axis_args!(plt, plotattributes, letter)
Removes the :letter
key from plotattributes
and does the same prepending of the letters as preprocess_axis_args!
.
#
RecipesPipeline.preprocess_attributes!
— Method
preprocess_attributes!(plt, plotattributes)
Any plotting package specific preprocessing of user or recipe input happens here. For example, Plots replaces aliases and expands magic arguments.
#
RecipesPipeline.preprocess_axis_args!
— Method
preprocess_axis_args!(plt, plotattributes, letter)
This version additionally stores the letter name in plotattributes[:letter]
.
#
RecipesPipeline.preprocess_axis_args!
— Method
preprocess_axis_args!(plt, plotattributes)
Preprocessing of axis attributes. Prepends the axis letter to axis attributes by default.
#
RecipesPipeline.process_sliced_series_attributes!
— Method
process_sliced_series_attributes!(plt, kw_list)
All series attributes are now properly resolved. Any change of the kw_list
before the application of recipes must come here.
#
RecipesPipeline.process_userrecipe!
— Method
process_userrecipe!(plt, attributes_list, attributes)
Do plotting package specific post-processing and add series attributes to attributes*list. For example, Plots increases the number of series in plt
, sets :series*plotindex
in attributes and possible adds new series attributes for errorbars or smooth.
#
RecipesPipeline.recipe_pipeline!
— Method
recipe_pipeline!(plt, plotattributes, args)
Recursively apply user recipes, type recipes, plot recipes and series recipes to build a list of Dict
s, each corresponding to a series. At the beginning, plotattributes
contains only the keyword arguments passed in by the user. Then, add all series to the plot object plt
and return it.
#
RecipesPipeline.series_defaults
— Method
series_defaults(plt)
Returns a Dict
storing the defaults for series attributes.
#
RecipesPipeline.slice_series_attributes!
— Method
slice_series_attributes!(plt, kw_list, kw)
For attributes given as vector with one element per series, only select the value for current series.
#
RecipesPipeline.split_attribute
— Method
split_attribute(plt, key, val, indices)
Select the proper indices from val
for attribute key
.
#
RecipesPipeline.splittable_attribute
— Method
splittable_attribute(plt, key, val, len)
Returns true
if the attribute key
with the value val
can be split into groups with group provided as a vector of length len
, false
otherwise.
#
RecipesPipeline.warn_on_recipe_aliases!
— Method
warn_on_recipe_aliases!(plt, plotattributes, recipe_type, args...)
Warn if an alias is detected in plotattributes
after a recipe of type recipe_type
is applied to 'args'. recipe_type
is either :user
, :type
, :plot
or :series
.