Improve dim converts recipe compatibility, usability

Makie/ext/MakieDynamicQuantitiesExt.jl

@@ -5,7 +5,6 @@ import DynamicQuantities as DQ
 
 M.expand_dimensions(::M.PointBased, y::AbstractVector{<:DQ.UnionAbstractQuantity}) = (keys(y), y)
 M.create_dim_conversion(::Type{<:DQ.UnionAbstractQuantity}) = M.DQConversion()
-M.should_dim_convert(::Type{<:DQ.UnionAbstractQuantity}) = true
 
 unit_string(quantity::DQ.UnionAbstractQuantity) = string(DQ.dimension(quantity))
 
@@ -24,18 +23,22 @@ function unit_convert(quantity::DQ.UnionAbstractQuantity, value)
 end
 
 needs_tick_update_observable(conversion::M.DQConversion) = conversion.quantity
+show_dim_convert_in_ticklabel(::M.DQConversion) = false
+show_dim_convert_in_axis_label(::M.DQConversion) = true
 
-function M.get_ticks(conversion::M.DQConversion, ticks, scale, formatter, vmin, vmax)
+function M.get_ticks(conversion::M.DQConversion, ticks, scale, formatter, vmin, vmax, show_in_label)
     quantity = conversion.quantity[]
     quantity isa M.Automatic && return [], []
     unit_str = unit_string(quantity)
     tick_vals, labels = M.get_ticks(ticks, scale, formatter, vmin, vmax)
-    if conversion.units_in_label[]
+    if show_in_label
         labels = labels .* unit_str
     end
     return tick_vals, labels
 end
 
+M.get_label_suffix(conversion::M.DQConversion) = unit_string(conversion.quantity[])
+
 function M.convert_dim_value(conversion::M.DQConversion, attr, values, last_values)
     if conversion.quantity[] isa M.Automatic
         conversion.quantity[] = oneunit(first(values))

Makie/src/Makie.jl

@@ -131,6 +131,7 @@ include("dim-converts/unitful-integration.jl")
 include("dim-converts/dynamic-quantities-integration.jl")
 include("dim-converts/categorical-integration.jl")
 include("dim-converts/dates-integration.jl")
+include("dim-converts/argument_dims.jl")
 
 include("scenes.jl")
 include("float32-scaling.jl")

Makie/src/basic_plots.jl

@@ -316,13 +316,7 @@ All volume plots are derived from casting rays for each drawn pixel. These rays
 intersect with the volume data to derive some color, usually based on the given
 colormap. How exactly the color is derived depends on the algorithm used.
 """
-@recipe Volume (
-    x::EndPoints,
-    y::EndPoints,
-    z::EndPoints,
-    # TODO: consider using RGB{N0f8}, RGBA{N0f8} instead of Vec/RGB(A){Float32}
-    volume::AbstractArray{<:Union{Float32, Vec3f, RGB{Float32}, Vec4f, RGBA{Float32}}, 3},
-) begin
+@recipe Volume (x, y, z, volume) begin
     """
     Sets the volume algorithm that is used. Available algorithms are:
     * `:iso`: Shows an isovalue surface within the given float data. For this only samples within `isovalue - isorange .. isovalue + isorange` are included in the final color of a pixel.
@@ -361,7 +355,7 @@ const VecOrMat{T} = Union{AbstractVector{T}, AbstractMatrix{T}}
 Plots a surface, where `(x, y)` define a grid whose heights are the entries in `z`.
 `x` and `y` may be `Vectors` which define a regular grid, **or** `Matrices` which define an irregular grid.
 """
-@recipe Surface (x::VecOrMat{<:FloatType}, y::VecOrMat{<:FloatType}, z::VecOrMat{<:FloatType}) begin
+@recipe Surface (x, y, z) begin
     "Can be set to an `Matrix{<: Union{Number, Colorant}}` to color surface independent of the `z` component. If `color=nothing`, it defaults to `color=z`. Can also be a `Makie.AbstractPattern`."
     color = nothing
     """
@@ -713,7 +707,12 @@ representation and may behave a bit differently than usual.
 Note that `voxels` is currently considered experimental and may still see breaking
 changes in patch releases.
 """
-@recipe Voxels (x, y, z, chunk) begin
+@recipe Voxels (
+    x::EndPoints{Float32},
+    y::EndPoints{Float32},
+    z::EndPoints{Float32},
+    chunk::Array{<:Real, 3},
+) begin
     "A function that controls which values in the input data are mapped to invisible (air) voxels."
     is_air = x -> isnothing(x) || ismissing(x) || isnan(x)
     """

