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 returnedRecipeDatavector. If an element with empyargsis returned pop it from the vector, finish up, and it to vector ofDicts with processed series. When all arguments are processed return the seriesDict`.
#
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 Dicts, 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.