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,21 @@ function unit_convert(quantity::DQ.UnionAbstractQuantity, value)
 end
 
 needs_tick_update_observable(conversion::M.DQConversion) = conversion.quantity
+show_dim_convert_in_ticklabel(::M.DQConversion, ::M.Automatic) = 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_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,6 +167,12 @@ function closest_point_on_rectangle(r::Rect2, p)
     return argmin(c -> norm(c - p), candidates)
 end
 
+argument_dims(::Type{<:Annotation}, x, y) = (1, 2)
+argument_dims(::Type{<:Annotation}, xy) = ((1, 2),)
+argument_dims(::Type{<:Annotation}, x, y, x2, y2) = (1, 2, 1, 2)
+argument_dims(::Type{<:Annotation}, xy::VecTypes{2}, xy2::VecTypes{2}) = ((1, 2), (1, 2))
+argument_dims(::Type{<:Annotation}, xy::VecTypesVector{2}, xy2::VecTypesVector{2}) = ((1, 2), (1, 2))
+
 function Makie.convert_arguments(::Type{<:Annotation}, x::Real, y::Real)
     return ([Vec4d(NaN, NaN, x, y)],)
 end

Makie/src/basic_recipes/arrows.jl

@@ -4,32 +4,39 @@
 
 struct ArrowLike <: ConversionTrait end
 
+argument_dims(::ArrowLike, xy::VecTypes{N}, uv::VecTypes{N}) where {N} = (1:N, 1:N)
+argument_dims(::ArrowLike, xy::VecTypesVector{N}, uv::VecTypesVector{N}) where {N} = (1:N, 1:N)
+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
 

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,19 +7,28 @@ 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) : (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)

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

@@ -78,6 +78,10 @@ By default each label is rotated parallel to the line between the bracket points
     space = :data
 end
 
+argument_dims(::Type{<:Bracket}, xy1::VecTypes{2}, xy2::VecTypes{2}) = ((1, 2), (1, 2))
+argument_dims(::Type{<:Bracket}, xy1::VecTypesVector{2}, xy2::VecTypesVector{2}) = ((1, 2), (1, 2))
+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, T2}
     return ([(Point2{float_type(T1)}(point1), Point2{float_type(T2)}(point2))],)
 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)

Makie/src/basic_recipes/error_and_rangebars.jl

@@ -51,6 +51,40 @@ end
 
 ### conversions for errorbars
 
+argument_dim_kwargs(::Type{<:Union{Errorbars, Rangebars}}) = (:direction,)
+
+function argument_dims(::Type{<:Errorbars}, x, y, e; direction)
+    return ifelse(direction === :y, (1, 2, 2), (1, 2, 1))
+end
+
+function argument_dims(::Type{<:Errorbars}, x, y, l, h; direction)
+    return ifelse(direction === :y, (1, 2, 2, 2), (1, 2, 1, 1))
+end
+
+function argument_dims(::Type{<:Errorbars}, x, y, lh::VecTypesVector{2}; direction)
+    return ifelse(direction === :y, (1, 2, (2, 2)), (1, 2, (1, 1)))
+end
+
+function argument_dims(::Type{<:Errorbars}, xy::VecTypesVector{2}, e; direction)
+    return ifelse(direction === :y, ((1, 2), 2), ((1, 2), 1))
+end
+
+function argument_dims(::Type{<:Errorbars}, xy::VecTypesVector{2}, l, h; direction)
+    return ifelse(direction === :y, ((1, 2), 2, 2), ((1, 2), 1, 1))
+end
+
+function argument_dims(::Type{<:Errorbars}, xy::VecTypesVector{2}, lh::VecTypesVector{2}; direction)
+    return ifelse(direction === :y, ((1, 2), (2, 2)), ((1, 2), (1, 1)))
+end
+
+function argument_dims(::Type{<:Errorbars}, xye::VecTypesVector{3}; direction)
+    return ifelse(direction === :y, ((1, 2, 2),), ((1, 2, 1),))
+end
+
+function argument_dims(::Type{<:Errorbars}, xylh::VecTypesVector{4}; direction)
+    return ifelse(direction === :y, ((1, 2, 2, 2),), ((1, 2, 1, 1),))
+end
+
 function convert_arguments(::Type{<:Errorbars}, x::RealOrVec, y::RealOrVec, error_both::RealOrVec)
     T = float_type(x, y, error_both)
     xyerr = broadcast(x, y, error_both) do x, y, e