Makie/src/basic_recipes/ablines.jl

@@ -8,6 +8,8 @@ You can pass one or multiple intercepts or slopes.
     documented_attributes(LineSegments)...
 end
 
+argument_dims(::Type{<:ABLines}, args...) = nothing
+
 function Makie.plot!(p::ABLines)
     scene = Makie.parent_scene(p)
     transf = transform_func(scene)

Makie/src/basic_recipes/annotation.jl

@@ -65,7 +65,7 @@ If no label positions are given, they will be determined automatically such
 that overlaps between labels and data points are reduced. In this mode, the labels should
 be very close to their associated data points so connection plots are typically not visible.
 """
-@recipe Annotation begin
+@recipe Annotation (merged_positions::VecTypesVector{4, <:Real},) begin
     """
     The color of the text labels. If `automatic`, `textcolor` matches `color`.
     """
@@ -167,40 +167,51 @@ function closest_point_on_rectangle(r::Rect2, p)
     return argmin(c -> norm(c - p), candidates)
 end
 
-function Makie.convert_arguments(::Type{<:Annotation}, x::Real, y::Real)
+argument_dims(::Type{<:Annotation}, x, y) = (1, 2)
+argument_dims(::Type{<:Annotation}, xy::VecTypes{2}) = ((1, 2),)
+argument_dims(::Type{<:Annotation}, xy::VecTypesVector{2}) = ((1, 2),)
+argument_dims(::Type{<:Annotation}, xy::VecTypes{4}) = ((1, 2, 1, 2),)
+argument_dims(::Type{<:Annotation}, xy::VecTypesVector{4}) = ((1, 2, 1, 2),)
+argument_dims(::Type{<:Annotation}, x, y, x2, y2) = (1, 2, 1, 2)
+
+function convert_arguments(::Type{<:Annotation}, x::Real, y::Real)
     return ([Vec4d(NaN, NaN, x, y)],)
 end
 
-function Makie.convert_arguments(::Type{<:Annotation}, p::VecTypes{2})
+function convert_arguments(::Type{<:Annotation}, p::VecTypes{2, <:Real})
     return ([Vec4d(NaN, NaN, p...)],)
 end
 
-function Makie.convert_arguments(::Type{<:Annotation}, x::Real, y::Real, x2::Real, y2::Real)
+function convert_arguments(::Type{<:Annotation}, x::Real, y::Real, x2::Real, y2::Real)
     return ([Vec4d(x, y, x2, y2)],)
 end
 
-function Makie.convert_arguments(::Type{<:Annotation}, p1::VecTypes{2}, p2::VecTypes{2})
+function convert_arguments(::Type{<:Annotation}, p1::VecTypes{2, <:Real}, p2::VecTypes{2, <:Real})
     return ([Vec4d(p1..., p2...)],)
 end
 
-function Makie.convert_arguments(::Type{<:Annotation}, v::AbstractVector{<:VecTypes{2}})
+function convert_arguments(::Type{<:Annotation}, p1::VecTypes{2}, p2::VecTypes{2})
+    return ([Vec4(p1..., p2...)],)
+end
+
+function convert_arguments(::Type{<:Annotation}, v::AbstractVector{<:VecTypes{2, <:Real}})
     return (Vec4d.(NaN, NaN, getindex.(v, 1), getindex.(v, 2)),)
 end
 
-function Makie.convert_arguments(::Type{<:Annotation}, v1::AbstractVector{<:VecTypes{2}}, v2::AbstractVector{<:VecTypes{2}})
-    return (Vec4d.(getindex.(v1, 1), getindex.(v1, 2), getindex.(v2, 1), getindex.(v2, 2)),)
+function convert_arguments(::Type{<:Annotation}, v1::AbstractVector{<:VecTypes{2}}, v2::AbstractVector{<:VecTypes{2}})
+    return (Vec4.(getindex.(v1, 1), getindex.(v1, 2), getindex.(v2, 1), getindex.(v2, 2)),)
 end
 
-function Makie.convert_arguments(::Type{<:Annotation}, v1::AbstractVector{<:Real}, v2::AbstractVector{<:Real})
+function convert_arguments(::Type{<:Annotation}, v1::AbstractVector{<:Real}, v2::AbstractVector{<:Real})
     return (Vec4d.(NaN, NaN, v1, v2),)
 end
 
-function Makie.convert_arguments(::Type{<:Annotation}, v1::AbstractVector{<:Real}, v2::AbstractVector{<:Real}, v3::AbstractVector{<:Real}, v4::AbstractVector{<:Real})
+function convert_arguments(::Type{<:Annotation}, v1::AbstractVector{<:Real}, v2::AbstractVector{<:Real}, v3::AbstractVector{<:Real}, v4::AbstractVector{<:Real})
     return (Vec4d.(v1, v2, v3, v4),)
 end
 
-function Makie.plot!(p::Annotation{<:Tuple{<:AbstractVector{<:Vec4}}})
-    scene = Makie.get_scene(p)
+function plot!(p::Annotation{<:Tuple{<:AbstractVector{<:VecTypes{4}}}})
+    scene = get_scene(p)
 
     textpositions = lift(p[1]) do vecs
         Point2d.(getindex.(vecs, 3), getindex.(vecs, 4))
@@ -538,8 +549,8 @@ function startpoint(::Ann.Paths.Corner, text_bb, p2)
     return Point2d(x, y)
 end
 
-Makie.data_limits(p::Annotation) = Rect3f(Rect2f([Vec2f(x[3], x[4]) for x in p[1][]]))
-Makie.boundingbox(p::Annotation, space::Symbol = :data) = Makie.apply_transform_and_model(p, Makie.data_limits(p))
+data_limits(p::Annotation) = Rect3f(Rect2f([Vec2f(x[3], x[4]) for x in p[1][]]))
+boundingbox(p::Annotation, space::Symbol = :data) = apply_transform_and_model(p, data_limits(p))
 
 function connection_path(::Ann.Paths.Line, p1, p2)
     return BezierPath(
@@ -966,7 +977,7 @@ function line_rectangle_intersection(p1::Point2, p2::Point2, rect::Rect2)
     end
 end
 
-annotation_style_plotspecs(::Makie.Automatic, path, p1, p2; kwargs...) = annotation_style_plotspecs(Ann.Styles.Line(), path, p1, p2; kwargs...)
+annotation_style_plotspecs(::Automatic, path, p1, p2; kwargs...) = annotation_style_plotspecs(Ann.Styles.Line(), path, p1, p2; kwargs...)
 
 function annotation_style_plotspecs(l::Ann.Styles.LineArrow, path::BezierPath, p1, p2; color, linewidth)
     length(path.commands) < 2 && return PlotSpec[]
@@ -1006,7 +1017,7 @@ function annotation_style_plotspecs(::Ann.Styles.Line, path::BezierPath, p1, p2;
     ]
 end
 
-_auto(x::Makie.Automatic, default) = default
+_auto(x::Automatic, default) = default
 _auto(x, default) = x
 
 shrinksize(other) = 0.0
@@ -1024,7 +1035,7 @@ function plotspecs(l::Ann.Arrows.Line, pos; rotation, color, linewidth)
     p1 = pos + dir1 * sidelen
     p2 = pos + dir2 * sidelen
     return [
-        Makie.PlotSpec(:Lines, [p1, pos, p2]; space = :pixel, color, linewidth),
+        PlotSpec(:Lines, [p1, pos, p2]; space = :pixel, color, linewidth),
     ]
 end
 
@@ -1038,7 +1049,7 @@ function plotspecs(h::Ann.Arrows.Head, pos; rotation, color, linewidth)
 
     marker = BezierPath([MoveTo(0, 0), LineTo(p1), LineTo(p2), LineTo(p3), ClosePath()])
     return [
-        Makie.PlotSpec(:Scatter, pos; space = :pixel, rotation, color, marker, markersize = len),
+        PlotSpec(:Scatter, pos; space = :pixel, rotation, color, marker, markersize = len),
     ]
 end
 

Makie/src/basic_recipes/arc.jl

@@ -18,6 +18,8 @@ Examples:
     resolution = 361
 end
 
+argument_dims(::Type{<:Arc}, args...) = nothing
+
 function plot!(p::Arc)
     map!(p, [:origin, :radius, :start_angle, :stop_angle, :resolution], :positions) do origin, radius, start_angle, stop_angle, resolution
         return map(range(start_angle, stop = stop_angle, length = resolution)) do angle

Makie/src/basic_recipes/arrows.jl

@@ -4,32 +4,41 @@
 
 struct ArrowLike <: ConversionTrait end
 
+function types_for_plot_arguments(::ArrowLike)
+    return Tuple{VecTypesVector{N, <:Real}, VecTypesVector{N, <:Real}} where {N}
+end
+
+argument_dims(::ArrowLike, x, y, f) = (1, 2)
+argument_dims(::ArrowLike, x, y, z, f::Function) = (1, 2, 3)
+argument_dims(::ArrowLike, x, y, u, v) = (1, 2, 1, 2)
+argument_dims(::ArrowLike, x, y, z, u, v, w) = (1, 2, 3, 1, 2, 3)
+
 # vec(::Point) and vec(::Vec) works (returns input), but vec(::Tuple) errors
 convert_arguments(::ArrowLike, pos::VecTypes{N}, dir::VecTypes{N}) where {N} = ([pos], [dir])
 
 function convert_arguments(::ArrowLike, pos::AbstractArray, dir::AbstractArray)
     return (
-        convert_arguments(PointBased(), vec(pos))[1],
-        convert_arguments(PointBased(), vec(dir))[1],
+        convert_arguments(PointBased(), vec(pos))...,
+        convert_arguments(PointBased(), vec(dir))...,
     )
 end
 
 function convert_arguments(::ArrowLike, x, y, u, v)
     return (
-        convert_arguments(PointBased(), vec(x), vec(y))[1],
-        convert_arguments(PointBased(), vec(u), vec(v))[1],
+        convert_arguments(PointBased(), vec(x), vec(y))...,
+        convert_arguments(PointBased(), vec(u), vec(v))...,
     )
 end
 function convert_arguments(::ArrowLike, x::AbstractVector, y::AbstractVector, u::AbstractMatrix, v::AbstractMatrix)
     return (
         vec(Point{2, float_type(x, y)}.(x, y')),
-        convert_arguments(PointBased(), vec(u), vec(v))[1],
+        convert_arguments(PointBased(), vec(u), vec(v))...,
     )
 end
 function convert_arguments(::ArrowLike, x, y, z, u, v, w)
     return (
-        convert_arguments(PointBased(), vec(x), vec(y), vec(z))[1],
-        convert_arguments(PointBased(), vec(u), vec(v), vec(w))[1],
+        convert_arguments(PointBased(), vec(x), vec(y), vec(z))...,
+        convert_arguments(PointBased(), vec(u), vec(v), vec(w))...,
     )
 end
 
@@ -314,6 +323,7 @@ end
 
 conversion_trait(::Type{<:Arrows2D}) = ArrowLike()
 
+
 function _get_arrow_shape(f::Function, length, width, metrics)
     nt = NamedTuple{(:taillength, :tailwidth, :shaftlength, :shaftwidth, :tiplength, :tipwidth)}(metrics)
     return poly_convert(f(length, width, nt))

Makie/src/basic_recipes/axis.jl

@@ -100,6 +100,9 @@ $(ATTRIBUTES)
     )
 end
 
+argument_dim_kwargs(::Type{<:Axis3D}) = tuple()
+argument_dims(::Type{<:Axis3D}, args...) = nothing
+
 isaxis(x) = false
 isaxis(x::Axis3D) = true
 

Makie/src/basic_recipes/band.jl

@@ -7,27 +7,39 @@ Plots a band from `ylower` to `yupper` along `x`. The form `band(lower, upper)`
 between the points in `lower` and `upper`.
 Both bounds can be passed together as `lowerupper`, a vector of intervals.
 """
