Help on recipe for Parallel Coordinate Plots [WIP]

[ConnectedSystems]

Hello!

I'm trying to create a plot recipe for a parallel coordinate plot for my own use and to address #1954

I'm running into a possible limitation where

1. it doesn't seem possible to modify a given plot within a recipe (e.g., remove axis decorations)
   To address the first, I've added a wrapper function (parallel_coordinates()) to make the changes I want.

2. I haven't gotten my head around the relationship between the defined Attributes() or Theme() in the recipe definition. How do I make use of them? Can I add custom attributes for a specific plot recipe (as with show_min/max below?)
   For example, you'll see I've included colors in the plot recipe, but I expect this should be an "inherited" attribute that I can reuse somehow

Please note this is an early attempt. I expect to rework things to support Observables properly in the future.

using GLMakie


"""
    pcp(data, limits, names, colors)

Creates a [parallel coordinate plot](https://en.wikipedia.org/wiki/Parallel_coordinates) with the given data.

# Arguments
- data : Matrix
- limits : Vector{Tuple} of known limits for each column in `data`
- names : Vector or Tuple of names (for x-axis)
- colors : colors to use for each line
"""
@recipe(Pcp, data, limits, names, colors) do scene
    Attributes(
        normalize=true,
        inspectable=theme(scene, :inspectable),
        visible=true,
        min_color_step=0.05,
        max_alpha=0.5,
        show_max=true,
        show_min=true
    )
end


"""
Parallel Coordinate Plot
"""
function Makie.plot!(plot::Pcp)
    data = plot[1][]
    lims = plot[2][]
    colors = plot[4][]
    min_color_step = plot.min_color_step[]
    max_alpha = plot.max_alpha[]
    k, n = size(data)

    data = hcat([(d .- mi) ./ (ma - mi) for (d, (mi, ma)) in zip(eachcol(data), lims)]...)

    # Make vertical bars for each column
    vlines!(plot, 1:n; color=:black, strokewidth=4)

    # Determine alpha level for each series, up to `max_alpha`
    color_weight = min((1.0 / k / min_color_step), max_alpha)
    for i in 1:k
        lines!(plot, data[i, :], color=(colors[i], color_weight))
    end

    return plot
end

function parallel_coordinates(data, limits, names, colors; kwargs...)

    fig, ax, _ = pcp(data, limits, names, colors; kwargs...)
    k, n = size(data)

    ax.xticks = (collect(1:n), names)
    # ax.xticklabelrotation = 0.45

    ylims!(ax, 0, 1)
    hideydecorations!(ax)
    hidespines!(ax)

    # How to actually access plot attributes?
    if any(kwargs[:show_max])  # kwargs[:show_min]
        for (idx, l) in enumerate(limits)
            # if kwargs[:show_min]
            #     text!(ax, string(l[1]), position=(idx - 0.2, 0))
            # end
            if kwargs[:show_max]
                text!(ax, string(l[2]), position=(idx, 0.95))  # margin=(0, 5, 0, 0)
            end
        end
    end

    fig
end

Current WIP figure:

[jkrumbiegel]

Hi, thank you for the PR!

I think plot recipes are not the right tool for this job, because a parallel plot consists of multiple axes in a particular arrangement, while plot recipes are meant to build the visual primitives you place inside an Axis or Scene. You cannot currently change axis properties in recipes because a plot primitive in its basic form doesn't have an axis to control, it usually happens to be plotted inside an axis with certain settings like ticks and labels, but that's a different thing.

I've grabbed some parallel plot example off of Google, to me that looks like a composite plot with multiple axes side by side. For example, if the same thing were built as a plot recipe, the left side tick labels would have to remain inside the axis area unlike an Axis's labels which are outside of it because they belong to a different part of the figure.

Maybe one doesn't need a bunch of full Axis objects but instead can use the LineAxis object which makes the axis markings of Axis directly, placing a couple of those in a Scene. In any case, this seems more like it would need either a new Axis-like object or just a function building the assembly of Axes. In terms of api, the question would mostly be, how do you plot into that, because the semantics of a parallel plot are so different from a normal one. What do you think?

[ConnectedSystems]

Thanks - I think I misunderstood the purpose of recipes then. If I understand correctly, all I really need to do is write up two functions (e.g., pcp() and pcp!())? If so, sounds easy enough. If not, could you point me to existing functions that I can adapt for this?

I can't seem to find LineAxis documented

I'll set up a proper PR once I get it working smoothly.

the semantics of a parallel plot are so different from a normal one.

In my mind, it's not so different. Unless I've misunderstood your position.

# Dummy data (could be a dataframe or named array/tuple instead?)
y = rand(2, 10)  # 2 experiments (the lines), 10 dimensions (cylinders, displacement, etc in your example)
dim_names = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"]

pcp(data, dim_names; some_additional_options)
pcp!(ax, data, dim_names; some_additional_options)

The additional options here would control the usual attributes plus whether to display just the min/max for each axis marking.

[ConnectedSystems]

I think I am close.

Mocked it up by layering multiple Axis objects that hold the y-axis for each dimension over a main figure that displays the series.
Tried to use the LineAxis as suggested but I couldn't get it to work. I don't understand Makie internals well enough I think.

As you can see, the main stumbling block is aligning the series data with x-axis of the main plot. A bit tricky cos of the padding and margins etc etc, so not the best way of doing this I know.
Is there a way of extracting the y-axes and placing them precisely along the x-axis of the main figure?

Here is an alternate figure with the decorations for the main Axis displayed so you can see the misalignment clearer.

[behinger]

some students of mine implemented a version using LinkedAxes - maybe this is helpful to combine?

I'm not convinced our solution is a particularly good one, but the LinekdAxes work.

https://github.com/unfoldtoolbox/UnfoldMakie.jl/blob/refactorV0.3/src/plot_parallelcoordinates.jl