AlgebraOfGraphics.jl

When you call draw(spec) in AlgebraOfGraphics, it returns a figuregrid object. This object contains two primary fields:

• figure: The Makie Figure object containing all visual elements.
• grid: An object containing AxisEntries for facet layouts.

You can access the figure to perform global modifications like changing the background color or resizing the canvas.

figuregrid = draw(spec)
figure = figuregrid.figure

# Change background color
figure.scene.backgroundcolor = Makie.to_color(:gray90)

# Resize the figure
resize!(figure, 500, 300)

The mapping function translates data columns into visual attributes of a plot. It accepts two types of arguments:

1. Positional arguments: Passed in order to the plotting function. For example, in Scatter, the first argument maps to the x-axis and the second to the y-axis.
2. Named arguments: Map data to specific visual attributes (keywords) like color, markersize, or linestyle. The available keywords depend on the specific plotting function being used.

To discover which arguments and aesthetics a specific plotting function supports, use show_aesthetics(PlotType).

mapping(:weight, :height)  # weight → x-axis, height → y-axis
mapping(:weight, :height, color = :age, markersize = :age)

# Check supported aesthetics for Scatter
show_aesthetics(Scatter)

AlgebraOfGraphics automatically treats numeric columns as continuous and other types as categorical.

• Continuous data: Mapping a numeric column to an aesthetic like color will automatically generate a Colorbar.
• Categorical data: Mapping a non-numeric column (e.g., :species) will automatically generate a Legend.

You can merge new mappings into an existing layer using the * operator.

# Continuous mapping
color_layer_continuous = layer * mapping(color = :body_mass_g)
draw(color_layer_continuous)

# Categorical mapping
color_layer_categorical = layer * mapping(color = :species)
draw(color_layer_categorical)

When combining multiple datasets (e.g., using data(df1) + data(df2)), you can manage the unified categorical scale in two ways:

1. Apply the same renamer to multiple mappings in the expression.
2. Set the global ordering and labeling in one place using the categories keyword in the draw call.

# Combining datasets
plt = (data(df1) + data(df2)) * mapping(:x, :y) * visual(BoxPlot)

# Setting the unified scale order/labels in one place
draw(plt, scales(X = (; 
    categories = ["one", "two", "three", "four"]
))

AlgebraOfGraphics uses algebraic operators to build complex plots from simple components:

• * (Multiplication): Used to combine a data specification with mappings or transformations (e.g., data(df) * mapping(...) or spec * mapping(col = :var) for faceting).
• + (Addition): Used to combine layers or visual properties within a specification (e.g., linear() + visual(alpha = 0.3)).

This allows for a highly modular approach to building plots, where you can start with a base specification and incrementally add color, facets, or statistical layers.

# Example of composition
spec = data(penguins) * mapping(:bill_length_mm, :bill_depth_mm)

# Adding color via multiplication
by_color = spec * mapping(color = :species)

# Adding a layer and visual property via addition
with_regression = by_color * (linear() + visual(alpha = 0.3))

In AlgebraOfGraphics, layers are the fundamental building blocks. A layer is constructed by combining four elementary objects using algebraic operations:

• Data: The dataset being encoded.
• Mapping: The association of variables from the dataset to specific plot attributes (e.g., mapping a column to the x-axis).
• Visual: Data-independent plot information (e.g., setting a fixed color or line width regardless of the data).
• Analyses: Transformations applied to the data before it is plotted (e.g., statistical transformations).

You can combine these objects using algebraic operations to form complex layers, which can then be visualized.

Faceting breaks visualizations into multiple axes (facets) to reduce overplotting. AlgebraOfGraphics provides three primary mappings for this:

• layout: Creates a wrapped layout that attempts an approximately square configuration of facets.
• col: Distributes groups along the columns of a grid.
• row: Distributes groups along the rows of a grid.

You can combine row and col to create a grid layout.

Note: You cannot combine layout with row or col facetting in the same specification.

# Wrapped layout
spec_layout = data(df) * mapping(:x, :y) * mapping(layout = :category)

# Grid layout (rows and columns)
spec_grid = data(df) * mapping(:x, :y) * mapping(row = :sex, col = :species)

In AlgebraOfGraphics, you can use the multiplication operator * on individual Layer objects. This is an associative operation used to combine partially defined layers. When you multiply two layers, the resulting layer is a composition where:

• Datasets can be replaced.
• Mappings can be merged.
• Transformations can be concatenated.

This is primarily useful for building complex layers from smaller, reusable components.

# Example concept (not a literal code snippet from source, but representing the logic)
layer_a * layer_b

Transformations within a mapping, such as mapping(:x => log => "log(x)"), are applied element-wise.

Whole-column operations are intentionally not supported to prevent errors when data is grouped or when multiple datasets are used.

If you require column-wise transformations (like calculating a density), you should:

1. Implement a custom analysis (e.g., density()) that accepts the whole data as input.
2. Apply the transformation directly to your data before passing it to AlgebraOfGraphics.