@@ -111,6 +145,18 @@ end
 
 ### conversions for rangebars
 
+function argument_dims(::Type{<:Rangebars}, x, l, h; direction)
+    return ifelse(direction === :y, (1, 2, 2), (2, 1, 1))
+end
+
+function argument_dims(::Type{<:Rangebars}, x, lh::VecTypesVector{2}; direction)
+    return ifelse(direction === :y, (1, (2, 2)), (2, (1, 1)))
+end
+
+function argument_dims(::Type{<:Rangebars}, xlh::VecTypesVector{3}; direction)
+    return ifelse(direction === :y, ((1, 2, 2),), ((2, 1, 1),))
+end
+
 function convert_arguments(::Type{<:Rangebars}, val::RealOrVec, low::RealOrVec, high::RealOrVec)
     T = float_type(val, low, high)
     val_low_high = broadcast(Vec3{T}, val, low, high)
@@ -129,8 +175,9 @@ function convert_arguments(
     return (val_low_high,)
 end
 
-Makie.convert_arguments(P::Type{<:Rangebars}, x::AbstractVector{<:Number}, y::AbstractVector{<:Interval}) =
-    convert_arguments(P, x, endpoints.(y))
+function convert_arguments(P::Type{<:Rangebars}, x::AbstractVector, y::AbstractVector{<:Interval})
+    return convert_arguments(P, x, endpoints.(y))
+end
 
 ### the two plotting functions create linesegpairs in two different ways
 ### and then hit the same underlying implementation in `_plot_bars!`

Makie/src/basic_recipes/hvlines.jl

@@ -42,6 +42,9 @@ function projview_to_2d_limits(plot::AbstractPlot)
     end
 end
 
+argument_dims(::Type{<:HLines}, y) = (2,)
+argument_dims(::Type{<:VLines}, x) = (1,)
+
 function Makie.plot!(p::Union{HLines, VLines})
     mi = p isa HLines ? (:xmin) : (:ymin)
     ma = p isa HLines ? (:xmax) : (:ymax)

Makie/src/basic_recipes/hvspan.jl

@@ -34,6 +34,9 @@ Both bounds can be passed together as an interval `xs_lowhigh`.
     documented_attributes(Poly)...
 end
 
+argument_dims(::Type{<:HSpan}, ylow, yhigh) = (2, 2)
+argument_dims(::Type{<:VSpan}, xlow, yhigh) = (1, 1)
+
 function Makie.plot!(p::Union{HSpan, VSpan})
     mi = p isa HSpan ? :xmin : :ymin
     ma = p isa HSpan ? :xmax : :ymax

Makie/src/basic_recipes/poly.jl

@@ -3,6 +3,7 @@ const PolyElements = Union{Polygon, MultiPolygon, Circle, Rect, AbstractMesh, Ve
 convert_arguments(::Type{<:Poly}, v::AbstractVector{<:PolyElements}) = (v,)
 convert_arguments(::Type{<:Poly}, v::Union{Polygon, MultiPolygon}) = (v,)
 
+argument_dims(::Type{<:Poly}, vertices::VecTypesVector{N}, indices) where {N} = (1:N,)
 
 function convert_pointlike(args...)
     return convert_arguments(PointBased(), args...)
@@ -24,7 +25,11 @@ function convert_arguments(::Type{<:Poly}, path::AbstractMatrix{<:Number})
     return convert_pointlike(path)
 end
 
-function convert_arguments(::Type{<:Poly}, vertices::AbstractArray, indices::AbstractArray)
+function convert_arguments(::Type{<:Poly}, vertices::RealArray, indices::AbstractArray)
+    return convert_arguments(Mesh, vertices, indices)
+end
+
+function convert_arguments(::Type{<:Poly}, vertices::AbstractArray{<:VecTypes}, indices::AbstractArray)
     return convert_arguments(Mesh, vertices, indices)
 end
 

Makie/src/basic_recipes/spy.jl

@@ -66,6 +66,8 @@ function boundingbox(p::Spy, space::Symbol = :data)
     return apply_transform_and_model(p, data_limits(p))
 end
 
+argument_dims(::Type{<:Spy}, x, y, mat) = (1, 2)
+
 function convert_arguments(::Type{<:Spy}, matrix::AbstractMatrix{T}) where {T}
     Tr = Makie.float_type(T)
     return convert_arguments(Spy, Tr.((0, size(matrix, 1))), Tr.((0, size(matrix, 2))), matrix)

Makie/src/basic_recipes/stairs.jl

@@ -5,7 +5,7 @@ Plot a stair function.
 
 The conversion trait of `stairs` is `PointBased`.
 """
-@recipe Stairs begin
+@recipe Stairs (positions,) begin
     """
     The `step` parameter can take the following values:
     - `:pre`: horizontal part of step extends to the left of each value in `xs`.
@@ -19,7 +19,7 @@ end
 conversion_trait(::Type{<:Stairs}) = PointBased()
 
 function plot!(p::Stairs{<:Tuple{<:AbstractVector{T}}}) where {T <: Point2}
-    map!(p, [:converted_1, :step], :steppoints) do points, step
+    map!(p, [:positions, :step], :steppoints) do points, step
         if step === :pre
             s_points = Vector{T}(undef, length(points) * 2 - 1)
             s_points[1] = point = points[1]

Makie/src/basic_recipes/streamplot.jl

@@ -82,13 +82,24 @@ See the function `Makie.streamplot_impl` for implementation details.
     mixin_generic_plot_attributes()...
 end
 
-function convert_arguments(::Type{<:StreamPlot}, f::Function, xrange, yrange)
+argument_dims(::Type{<:StreamPlot}, f, x, y) = (0, 1, 2)
+argument_dims(::Type{<:StreamPlot}, f, x, y, z) = (0, 1, 2, 3)
+
+# Normalize x, y, (z) types for dim converts
+function convert_arguments(::Type{<:StreamPlot}, f::Function, xrange::RangeLike, yrange::RangeLike)
+    return (f, extrema(xrange), extrema(yrange))
+end
+function convert_arguments(::Type{<:StreamPlot}, f::Function, xrange::RangeLike, yrange::RangeLike, zrange::RangeLike)
+    return (f, extrema(xrange), extrema(yrange), extrema(zrange))
+end
+
+function convert_arguments(::Type{<:StreamPlot}, f::Function, xrange::RangeLike{<:Real}, yrange::RangeLike{<:Real})
     xmin, xmax = extrema(xrange)
     ymin, ymax = extrema(yrange)
     return (f, Rect(xmin, ymin, xmax - xmin, ymax - ymin))
 end
 
-function convert_arguments(::Type{<:StreamPlot}, f::Function, xrange, yrange, zrange)
+function convert_arguments(::Type{<:StreamPlot}, f::Function, xrange::RangeLike{<:Real}, yrange::RangeLike{<:Real}, zrange::RangeLike{<:Real})
     xmin, xmax = extrema(xrange)
     ymin, ymax = extrema(yrange)
     zmin, zmax = extrema(zrange)

Makie/src/basic_recipes/text.jl

@@ -1,13 +1,3 @@
-struct RichText
-    type::Symbol
-    children::Vector{Union{RichText, String}}
-    attributes::Dict{Symbol, Any}
-    function RichText(type::Symbol, children...; kwargs...)
-        cs = Union{RichText, String}[children...]
-        return new(type, cs, Dict(kwargs))
-    end
-end
-
 function check_textsize_deprecation(@nospecialize(dictlike))
     return if haskey(dictlike, :textsize)
         throw(ArgumentError("`textsize` has been renamed to `fontsize` in Makie v0.19. Please change all occurrences of `textsize` to `fontsize` or revert back to an earlier version."))
@@ -855,7 +845,7 @@ struct GlyphInfo
     origin::Point2f
     extent::GlyphExtent
     size::Vec2f
-    rotation::Quaternion
+    rotation::Quaternionf
     color::RGBAf
     strokecolor::RGBAf
     strokewidth::Float32

Makie/src/basic_recipes/textlabel.jl

@@ -5,7 +5,12 @@
 
 Plots the given text(s) with a background(s) at the given position(s).
 """
-@recipe TextLabel (positions,) begin
+@recipe TextLabel (positions::Union{
+        VecTypesVector{N, <:Real} where {N},
+        AbstractArray{<:Tuple{<:AbstractString, <:VecTypes{N, <:Real} where {N}}},
+        AbstractArray{<:AbstractString},
+        AbstractString
+    },) begin
     # text-like args interface
     "Specifies one piece of text or a vector of texts to show, where the number has to match the number of positions given. Makie supports `String` which is used for all normal text and `LaTeXString` which layouts mathematical expressions using `MathTeXEngine.jl`."
     text = ""