-@recipe Band (lowerpoints, upperpoints) begin
+@recipe Band (
+    lowerpoints::VecTypesVector{N, <:Real} where {N},
+    upperpoints::VecTypesVector{N, <:Real} where {N},
+) begin
     documented_attributes(Mesh)...
     "The direction of the band. If set to `:y`, x and y coordinates will be flipped, resulting in a vertical band. This setting applies only to 2D bands."
     direction = :x
     shading = NoShading
 end
 
-function convert_arguments(::Type{<:Band}, x, ylower, yupper)
+argument_dim_kwargs(::Type{<:Band}) = (:direction,)
+function argument_dims(::Type{<:Band}, x, ylower, yupper; direction)
+    return direction === :x ? (1, 2, 2) : (2, 1, 1)
+end
+function argument_dims(::Type{<:Band}, lower::VecTypesVector{N}, upper::VecTypesVector{N}; direction) where {N}
+    return direction === :x ? ((1, 2), (1, 2)) : ((2, 1), (2, 1))
+end
+
+function convert_arguments(::Type{<:Band}, x::RealVector, ylower::RealVector, yupper::RealVector)
     return (Point2{float_type(x, ylower)}.(x, ylower), Point2{float_type(x, yupper)}.(x, yupper))
 end
 
-convert_arguments(P::Type{<:Band}, x::AbstractVector{<:Number}, y::AbstractVector{<:Interval}) =
-    convert_arguments(P, x, leftendpoint.(y), rightendpoint.(y))
+function convert_arguments(P::Type{<:Band}, x::AbstractVector, y::AbstractVector{<:Interval})
+    return convert_arguments(P, x, leftendpoint.(y), rightendpoint.(y))
+end
 
 function band_connect(n)
     ns = 1:(n - 1)
     ns2 = (n + 1):(2n - 1)
     return [GLTriangleFace.(ns, ns .+ 1, ns2); GLTriangleFace.(ns .+ 1, ns2 .+ 1, ns2)]
 end
 
