juliaplots/abstractplotting.jl

An abstract interface for plotting libraries, part of the Makie ecosystem.

AbstractPlotting (deprecated)

Everything from AbstractPlotting.jl got moved to Makie.jl. Makie went through a few breaking changes since then and the version closest to the current AbstractPlotting is [email protected]. If you want to upgrade to that new version, simply replace every instance of AbstractPlotting by Makie. If you just want you just want to plot, use one of the backends directly: GLMakie, CairoMakie, WGLMakie. They re-export all the functionality of Makie.jl.

abstractplotting.jl's Issues

camera zooming with orthographic projection type

In this example the zooming does not work out-of-plane, but moves the image in-plane. I would expect to see similar zooming as in the Perspective option.

using Makie
using GLMakie
scene = wireframe(GLMakie.loadasset("cat.obj"))
cam = cameracontrols(scene)
cam.projectiontype[] = Makie.AbstractPlotting.Orthographic # not zooming
#cam.projectiontype[] = Makie.AbstractPlotting.Perspective # works as expected
update_cam!(scene, cam)

Edit: AbstractPlotting 0.9.17, GLMakie 0.0.13

Volume does not have alpha implemented

Specify level values in contour

Hi,
I was wondering if there is a way to specify the values of the levels in contour, rather than just the number of levels? My scenario is that I would like to compare matrices of decoding performance for slightly different decoders. I find that contours work better than heatmaps for visualising each matrix, but to compare them, I'd want the contour levels to be drawn at the same values for each matrix. Thanks!

`button` should work for clicking anywhere in the box

Hello,

I initialize a button like:

    statebutton = AbstractPlotting.button(Theme(raw = true, camera = campixel!), "latest state")
    on(statebutton[end][:clicks]) do c
        u0, col = laststate[]
        println("Latest state: ")
        println(u0)
        println("with color: $(col)")
    end

which looks like:

In the image I have circled with blue places where I click the button but it does not trigger. In fact after trial and error I found that the button only triggers if you press exactly on the letters or exactly on the borders. It does not trigger when you press the white space in-between. I think this is unintuitive and also not the behavior one expects when using a "button".

I mean, the buttons on my keyboard work even If I press the black space inbetwee then white lines that define the letters, right? ;)

Missing docstrings

