fix tests

.zenodo.json

@@ -15,9 +15,8 @@
             "type": "ProjectLeader"
         },
         {
-            "affiliation": "GLOBE Institute, University of Copenhagen",
+            "affiliation": "GLOBE Institute",
             "name": "Michael Krabbe Borregaard",
-            "orcid": "0000-0002-8146-8435",
             "type": "ProjectLeader"
         },
         {

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.19.0"
+version = "1.16.8"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -76,6 +76,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
@@ -83,6 +84,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
@@ -91,8 +93,8 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:scale, :guide), Tuple{Symbol, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
@@ -104,76 +106,90 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation, :color), Tuple{Symbol, Symbol, Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(heatmap)),Any,typeof(heatmap),Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(hline!)),Any,typeof(hline!),Any})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, PlotText}}}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, PlotText}}}},typeof(plot!),Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, PlotText}}}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :xlims), Tuple{GridLayout, Tuple{Int64, Float64}}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{GRBackend},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{PlotlyBackend},Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Function,Float64,Irrational{:π}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Plot{GRBackend},Function,Float64,Vararg{Any, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Function,Float64,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Plot{GRBackend},Function,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis,), Tuple{Tuple{String, Symbol}}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis,), Tuple{Tuple{String, Symbol}}},typeof(plot!),Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis,), Tuple{Tuple{String, Symbol}}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker), Tuple{Matrix{Symbol}, Tuple{Symbol, Int64}, Tuple{Matrix{Symbol}, Int64, Float64, Stroke}}},typeof(plot),Vector{Vector{T} where T}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vector{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype), Tuple{Bool, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vararg{Vector{Int64}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype), Tuple{Bool, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype), Tuple{Matrix{Symbol}, Matrix{String}, Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}}, Int64, String, Int64, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Vector{Float64}},Vector{Vector{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title), Tuple{Tuple{Symbol, Symbol, Symbol, Int64, Float64}, String}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Float64})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Vararg{Float64, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:labels,), Tuple{Matrix{String}}},typeof(plot),PortfolioComposition})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{GridLayout, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :margin), Tuple{GridLayout, AbsoluteLength}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :palette, :bg_inside), Tuple{Int64, Matrix{PlotUtils.ContinuousColorGradient}, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border), Tuple{GridLayout, Matrix{Symbol}, Bool, Nothing, Symbol}},typeof(plot),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation), Tuple{GridLayout, Matrix{String}, Symbol, Matrix{AbsoluteLength}, AbsoluteLength, Int64}},typeof(plot),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xguide, :yguide, :xguidefonthalign, :yguidefontvalign, :xguideposition, :yguideposition, :ymirror, :xmirror, :legend, :seriestype), Tuple{Int64, String, String, Matrix{Symbol}, Matrix{Symbol}, Symbol, Matrix{Symbol}, Matrix{Bool}, Matrix{Bool}, Bool, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims), Tuple{GridLayout, Tuple{Int64, Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims), Tuple{GridLayout, Tuple{Int64, Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Vector{Tuple{Int64, Real}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms), Tuple{Tuple{Matrix{Symbol}, Int64}, Matrix{String}, Int64}},typeof(plot),Vector{Vector{T} where T},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle), Tuple{Tuple{Int64, Matrix{Symbol}}, Matrix{String}, String}},typeof(plot),Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill), Tuple{Int64, Bool, Tuple{Int64, Symbol}}},typeof(plot),Function,Function,Int64,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill), Tuple{Int64, Bool, Tuple{Int64, Symbol}}},typeof(plot),Function,Function,Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg), Tuple{Tuple{Int64, Symbol, Symbol}, Tuple{Shape{Float64, Float64}, Int64, RGBA{Float64}}, Symbol, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Bool}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int64, Bool}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :markersize, :lab, :bg, :xlim, :ylim, :seriestype), Tuple{Matrix{Symbol}, Int64, Matrix{String}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
@@ -184,27 +200,27 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64, Symbol}},typeof(plot),Vector{ComplexF64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:proj, :m), Tuple{Symbol, Int64}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},Matrix{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{OHLC}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel), Tuple{Symbol, String, String, String}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel), Tuple{Symbol, String, String, String}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :l, :seriestype), Tuple{String, Float64, Symbol}},typeof(plot),Vector{String},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xflip, :yflip, :zflip, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xmirror, :ymirror, :zmirror, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xflip, :yflip, :zflip, :zlabel, :dpi, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Int64, Bool, String, Bool, String, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xmirror, :ymirror, :zmirror, :zlabel, :dpi, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Int64, Bool, String, Bool, String, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :zlabel, :dpi, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, String, Int64, Bool, String, Bool, String, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot),Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg), Tuple{Tuple{String, Tuple{Int64, Int64}, StepRange{Int64, Int64}, Symbol}, RGB{Float64}, Bool}},typeof(plot),Matrix{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w), Tuple{StepRange{Int64, Int64}, Tuple{Int64, Float64, Symbol, Stroke}, Bool, Bool, Int64}},typeof(plot),Vector{Float64},Vector{Float64},UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:yflip, :aspect_ratio), Tuple{Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w), Tuple{StepRange{Int64, Int64}, Tuple{Int64, Float64, Symbol, Stroke}, Bool, Bool, Int64}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any})
     Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp), Tuple{Vector{Int64}, Bool}},typeof(test_examples),Symbol})
@@ -217,10 +233,12 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bar}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bins2d}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram2d}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hline}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:steppost}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:steppre}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
@@ -244,7 +262,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
     Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
     Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@@ -261,25 +282,26 @@ function _precompile_()
     Base.precompile(Tuple{typeof(backend),PlotlyBackend})
     Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
-    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
+    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64})
+    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
     Base.precompile(Tuple{typeof(create_grid),Expr})
+    Base.precompile(Tuple{typeof(discrete_value!),Axis,Vector{String}})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{typeof(error_style!),DefaultsDict})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{PlotlyBackend},Int64,Symbol})
     Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
-    Base.precompile(Tuple{typeof(get_xy),OHLC{Float64},Int64,Float64})
     Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
     Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
-    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},AbsoluteLength,AbsoluteLength,Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64, Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
@@ -294,18 +316,19 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_shapes),Series,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_surface),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Int64}, Vector{String}},Int64})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
-    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
+    Base.precompile(Tuple{typeof(gr_polyline),Vector{Float64},Vector{Float64},Function})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
-    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
+    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}}})
     Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
     Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,Tuple{Int64, Int64},Bool})
@@ -315,7 +338,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
-    Base.precompile(Tuple{typeof(isvertical),Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(layout_args),Int64})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
@@ -325,12 +347,14 @@ function _precompile_()
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),StepRange{Int64, Int64},Tuple{Int64, Int64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
-    Base.precompile(Tuple{typeof(plot),Any,Any})
+    Base.precompile(Tuple{typeof(plot),Any,Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(plot),Any})
-    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
     Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend}})
-    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend}})
+    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
     Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{typeof(processGridArg!),DefaultsDict,Bool,Symbol})
     Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