-function Makie.plot!(plot::Band)
+function plot!(plot::Band)
     @extract plot (lowerpoints, upperpoints)
     nanpoint(::Type{<:Point3}) = Point3(NaN)
     nanpoint(::Type{<:Point2}) = Point2(NaN)

Makie/src/basic_recipes/barplot.jl

@@ -129,6 +129,7 @@ Plots bars of the given `heights` at the given (scalar) `positions`.
 end
 
 conversion_trait(::Type{<:BarPlot}) = PointBased()
+argument_dim_kwargs(::Type{<:BarPlot}) = (:direction,)
 
 function bar_rectangle(x, y, width, fillto, in_y_direction)
     # y could be smaller than fillto...

Makie/src/basic_recipes/bracket.jl

@@ -8,7 +8,7 @@ Draws a bracket between each pair of points (x1, y1) and (x2, y2) with a text la
 
 By default each label is rotated parallel to the line between the bracket points.
 """
-@recipe Bracket (positions,) begin
+@recipe Bracket (positions::Vector{<:Tuple{Point2{<:Real}, Point2{<:Real}}},) begin
     """
     The offset of the bracket perpendicular to the line from start to end point in screen units.
     The direction depends on the `orientation` attribute.
@@ -78,10 +78,16 @@ By default each label is rotated parallel to the line between the bracket points
     space = :data
 end
 