┌ Warning: 160 docstrings potentially missing:
│
│     AbstractPlotting.recordframe! :: Tuple{VideoStream}
│     AbstractPlotting.volumeslices! :: Tuple
│     AbstractPlotting.safe_off :: Tuple{Observables.AbstractObservable,Any}
│     AbstractPlotting.streamlines! :: Tuple
│     AbstractPlotting.reasonable_resolution :: Tuple{}
│     AbstractPlotting.to_color :: Tuple{Any}
│     AbstractPlotting.mesh! :: Tuple
│     AbstractPlotting.annotations! :: Tuple
│     AbstractPlotting.interpolated_getindex :: Union{Tuple{T}, Tuple{AbstractArray{T,N} where N,AbstractFloat}, Tuple{AbstractArray{T,N} where N,AbstractFloat,Any}} where T
│     AbstractPlotting.Automatic
│     AbstractPlotting.scatterlines :: Tuple
│     AbstractPlotting.must_update :: Tuple{}
│     AbstractPlotting.elconvert :: Union{Tuple{N}, Tuple{T2}, Tuple{T1}, Tuple{Type{T1},AbstractArray{T2,N}}} where N where T2 where T1
│     AbstractPlotting.@get_attribute :: Tuple{Any,Any}
│     AbstractPlotting.default_printer :: Tuple{Any}
│     AbstractPlotting.wireframe :: Tuple
│     AbstractPlotting.fit_factor :: Union{Tuple{N}, Tuple{Any,Tuple{Vararg{Any,N}}}} where N
│     AbstractPlotting.available_gradients :: Tuple{}
│     AbstractPlotting.lookat :: Union{Tuple{T}, Tuple{Vec{3,T},Vec{3,T},Vec{3,T}}} where T
│     AbstractPlotting.colorswatch :: Union{Tuple{}, Tuple{Any}}
│     AbstractPlotting.available_marker_symbols :: Tuple{}
│     AbstractPlotting.replay_events :: Tuple{Scene,String}
│     AbstractPlotting.mergekeys :: Union{Tuple{N}, Tuple{Tuple{Vararg{Symbol,N}},Attributes,Attributes}} where N
│     AbstractPlotting.colorlegend :: Tuple
│     AbstractPlotting.annotations :: Tuple
│     AbstractPlotting.detach! :: Tuple{Combined}
│     AbstractPlotting.plottype :: Union{Tuple{T}, Tuple{Type{#s154} where #s154<:(Combined{Any,T} where T),Type{#s153} where #s153<:(Combined{T,T1} where T1)}} where T
│     AbstractPlotting.plottype :: Tuple
│     AbstractPlotting.fit_ratio :: Tuple{Any,Any}
│     AbstractPlotting.contour3d! :: Tuple
│     AbstractPlotting.to_type :: Tuple{Function}
│     AbstractPlotting.cam2d :: Tuple{Scene}
│     AbstractPlotting.fit_factor_stretch :: Union{Tuple{N}, Tuple{Any,Tuple{Vararg{Any,N}}}} where N
│     AbstractPlotting.text! :: Tuple
│     AbstractPlotting.FRect :: NTuple{4,Any}
│     AbstractPlotting.step! :: Tuple{Stepper}
│     AbstractPlotting.Mouse
│     AbstractPlotting.argument_names :: Union{Tuple{P}, Tuple{P}} where P<:AbstractPlot
│     FileIO.save :: Union{Tuple{F}, Tuple{File{F},Scene}} where F
│     FileIO.save :: Tuple{String,VideoStream}
│     AbstractPlotting.series :: Tuple
│     AbstractPlotting.update_limits! :: Union{Tuple{Scene,GeometryTypes.HyperRectangle}, Tuple{Scene,GeometryTypes.HyperRectangle,Any}}
│     AbstractPlotting.update_limits! :: Tuple{Scene}
│     AbstractPlotting.barplot! :: Tuple
│     AbstractPlotting.wireframe! :: Tuple
│     AbstractPlotting.linesegments! :: Tuple
│     AbstractPlotting.ColorSampler
│     AbstractPlotting.broadcast_foreach :: Tuple{Any,Vararg{Any,N} where N}
│     AbstractPlotting.mouseposition :: Union{Tuple{}, Tuple{Any}}
│     AbstractPlotting.arrows! :: Tuple
│     AbstractPlotting.surface! :: Tuple
│     AbstractPlotting.lines! :: Tuple
│     AbstractPlotting.colorlegend! :: Tuple
│     AbstractPlotting.plot! :: Tuple{Union{AbstractScene, AbstractPlotting.ScenePlot},Union{Type{Any}, Type{#s156} where #s156<:AbstractPlot},Attributes,Vararg{Any,N} where N}
│     AbstractPlotting.plot! :: Tuple{Wireframe{...}}
│     AbstractPlotting.update! :: Tuple{Scene}
│     AbstractPlotting.arc! :: Tuple
│     AbstractPlotting.close2square :: Tuple{Real}
│     AbstractPlotting.perspectiveprojection :: Union{Tuple{T}, Tuple{GeometryTypes.SimpleRectangle,T,T,T}} where T
│     AbstractPlotting.perspectiveprojection :: Union{Tuple{T}, NTuple{4,T}} where T
│     AbstractPlotting.apply_convert! :: Tuple{Any,Attributes,Tuple}
│     AbstractPlotting.apply_convert! :: Union{Tuple{S}, Tuple{Any,Attributes,PlotSpec{S}}} where S
│     AbstractPlotting.@extractvalue :: Tuple{Any,Any}
│     AbstractPlotting.calculated_attributes! :: Union{Tuple{T}, Tuple{T}} where T
│     AbstractPlotting.calculated_attributes! :: Tuple{Any,Any}
│     AbstractPlotting.contour3d :: Tuple
│     AbstractPlotting.band! :: Tuple
│     AbstractPlotting.force_update! :: Tuple{}
│     AbstractPlotting.series! :: Tuple
│     AbstractPlotting.to_spritemarker :: Tuple{AbstractArray{T,1} where T}
│     AbstractPlotting.to_spritemarker :: Tuple{Array{#s155,2} where #s155<:AbstractFloat}
│     AbstractPlotting.to_spritemarker :: Tuple{AbstractArray{#s155,2} where #s155<:ColorTypes.Colorant}
│     AbstractPlotting.to_spritemarker :: Tuple{Char}
│     AbstractPlotting.to_spritemarker :: Tuple{Symbol}
│     AbstractPlotting.to_spritemarker :: Tuple{Type{#s155} where #s155<:(GeometryTypes.HyperSphere{2,T} where T)}
│     AbstractPlotting.to_spritemarker :: Tuple{Type{#s155} where #s155<:GeometryTypes.SimpleRectangle}
│     AbstractPlotting.to_spritemarker :: Tuple{GeometryTypes.HyperSphere{2,T} where T}
│     AbstractPlotting.button :: Tuple
│     AbstractPlotting.to_colormap :: Tuple{Any}
│     AbstractPlotting.raw_boundingbox :: Tuple{Union{Image{...}, MeshScatter{...}, Scatter{...}, Mesh{...}, LineSegments{...}, Lines{...}, Surface{...}, Volume{...}, Heatmap{...}, Text{...}} where Arg}
│     AbstractPlotting.flatten_combined :: Union{Tuple{Array{T,1} where T}, Tuple{Array{T,1} where T,Any}}
│     AbstractPlotting.IRect :: Tuple{Any,Any,Union{Tuple{Vararg{T,N}}, StaticArrays.StaticArray{Tuple{N},T,1}} where T where N}
│     AbstractPlotting.IRect :: Tuple{NamedTuple{(:x, :y),T} where T<:Tuple,NamedTuple{(:width, :height),T} where T<:Tuple}
│     AbstractPlotting.IRect :: NTuple{4,Any}
│     AbstractPlotting.IRect :: Tuple{Union{Tuple{Vararg{T,N}}, StaticArrays.StaticArray{Tuple{N},T,1}} where T where N,Any,Any}
│     AbstractPlotting.IRect :: Tuple{Union{Tuple{Vararg{T,N}}, StaticArrays.StaticArray{Tuple{N},T,1}} where T where N,Union{Tuple{Vararg{T,N}}, StaticArrays.StaticArray{Tuple{N},T,1}} where T where N}
│     AbstractPlotting.IRect3D
│     AbstractPlotting.volume! :: Tuple
│     AbstractPlotting.mergekeys! :: Union{Tuple{N}, Tuple{Tuple{Vararg{Symbol,N}},Attributes,Attributes}} where N
│     AbstractPlotting.legend :: Tuple
│     AbstractPlotting.resampled_colors :: Tuple{Any,Integer}
│     AbstractPlotting.convert_attribute :: Tuple{Union{String, Symbol},AbstractPlotting.Key{:algorithm}}
│     AbstractPlotting.convert_attribute :: Tuple{Tuple{Symbol,Symbol},AbstractPlotting.Key{:align}}
│     AbstractPlotting.convert_attribute :: Tuple{Quaternion,AbstractPlotting.Key{:rotation}}
│     AbstractPlotting.convert_attribute :: Tuple{Union{Tuple, Pair},AbstractPlotting.Key{:colormap}}
│     AbstractPlotting.convert_attribute :: Union{Tuple{Union{String, Symbol},AbstractPlotting.Key{:colormap}}, Tuple{Union{String, Symbol},AbstractPlotting.Key{:colormap},Integer}}
│     AbstractPlotting.convert_attribute :: Tuple{AbstractArray{T,1} where T,AbstractPlotting.Key{:colormap}}
│     AbstractPlotting.convert_attribute :: Tuple{Any,AbstractPlotting.Key{:algorithm}}
│     AbstractPlotting.convert_attribute :: Tuple{AbstractArray{T,1} where T,AbstractPlotting.Key{:linestyle}}
│     AbstractPlotting.convert_attribute :: Tuple{Symbol,AbstractPlotting.Key{:linestyle}}
│     AbstractPlotting.convert_attribute :: Tuple{Union{String, Symbol},AbstractPlotting.Key{:font}}
│     AbstractPlotting.used_attributes :: Tuple{Any,Vararg{Any,N} where N}
│     AbstractPlotting.image! :: Tuple
│     AbstractPlotting.update_cam! :: Tuple{Union{AbstractScene, AbstractPlotting.ScenePlot},Any}
│     AbstractPlotting.update_cam! :: Tuple{Union{AbstractScene, AbstractPlotting.ScenePlot}}
│     AbstractPlotting.primary_resolution :: Tuple{}
│     AbstractPlotting.available_backends
│     AbstractPlotting.Rect3D
│     AbstractPlotting.Reverse
│     AbstractPlotting.move_from_touch :: Union{Tuple{T}, Tuple{N}, Tuple{GeometryTypes.GeometryPrimitive{N,T},GeometryTypes.GeometryPrimitive{N,T} where T,Vec{N,T} where T}} where T where N
│     AbstractPlotting.dont_touch :: Union{Tuple{N}, Tuple{GeometryTypes.GeometryPrimitive{N,T} where T,GeometryTypes.GeometryPrimitive{N,T} where T,Vec{N,T} where T}} where N
│     AbstractPlotting.notify! :: Tuple{Observables.Observable}
│     AbstractPlotting.mouse_selection
│     AbstractPlotting.onpick
│     AbstractPlotting.replace_automatic! :: Tuple{Any,Any,Any}
│     AbstractPlotting.scatter! :: Tuple
│     AbstractPlotting.PlotList
│     AbstractPlotting.FRect3D
│     AbstractPlotting.to_func :: Union{Tuple{Type{#s155} where #s155<:AbstractPlot{F}}, Tuple{F}} where F
│     AbstractPlotting.volumeslices :: Tuple
│     AbstractPlotting.automatic
│     AbstractPlotting.IRect2D
│     AbstractPlotting.atomic_limits :: Union{Tuple{Union{MeshScatter{...}, Scatter{...}, Text{...}, Mesh{...}, LineSegments{...}, Lines{...}, Surface{...}, Volume{...}, Heatmap{...}, Image{...}} where #s155<:Tuple{Arg1}}, Tuple{Arg1}} where Arg1
│     Observables.on :: Tuple{Any,Camera,Vararg{Observables.Observable,N} where N}
│     AbstractPlotting.hovered_scene :: Tuple{}
│     AbstractPlotting.showgradients :: Tuple{AbstractArray{Symbol,1}}
│     AbstractPlotting.Plot :: Union{Tuple{Vararg{Any,N}}, Tuple{N}} where N
│     AbstractPlotting.arc :: Tuple
│     AbstractPlotting.VideoStream :: Tuple{Scene}
│     AbstractPlotting.default_plot_signatures :: Tuple{Any,Any,Any}
│     AbstractPlotting.title :: Tuple{Any,Any}
│     AbstractPlotting.to_string :: Tuple{Function}
│     AbstractPlotting.ispressed :: Tuple{Union{AbstractScene, AbstractPlotting.ScenePlot},Union{Tuple, Array{T,1} where T}}
│     AbstractPlotting.Billboard
│     AbstractPlotting.showlibrary :: Tuple{Symbol}
│     AbstractPlotting.legend! :: Tuple
│     AbstractPlotting.PlotSpec
│     AbstractPlotting.streamlines :: Tuple
│     AbstractPlotting.resample :: Tuple{AbstractArray{T,1} where T,Integer}
│     AbstractPlotting.plots_from_camera :: Tuple{Scene}
│     AbstractPlotting.@extract :: Tuple{Any,Any}
│     AbstractPlotting.meshscatter! :: Tuple
│     AbstractPlotting.sig_printer :: Tuple{Real}
│     AbstractPlotting.pick
│     AbstractPlotting.current_scene :: Tuple{}
│     AbstractPlotting.poly! :: Tuple
│     AbstractPlotting.button! :: Tuple
│     AbstractPlotting.heatmap! :: Tuple
│     AbstractPlotting.map_once :: Tuple{Any,Observables.Observable,Vararg{Observables.Observable,N} where N}
│     AbstractPlotting.record_events :: Tuple{Any,Scene,String}
│     AbstractPlotting.frustum :: Union{Tuple{T}, NTuple{6,T}} where T
│     AbstractPlotting.scatterlines! :: Tuple
│     AbstractPlotting.print_rec :: Union{Tuple{IO,Any}, Tuple{IO,Any,Int64}}
│     AbstractPlotting.select_rectangle :: Tuple{Any}
│     AbstractPlotting.zoom! :: Tuple{Any,Any,Any}
│     AbstractPlotting.slider! :: Tuple
│     AbstractPlotting.contour! :: Tuple
│     AbstractPlotting.fill_between! :: Tuple{Any,Any,Any}
│     AbstractPlotting.@recipe :: Tuple{Any,Symbol,Vararg{Symbol,N} where N}
│     AbstractPlotting.from_dict :: Union{Tuple{T}, Tuple{Type{T},Any}} where T
└ @ Documenter.DocChecks ~/.julia/packages/Documenter/msPrq/src/DocChecks.jl:62

Arbitrary levels and colormaps don't work with 2D contours

It looks like 2D contour assumes that levels will be a single number rather than an array. There also doesn't seem to be a way to specify the color map, unlike in the 3D case.

AbstractPlotting.jl/src/basic_recipes/basic_recipes.jl

Line 613 in 02661dc

function plot!(plot::T) where T <: Union{Contour, Contour3d}

2D contour maps of non-square arrays don't work.

Perhaps the size(z,1) and size(z,2) are around the wrong way here?

AbstractPlotting.jl/src/basic_recipes/basic_recipes.jl

Line 624 in 02661dc

contours = Contours.contours(to_vector(x, size(z, 2), t), to_vector(y, size(z, 1), t), z, levels)

recipe macro exports too much

In this line @recipe exports the plotting function (e.g. histogram) as well as the type (Histogram). This is probably a bit too much, especially since there is no way to "unexport" it. For example, I cannot do a histogram recipe without clashing with the Histogram type in StatsBase. I think the type is a bit of an implementation detail and could be kept private.

Excessive export?

julia> using Distributions

julia> using AbstractPlotting
WARNING: using AbstractPlotting.Text in module Main conflicts with an existing identifier.
WARNING: using AbstractPlotting.scale! in module Main conflicts with an existing identifier.

AbstractPlotting.Text conflicts with Text from Base: I think it's really strange to export something that exists in Base with a different meaning. AbstractPlotting.scale! conflicts with Distributions.scale!. The signatures don't seem to overlap though, but it's strange to take a dependency on Distributions just to overload the same function.

More StaticArrays depwarns

 Running sphere_mesh
 ┌ Warning: `a::StaticArray - b::Number` is deprecated, use `a .- b` instead.
 │   caller = _broadcast_getindex at broadcast.jl:625 [inlined]
 └ @ Core ./broadcast.jl:625
 Running stars

Not sure which code paths this went along, and can't test right now. Will try to check later.

Button seems broken?

sc = lines(rand(10))
button!(x -> print(x), sc, "click me")
sc

Ambiguity error on type recipe

I'm trying to follow the documentation here for type recipes (I'm on Julia 1.0, AbstractPlotting master and Makie master), but I get some ambiguity errors:

julia> using Makie, AbstractPlotting, KernelDensity

julia> AbstractPlotting.argument_convert(d::UnivariateKDE) = (d.x, d.density)

julia> d = kde(rand(100));

julia> d::UnivariateKDE
UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}(-0.38950987428266626:0.0008619116014773724:1.374823173941515, [7.03176e-5, 7.05523e-5, 7.08734e-5, 7.12811e-5, 7.17759e-5, 7.2358e-5, 7.30281e-5, 7.37867e-5, 7.46344e-5, 7.55719e-5  …  7.2727e-5, 7.20934e-5, 7.15482e-5, 7.10908e-5, 7.07207e-5, 7.04376e-5, 7.02411e-5, 7.01309e-5, 7.0107e-5, 7.01692e-5])

julia> plot(d)
ERROR: MethodError: AbstractPlotting.plot!(::Combined{Any,Tuple{UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}}}, ::Type{Any}, ::Attributes) is ambiguous. Candidates:
  plot!(scene::Combined, ::Type{PlotType}, attributes::Attributes, args...) where PlotType in AbstractPlotting at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:397
  plot!(scene::Union{AbstractScene, ScenePlot}, ::Type{Any}, attributes::Attributes, args...) in AbstractPlotting at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:379
Possible fix, define
  plot!(::Combined, ::Type{Any}, ::Attributes, ::Vararg{Any,N} where N)
Stacktrace:
 [1] #plot!#155(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::Combined{Any,Tuple{UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}}}, ::Type) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:369
 [2] plot!(::Combined{Any,Tuple{UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}}}, ::Type) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:369
 [3] #plot!#154(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::Combined{Any,Tuple{UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}}}) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:368
 [4] plot!(::Combined{Any,Tuple{UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}}}) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:368
 [5] plot!(::Scene, ::Type{Combined{Any,Tuple{UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}}}}, ::Attributes, ::UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:389
 [6] plot!(::Scene, ::Type{Any}, ::Attributes, ::UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:380
 [7] #plot!#155(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::Scene, ::Type, ::UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:369
 [8] plot!(::Scene, ::Type, ::UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:369
 [9] #plot#148(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::Function, ::UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:355
 [10] plot(::UnivariateKDE{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}) at /home/pietro/.julia/dev/AbstractPlotting/src/interfaces.jl:355
 [11] top-level scope at none:0

Regression with CairoMakie when upgrading from v0.9.8 to v0.9.9 (push_screen!)

I did some work with AbstractPlotting and CairoMakie in Jupyter, earlier this year. After upgrading to the newest versions of these packages, I don't see any output in Jupyter (which worked before).

I then found that downgrading to AbstractPlotting v0.9.6 made it work again.

The following snippet was used to git bisect to the offending commit in AbstractPlotting, in an environment that had ] dev AbstractPlotting and ] add CairoMakie:

using Pkg
Pkg.resolve()
using AbstractPlotting
using CairoMakie

s = Scene(resolution=(50, 50))
@show display(s)

Before, the output in the REPL was some display(s) = (CairoMakie.CairoBackend(SVG::RenderType = 0, "/tmp/tmpf430JI/cairo.svg"),..., but later there was an error message

ERROR: LoadError: MethodError: no method matching push_screen!(::Scene, ::Tuple{CairoMakie.CairoBackend,Scene})
Closest candidates are:
  push_screen!(::Scene, !Matched::AbstractDisplay) at /home/rs/.julia/dev/AbstractPlotting/src/display.jl:29
Stacktrace:
 [1] display(::AbstractPlotting.PlotDisplay, ::Scene) at /home/rs/.julia/dev/AbstractPlotting/src/display.jl:46

that I still get in AbstractPlotting#master.

License for Fonts

@Evizero pointed out, that AbstractPlotting ships some fonts without proper license!

@aviks was so kind to hunt down the licenses:

• DejaVu License: https://dejavu-fonts.github.io/License.html
• Noto license: https://github.com/googlei18n/noto-fonts/blob/master/LICENSE
• Black Chancery seems to be public domain, but I can’t find a definitive source
• Hack is MIT on top of Bitstream: https://github.com/source-foundry/Hack/blob/master/LICENSE.md
• Fira: https://github.com/mozilla/Fira/blob/master/LICENSE

I'm not 100% sure how to attribute the licenses, and need to leave this for today, hence this issue to not forget about it!

AbstractObservable not defined

AbstractPlotting.jl/src/interaction/nodes.jl

Line 5 in 0b75085

f, o1::AbstractObservable, rest...;

Observables does not export AbstractObservable. This should be changed to Observables.AbstractObservable

Layout is clumsy in combination with the plot! recipe approach

We quickly mentioned this on slack but I think it deserves its own issue. The standard way to create layouts seems to be:

scene3 = vbox(scene1, scene2)

which makes it quite clumsy to create recipes that have a layout, where one should instead modify a scene in place.

Possible solutions:

• Restore something like grid! that would change the layout in place
• Add to the scene type a method scene.layout that would be used to determine the layout on rendering (it's the technique used in Interact)

linesegments does not accept colors as floats

lines accepts any good old float as an argument for color, interpreting the number to some color scale, but linesegments doesn't.

float32type(::DataType) should be caught

I'm still investigating how I got there, but currently it results in an infinite recursion. Thus I'd say this should be caught and handled somehow.

EDIT: I got there because my array contained missings and the type was Union{Missing, Float64}. Is there any way to render missings in a heatmap with a customcolor outside of the color range for valid values?

colorful linesegments

While this

linesegments([Point2f0(rand(), rand()) => Point2f0(rand(), rand()) for i in 1:5], color=[rand(Gray) for i in 1:5])

works, this:

linesegments([Point2f0(rand(), rand()) => Point2f0(rand(), rand()) for i in 1:5], color=[rand(RGB) for i in 1:5])

doesn't.

Docstring for function `AbstractPlotting.mouse_selection`

I do not know what the function does exactly. I only know that we use it in an interactive application.

Thus, I will put it in the Makie "Interactive Atomic Functions" documentation once it has a docstring that describes what it does.

Type inference regression from Julia 1.3 to 1.4-DEV

]add AbstractPlotting#master
using AbstractPlotting
Scene()

works on 1.3, but enters an endless loop of type inference on 1.4 (commit JuliaLang/julia@71c4d9b and JuliaLang/julia@0a277811c8).

is_derived_type at ./compiler/typelimits.jl:71
is_derived_type at ./compiler/typelimits.jl:58
is_derived_type at ./compiler/typelimits.jl:71
is_derived_type at ./compiler/typelimits.jl:58
is_derived_type at ./compiler/typelimits.jl:71
is_derived_type at ./compiler/typelimits.jl:58
is_derived_type at ./compiler/typelimits.jl:71
is_derived_type at ./compiler/typelimits.jl:58
is_derived_type at ./compiler/typelimits.jl:71
is_derived_type at ./compiler/typelimits.jl:58
is_derived_type at ./compiler/typelimits.jl:71
is_derived_type at ./compiler/typelimits.jl:58
is_derived_type at ./compiler/typelimits.jl:71
is_derived_type at ./compiler/typelimits.jl:58
is_derived_type at ./compiler/typelimits.jl:71
is_derived_type at ./compiler/typelimits.jl:58

...

ambiguity error

MethodError: AbstractPlotting.plot!(::PhasePlot{...}, ::Type{Any}, ::AbstractPlotting.Attributes) is ambiguous. Candidates:
  plot!(scene::AbstractPlotting.Combined, ::Type{PlotType}, attributes::AbstractPlotting.Attributes, args...) where PlotType in AbstractPlotting at /Users/solver/.julia/packages/AbstractPlotting/ujaz8/src/interfaces.jl:397
  plot!(scene::Union{AbstractScene, ScenePlot}, ::Type{Any}, attributes::AbstractPlotting.Attributes, args...) in AbstractPlotting at /Users/solver/.julia/packages/AbstractPlotting/ujaz8/src/interfaces.jl:379
Possible fix, define
  plot!(::AbstractPlotting.Combined, ::Type{Any}, ::AbstractPlotting.Attributes, ::Vararg{Any,N} where N)

@recipe always results in invalid redefinition

I keep running into this:

julia> using Makie

julia> grd
ERROR: UndefVarError: grd not defined

julia> @recipe(GridPlot, grd)
ERROR: invalid redefinition of constant grd
Stacktrace:
 [1] top-level scope at C:\Users\Matthis\.julia\packages\AbstractPlotting\YiGTI\src\recipes.jl:153

Bounding box or camera error in AbstractPlotting#master?

MWE:

using Makie
arc(0, 1, 0, π)

yields

Looks like a camera issue since update_cam! fixes it...

EDIT: This is happening on any plot on both master and 0.9.6...suspecting it might be something on my system?

Failed to precompile AbstractPlotting on win32 platform

On clean Julia 1.0.0 (and 1.0.1) at win32 platform (at 2 different machines). After adding AbstractPlotting package (]add AbstractPlotting or ]add AbstractPlotting#master) and after using AbstractPlotting I got following:

[ Info: Precompiling AbstractPlotting [537997a7-5e4e-5d89-9595-2241ea00577e]

Please submit a bug report with steps to reproduce this fault, and any error messages that follow (in their entirety). Thanks.
Exception: EXCEPTION_ACCESS_VIOLATION at 0x1575cc21 -- #68 at C:\Users\ashindin.julia\packages\AbstractPlotting\4EywS\src\scenes.jl:201 [inlined]
ntuple at .\tuple.jl:133
in expression starting at C:\Users\ashindin.julia\packages\AbstractPlotting\4EywS\src\scenes.jl:234
#68 at C:\Users\ashindin.julia\packages\AbstractPlotting\4EywS\src\scenes.jl:201 [inlined]
ntuple at .\tuple.jl:133
primary_resolution at C:\Users\ashindin.julia\packages\AbstractPlotting\4EywS\src\scenes.jl:200 [inlined]
primary_resolution at C:\Users\ashindin.julia\packages\AbstractPlotting\4EywS\src\scenes.jl:215
reasonable_resolution at C:\Users\ashindin.julia\packages\AbstractPlotting\4EywS\src\scenes.jl:222
jl_fptr_args at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1841
jl_fptr_trampoline at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1831
jl_apply_generic at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:2184
do_call at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:324
eval_value at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:430
eval_stmt_value at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:363 [inlined]
eval_body at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:678
jl_interpret_toplevel_thunk_callback at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:795
unknown function (ip: FFFFFFFE)
unknown function (ip: 1B3D5C8F)
unknown function (ip: 00000001)
jl_interpret_toplevel_thunk at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:804
jl_toplevel_eval_flex at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:813
jl_parse_eval_all at /home/Administrator/buildbot/worker/package_win32/build/src\ast.c:838
jl_load at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:847 [inlined]
jl_load at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:854
applyn at /home/Administrator/buildbot/worker/package_win32/build/src/flisp\flisp.c:682
include at .\sysimg.jl:29 [inlined]
include at C:\Users\ashindin.julia\packages\AbstractPlotting\4EywS\src\AbstractPlotting.jl:1
jl_fptr_args at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1841
jl_apply_generic at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:2184
do_call at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:324
eval_value at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:430
eval_stmt_value at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:363 [inlined]
eval_body at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:678
jl_interpret_toplevel_thunk_callback at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:795
unknown function (ip: FFFFFFFE)
unknown function (ip: 1B3BE37F)
unknown function (ip: FFFFFFFF)
jl_interpret_toplevel_thunk at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:804
jl_toplevel_eval_flex at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:813
jl_eval_module_expr at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:233
jl_toplevel_eval_flex at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:651
jl_parse_eval_all at /home/Administrator/buildbot/worker/package_win32/build/src\ast.c:838
jl_load at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:847 [inlined]
jl_load at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:854
include at .\boot.jl:317 [inlined]
include_relative at .\loading.jl:1041
include at .\sysimg.jl:29
jl_fptr_args at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1841
jl_apply_generic at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:2184
do_call at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:324
eval_value at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:430
eval_stmt_value at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:363 [inlined]
eval_body at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:678
eval_body at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:613
jl_interpret_toplevel_thunk_callback at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:795
unknown function (ip: FFFFFFFE)
unknown function (ip: 0E778E7F)
unknown function (ip: 00000002)
jl_interpret_toplevel_thunk at /home/Administrator/buildbot/worker/package_win32/build/src\interpreter.c:804
jl_toplevel_eval_flex at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:813
jl_toplevel_eval at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:822
jl_toplevel_eval_in at /home/Administrator/buildbot/worker/package_win32/build/src\builtins.c:622
eval at .\boot.jl:319 [inlined]
eval at .\client.jl:389
jl_fptr_args at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1841
jl_apply_generic at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:2184
top-level scope at .\none:3
jl_fptr_args at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1841
jl_fptr_trampoline at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1831
jl_toplevel_eval_flex at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:807
jl_toplevel_eval at /home/Administrator/buildbot/worker/package_win32/build/src\toplevel.c:822
jl_toplevel_eval_in at /home/Administrator/buildbot/worker/package_win32/build/src\builtins.c:622
eval at .\boot.jl:319
jl_fptr_args at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1841
jl_apply_generic at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:2184
macro expansion at .\logging.jl:317 [inlined]
exec_options at .\client.jl:219
_start at .\client.jl:421
jl_fptr_args at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:1841
jl_apply_generic at /home/Administrator/buildbot/worker/package_win32/build/src\gf.c:2184
jl_apply at /home/Administrator/buildbot/worker/package_win32/build/src\julia.h:1537 [inlined]
true_main at /home/Administrator/buildbot/worker/package_win32/build/ui\repl.c:112
wmain at /home/Administrator/buildbot/worker/package_win32/build/ui\repl.c:233
__tmainCRTStartup at /usr/src/debug/mingw64-i686-runtime-5.0.3-1/crt\crtexe.c:329
BaseThreadInitThunk at C:\WINDOWS\System32\KERNEL32.DLL (unknown line)
PssNtCaptureSnapshot at C:\WINDOWS\SYSTEM32\ntdll.dll (unknown line)
PssNtCaptureSnapshot at C:\WINDOWS\SYSTEM32\ntdll.dll (unknown line)
Allocations: 11867069 (Pool: 11866327; Big: 742); GC: 49
ERROR: Failed to precompile AbstractPlotting [537997a7-5e4e-5d89-9595-2241ea00577e] to C:\Users\ashindin.julia\compiled\v1.0\AbstractPlotting\6fydZ.ji.
Stacktrace:
[1] error(::String) at .\error.jl:33
[2] macro expansion at .\logging.jl:313 [inlined]
[3] compilecache(::Base.PkgId, ::String) at .\loading.jl:1187
[4] _require(::Base.PkgId) at .\logging.jl:311
[5] require(::Base.PkgId) at .\loading.jl:855
[6] require(::Module, ::Symbol) at .\logging.jl:311

Missing docstrings

┌ Warning: 160 docstrings potentially missing:
│
│     AbstractPlotting.recordframe! :: Tuple{VideoStream}
│     AbstractPlotting.volumeslices! :: Tuple
│     AbstractPlotting.safe_off :: Tuple{Observables.AbstractObservable,Any}
│     AbstractPlotting.streamlines! :: Tuple
│     AbstractPlotting.reasonable_resolution :: Tuple{}
│     AbstractPlotting.to_color :: Tuple{Any}
│     AbstractPlotting.mesh! :: Tuple
│     AbstractPlotting.annotations! :: Tuple
│     AbstractPlotting.interpolated_getindex :: Union{Tuple{T}, Tuple{AbstractArray{T,N} where N,AbstractFloat}, Tuple{AbstractArray{T,N} where N,AbstractFloat,Any}} where T
│     AbstractPlotting.Automatic
│     AbstractPlotting.scatterlines :: Tuple
│     AbstractPlotting.must_update :: Tuple{}
│     AbstractPlotting.elconvert :: Union{Tuple{N}, Tuple{T2}, Tuple{T1}, Tuple{Type{T1},AbstractArray{T2,N}}} where N where T2 where T1
│     AbstractPlotting.@get_attribute :: Tuple{Any,Any}
│     AbstractPlotting.default_printer :: Tuple{Any}
│     AbstractPlotting.wireframe :: Tuple
│     AbstractPlotting.fit_factor :: Union{Tuple{N}, Tuple{Any,Tuple{Vararg{Any,N}}}} where N
│     AbstractPlotting.available_gradients :: Tuple{}
│     AbstractPlotting.lookat :: Union{Tuple{T}, Tuple{Vec{3,T},Vec{3,T},Vec{3,T}}} where T
│     AbstractPlotting.colorswatch :: Union{Tuple{}, Tuple{Any}}
│     AbstractPlotting.available_marker_symbols :: Tuple{}
│     AbstractPlotting.replay_events :: Tuple{Scene,String}
│     AbstractPlotting.mergekeys :: Union{Tuple{N}, Tuple{Tuple{Vararg{Symbol,N}},Attributes,Attributes}} where N
│     AbstractPlotting.colorlegend :: Tuple
│     AbstractPlotting.annotations :: Tuple
│     AbstractPlotting.detach! :: Tuple{Combined}
│     AbstractPlotting.plottype :: Union{Tuple{T}, Tuple{Type{#s154} where #s154<:(Combined{Any,T} where T),Type{#s153} where #s153<:(Combined{T,T1} where T1)}} where T
│     AbstractPlotting.plottype :: Tuple
│     AbstractPlotting.fit_ratio :: Tuple{Any,Any}
│     AbstractPlotting.contour3d! :: Tuple
│     AbstractPlotting.to_type :: Tuple{Function}
│     AbstractPlotting.cam2d :: Tuple{Scene}
│     AbstractPlotting.fit_factor_stretch :: Union{Tuple{N}, Tuple{Any,Tuple{Vararg{Any,N}}}} where N
│     AbstractPlotting.text! :: Tuple
│     AbstractPlotting.FRect :: NTuple{4,Any}
│     AbstractPlotting.step! :: Tuple{Stepper}
│     AbstractPlotting.Mouse
│     AbstractPlotting.argument_names :: Union{Tuple{P}, Tuple{P}} where P<:AbstractPlot
│     FileIO.save :: Union{Tuple{F}, Tuple{File{F},Scene}} where F
│     FileIO.save :: Tuple{String,VideoStream}
│     AbstractPlotting.series :: Tuple
│     AbstractPlotting.update_limits! :: Union{Tuple{Scene,GeometryTypes.HyperRectangle}, Tuple{Scene,GeometryTypes.HyperRectangle,Any}}
│     AbstractPlotting.update_limits! :: Tuple{Scene}
│     AbstractPlotting.barplot! :: Tuple
│     AbstractPlotting.wireframe! :: Tuple
│     AbstractPlotting.linesegments! :: Tuple
│     AbstractPlotting.ColorSampler
│     AbstractPlotting.broadcast_foreach :: Tuple{Any,Vararg{Any,N} where N}
│     AbstractPlotting.mouseposition :: Union{Tuple{}, Tuple{Any}}
│     AbstractPlotting.arrows! :: Tuple
│     AbstractPlotting.surface! :: Tuple
│     AbstractPlotting.lines! :: Tuple
│     AbstractPlotting.colorlegend! :: Tuple
│     AbstractPlotting.plot! :: Tuple{Union{AbstractScene, AbstractPlotting.ScenePlot},Union{Type{Any}, Type{#s156} where #s156<:AbstractPlot},Attributes,Vararg{Any,N} where N}
│     AbstractPlotting.plot! :: Tuple{Wireframe{...}}
│     AbstractPlotting.update! :: Tuple{Scene}
│     AbstractPlotting.arc! :: Tuple
│     AbstractPlotting.close2square :: Tuple{Real}
│     AbstractPlotting.perspectiveprojection :: Union{Tuple{T}, Tuple{GeometryTypes.SimpleRectangle,T,T,T}} where T
│     AbstractPlotting.perspectiveprojection :: Union{Tuple{T}, NTuple{4,T}} where T
│     AbstractPlotting.apply_convert! :: Tuple{Any,Attributes,Tuple}
│     AbstractPlotting.apply_convert! :: Union{Tuple{S}, Tuple{Any,Attributes,PlotSpec{S}}} where S
│     AbstractPlotting.@extractvalue :: Tuple{Any,Any}
│     AbstractPlotting.calculated_attributes! :: Union{Tuple{T}, Tuple{T}} where T
│     AbstractPlotting.calculated_attributes! :: Tuple{Any,Any}
│     AbstractPlotting.contour3d :: Tuple
│     AbstractPlotting.band! :: Tuple
│     AbstractPlotting.force_update! :: Tuple{}
│     AbstractPlotting.series! :: Tuple
│     AbstractPlotting.to_spritemarker :: Tuple{AbstractArray{T,1} where T}
│     AbstractPlotting.to_spritemarker :: Tuple{Array{#s155,2} where #s155<:AbstractFloat}
│     AbstractPlotting.to_spritemarker :: Tuple{AbstractArray{#s155,2} where #s155<:ColorTypes.Colorant}
│     AbstractPlotting.to_spritemarker :: Tuple{Char}
│     AbstractPlotting.to_spritemarker :: Tuple{Symbol}
│     AbstractPlotting.to_spritemarker :: Tuple{Type{#s155} where #s155<:(GeometryTypes.HyperSphere{2,T} where T)}
│     AbstractPlotting.to_spritemarker :: Tuple{Type{#s155} where #s155<:GeometryTypes.SimpleRectangle}
│     AbstractPlotting.to_spritemarker :: Tuple{GeometryTypes.HyperSphere{2,T} where T}
│     AbstractPlotting.button :: Tuple
│     AbstractPlotting.to_colormap :: Tuple{Any}
│     AbstractPlotting.raw_boundingbox :: Tuple{Union{Image{...}, MeshScatter{...}, Scatter{...}, Mesh{...}, LineSegments{...}, Lines{...}, Surface{...}, Volume{...}, Heatmap{...}, Text{...}} where Arg}
│     AbstractPlotting.flatten_combined :: Union{Tuple{Array{T,1} where T}, Tuple{Array{T,1} where T,Any}}
│     AbstractPlotting.IRect :: Tuple{Any,Any,Union{Tuple{Vararg{T,N}}, StaticArrays.StaticArray{Tuple{N},T,1}} where T where N}
│     AbstractPlotting.IRect :: Tuple{NamedTuple{(:x, :y),T} where T<:Tuple,NamedTuple{(:width, :height),T} where T<:Tuple}
│     AbstractPlotting.IRect :: NTuple{4,Any}
│     AbstractPlotting.IRect :: Tuple{Union{Tuple{Vararg{T,N}}, StaticArrays.StaticArray{Tuple{N},T,1}} where T where N,Any,Any}
│     AbstractPlotting.IRect :: Tuple{Union{Tuple{Vararg{T,N}}, StaticArrays.StaticArray{Tuple{N},T,1}} where T where N,Union{Tuple{Vararg{T,N}}, StaticArrays.StaticArray{Tuple{N},T,1}} where T where N}
│     AbstractPlotting.IRect3D
│     AbstractPlotting.volume! :: Tuple
│     AbstractPlotting.mergekeys! :: Union{Tuple{N}, Tuple{Tuple{Vararg{Symbol,N}},Attributes,Attributes}} where N
│     AbstractPlotting.legend :: Tuple
│     AbstractPlotting.resampled_colors :: Tuple{Any,Integer}
│     AbstractPlotting.convert_attribute :: Tuple{Union{String, Symbol},AbstractPlotting.Key{:algorithm}}
│     AbstractPlotting.convert_attribute :: Tuple{Tuple{Symbol,Symbol},AbstractPlotting.Key{:align}}
│     AbstractPlotting.convert_attribute :: Tuple{Quaternion,AbstractPlotting.Key{:rotation}}
│     AbstractPlotting.convert_attribute :: Tuple{Union{Tuple, Pair},AbstractPlotting.Key{:colormap}}
│     AbstractPlotting.convert_attribute :: Union{Tuple{Union{String, Symbol},AbstractPlotting.Key{:colormap}}, Tuple{Union{String, Symbol},AbstractPlotting.Key{:colormap},Integer}}
│     AbstractPlotting.convert_attribute :: Tuple{AbstractArray{T,1} where T,AbstractPlotting.Key{:colormap}}
│     AbstractPlotting.convert_attribute :: Tuple{Any,AbstractPlotting.Key{:algorithm}}
│     AbstractPlotting.convert_attribute :: Tuple{AbstractArray{T,1} where T,AbstractPlotting.Key{:linestyle}}
│     AbstractPlotting.convert_attribute :: Tuple{Symbol,AbstractPlotting.Key{:linestyle}}
│     AbstractPlotting.convert_attribute :: Tuple{Union{String, Symbol},AbstractPlotting.Key{:font}}
│     AbstractPlotting.used_attributes :: Tuple{Any,Vararg{Any,N} where N}
│     AbstractPlotting.image! :: Tuple
│     AbstractPlotting.update_cam! :: Tuple{Union{AbstractScene, AbstractPlotting.ScenePlot},Any}
│     AbstractPlotting.update_cam! :: Tuple{Union{AbstractScene, AbstractPlotting.ScenePlot}}
│     AbstractPlotting.primary_resolution :: Tuple{}
│     AbstractPlotting.available_backends
│     AbstractPlotting.Rect3D
│     AbstractPlotting.Reverse
│     AbstractPlotting.move_from_touch :: Union{Tuple{T}, Tuple{N}, Tuple{GeometryTypes.GeometryPrimitive{N,T},GeometryTypes.GeometryPrimitive{N,T} where T,Vec{N,T} where T}} where T where N
│     AbstractPlotting.dont_touch :: Union{Tuple{N}, Tuple{GeometryTypes.GeometryPrimitive{N,T} where T,GeometryTypes.GeometryPrimitive{N,T} where T,Vec{N,T} where T}} where N
│     AbstractPlotting.notify! :: Tuple{Observables.Observable}
│     AbstractPlotting.mouse_selection
│     AbstractPlotting.onpick
│     AbstractPlotting.replace_automatic! :: Tuple{Any,Any,Any}
│     AbstractPlotting.scatter! :: Tuple
│     AbstractPlotting.PlotList
│     AbstractPlotting.FRect3D
│     AbstractPlotting.to_func :: Union{Tuple{Type{#s155} where #s155<:AbstractPlot{F}}, Tuple{F}} where F
│     AbstractPlotting.volumeslices :: Tuple
│     AbstractPlotting.automatic
│     AbstractPlotting.IRect2D
│     AbstractPlotting.atomic_limits :: Union{Tuple{Union{MeshScatter{...}, Scatter{...}, Text{...}, Mesh{...}, LineSegments{...}, Lines{...}, Surface{...}, Volume{...}, Heatmap{...}, Image{...}} where #s155<:Tuple{Arg1}}, Tuple{Arg1}} where Arg1
│     Observables.on :: Tuple{Any,Camera,Vararg{Observables.Observable,N} where N}
│     AbstractPlotting.hovered_scene :: Tuple{}
│     AbstractPlotting.showgradients :: Tuple{AbstractArray{Symbol,1}}
│     AbstractPlotting.Plot :: Union{Tuple{Vararg{Any,N}}, Tuple{N}} where N
│     AbstractPlotting.arc :: Tuple
│     AbstractPlotting.VideoStream :: Tuple{Scene}
│     AbstractPlotting.default_plot_signatures :: Tuple{Any,Any,Any}
│     AbstractPlotting.title :: Tuple{Any,Any}
│     AbstractPlotting.to_string :: Tuple{Function}
│     AbstractPlotting.ispressed :: Tuple{Union{AbstractScene, AbstractPlotting.ScenePlot},Union{Tuple, Array{T,1} where T}}
│     AbstractPlotting.Billboard
│     AbstractPlotting.showlibrary :: Tuple{Symbol}
│     AbstractPlotting.legend! :: Tuple
│     AbstractPlotting.PlotSpec
│     AbstractPlotting.streamlines :: Tuple
│     AbstractPlotting.resample :: Tuple{AbstractArray{T,1} where T,Integer}
│     AbstractPlotting.plots_from_camera :: Tuple{Scene}
│     AbstractPlotting.@extract :: Tuple{Any,Any}
│     AbstractPlotting.meshscatter! :: Tuple
│     AbstractPlotting.sig_printer :: Tuple{Real}
│     AbstractPlotting.pick
│     AbstractPlotting.current_scene :: Tuple{}
│     AbstractPlotting.poly! :: Tuple
│     AbstractPlotting.button! :: Tuple
│     AbstractPlotting.heatmap! :: Tuple
│     AbstractPlotting.map_once :: Tuple{Any,Observables.Observable,Vararg{Observables.Observable,N} where N}
│     AbstractPlotting.record_events :: Tuple{Any,Scene,String}
│     AbstractPlotting.frustum :: Union{Tuple{T}, NTuple{6,T}} where T
│     AbstractPlotting.scatterlines! :: Tuple
│     AbstractPlotting.print_rec :: Union{Tuple{IO,Any}, Tuple{IO,Any,Int64}}
│     AbstractPlotting.select_rectangle :: Tuple{Any}
│     AbstractPlotting.zoom! :: Tuple{Any,Any,Any}
│     AbstractPlotting.slider! :: Tuple
│     AbstractPlotting.contour! :: Tuple
│     AbstractPlotting.fill_between! :: Tuple{Any,Any,Any}
│     AbstractPlotting.@recipe :: Tuple{Any,Symbol,Vararg{Symbol,N} where N}
│     AbstractPlotting.from_dict :: Union{Tuple{T}, Tuple{Type{T},Any}} where T
└ @ Documenter.DocChecks ~/.julia/packages/Documenter/msPrq/src/DocChecks.jl:62

[request] animation speed (FPS) setting

Just implementation request.

I want to change animation speed when I record scenes.

I prefer to be able to set FPS(frame per sec) to record function.

e.g.
record(func, scene, path, iter, fps=30)

`plot(1:10, rand(10))` gets MethodError for `_default`

It seems there is a recipe for plot(1:10, rand(10)) but it throws an error somewhere deeper into the system.

julia> plot(1:100, rand(100))
ERROR: MethodError: no method matching _default(::Observables.Observable{UnitRange{Int64}}, ::GLMakie.GLAbstraction.Style{:lines}, ::Dict{Symbol,Any})
Closest candidates are:
  _default(::GLNormalColorMesh, ::GLMakie.GLAbstraction.Style, ::Dict) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/GLVisualize/visualize/mesh.jl:49
  _default(::Union{GPUArray{#s82,1}, Union{Observable{X}, X} where X<:AbstractArray{#s82,1}} where #s82<:Point, ::GLMakie.GLAbstraction.Style{:lines}, ::Dict) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/GLVisualize/visualize/lines.jl:53
  _default(::Union{GPUArray{#s82,2}, Union{Observable{X}, X} where X<:AbstractArray{#s82,2}} where #s82<:Point, ::GLMakie.GLAbstraction.Style{:lines}, ::Dict) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/GLVisualize/visualize/lines.jl:56
  ...
Stacktrace:
 [1] default(::Any, ::Any, ::Any) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/GLVisualize/visualize_interface.jl:4
 [2] visualize(::Any, ::GLMakie.GLAbstraction.Style{:lines}, ::Dict{Symbol,Any}) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/GLVisualize/visualize_interface.jl:21
 [3] (::getfield(GLMakie, Symbol("##67#68")){Lines{...}})(::Dict{Symbol,Any}) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/drawing_primitives.jl:145
 [4] (::getfield(GLMakie, Symbol("##47#50")){getfield(GLMakie, Symbol("##67#68")){Lines{...}},GLMakie.Screen,Scene,Lines{...}})() at /home/sfr/.julia/packages/GLMakie/nDrlO/src/drawing_primitives.jl:40
 [5] get!(::getfield(GLMakie, Symbol("##47#50")){getfield(GLMakie, Symbol("##67#68")){Lines{...}},GLMakie.Screen,Scene,Lines{...}}, ::Dict{UInt64,GLMakie.GLAbstraction.RenderObject}, ::UInt64) at ./dict.jl:453
 [6] cached_robj!(::getfield(GLMakie, Symbol("##67#68")){Lines{...}}, ::GLMakie.Screen, ::Scene, ::Lines{...}) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/drawing_primitives.jl:33
 [7] draw_atomic at /home/sfr/.julia/packages/GLMakie/nDrlO/src/drawing_primitives.jl:139 [inlined]
 [8] insert!(::GLMakie.Screen, ::Scene, ::Lines{...}) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/drawing_primitives.jl:105
 [9] insertplots!(::GLMakie.Screen, ::Scene) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/screen.jl:51
 [10] display(::GLMakie.Screen, ::Scene) at /home/sfr/.julia/packages/GLMakie/nDrlO/src/screen.jl:89
 [11] backend_display at /home/sfr/.julia/packages/GLMakie/nDrlO/src/gl_backend.jl:57 [inlined]
 [12] display(::AbstractPlotting.PlotDisplay, ::Scene) at /home/sfr/.julia/packages/AbstractPlotting/NOT5R/src/display.jl:40
 [13] display(::Any) at ./multimedia.jl:287
 [14] #invokelatest#1 at ./essentials.jl:742 [inlined]
 [15] invokelatest at ./essentials.jl:741 [inlined]
 [16] print_response(::IO, ::Any, ::Any, ::Bool, ::Bool, ::Any) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.1/REPL/src/REPL.jl:155
 [17] print_response(::REPL.AbstractREPL, ::Any, ::Any, ::Bool, ::Bool) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.1/REPL/src/REPL.jl:140
 [18] (::getfield(REPL, Symbol("#do_respond#38")){Bool,getfield(REPL, Symbol("##48#57")){REPL.LineEditREPL,REPL.REPLHistoryProvider},REPL.LineEditREPL,REPL.LineEdit.Prompt})(::Any, ::Any, ::Any) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.1/REPL/src/REPL.jl:714
 [19] #invokelatest#1 at ./essentials.jl:742 [inlined]
 [20] invokelatest at ./essentials.jl:741 [inlined]
 [21] run_interface(::REPL.Terminals.TextTerminal, ::REPL.LineEdit.ModalInterface, ::REPL.LineEdit.MIState) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.1/REPL/src/LineEdit.jl:2273
 [22] run_frontend(::REPL.LineEditREPL, ::REPL.REPLBackendRef) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.1/REPL/src/REPL.jl:1035
 [23] run_repl(::REPL.AbstractREPL, ::Any) at /buildworker/worker/package_linux64/build/usr/share/julia/stdlib/v1.1/REPL/src/REPL.jl:192
 [24] (::getfield(Base, Symbol("##734#736")){Bool,Bool,Bool,Bool})(::Module) at ./client.jl:362
 [25] #invokelatest#1 at ./essentials.jl:742 [inlined]
 [26] invokelatest at ./essentials.jl:741 [inlined]
 [27] run_main_repl(::Bool, ::Bool, ::Bool, ::Bool, ::Bool) at ./client.jl:346
 [28] exec_options(::Base.JLOptions) at ./client.jl:284
 [29] _start() at ./client.jl:436

Specify the type of zoom_step in the `zoom!` func.

AbstractPlotting.jl/src/camera/camera3d.jl

Lines 211 to 215 in 27697b4

	"""
	zoom!(scene, point, zoom_step)
	Zooms the camera of `scene` in towards `point` by a factor of `zoom_step`.
	"""

WHat's the type of zoom_step? Should that be in the docstring?

Aspect ratio ignored

When specifying scale_plot = false the resulting plot does not have an aspect ratio of 1.

I activated a new environment in an empty directory:

(v1.1) pkg> activate .
(tmp) pkg> add AbstractPlotting#master GLMakie#master Makie#master

and plotted a unit circle:

using Makie
t = range(0, 2π, length = 100)
p = lines(cos.(t), sin.(t), scale_plot = false)
save("a.png", p)

which resulted in this ellipse:

no recipe for `plot(::Vector)`

trying plot(rand(100)) throws an error because there's no default recipe. Seems like a reasonable default would be lines

Passing backgroundcolor in non mutating plot call is broken on master

using Makie, MakieThemes
show_ggthemr(:flat_dark)

to_colormap(:Viridis, n) always returns 20 colors

I see it's hardcoded in conversions.jl
A missing call to resample ?

Plot recipes not working or documentation incorrect

In Julia 1.2.0-rc2, the documentation example doesn't work. Copying the example almost directly:

julia> using Makie, GLMakie, AbstractPlotting
julia> @recipe(MyPlot, x, y, z) do scene
    Theme(
        :plot_color => :red
    )
end
julia> function AbstractPlotting.plot!(plot::MyPlot)
    # normal plotting code, building on any previously defined recipes
    # or atomic plotting operations, and adding to the combined `plot`:
    lines!(plot, rand(10), color = plot[:plot_color])
    plot!(plot, plot[:x], plot[:y])
    plot
end
julia> myplot(rand(10), rand(10), rand(10))
ERROR: KeyError: key :x not found
Stacktrace:
 [1] getindex at ./dict.jl:477 [inlined]
 [2] getindex(::Attributes, ::Symbol) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/types.jl:334
 [3] getindex(::MyPlot{...}, ::Symbol) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/types.jl:418
 [4] plot!(::MyPlot{...}) at ./REPL[3]:5
 [5] plot!(::Scene, ::Type{MyPlot{...}}, ::Attributes, ::Tuple{Observables.Observable{Array{Float64,1}},Observables.Observable{Array{Float64,1}},Observables.Observable{Array{Float64,1}}}, ::Observables.Observable{Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:607
 [6] #plot!#195(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(plot!), ::Scene, ::Type{MyPlot{...}}, ::Attributes, ::Array{Float64,1}, ::Vararg{Array{Float64,1},N} where N) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:564
 [7] plot!(::Scene, ::Type{MyPlot{...}}, ::Attributes, ::Array{Float64,1}, ::Array{Float64,1}, ::Array{Float64,1}) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:533
 [8] #myplot#5(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(myplot), ::Array{Float64,1}, ::Vararg{Array{Float64,1},N} where N) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/recipes.jl:11
 [9] myplot(::Array{Float64,1}, ::Array{Float64,1}, ::Vararg{Array{Float64,1},N} where N) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/recipes.jl:11
 [10] top-level scope at REPL[4]:1

(Note I fixed the key in Theme to be :plot_color since without a colon it doesn't make syntactic sense)

The error seems to be that the arguments are not stored as attributes, so indexing into the plot's attributes gives a key error (yay; arguments being attributes seems like a bad idea).

However, to try and get around this, I reopened the REPL (to clear the function definitions), re-ran the MyPlot recipe above, but modified plot! as follows, using indexing rather than keying. The new error seems harder to sneak around, but I haven't tried too hard. Any pointers appreciated.

julia> function AbstractPlotting.plot!(plot::MyPlot)
           # normal plotting code, building on any previously defined recipes
           # or atomic plotting operations, and adding to the combined `plot`:
           lines!(plot, rand(10), color = plot[:plot_color])
           plot!(plot, plot[1], plot[2])
           plot
       end

julia> myplot(rand(10), rand(10), rand(10))
ERROR: MethodError: plot!(::MyPlot{...}, ::Type{Lines{...}}, ::Attributes, ::Tuple{Observables.Observable{Array{Float64,1}},Observables.Observable{Array{Float64,1}}}, ::Observables.Observable{Tuple{Array{Point{2,Float32},1}}}) is ambiguous. Candidates:
  plot!(scene::Combined, ::Type{PlotType}, attributes::Attributes, args...) where PlotType<:AbstractPlot in AbstractPlotting at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:628
  plot!(scene::Union{AbstractScene, AbstractPlotting.ScenePlot}, ::Type{PlotType}, attributes::Attributes, input::Tuple{Vararg{Observables.Observable,N}}, args::Observables.Observable) where {N, PlotType<:AbstractPlot} in AbstractPlotting at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:590
Possible fix, define
  plot!(::Combined, ::Type{PlotType<:AbstractPlot}, ::Attributes, ::Tuple{Vararg{Observables.Observable,N}}, ::Observables.Observable)
Stacktrace:
 [1] #plot!#195(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(plot!), ::MyPlot{...}, ::Type{Any}, ::Attributes, ::Observables.Observable{Array{Float64,1}}, ::Vararg{Observables.Observable{Array{Float64,1}},N} where N) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:564
 [2] plot!(::MyPlot{...}, ::Type{Any}, ::Attributes, ::Observables.Observable{Array{Float64,1}}, ::Observables.Observable{Array{Float64,1}}) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:533
 [3] #plot!#191 at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/recipes.jl:15 [inlined]
 [4] plot!(::MyPlot{...}, ::Observables.Observable{Array{Float64,1}}, ::Observables.Observable{Array{Float64,1}}) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/recipes.jl:15
 [5] plot!(::MyPlot{...}) at ./REPL[3]:5
 [6] plot!(::Scene, ::Type{MyPlot{...}}, ::Attributes, ::Tuple{Observables.Observable{Array{Float64,1}},Observables.Observable{Array{Float64,1}},Observables.Observable{Array{Float64,1}}}, ::Observables.Observable{Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}}) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:607
 [7] #plot!#195(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(plot!), ::Scene, ::Type{MyPlot{...}}, ::Attributes, ::Array{Float64,1}, ::Vararg{Array{Float64,1},N} where N) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:564
 [8] plot!(::Scene, ::Type{MyPlot{...}}, ::Attributes, ::Array{Float64,1}, ::Array{Float64,1}, ::Array{Float64,1}) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/interfaces.jl:533
 [9] #myplot#5(::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(myplot), ::Array{Float64,1}, ::Vararg{Array{Float64,1},N} where N) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/recipes.jl:11
 [10] myplot(::Array{Float64,1}, ::Array{Float64,1}, ::Vararg{Array{Float64,1},N} where N) at /home/grahams/.julia/packages/AbstractPlotting/IYMTX/src/recipes.jl:11
 [11] top-level scope at REPL[4]:1

UndefVarError: removehandler_callbacks not defined

At

AbstractPlotting.jl/src/interaction/nodes.jl

Line 53 in e2f48d3

for g in removehandler_callbacks

Seems to come from a missing definition. It can probably be removed altogether.
https://github.com/JuliaGizmos/Observables.jl/blob/77e984fc72765ab1b30486809300255c1361f715/src/Observables.jl#L8

This never gets triggered, except when I was trying to use @enter from Debugger.jl

Error with colours after PlotUtils integration

From Slack (@miguelraz)

It seems that PlotUtils integration has hijacked something to do with the color conversion pipeline.

julia> vbox(
        hbox(s1, s2, s3, s4, s5, s6),
        mesh_scene, parent = parent)
┌ Warning: gray is found in more than one library: cmocean, colorcet. Choosing cmocean
└ @ PlotUtils ~/.julia/packages/PlotUtils/GxT73/src/color_gradients.jl:40
Error showing value of type Scene:
ERROR: MethodError: no method matching color(::Array{RGB{FixedPointNumbers.Normed{UInt8,8}},1})

I think this should probably just return a single colour, so no clue why it's doing that.

It could also be that to_colormap is overriding to_color...

`Base.convert(Node{T}, x)` yields `Node{Any}`

Due to

AbstractPlotting.jl/src/types.jl

Line 289 in 420fa25

Base.convert(::Type{<: Node}, x) = to_node(Any, x)

conversion to a concrete node type yields a result of Node{Any} rather than type parameter passed.

typeof(convert(Node{Bool}, false))
> Observables.Observable{Any}

In particular, this breaks structs with Node fields with a slightly confusing error message:

struct Foo x::Node{Bool} end
Foo(false)
> ERROR: TypeError: in new, expected Observables.Observable{Bool}, got Observables.Observable{Any}
Stacktrace:
 [1] Foo(::Bool) at ./none:1
 [2] top-level scope at none:0

Creating CAD style camera handling

This relates to:
JuliaGL/GLAbstraction.jl#96 (and also: MakieOrg/Makie.jl#38, JuliaGL/GLAbstraction.jl#76, JuliaGL/GLAbstraction.jl#80, MakieOrg/Makie.jl#329).

Moving discussion here as it is about AbstractPlotting's camera handling (in particular https://github.com/JuliaPlots/AbstractPlotting.jl/blob/master/src/camera/camera3d.jl)

NoConversion trait?

I'm looking at the ConversionTrait code and found the use of nothing trait.

conversion_trait(x) = nothing
# nothing trait - don't convert
convert_arguments(::Nothing, args...) = args

Wouldn't it be cleaner with a new NoConversion trait?

struct NoConversion <: ConversionTrait end

conversion_trait(::Type) = NoConversion()
convert_arguments(::NoConversion, args...) = args

Timeseries & streamplot need docs

And examples

ERROR: LoadError: UndefVarError: update_limits! not defined

Hey,

I get the error on the subject while trying to call update_limits. The same happens when I try to call update!, hbox or vbox. Tests successfully pass. I am on version 0.9.0 under Kubuntu 16.04 and Kubuntu 18.04. Julia version is 1.0.2.

Thanks in advance for any help.

customize some attributes in type recipes

Allow convert_arguments to also specify some default attributes, as in:

function convert_arguments(::Type{AbstractPlot}, x::MyType)
    return (new_args...), Theme(...)
end

RGBA volumes

Hello! How does one plot 3D volumes with RGBA values?
Putting a 3D array of RGBAf0 values in as the argument to volume! gives the following error:
MethodError: no method matching GLMakie.GLVisualize.VolumePrerender()

Also, is additive blending possible? Absorption is I guess subtractive blending, suitable for displays with white background?

README DOCS/EXAMPLES

Would be useful to provide some examples or a link to a very basic documentation to encourage usage.

docs??

I wanted to make a recipe for plotting Fun's in ApproxFun.

I'll just override mesh and mesh! for now.

Support Dates for `title` or more generally for whatever textbox

julia> times[1]
2000-03-15

julia> titletext = Node(times[1])
Observable{Date} with 0 listeners. Value:
2000-03-15

julia> fullsc = title(scene, titletext; fontsize = 40)
ERROR: MethodError: no method matching boundingbox(::Text{...}, ::Date)
Closest candidates are:
  boundingbox(::Text{...}) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\boundingbox.jl:97
  boundingbox(::Union{Text{...}, MeshScatter{...}, Scatter{...}, Mesh{...}, LineSegments{...}, Lines{...}, Surface{...}, Volume{...}, Heatmap{...}, Image{...}} where Arg) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\boundingbox.jl:41        
  boundingbox(::Text{...}, ::String) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\boundingbox.jl:86
  ...
Stacktrace:
 [1] boundingbox(::Text{...}) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\boundingbox.jl:97
 [2] raw_boundingbox(::Array{AbstractPlotting.Transformable,1}) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\boundingbox.jl:71
 [3] raw_boundingbox(::Scene) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\boundingbox.jl:59
 [4] boundingbox at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\boundingbox.jl:45 [inlined]
 [5] layout_sizes(::Array{Scene,1}, ::Vec{2,Int64}, ::Int64) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\layouting.jl:294
 [6] #587 at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\layouting.jl:228 [inlined]
 [7] lift at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\interaction\nodes.jl:9 [inlined]
 [8] #layout#586(::Scene, ::Nothing, ::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}, ::typeof(AbstractPlotting.layout), ::Array{Scene,1}, ::Int64) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\layouting.jl:228
 [9] #hbox at .\none:0 [inlined]
 [10] #hbox#583(::Base.Iterators.Pairs{Symbol,Scene,Tuple{Symbol},NamedTuple{(:parent,),Tuple{Scene}}}, ::typeof(hbox), ::Scene, ::Vararg{Scene,N} where N) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\layouting\layouting.jl:206
 [11] (::AbstractPlotting.var"#kw##hbox")(::NamedTuple{(:parent,),Tuple{Scene}}, ::typeof(hbox), ::Scene, ::Scene) at .\none:0
 [12] #title#709(::Tuple{Symbol,Symbol}, ::Int64, ::Scene, ::Base.Iterators.Pairs{Symbol,Int64,Tuple{Symbol},NamedTuple{(:fontsize,),Tuple{Int64}}}, ::typeof(title), ::Scene, ::Observables.Observable{Date}) at C:\Users\datse\.julia\packages\AbstractPlotting\3uXXp\src\basic_recipes\title.jl:23
 [13] (::AbstractPlotting.var"#kw##title")(::NamedTuple{(:fontsize,),Tuple{Int64}}, ::typeof(title), ::Scene, ::Observables.Observable{Date}) at .\none:0
 [14] top-level scope at none:0

I guess the way to solve this is to always convert whatever the user gives to a textbox by calling string(arg) ? In any case, I'd like to contribute the solution to this if someone guides me on where to start.

Package compatibility caps

Ref: https://discourse.julialang.org/t/package-compatibility-caps/15301

Add ctrl and shift buttons to `Keyboard`

Both are very useful for developing interactive applications as currently "just click" or "space+click" are both overloaded.

I would like to use "shift+click" or "ctrl+click" for some applications.

Add support for categorical values on x axis

At the moment barplot(["a", "b", "c"], rand(3)) errors, but ideally it should convert the strings to 1:3, and let a "hint" to the scene that the preferred ticks values are ["a", "b", "c"] at location [1, 2, 3].

Bad interaction of symbol marker and markersize

This works as expected

julia> scatter(rand(10), marker = Circle, markersize = rand(10))

but passing the marker as a symbol gives error:

julia> scatter(rand(10), marker = :circle, markersize = rand(10))
Error showing value of type Scene:
ERROR: MethodError: no method matching glyph_scale!(::Observable{Char}, ::Array{Vec{2,Float32},1})
Closest candidates are:
  glyph_scale!(::Char, ::Any) at /home/pietro/.julia/packages/AbstractPlotting/7QqXZ/src/utilities/texture_atlas.jl:128