@@ -339,32 +363,36 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
-    Base.precompile(Tuple{typeof(processMinorGridArg!),Dict{Symbol, Any},Bool,Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
-    Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
+    Base.precompile(Tuple{typeof(scalefontsizes)})
+    Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
     Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol, N} where N})
     Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(text),String,Symbol})
     Base.precompile(Tuple{typeof(title!),AbstractString})
     Base.precompile(Tuple{typeof(unzip),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{typeof(vline!),Any})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(xgrid!),Plot{PlotlyBackend},Symbol,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#126")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#126")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#127")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#127")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
+    Base.precompile(Tuple{typeof(yaxis!),Any,Any})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#125")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#125")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#126")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#126")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
     let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
         if !ismissing(fbody)
             precompile(fbody, (Any,typeof(plot!),Any,))

src/arg_desc.jl

@@ -53,8 +53,7 @@ const _arg_desc = KW(
 :colorbar_entry              => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",
 
 # plot args
-:plot_title                  => "String. Title for the whole plot (not the subplots)",
-:plot_titlevspan             => "Number in [0,1]. Vertical span of the whole plot title (fraction of the plot height)",
+:plot_title                  => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
 :background_color            => "Color Type.  Base color for all backgrounds.",
 :background_color_outside    => "Color Type or `:match` (matches `:background_color`).  Color outside the plot area(s)",
 :foreground_color            => "Color Type.  Base color for all foregrounds.",
@@ -116,7 +115,7 @@ const _arg_desc = KW(
 :colorbar_formatter          => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
 :legendfont                  => "Font. Font of legend items.",
 :legendtitlefont             => "Font. Font of the legend title.",
-:annotations                 => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String, PlotText (created with `text(args...)`), or a tuple of arguments to `text` (e.g., `(\"Label\", 8, :red, :top)`).  Add one-off text annotations at the x,y coordinates.",
+:annotations                 => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
 :annotationfontfamily        => "String or Symbol. Font family of annotations.",
 :annotationfontsize          => "Integer. Font pointsize of annotations.",
 :annotationhalign            => "Symbol. horizontal alignment of annotations, :hcenter, :left, :right or :center.",

src/args.jl

@@ -331,15 +331,13 @@ const _series_defaults = KW(
 
 const _plot_defaults = KW(
     :plot_title                  => "",
-    :plot_titleindex             => 0,
     :plot_titlefontsize          => 16,
-    :plot_titlelocation          => :center,           # also :left or :right
+    :plot_title_location         => :center,           # also :left or :right
     :plot_titlefontfamily        => :match,
     :plot_titlefonthalign        => :hcenter,
     :plot_titlefontvalign        => :vcenter,
     :plot_titlefontrotation      => 0.0,
     :plot_titlefontcolor         => :match,
-    :plot_titlevspan             => 0.05,              # vertical span of the plot title, here 5%
     :background_color            => colorant"white",   # default for all backgrounds,
     :background_color_outside    => :match,            # background outside grid,
     :foreground_color            => :auto,             # default for all foregrounds, and title color,

src/axes.jl

@@ -172,9 +172,8 @@ function optimal_ticks_and_labels(ticks, alims, scale, formatter)
         scaled_ticks = optimize_ticks(
             sf(amin),
             sf(amax);
-            k_min = scale ∈ _logScales ? 2 : 4, # minimum number of ticks
+            k_min = 4, # minimum number of ticks
             k_max = 8, # maximum number of ticks
-            scale = scale,
         )[1]
     elseif typeof(ticks) <: Int
         scaled_ticks, viewmin, viewmax = optimize_ticks(
@@ -186,7 +185,6 @@ function optimal_ticks_and_labels(ticks, alims, scale, formatter)
             # `strict_span = false` rewards cases where the span of the
             # chosen  ticks is not too much bigger than amin - amax:
             strict_span = false,
-            scale = scale,
         )
         # axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax))
     else
@@ -333,48 +331,30 @@ _transform_ticks(ticks::AbstractArray{T}) where T <: Dates.TimeType = Dates.valu
 _transform_ticks(ticks::NTuple{2, Any}) = (_transform_ticks(ticks[1]), ticks[2])
 
 function get_minor_ticks(sp, axis, ticks)
-    axis[:minorticks] ∈ (:none, nothing, false) && !axis[:minorgrid] && return nothing
+    axis[:minorticks] in (:none, nothing, false) && !axis[:minorgrid] && return nothing
     ticks = ticks[1]
     length(ticks) < 2 && return nothing
 
     amin, amax = axis_limits(sp, axis[:letter])
-    scale = axis[:scale]
-    log_scaled = scale ∈ _logScales
-    base = get(_logScaleBases, scale, nothing)
-
-    # add one phantom tick either side of the ticks to ensure minor ticks extend to the axis limits
-    if log_scaled
-        sub = round(Int, log(base, ticks[2] / ticks[1]))
-        ticks = [ticks[1] / base; ticks; ticks[end] * base]
+    #Add one phantom tick either side of the ticks to ensure minor ticks extend to the axis limits
+    if length(ticks) > 2
+        ratio = (ticks[3] - ticks[2])/(ticks[2] - ticks[1])
+    elseif axis[:scale] in (:none, :identity)
+        ratio = 1
     else
-        sub = 1  # unused
-        ratio = length(ticks) > 2 ? (ticks[3] - ticks[2]) / (ticks[2] - ticks[1]) : 1
-        first_step = ticks[2] - ticks[1]
-        last_step = ticks[end] - ticks[end-1]
-        ticks = [ticks[1] - first_step / ratio; ticks; ticks[end] + last_step * ratio]
+        return nothing
     end
+    first_step = ticks[2] - ticks[1]
+    last_step = ticks[end] - ticks[end-1]
+    ticks =  [ticks[1] - first_step/ratio; ticks; ticks[end] + last_step*ratio]
 
-    # default to 9 intervals between major ticks for log10 scale and 5 intervals otherwise
-    n_default = (scale == :log10) ? 9 : 5
-    n = typeof(axis[:minorticks]) <: Integer && axis[:minorticks] > 1 ? axis[:minorticks] : n_default
-
+    #Default to 5 intervals between major ticks
+    n = typeof(axis[:minorticks]) <: Integer && axis[:minorticks] > 1 ? axis[:minorticks] : 5
     minorticks = typeof(ticks[1])[]
-    for (i, hi) ∈ enumerate(ticks[2:end])
+    for (i,hi) in enumerate(ticks[2:end])
         lo = ticks[i]
         if isfinite(lo) && isfinite(hi) && hi > lo
-            if log_scaled
-                for e ∈ 1:sub
-                    lo_ = lo * base^(e - 1)
-                    hi_ = lo_ * base
-                    step = (hi_ - lo_) / n
-                    append!(minorticks, collect(
-                        lo_ + (e > 1 ? 0 : step) : step : hi_ - (e < sub ? 0 : step / 2)
-                    ))
-                end
-            else
-                step = (hi - lo) / n
-                append!(minorticks, collect(lo + step : step : hi - step / 2))
-            end
+            append!(minorticks,collect(lo + (hi-lo)/n :(hi-lo)/n: hi - (hi-lo)/2n))
         end
     end
     minorticks[amin .<= minorticks .<= amax]
@@ -512,12 +492,12 @@ end
 # -------------------------------------------------------------------------
 
 # push the limits out slightly
-function widen(lmin, lmax, scale=:identity)
+function widen(lmin, lmax, scale = :identity)
     f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
     span = f(lmax) - f(lmin)
     # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10))
     eps = NaNMath.max(1e-16, 0.03span)
-    invf(f(lmin) - eps), invf(f(lmax) + eps)
+    invf(f(lmin)-eps), invf(f(lmax)+eps)
 end
 
 # figure out if widening is a good idea.
@@ -539,11 +519,10 @@ function default_should_widen(axis::Axis)
     false
 end
 
-function round_limits(amin, amax, scale)
-    base = get(_logScaleBases, scale, 10.)
-    factor = base^(1 - round(log(base, amax - amin)))
-    amin = floor(amin * factor) / factor
-    amax = ceil(amax * factor) / factor
+function round_limits(amin,amax)
+    scale = 10^(1-round(log10(amax - amin)))
+    amin = floor(amin*scale)/scale
+    amax = ceil(amax*scale)/scale
     amin, amax
 end
 
@@ -580,7 +559,7 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
         if axis[:letter] == :x
             amin, amax = 0, 2pi
         elseif lims == :auto
-            # widen max radius so ticks dont overlap with theta axis
+            #widen max radius so ticks dont overlap with theta axis
             0, amax + 0.1 * abs(amax - amin)
         else
             amin, amax
@@ -588,15 +567,12 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
     elseif should_widen
         widen(amin, amax, axis[:scale])
     elseif lims == :round
-        round_limits(amin, amax, axis[:scale])
+        round_limits(amin,amax)
     else
         amin, amax
     end
 
-    if (
-        !has_user_lims && consider_aspect && letter in (:x, :y) &&
-        !(sp[:aspect_ratio] in (:none, :auto) || RecipesPipeline.is3d(:sp))
-    )
+    if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || RecipesPipeline.is3d(:sp))
         aspect_ratio = isa(sp[:aspect_ratio], Number) ? sp[:aspect_ratio] : 1
         plot_ratio = height(plotarea(sp)) / width(plotarea(sp))
         dist = amax - amin
@@ -732,7 +708,6 @@ function axis_drawing_info(sp, letter)
             invf = RecipesPipeline.inverse_scale_func(oax[:scale])
 
             add_major_or_minor_segments(ticks, grid, segments, factor, cond) = begin
-                ticks === nothing && return
                 if cond
                     tick_start, tick_stop = if sp[:framestyle] == :origin
                         t = invf(f(0) + factor * (f(oamax) - f(oamin)))
@@ -858,7 +833,6 @@ function axis_drawing_info_3d(sp, letter)
             ga0, ga1 = sp[:framestyle] in (:origin, :zerolines) ? (namin, namax) : (na0, na1)
 
             add_major_or_minor_segments(ticks, grid, segments, factor, cond) = begin
-                ticks === nothing && return
                 if cond
                     tick_start, tick_stop = if sp[:framestyle] == :origin
                         t = invf(f(0) + factor * (f(namax) - f(namin)))

src/backends.jl

@@ -256,7 +256,6 @@ end
 @init_backend PGFPlotsX
 @init_backend InspectDR
 @init_backend HDF5
-@init_backend Gaston
 
 # ---------------------------------------------------------
 
@@ -353,7 +352,6 @@ const _gr_seriestype = [
     :scatter3d,
     :surface,
     :wireframe,
-    :mesh3d,
     :volume,
     :shape,
 ]
@@ -576,92 +574,6 @@ const _pyplot_style = [:auto, :solid, :dash, :dot, :dashdot]
 const _pyplot_marker = vcat(_allMarkers, :pixel)
 const _pyplot_scale = [:identity, :ln, :log2, :log10]
 
-# ------------------------------------------------------------------------------
-# Gaston
-
-function _initialize_backend(::GastonBackend)
-    @eval Main begin
-        import Gaston
-        export Gaston
-    end
-end
-
-const _gaston_attr = merge_with_base_supported([
-    # :annotations,
-    # :background_color_legend,
-    # :background_color_inside,
-    # :background_color_outside,
-    # :foreground_color_legend,
-    # :foreground_color_grid, :foreground_color_axis,
-    # :foreground_color_text, :foreground_color_border,
-    :label,
-    # :seriescolor, :seriesalpha,
-    :linecolor, :linestyle, :linewidth, :linealpha,
-    :markershape, :markercolor, :markersize, :markeralpha,
-    # :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
-    # :fillrange, :fillcolor, :fillalpha,
-    # :bins,
-    # :bar_width, :bar_edges,
-    # :title,
-    # :window_title,
-    :guide,
-    # :guide_position,
-    :lims, :ticks, :scale, # :flip, :rotation,
-    :tickfont, :guidefont,
-    # :legendfont,
-    # :grid, :legend,
-    # :colorbar, :colorbar_title,
-    # :fill_z, :line_z, :marker_z, :levels,
-    # :ribbon, :quiver, :arrow,
-    # :orientation,
-    # :overwrite_figure,
-    # :polar,
-    # :normalize, :weights, :contours,
-    # :aspect_ratio,
-    :tick_direction,
-    # :framestyle,
-    # :camera,
-    # :contour_labels,
-  ])
-const _gaston_seriestype = [:path,
-                            # :path3d,
-                            :scatter,
-                            :steppre,
-                            # :stepmid,
-                            :steppost,
-                            # :histogram2d,
-                            # :ysticks, :xsticks,
-                            # :contour,
-                            :shape,
-                            # :straightline,
-                            ]
-
-const _gaston_style = [:auto,
-                       :solid,
-                       :dash,
-                       :dot,
-                       :dashdot,
-                       :dashdotdot
-                       ]
-
-const _gaston_marker = [:none,
-                        # :auto,
-                        :circle,
-                        :rect,
-                        :diamond,
-                        :utriangle,
-                        :dtriangle,
-                        :pentagon,
-                        :x,
-                        :+
-                        ] #vcat(_allMarkers, Shape)
-
-const _gaston_scale = [:identity,
-                       # :ln,
-                       # :log2,
-                       :log10,
-                       ]
-
 # ------------------------------------------------------------------------------
 # unicodeplots
 

src/backends/gaston.jl

@@ -1,331 +0,0 @@
-# https://github.com/mbaz/Gaston.
-const G = Gaston
-const GastonSubplot = G.Plot
-const GASTON_MARKER_SCALING = 1.3 / 5.0
-const GNUPLOT_DPI = 72  # Compensate for DPI with increased resolution
-
-#
-# --------------------------------------------
-# These functions are called by Plots
-# --------------------------------------------
-#
-# Create the window/figure for this backend.
-function _create_backend_figure(plt::Plot{GastonBackend})
-    xsize = plt.attr[:size][1]
-    ysize = plt.attr[:size][2]
-    G.set(termopts="""size $xsize,$ysize""")
-
-    state_handle = G.nexthandle() # for now all the figures will be kept
-    plt.o = G.newfigure(state_handle)
-end
-
-
-function _before_layout_calcs(plt::Plot{GastonBackend})
-    # Initialize all the subplots first
-    plt.o.subplots = G.SubPlot[]
-    grid = size(plt.layout)
-    plt.o.layout = grid
-
-
-    for sp in plt.subplots
-        gaston_init_subplot(plt, sp)
-    end
-
-    # Then add the series (curves in gaston)
-    for series in plt.series_list
-        gaston_add_series(plt, series)
-    end
-end
-
-function _update_min_padding!(sp::Subplot{GastonBackend})
-    sp.minpad = (20mm, 5mm, 2mm, 10mm)
-end
-
-function _update_plot_object(plt::Plot{GastonBackend})
-end
-
-for (mime, term) in (
-    "application/eps"         => "epscairo",   # NEED fixing TODO
-    "image/eps"               => "epslatex",   # NEED fixing TODO
-    "application/pdf"         => "pdfcairo",   # NEED fixing TODO
-    "application/postscript"  => "postscript", # NEED fixing TODO
-    "image/svg+xml"           => "svg",
-    "text/latex"              => "tikz",       # NEED fixing TODO
-    "application/x-tex"       => "epslatex",   # NEED fixing TODO
-    "text/plain"              => "dumb",       # NEED fixing TODO
-)
-    @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GastonBackend})
-        xsize = plt.attr[:size][1]
-        ysize = plt.attr[:size][2]
-        termopts="""size $xsize,$ysize"""
-
-        tmpfile = G.tempname() * "." * $term
-
-        G.save(
-            term = $term,
-            output = tmpfile,
-            handle = plt.o.handle,
-            saveopts = termopts
-        )
-        while !isfile(tmpfile) end  # avoid race condition with read in next line
-        write(io, read(tmpfile))
-        rm(tmpfile, force=true)
-        nothing
-
-    end
-end
-
-function _show(io::IO, mime::MIME{Symbol("image/png")},
-               plt::Plot{GastonBackend},)
-    scaling = plt.attr[:dpi] / GNUPLOT_DPI
-    xsize = plt.attr[:size][1] * scaling
-    ysize = plt.attr[:size][2] * scaling
-
-    # Scale all plot elements to match Plots.jl DPI standard
-    termopts="""size $xsize,$ysize fontscale $scaling lw $scaling dl $scaling ps $scaling"""
-
-    tmpfile = G.tempname()
-
-    G.save(
-        term = "pngcairo",
-        output = tmpfile,
-        handle = plt.o.handle,
-        saveopts = termopts
-    )
-    while !isfile(tmpfile) end  # avoid race condition with read in next line
-    write(io, read(tmpfile))
-    rm(tmpfile, force=true)
-    nothing
-end
-
-
-function _display(plt::Plot{GastonBackend})
-    display(plt.o)
-end
-#
-# --------------------------------------------
-# These functions are gaston specific
-# --------------------------------------------
-#
-function gaston_init_subplot(plt::Plot{GastonBackend}, sp::Subplot{GastonBackend})
-    dims = RecipesPipeline.is3d(sp) ? 3 : 2
-
-    axesconf = gaston_parse_axes_args(plt, sp)  # Gnuplot string
-    sp.o = GastonSubplot(dims=dims, axesconf = axesconf, curves = [])
-    push!(plt.o.subplots,  sp.o)
-
-end
-
-function gaston_add_series(plt::Plot{GastonBackend}, series::Series)
-    # Gaston.Curve = Plots.Series
-    sp = series[:subplot]
-    g_sp = sp.o  # Gaston subplot object
-
-    seriesconf = gaston_parse_series_args(series)  # Gnuplot string
-    c = G.Curve(series[:x], series[:y], nothing, nothing, seriesconf )
-
-    isfirst = length(g_sp.curves) == 0 ? true : false
-    push!(g_sp.curves, c)
-    G.write_data(c, g_sp.dims, g_sp.datafile, append = isfirst ? false : true)
-end
-
-function gaston_parse_series_args(series::Series)
-    curveconf = String[]
-    st = series[:seriestype]
-
-    if st == :scatter
-        pt = gaston_marker(series[:markershape])
-        ps = series[:markersize] * GASTON_MARKER_SCALING
-        lc = gaston_color(series[:markercolor])
-        # alpha = series[:markeralpha] # TODO merge alpha with rgb color
-        push!(curveconf, """with points pt $pt ps $ps lc $lc""")
-    elseif st == :path
-        lc = gaston_color(series[:linecolor])
-        dt = gaston_linestyle(series[:linestyle])
-        lw = series[:linewidth]
-        # alpha = series[:linealpha] # TODO merge alpha with rgb color
-        if series[:markershape] == :none # simplepath
-            push!(curveconf, """with lines lc $lc dt $dt lw $lw""")
-        else
-            pt = gaston_marker(series[:markershape])
-            ps = series[:markersize] * GASTON_MARKER_SCALING
-            push!(curveconf, """with lp lc $lc dt $dt lw $lw pt $pt ps $ps""")
-        end
-    elseif st == :shape
-        fc = gaston_color(series[:fillcolor])
-        fs = "solid"
-        lc = gaston_color(series[:linecolor])
-        push!(curveconf, """with filledcurves fc $fc fs $fs border lc $lc""")
-    elseif st == :steppre
-        push!(curveconf, """with steps""")
-    elseif st == :steppost
-        push!(curveconf, """with fsteps""")  # Not sure if not the other way
-    end
-
-    # label
-    push!(curveconf, """title "$(series[:label])" """)
-
-    return join(curveconf, " ")
-end
-
-function gaston_parse_axes_args(plt::Plot{GastonBackend}, sp::Subplot{GastonBackend})
-    axesconf = String[]
-    # Standard 2d axis
-    if !ispolar(sp) && !RecipesPipeline.is3d(sp)
-        # TODO
-        # configure grid, axis spines, thickness
-    end
-
-    for letter in (:x, :y, :z)
-        axis_attr = sp.attr[Symbol(letter, :axis)]
-        # label names
-        push!(axesconf, """set $(letter)label "$(axis_attr[:guide])"  """)
-        push!(axesconf, """set $(letter)label font "$(axis_attr[:guidefontfamily]), $(axis_attr[:guidefontsize])"  """)
-
-        # Handle ticks
-        # ticksyle
-        push!(axesconf, """set $(letter)tics font "$(axis_attr[:tickfontfamily]), $(axis_attr[:tickfontsize])"  """)
-        push!(axesconf, """set $(letter)tics textcolor rgb "#$(hex(axis_attr[:tickfontcolor], :rrggbb))" """)
-        push!(axesconf, """set $(letter)tics  $(axis_attr[:tick_direction])""")
-
-        mirror = axis_attr[:mirror] ? "mirror" : "nomirror"
-        push!(axesconf, """set $(letter)tics  $(mirror) """)
-
-        logscale = if axis_attr[:scale] == :identity
-            "nologscale"
-        elseif axis_attr[:scale] == :log10
-            "logscale"
-        end
-        push!(axesconf, """set $logscale $(letter)""")
-
-        # tick locations
-        if axis_attr[:ticks] != :native
-            # axis limits
-            from, to = axis_limits(sp, letter)
-            push!(axesconf, """set $(letter)range [$from:$to]""")
-
-            ticks = get_ticks(sp, axis_attr)
-            gaston_set_ticks!(axesconf, ticks, letter)
-        end
-        # set title {"<title-text>"} {offset <offset>} {font "<font>{,<size>}"}{{textcolor | tc} {<colorspec> | default}} {{no}enhanced}1
-    end
-    gaston_set_legend!(axesconf, sp) # Set legend params
-
-    if sp[:title] != nothing
-        push!(axesconf, """set title '$(sp[:title])' """)
-        push!(axesconf, """set title font '$(sp[:titlefontfamily]), $(sp[:titlefontsize])' """)
-    end
-
-    return join(axesconf, "\n")
-end
-
-function gaston_set_ticks!(axesconf, ticks, letter)
-
-    ticks == :auto && return
-    if ticks == :none || ticks === nothing || ticks == false
-        push!(axesconf, """unset $(letter)tics """)
-        return
-    end
-
-    ttype = ticksType(ticks)
-    if ttype == :ticks
-        tick_locations = @view ticks[:]
-        gaston_tick_string = []
-        for i in eachindex(tick_locations)
-            lac = tick_locations[i]
-            push!(gaston_tick_string, "$loc")
-        end
-        push!(
-            axesconf,
-            "set $(letter)tics (" * join(gaston_tick_string, ", ") * ")"
-        )
-
-    elseif ttype == :ticks_and_labels
-        tick_locations = @view ticks[1][:]
-        tick_labels = @view ticks[2][:]
-        gaston_tick_string = []
-        for i in eachindex(tick_locations)
-            loc = tick_locations[i]
-            lab = gaston_enclose_tick_string(tick_labels[i])
-            push!(gaston_tick_string, "'$lab' $loc")
-        end
-        push!(
-            axesconf,
-            "set $(letter)tics (" * join(gaston_tick_string, ", ") * ")"
-        )
-
-    else
-        error("Invalid input for $(letter)ticks: $ticks")
-    end
-end
-
-function gaston_set_legend!(axesconf, sp)
-    leg = sp[:legend]
-    if !(sp[:legend] in(:none, :inline))
-        if leg == :best
-            leg = :topright
-        end
-
-        if occursin("outer", string(leg))
-            push!(axesconf, "set key outside")
-        else
-            push!(axesconf, "set key inside")
-        end
-        positions = ["top", "bottom", "left", "right"]
-        for position in positions
-            if occursin(position, string(leg))
-                push!(axesconf, "set key $position")
-            end
-        end
-        if sp[:legendtitle] != nothing
-            push!(axesconf, "set key title '$(sp[:legendtitle])'")
-        end
-        push!(axesconf, "set key box linewidth 1")
-        push!(axesconf, "set key opaque")
-
-        push!(axesconf, "set border back")
-        push!(axesconf, """set key font "$(sp[:legendfontfamily]), $(sp[:legendfontsize])"  """)
-    else
-        push!(axesconf, "set key off")
-
-    end
-
-end
-
-function gaston_marker(marker)
-    marker == :none && return -1
-    marker == :circle && return 7
-    marker == :rect && return 5
-    marker == :diamond && return 28
-    marker == :utriangle && return 9
-    marker == :dtriangle && return 11
-    marker == :+ && return 1
-    marker == :x && return 2
-    marker == :star5 && return 3
-    marker == :pentagon && return 15
-    marker == :pixel && return 0
-
-    @warn("Unsupported marker $marker")
-    return 1
-end
-
-gaston_color(color) = """rgb "#$(hex(color, :rrggbb))"  """
-
-function gaston_linestyle(style)
-    style == :solid && return "1"
-    style == :dash && return "2"
-    style == :dot && return "3"
-    style == :dashdot && return "4"
-    style == :dashdotdot && return "5"
-end
-
-function gaston_enclose_tick_string(tick_string)
-    if findfirst("^", tick_string) == nothing
-        return tick_string
-    end
-
-
-    base, power = split(tick_string, "^")
-    power = string("{", power, "}")
-    return string(base, "^", power)
-end

src/backends/gr.jl

@@ -355,9 +355,9 @@ end
 
 # draw ONE symbol marker
 function gr_draw_marker(series, xi, yi, clims, i, msize, strokewidth, shape::Symbol)
-    GR.setborderwidth(strokewidth)
-    gr_set_bordercolor(get_markerstrokecolor(series, i))
-    gr_set_markercolor(get_markercolor(series, clims, i))
+    GR.setborderwidth(strokewidth);
+    gr_set_bordercolor(get_markerstrokecolor(series, i));
+    gr_set_markercolor(get_markercolor(series, clims, i));
     gr_set_transparency(get_markeralpha(series, i))
     GR.setmarkertype(gr_markertype(shape))
     GR.setmarkersize(0.3msize / gr_nominal_size(series))
@@ -524,7 +524,7 @@ function gr_draw_colorbar(cbar::GRColorbar, sp::Subplot, clims, viewport_plotare
         levels = _cbar_unique(contour_levels.(series, Ref(clims)), "levels")
         # GR implicitly uses the maximal z value as the highest level
         if levels[end] < clims[2]
-            @warn "GR: highest contour level less than maximal z value is not supported."
+            @warn("GR: highest contour level less than maximal z value is not supported.")
             # replace levels, rather than assign to levels[end], to ensure type
             # promotion in case levels is an integer array
             levels = [levels[1:end-1]; clims[2]]
@@ -1162,25 +1162,25 @@ function gr_legend_pos(theta::Real, leg, viewport_plotarea; axisclearance=nothin
 end
 
 function gr_get_legend_geometry(viewport_plotarea, sp)
-    legendn = legendw = dy = 0
+    legendn = 0
+    legendw = 0
     if sp[:legend] != :none
         GR.savestate()
         GR.selntran(0)
         GR.setscale(0)
         if sp[:legendtitle] !== nothing
             gr_set_font(legendtitlefont(sp), sp)
-            legendn += 1
             tbx, tby = gr_inqtext(0, 0, string(sp[:legendtitle]))
             legendw = tbx[3] - tbx[1]
-            dy = tby[3] - tby[1]
+            legendn += 1
         end
         gr_set_font(legendfont(sp), sp)
         for series in series_list(sp)
             should_add_to_legend(series) || continue
             legendn += 1
-            tbx, tby = gr_inqtext(0, 0, string(series[:label]))
+            lab = series[:label]
+            tbx, tby = gr_inqtext(0, 0, string(lab))
             legendw = max(legendw, tbx[3] - tbx[1]) # Holds text width right now
-            dy = max(dy, tby[3] - tby[1])
         end
 
         GR.setscale(1)
@@ -1197,8 +1197,7 @@ function gr_get_legend_geometry(viewport_plotarea, sp)
     x_legend_offset = (viewport_plotarea[2] - viewport_plotarea[1]) / 30
     y_legend_offset = (viewport_plotarea[4] - viewport_plotarea[3]) / 30
 
-    dy *= get(sp[:extra_kwargs], :legend_hfactor, 1)
-
+    dy = gr_point_mult(sp) * sp[:legendfontsize] * 1.75
     legendh = dy * legendn
 
     return (
@@ -1327,13 +1326,7 @@ function gr_draw_axes(sp, viewport_plotarea)
         # set space
         xmin, xmax, ymin, ymax = gr_xy_axislims(sp)
         zmin, zmax = gr_z_axislims(sp)
-
-        camera = round.(Int, sp[:camera])
-
-        warn_invalid(val) = if val < 0 || val > 90 @warn "camera: $(val)° ∉ [0°, 90°]" end
-        warn_invalid.(camera)
-
-        GR.setspace(zmin, zmax, camera...)
+        GR.setspace(zmin, zmax, round.(Int, sp[:camera])...)
 
         # fill the plot area
         gr_set_fill(plot_color(sp[:background_color_inside]))
@@ -1682,7 +1675,7 @@ function gr_add_series(sp, series)
         end
     elseif st === :contour
         gr_draw_contour(series, x, y, z, clims)
-    elseif st in (:surface, :wireframe, :mesh3d)
+    elseif st in (:surface, :wireframe)
         gr_draw_surface(series, x, y, z, clims)
     elseif st === :volume
         sp[:legend] = :none
@@ -1724,7 +1717,7 @@ end
 function gr_draw_segments(series, x, y, fillrange, clims)
     st = series[:seriestype]
     if x !== nothing && length(x) > 1
-        segments = series_segments(series, st; check=true)
+        segments = series_segments(series, st)
         # do area fill
         if fillrange !== nothing
             GR.setfillintstyle(GR.INTSTYLE_SOLID)
@@ -1761,7 +1754,7 @@ end
 function gr_draw_segments_3d(series, x, y, z, clims)
     if series[:seriestype] === :path3d && length(x) > 1
         lz = series[:line_z]
-        segments = series_segments(series, :path3d; check=true)
+        segments = series_segments(series, :path3d)
         for segment in segments
             i, rng = segment.attr_index, segment.range
             lc = get_linecolor(series, clims, i)
@@ -1838,7 +1831,7 @@ function gr_draw_contour(series, x, y, z, clims)
     h = gr_contour_levels(series, clims)
     if series[:fillrange] !== nothing
         if series[:fillcolor] != series[:linecolor] && !is_lc_black
-            @warn "GR: filled contour only supported with black contour lines"
+            @warn("GR: filled contour only supported with black contour lines")
         end
         GR.contourf(x, y, h, z, series[:contour_labels] == true ? 1 : 0)
     else
@@ -1848,59 +1841,22 @@ function gr_draw_contour(series, x, y, z, clims)
 end
 
 function gr_draw_surface(series, x, y, z, clims)
-    e_kwargs = series[:extra_kwargs]
-    st = series[:seriestype]
-    if st === :surface
+
+    if series[:seriestype] === :surface
         fillalpha = get_fillalpha(series)
         fillcolor = get_fillcolor(series)
-        # NOTE: setting nx = 0 or ny = 0 disables GR.gridit interpolation
-        nx, ny = get(e_kwargs, :nx, 200), get(e_kwargs, :ny, 200)
-        if length(x) == length(y) == length(z) && nx > 0 && ny > 0
-            x, y, z = GR.gridit(x, y, z, nx, ny)
+        if length(x) == length(y) == length(z)
+            x, y, z = GR.gridit(x, y, z, 200, 200)
         end
-        d_opt = get(e_kwargs, :display_option, GR.OPTION_COLORED_MESH)
         if (!isnothing(fillalpha) && fillalpha < 1) || alpha(first(fillcolor)) < 1
             gr_set_transparency(fillcolor, fillalpha)
-            GR.surface(x, y, z, d_opt)
+            GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
         else
-            GR.gr3.surface(x, y, z, d_opt)
+            GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
         end
-    elseif st === :wireframe
+    else # wireframe
         GR.setfillcolorind(0)
-        GR.surface(x, y, z, get(e_kwargs, :display_option, GR.OPTION_FILLED_MESH))
-    elseif st === :mesh3d
-        @warn "GR: mesh3d is experimental (no face colors)"
-        conn = series[:connections]
-        if typeof(conn) <: Tuple{Array, Array, Array}
-            ci, cj, ck = conn
-            if !(length(ci) == length(cj) == length(ck))
-                throw(ArgumentError("Argument connections must consist of equally sized arrays."))
-            end
-        else
-            throw(ArgumentError("Argument connections has to be a tuple of three arrays."))
-        end
-        X = zeros(eltype(x), 4length(ci))
-        Y = zeros(eltype(y), 4length(cj))
-        Z = zeros(eltype(z), 4length(ck))
-        @inbounds for I ∈ 1:length(ci)
-            i = ci[I] + 1  # connections are 0-based
-            j = cj[I] + 1
-            k = ck[I] + 1
-            m = 4(I - 1) + 1; n = m + 1; o = m + 2; p = m + 3
-            X[m] = X[p] = x[i]
-            Y[m] = Y[p] = y[i]
-            Z[m] = Z[p] = z[i]
-            X[n] = x[j]
-            Y[n] = y[j]
-            Z[n] = z[j]
-            X[o] = x[k]
-            Y[o] = y[k]
-            Z[o] = z[k]
-        end
-        gr_set_line(get_linewidth(series), get_linestyle(series), get_linecolor(series), series)
-        GR.polyline3d(X, Y, Z)
-    else
-        throw(ArgumentError("Not handled !"))    
+        GR.surface(x, y, z, GR.OPTION_FILLED_MESH)
     end
 end
 

src/backends/pgfplotsx.jl

@@ -118,22 +118,11 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
         end
 
         for sp in plt.subplots
+            bb1 = sp.plotarea
             bb2 = bbox(sp)
+            sp_width = width(bb2)
+            sp_height = height(bb2)
             dx, dy = bb2.x0
-            sp_width = width(bb2)
-            sp_height = height(bb2)
-            if sp[:subplot_index] == plt[:plot_titleindex]
-                x = dx + sp_width / 2 - 10mm # FIXME: get rid of magic constant
-                y = dy + sp_height / 2
-                pgfx_add_annotation!(the_plot, x, y, PlotText(plt[:plot_title], plottitlefont(plt)), pgfx_thickness_scaling(plt);
-                    cs = "",
-                    options = PGFPlotsX.Options("anchor" => "center")
-                )
-                continue
-            end
-
-            sp_width = width(bb2)
-            sp_height = height(bb2)
             lpad = leftpad(sp) + sp[:left_margin]
             rpad = rightpad(sp) + sp[:right_margin]
             tpad = toppad(sp) + sp[:top_margin]
@@ -142,6 +131,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             dy += tpad
             axis_height = sp_height - (tpad + bpad)
             axis_width = sp_width - (rpad + lpad)
+
             title_cstr = plot_color(sp[:titlefontcolor])
             title_a = alpha(title_cstr)
             title_loc = sp[:titlelocation]
@@ -337,7 +327,7 @@ end
 
 function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, opt)
     # treat segments
-    segments = collect(series_segments(series, series[:seriestype]; check=true))
+    segments = collect(series_segments(series, series[:seriestype]))
     sf = opt[:fillrange]
     for (k, segment) in enumerate(segments)
         i, rng = segment.attr_index, segment.range
@@ -899,7 +889,7 @@ function pgfx_framestyle(style::Symbol)
         return style
     else
         default_style = get((semi = :box,), style, :axes)
-        @warn "Framestyle :$style is not (yet) supported by the PGFPlotsX backend. :$default_style was chosen instead."
+        @warn( "Framestyle :$style is not (yet) supported by the PGFPlotsX backend. :$default_style was cosen instead.",)
         default_style
     end
 end
@@ -1009,27 +999,24 @@ function pgfx_marker(plotattributes, i = 1)
     )
 end
 
-function pgfx_add_annotation!(o, x, y, val, thickness_scaling = 1; cs = "axis cs:", options = PGFPlotsX.Options())
+function pgfx_add_annotation!(o, x, y, val, thickness_scaling = 1)
     # Construct the style string.
     cstr = val.font.color
     a = alpha(cstr)
     push!(
         o,
-        join([
+        [
             "\\node",
-            sprint(PGFPlotsX.print_tex, merge(
-                PGFPlotsX.Options(
-                    get((hcenter = "", left = "right", right = "left"), val.font.halign, "") =>
-                        nothing,
-                    "color" => cstr,
-                    "draw opacity" => convert(Float16, a),
-                    "rotate" => val.font.rotation,
-                    "font" => pgfx_font(val.font.pointsize, thickness_scaling),
-                ),
-                options
-            )),
-            string(" at (", cs, x, ",", y, ") {", val.str, "};"),
-        ]),
+            PGFPlotsX.Options(
+                get((center = "", left = "right", right = "left"), val.font.halign, "") =>
+                    nothing,
+                "color" => cstr,
+                "draw opacity" => convert(Float16, a),
+                "rotate" => val.font.rotation,
+                "font" => pgfx_font(val.font.pointsize, thickness_scaling),
+            ),
+            " at (axis cs:$x, $y) {$(val.str)};",
+        ],
     )
 end
 

src/backends/plotly.jl

@@ -663,7 +663,7 @@ function plotly_series(plt::Plot, series::Series)
 end
 
 function plotly_series_shapes(plt::Plot, series::Series, clims)
-    segments = series_segments(series; check=true)
+    segments = series_segments(series)
     plotattributes_outs = Vector{KW}(undef, length(segments))
 
     # TODO: create a plotattributes_out for each polygon

src/backends/pyplot.jl

@@ -442,7 +442,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             #     end
             #     push!(handles, handle)
             # else
-            for (k, segment) in enumerate(series_segments(series, st; check=true))
+            for (k, segment) in enumerate(series_segments(series, st))
                 i, rng = segment.attr_index, segment.range
                 handle = ax."plot"((arg[rng] for arg in xyargs)...;
                                    label = k == 1 ? series[:label] : "",

src/examples.jl

@@ -115,7 +115,7 @@ const _examples = PlotExample[
                     )
                     vline!([5, 10])
                     title!("TITLE")
-                    yaxis!("YLABEL", :log10, minorgrid = true)
+                    yaxis!("YLABEL", :log10)
                 end
             ),
         ],
@@ -370,19 +370,10 @@ const _examples = PlotExample[
         "Annotations",
         """
         The `annotations` keyword is used for text annotations in data-coordinates.  Pass in a
-        tuple `(x, y, text)`, or a vector of annotations, each of which is a tuple of `x`, `y`
-        and `text`.
-        `text` may be a simple `String`, or a `PlotText` object, which can be
-        built with the method `text(string, attrs...)`.
-        This wraps font and color attributes and allows you to set text styling.
-        `text` may also be a tuple `(string, attrs...)` of arguments which are passed
-        to `Plots.text`.
-
-        `annotate!(ann)` is shorthand for `plot!(; annotation=ann)`.
-
-        Series annotations are used for annotating individual data points.
-        They require only the annotation; x/y values are computed.  Series annotations
-        require either plain `String`s or `PlotText` objects.
+        tuple (x,y,text) or a vector of annotations.  `annotate!(ann)` is shorthand for `plot!(;
+        annotation=ann)`.  Series annotations are used for annotating individual data points.
+        They require only the annotation... x/y values are computed.  A `PlotText` object can be
+        build with the method `text(string, attr...)`, which wraps font and color attributes.
         """,
         [
             :(
@@ -394,11 +385,11 @@ const _examples = PlotExample[
                         leg = false,
                     )
                     annotate!([
-                        (5, y[5], ("this is #5", 16, :red, :center)),
+                        (5, y[5], Plots.text("this is #5", 16, :red, :center)),
                         (
                             10,
                             y[10],
-                            ("this is #10", :right, 20, "courier"),
+                            Plots.text("this is #10", :right, 20, "courier"),
                         ),
                     ])
                     scatter!(
@@ -1007,37 +998,33 @@ const _examples = PlotExample[
         end]
     ),
     PlotExample( # 47
-        "Mesh3d",
-        """
-        Allows to plot arbitrary 3d meshes. If only x,y,z are given the mesh is generated automatically.
-        You can also specify the connections using the connections keyword.
-        The connections are specified using a tuple of vectors. Each vector contains the 0-based indices of one point of a triangle,
-        such that elements at the same position of these vectors form a triangle.
-        """,
-        [
-            :(
-                begin
-                    # specify the vertices
-                    x=[0, 1, 2, 0]
-                    y=[0, 0, 1, 2]
-                    z=[0, 2, 0, 1]
+	"Mesh3d",
+	"""
+	Allows to plot arbitrary 3d meshes. If only x,y,z are given the mesh is generated automatically.
+	You can also specify the connections using the connections keyword.
+    The connections are specified using a tuple of vectors. Each vector contains the 0-based indices of one point of a triangle,
+	such that elements at the same position of these vectors form a triangle.
+	""",
+	[
+		:(
+		  begin
+			# specify the vertices
+			x=[0, 1, 2, 0]
+			y=[0, 0, 1, 2]
+			z=[0, 2, 0, 1]
 
-                    # specify the triangles
-                    # every column is one triangle,
-                    # where the values denote the indices of the vertices of the triangle
-                    i=[0, 0, 0, 1]
-                    j=[1, 2, 3, 2]
-                    k=[2, 3, 1, 3]
+			# specify the triangles
+			# every column is one triangle,
+			# where the values denote the indices of the vertices of the triangle
+			i=[0, 0, 0, 1]
+			j=[1, 2, 3, 2]
+			k=[2, 3, 1, 3]
 
-                    # the four triangles gives above give a tetrahedron
-                    mesh3d(
-                        x, y, z; connections=(i, j, k),
-                        title="triangles", xlabel="x", ylabel="y", zlabel="z",
-                        legend=:none, margin=2Plots.mm
-                    )
-                end
-            ),
-        ],
+			# the four triangles gives above give a tetrahedron
+			mesh3d(x,y,z;connections=(i,j,k))
+		  end
+		),
+	],
     ),
     PlotExample( # 48
         "Vectors of markershapes and segments",
@@ -1227,7 +1214,7 @@ const _examples = PlotExample[
 # Some constants for PlotDocs and PlotReferenceImages
 _animation_examples = [2, 31]
 _backend_skips = Dict(
-    :gr => [25, 30],
+    :gr => [25, 30, 47],
     :pyplot => [2, 25, 30, 31, 47, 49, 55],
     :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 51, 55],
     :plotly => [2, 21, 24, 25, 30, 31, 49, 50, 51, 55],
@@ -1241,8 +1228,6 @@ _backend_skips = Dict(
         49, # polar heatmap
         51, # image with custom axes
     ],
-    :inspectdr => [4, 6, 10, 22, 24, 28, 30, 38, 43, 45, 47, 48, 49, 50, 51, 55],
-    :unicodeplots => [6, 10, 22, 24, 28, 38, 43, 45, 47, 49, 50, 51, 55],
 )
 
 

src/init.jl

@@ -70,11 +70,6 @@ function __init__()
         include(fn)
     end
 
-    @require Gaston = "4b11ee91-296f-5714-9832-002c20994614" begin
-        fn = joinpath(@__DIR__, "backends", "gaston.jl")
-        include(fn)
-    end
-
     @require IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" begin
         if IJulia.inited
             _init_ijulia_plotting()

src/layouts.jl

@@ -494,42 +494,34 @@ layout_args(huh) = error("unhandled layout type $(typeof(huh)): $huh")
 
 function build_layout(args...)
     layout, n = layout_args(args...)
-    build_layout(layout, n, Array{Plot}(undef, 0))
+    build_layout(layout, n)
 end
 
+# # just a single subplot
+# function build_layout(sp::Subplot, n::Integer)
+#     sp, Subplot[sp], SubplotMap(gensym() => sp)
+# end
 
-# n is the number of subplots...
-function build_layout(layout::GridLayout, n::Integer, plts::AVec{Plot})
+# n is the number of subplots... build a grid and initialize the inner subplots recursively
+function build_layout(layout::GridLayout, n::Integer)
     nr, nc = size(layout)
     subplots = Subplot[]
     spmap = SubplotMap()
-    empty = isempty(plts)
     i = 0
-    for r = 1:nr, c = 1:nc
-        l = layout[r, c]
+    for r=1:nr, c=1:nc
+        l = layout[r,c]
         if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
-            if empty
-                # initialize the inner subplots recursively
-                sp = Subplot(backend(), parent=layout)
-                layout[r, c] = sp
-                push!(subplots, sp)
-                spmap[attr(l,:label,gensym())] = sp
-                inc = 1
-            else
-                # build a layout from a list of existing Plot objects
-                plt = popfirst!(plts)  # grab the first plot out of the list
-                layout[r, c] = plt.layout
-                append!(subplots, plt.subplots)
-                merge!(spmap, plt.spmap)
-                inc = length(plt.subplots)
-            end
+            sp = Subplot(backend(), parent=layout)
+            layout[r,c] = sp
+            push!(subplots, sp)
+            spmap[attr(l,:label,gensym())] = sp
             if get(l.attr, :width, :auto) != :auto
                 layout.widths[c] = attr(l,:width)
             end
             if get(l.attr, :height, :auto) != :auto
                 layout.heights[r] = attr(l,:height)
             end
-            i += inc
+            i += 1
         elseif isa(l, GridLayout)
             # sub-grid
             if get(l.attr, :width, :auto) != :auto
@@ -538,11 +530,11 @@ function build_layout(layout::GridLayout, n::Integer, plts::AVec{Plot})
             if get(l.attr, :height, :auto) != :auto
                 layout.heights[r] = attr(l,:height)
             end
-            l, sps, m = build_layout(l, n - i, plts)
+            l, sps, m = build_layout(l, n-i)
             append!(subplots, sps)
             merge!(spmap, m)
             i += length(sps)
-        elseif isa(l, Subplot) && empty
+        elseif isa(l, Subplot)
             error("Subplot exists. Cannot re-use existing layout.  Please make a new one.")
         end
         i >= n && break  # only add n subplots
@@ -551,6 +543,45 @@ function build_layout(layout::GridLayout, n::Integer, plts::AVec{Plot})
     layout, subplots, spmap
 end
 
+# build a layout from a list of existing Plot objects
+# TODO... much of the logic overlaps with the method above... can we merge?
+function build_layout(layout::GridLayout, numsp::Integer, plts::AVec{Plot})
+    nr, nc = size(layout)
+    subplots = Subplot[]
+    spmap = SubplotMap()
+    i = 0
+    for r=1:nr, c=1:nc
+        l = layout[r,c]
+        if isa(l, EmptyLayout) && !get(l.attr, :blank, false)
+            plt = popfirst!(plts)  # grab the first plot out of the list
+            layout[r,c] = plt.layout
+            append!(subplots, plt.subplots)
+            merge!(spmap, plt.spmap)
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            i += length(plt.subplots)
+        elseif isa(l, GridLayout)
+            # sub-grid
+            if get(l.attr, :width, :auto) != :auto
+                layout.widths[c] = attr(l,:width)
+            end
+            if get(l.attr, :height, :auto) != :auto
+                layout.heights[r] = attr(l,:height)
+            end
+            l, sps, m = build_layout(l, numsp-i, plts)
+            append!(subplots, sps)
+            merge!(spmap, m)
+            i += length(sps)
+        end
+        i >= numsp && break  # only add n subplots
+    end
+    layout, subplots, spmap
+end
+
 
 # ----------------------------------------------------------------------
 # @layout macro

src/pipeline.jl

@@ -141,7 +141,7 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW)
 end
 
 
-RecipesPipeline.get_axis_limits(plt::Plot, letter) = axis_limits(plt[1], letter, false)
+RecipesPipeline.get_axis_limits(plt::Plot, letter) = axis_limits(plt[1], letter)
 
 
 ## Plot recipes
@@ -262,7 +262,6 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
         sp_attrs[sp] = attr
     end
 
-    _add_plot_title!(plt)
     # override subplot/axis args.  `sp_attrs` take precendence
     for (idx, sp) in enumerate(plt.subplots)
         attr = if !haskey(plotattributes, :subplot) || plotattributes[:subplot] == idx
@@ -275,35 +274,12 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
 
     # do we need to link any axes together?
     link_axes!(plt.layout, plt[:link])
-    return nothing
 end
 
 function series_idx(kw_list::AVec{KW}, kw::AKW)
     Int(kw[:series_plotindex]) - Int(kw_list[1][:series_plotindex]) + 1
 end
 
-function _add_plot_title!(plt)
-    plot_title = plt[:plot_title]
-    if plot_title != ""
-        the_layout = plt.layout
-        vspan = plt[:plot_titlevspan]
-        plt.layout = grid(2, 1, heights=(vspan, 1 - vspan))
-        plt.layout.grid[1, 1] = subplot = Subplot(plt.backend, parent=plt.layout[1, 1])
-        plt.layout.grid[2, 1] = the_layout
-        subplot.plt = plt
-        # propagate arguments plt[:plot_titleXXX] --> subplot[:titleXXX]
-        for sym ∈ filter(x -> startswith(string(x), "plot_title"), keys(_plot_defaults))
-            subplot[Symbol(string(sym)[length("plot_") + 1:end])] = plt[sym]
-        end
-        plt[:force_minpad] = nothing, 0px, nothing, 0px
-        subplot[:subplot_index] = last(plt.subplots)[:subplot_index] + 1
-        plt[:plot_titleindex] = subplot[:subplot_index]
-        subplot[:framestyle] = :none
-        subplot[:margin] = 0px
-        push!(plt.subplots, subplot)
-    end
-    return nothing
-end
 
 ## Series recipes
 

src/plot.jl

@@ -160,7 +160,6 @@ function plot!(plt1::Plot, plt2::Plot, plts_tail::Plot...; kw...)
             cmdidx += 1
         end
     end
-    _add_plot_title!(plt)
 
     # first apply any args for the subplots
     for (idx,sp) in enumerate(plt.subplots)
@@ -226,16 +225,6 @@ function prepare_output(plt::Plot)
         _update_min_padding!(sp)
     end
 
-    # spedific to :plot_title see _add_plot_title!
-    force_minpad = get(plt, :force_minpad, ())
-    if !isempty(force_minpad)
-        for i ∈ eachindex(plt.layout.grid)
-            plt.layout.grid[i].minpad = Tuple(
-                i === nothing ? j : i for (i, j) ∈ zip(force_minpad, plt.layout.grid[i].minpad)
-            )
-        end
-    end
-
     # now another pass down, to update the bounding boxes
     update_child_bboxes!(plt.layout)
 

src/shorthands.jl

@@ -453,14 +453,12 @@ Add annotations to an existing plot.
 # Arguments
 
 - `anns`: An `AbstractVector` of tuples of the form `(x,y,text)`. The `text` object
-          can be a `String`, `PlotText` PlotText (created with `text(args...)`),
-          or a tuple of arguments to `text` (e.g., `("Label", 8, :red, :top)`).
+          can be a `String` or `PlotText`.
 
 # Example
 ```julia-repl
 julia> plot(1:10)
 julia> annotate!([(7,3,"(7,3)"),(3,7,text("hey", 14, :left, :top, :green))])
-julia> annotate!([(4, 4, ("More text", 8, 45.0, :bottom, :red))])
 ```
 """
 annotate!(anns...; kw...)             = plot!(; annotation = anns, kw...)

src/utils.jl

@@ -75,29 +75,13 @@ function iter_segments(args...)
     NaNSegmentsIterator(tup, n1, n2)
 end
 
-function series_segments(series::Series, seriestype::Symbol=:path; check=false)
+function series_segments(series::Series, seriestype::Symbol = :path)
     x, y, z = series[:x], series[:y], series[:z]
     (x === nothing || isempty(x)) && return UnitRange{Int}[]
 
     args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
     nan_segments = collect(iter_segments(args...))
 
-    if check
-        scales = :xscale, :yscale, :zscale
-        for (n, s) ∈ enumerate(args)
-            scale = get(series, scales[n], :identity)
-            if scale ∈ _logScales
-                for (i, v) ∈ enumerate(s)
-                    if v <= 0
-                        @warn "Invalid negative or zero value $v found at series index $i for $(scale) based $(scales[n])"
-                        @debug "" exception=(DomainError(v), stacktrace())
-                        break
-                    end
-                end
-            end
-        end
-    end
-
     segments = if has_attribute_segments(series)
         Iterators.flatten(map(nan_segments) do r
             if seriestype in (:scatter, :scatter3d)

test/test_pipeline.jl

@@ -1,5 +1,4 @@
 using Plots, Test
-using RecipesPipeline
 
 @testset "plot" begin
     pl = plot(1:5)
@@ -9,11 +8,3 @@ using RecipesPipeline
     plot!(pl, tex_output_standalone = true)
     @test pl[:tex_output_standalone] == true
 end
-
-@testset "get_axis_limits" begin
-    x = [.1, 5]
-    p1 = plot(x, [5, .1], yscale=:log10)
-    p2 = plot!(identity)
-    @test all(RecipesPipeline.get_axis_limits(p1, :x) .== x)
-    @test all(RecipesPipeline.get_axis_limits(p2, :x) .== x)
-end