-function convert_arguments(::Type{<:Bracket}, point1::VecTypes{2, T1}, point2::VecTypes{2, T2}) where {T1, T2}
+argument_dims(::Type{<:Bracket}, x1, y1, x2, y2) = (1, 2, 1, 2)
+
+function convert_arguments(::Type{<:Bracket}, point1::VecTypes{2, T1}, point2::VecTypes{2, T2}) where {T1 <: Real, T2 <: Real}
     return ([(Point2{float_type(T1)}(point1), Point2{float_type(T2)}(point2))],)
 end
 
+function convert_arguments(::Type{<:Bracket}, point1::VecTypesVector{2, T1}, point2::VecTypesVector{2, T2}) where {T1 <: Real, T2 <: Real}
+    return (tuple.(Point2{float_type(T1)}.(point1), Point2{float_type(T2)}.(point2)),)
+end
+
 function convert_arguments(::Type{<:Bracket}, x1::Real, y1::Real, x2::Real, y2::Real)
     return ([(Point2{float_type(x1, y1)}(x1, y1), Point2{float_type(x2, y2)}(x2, y2))],)
 end

Makie/src/basic_recipes/contourf.jl

@@ -44,12 +44,6 @@ similar to how [`surface`](@ref) works.
     mixin_colormap_attributes(allow = (:colormap, :colorscale, :nan_color))...
 end
 
-# these attributes are computed dynamically and needed for colorbar e.g.
-# _computed_levels
-# _computed_colormap
-# _computed_extendlow
-# _computed_extendhigh
-
 _get_isoband_levels(levels::Int, mi, ma) = collect(range(Float32(mi), nextfloat(Float32(ma)), length = levels + 1))
 
 function _get_isoband_levels(levels::AbstractVector{<:Real}, mi, ma)