Merge pull request #3307 from daschw/release

up version

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.10.2"
+version = "1.10.5"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -36,7 +36,7 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 Contour = "0.5"
 FFMPEG = "0.2, 0.3, 0.4"
 FixedPointNumbers = "0.6, 0.7, 0.8"
-GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53"
+GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54"
 GeometryBasics = "0.2, 0.3.1"
 JSON = "0.21, 1"
 Latexify = "0.14"
@@ -45,7 +45,7 @@ NaNMath = "0.3"
 PlotThemes = "2"
 PlotUtils = "1"
 RecipesBase = "1"
-RecipesPipeline = "0.2"
+RecipesPipeline = "0.3"
 Reexport = "0.2, 1.0"
 Requires = "1"
 Scratch = "1"

benchmark/benchmarks.jl

@@ -6,5 +6,5 @@ julia_cmd = split(get(ENV, "TESTCMD", Base.JLOptions().julia_bin))
 
 SUITE["load_plot_display"] = @benchmarkable run(`$julia_cmd --startup-file=no --project -e 'using Plots; display(plot(1:0.1:10, sin.(1:0.1:10)))'`)
 SUITE["load"] = @benchmarkable run(`$julia_cmd --startup-file=no --project -e 'using Plots'`)
-SUITE["plot"] = @benchmarkable p = plot(1:0.1:10, sin.(1:0.1:10))
-SUITE["display"] = @benchmarkable display(p) setup=(p = plot(1:0.1:10, sin.(1:0.1:10)))
+SUITE["plot"] = @benchmarkable p = plot(1:0.1:10, sin.(1:0.1:10)) samples=1 evals=1
+SUITE["display"] = @benchmarkable display(p) setup=(p = plot(1:0.1:10, sin.(1:0.1:10))) samples=1 evals=1

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -59,7 +59,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Array{Int64,1}}},typeof(_make_hist),Tuple{Array{Float64,1}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Tuple{Int64,Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1}},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})
@@ -90,7 +89,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Plot{GRBackend},Array{GeometryBasics.Point{2,Float64},1}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,PlotText},1}}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Plot{GRBackend},Array{Float64,2}})
     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},Array{Any,1},Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
@@ -101,11 +99,7 @@ function _precompile_()
     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},Array{Int64,1},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},Array{Int64,1},Vararg{Any,N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Array{Int64,1}})
-    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!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Plot{GRBackend},Array{Float64,1},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,),Tuple{Tuple{String,Symbol}}},typeof(plot!)})
@@ -113,7 +107,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plot{GRBackend},Array{Float64,1}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plot{PlotlyBackend},Array{Float64,1}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg),Tuple{Tuple{Int64,Float64,PlotText},Bool}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,),Tuple{Int64}},typeof(plot),Array{Float64,1},Array{Float64,1}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{String,1},Array{String,1},Vararg{Any,N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype),Tuple{Symbol,Array{Int64,1},Symbol}},typeof(plot),Array{Float64,1}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker),Tuple{Array{Symbol,2},Tuple{Symbol,Int64},Tuple{Array{Symbol,2},Int64,Float64,Stroke}}},typeof(plot),Array{Array{T,1} where T,1}})
@@ -152,7 +145,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype),Tuple{Symbol,Symbol}},typeof(plot),Array{Int64,2}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype),Tuple{Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}},Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill),Tuple{Bool,Tuple{Int64,Symbol}}},typeof(plot),Array{Float64,1}})
-    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}})
@@ -189,6 +181,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:spy}},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{:xerror}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),Dict{Symbol,Any},Type{Val{:quiver}},Plot{GRBackend}})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{PlotlyBackend},DefaultsDict})
     Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
@@ -196,10 +189,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},DefaultsDict,Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol,Any},Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},DefaultsDict,Symbol,String})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},Dict{Symbol,Any},Symbol,String})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},DefaultsDict,Symbol,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol,Any},Symbol,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},DefaultsDict,Symbol,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},Dict{Symbol,Any},Symbol,Any})
     Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
     Base.precompile(Tuple{typeof(_cbar_unique),Array{Int64,1},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Array{Nothing,1},String})
@@ -222,7 +215,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol,Any},Int64,Bool})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol,Any},Int64,Bool})
     Base.precompile(Tuple{typeof(backend),PlotlyBackend})
-    Base.precompile(Tuple{typeof(bbox!),Subplot{GRBackend},BoundingBox{Tuple{Length{:mm,Float64},Length{:mm,Float64}},Tuple{Length{:mm,Float64},Length{:mm,Float64}}}})
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(bbox),Length{:mm,Float64},Length{:mm,Float64},Length{:mm,Float64},Length{:mm,Float64}})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64})
@@ -230,12 +222,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Int64,Float64}})
     Base.precompile(Tuple{typeof(create_grid),Expr})
     Base.precompile(Tuple{typeof(error_coords),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(error_style!),DefaultsDict})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}})
     Base.precompile(Tuple{typeof(fakedata),Int64,Vararg{Int64,N} where N})
     Base.precompile(Tuple{typeof(font),String,Vararg{Any,N} where N})
     Base.precompile(Tuple{typeof(get_clims),Subplot{GRBackend},Series,Function})
-    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Float64,1},Array{Any,1}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Float64,1},Array{String,1}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Int64,1},Array{String,1}}})
     Base.precompile(Tuple{typeof(get_series_color),Array{Symbol,1},Subplot{GRBackend},Int64,Symbol})
@@ -247,20 +237,20 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},Length{:mm,Float64},Length{:mm,Float64},Array{Float64,1}})
     Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64,Float64},Array{Float64,1}})
     Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_grid),Subplot{GRBackend},Axis,Segments{Tuple{Float64,Float64,Float64}},Function})
     Base.precompile(Tuple{typeof(gr_draw_grid),Subplot{GRBackend},Axis,Segments{Tuple{Float64,Float64}}})
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Base.OneTo{Int64},Base.OneTo{Int64},Array{Float64,2},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64,Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,Array{Int64,1},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Array{Int64,1},Array{Int64,1},Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Array{Float64,1},Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Float64,1},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Float64,1},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Array{Float64,1},Array{Float64,1}},Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64,Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Array{Float64,1},Array{Float64,1},Array{Float64,1},Tuple{Float64,Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Float64,1},Array{Any,1}},Int64})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Float64,1},Array{String,1}},Int64})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Int64,1},Array{String,1}},Int64})
@@ -268,18 +258,18 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
     Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
     Base.precompile(Tuple{typeof(gr_polyline),Array{Float64,1},Array{Float64,1},Function})
-    Base.precompile(Tuple{typeof(gr_polyline3d),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
-    Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{Length{:mm,Float64},Length{:mm,Float64}},Tuple{Length{:mm,Float64},Length{:mm,Float64}}},Length{:mm,Float64},Length{:mm,Float64},Array{Float64,1}})
     Base.precompile(Tuple{typeof(heatmap_edges),Array{Float64,1},Symbol})
     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})
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
+    Base.precompile(Tuple{typeof(ignorenan_extrema),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Array{Int64,1}})
     Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1},Array{Float64,1},UnitRange{Int64}})
     Base.precompile(Tuple{typeof(iter_segments),Array{Float64,1}})
     Base.precompile(Tuple{typeof(iter_segments),Base.OneTo{Int64},Array{Float64,1}})
     Base.precompile(Tuple{typeof(layout_args),Int64})
+    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},Int64})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Subplot{GRBackend},Axis,StepRange{Int64,Int64}})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Subplot{GRBackend},Axis,UnitRange{Int64}})
@@ -292,7 +282,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Int64})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Symbol})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Array{Symbol,2}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Float64})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Shape})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Stroke})

src/axes.jl

@@ -815,7 +815,7 @@ function axis_drawing_info_3d(sp, letter)
                     t = invf(f(na0) + 0.006 * (f(na1) - f(na0)) * ticks_in)
                     (na0, t)
                 end
-                for tick in minorticks
+                for tick in minor_ticks
                     if ax[:showaxis]
                         push!(
                             tick_segments,

src/backends/gr.jl

@@ -1578,10 +1578,8 @@ function gr_add_series(sp, series)
         GR.gr3.clear()
         dmin, dmax = GR.gr3.volume(y.v, 0)
     elseif st === :heatmap
-        if !ispolar(series)
-            # `z` is already transposed, so we need to reverse before passing its size.
-            x, y = heatmap_edges(x, xscale, y, yscale, reverse(size(z)))
-        end
+        # `z` is already transposed, so we need to reverse before passing its size.
+        x, y = heatmap_edges(x, xscale, y, yscale, reverse(size(z)), ispolar(series))
         gr_draw_heatmap(series, x, y, z, clims)
     elseif st === :image
         gr_draw_image(series, x, y, z, clims)
@@ -1736,13 +1734,12 @@ end
 function gr_draw_surface(series, x, y, z, clims)
     if series[:seriestype] === :surface
         if length(x) == length(y) == length(z)
-            GR.trisurface(x, y, z)
-        else
-            try
-                GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
-            catch
-                GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
-            end
+            x, y, z = GR.gridit(x, y, z, 200, 200)
+        end
+        try
+            GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
+        catch
+            GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
         end
     else # wireframe
         GR.setfillcolorind(0)
@@ -1752,42 +1749,33 @@ end
 
 function gr_draw_heatmap(series, x, y, z, clims)
     fillgrad = _as_gradient(series[:fillcolor])
-    if !ispolar(series)
-        GR.setspace(clims..., 0, 90)
-        w, h = length(x) - 1, length(y) - 1
-        if is_uniformly_spaced(x) && is_uniformly_spaced(y)
-            # For uniformly spaced data use GR.drawimage, which can be
-            # much faster than GR.nonuniformcellarray, especially for
-            # pdf output, and also supports alpha values.
-            # Note that drawimage draws uniformly spaced data correctly
-            # even on log scales, where it is visually non-uniform.
-            colors = plot_color.(get(fillgrad, z, clims), series[:fillalpha])
-            rgba = gr_color.(colors)
-            GR.drawimage(first(x), last(x), last(y), first(y), w, h, rgba)
-        else
-            if something(series[:fillalpha], 1) < 1
-                @warn "GR: transparency not supported in non-uniform heatmaps. Alpha values ignored."
-            end
-            z_normalized = get_z_normalized.(z, clims...)
-            rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
-            GR.nonuniformcellarray(x, y, w, h, rgba)
-        end
+    GR.setspace(clims..., 0, 90)
+    w, h = length(x) - 1, length(y) - 1
+    if !ispolar(series) && is_uniformly_spaced(x) && is_uniformly_spaced(y)
+        # For uniformly spaced data use GR.drawimage, which can be
+        # much faster than GR.nonuniformcellarray, especially for
+        # pdf output, and also supports alpha values.
+        # Note that drawimage draws uniformly spaced data correctly
+        # even on log scales, where it is visually non-uniform.
+        colors = plot_color.(get(fillgrad, z, clims), series[:fillalpha])
+        rgba = gr_color.(colors)
+        GR.drawimage(first(x), last(x), last(y), first(y), w, h, rgba)
     else
-        phimin, phimax = 0.0, 360.0 # nonuniform polar array is not yet supported in GR.jl
-        nx, ny = length(series[:x]), length(series[:y])
-        xmin, xmax, ymin, ymax = gr_xy_axislims(series[:subplot])
-        GR.setwindow(-ymax, ymax, -ymax, ymax)
-        if ymin > 0
-            @warn "'ymin[1] > 0' (rmin) is not yet supported."
-        end
-        if series[:y][end] != ny
-            @warn "Right now only the maximum value of y (r) is taken into account."
+        if something(series[:fillalpha], 1) < 1
+            @warn "GR: transparency not supported in non-uniform heatmaps. Alpha values ignored."
         end
         z_normalized = get_z_normalized.(z, clims...)
         rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
-        GR.polarcellarray(0, 0, phimin, phimax, 0, ymax, nx, ny, rgba)
-        # Right now only the maximum value of y (r) is taken into account.
-        # This is certainly not perfect but nonuniform polar array is not yet supported in GR.jl
+        if !ispolar(series)
+            GR.nonuniformcellarray(x, y, w, h, rgba)
+        else
+            if y[1] < 0
+                @warn "'y[1] < 0' (rmin) is not yet supported."
+            end
+            xmin, xmax, ymin, ymax = gr_xy_axislims(series[:subplot])
+            GR.setwindow(-ymax, ymax, -ymax, ymax)
+            GR.nonuniformpolarcellarray(rad2deg.(x), y, w, h, rgba)
+        end
     end
 end
 

src/backends/inspectdr.jl

@@ -79,6 +79,58 @@ end
 
 # ---------------------------------------------------------------------------
 
+function _inspectdr_getaxisticks(ticks, gridlines, xfrm)
+    TickCustom = InspectDR.TickCustom
+    _xfrm(coord) = InspectDR.axis2aloc(Float64(coord), xfrm.spec) #Ensure Float64 - in case
+
+    ttype = ticksType(ticks)
+    if ticks == :native
+        #keep current
+    elseif ttype == :ticks_and_labels
+        pos = ticks[1]; labels = ticks[2]; nticks = length(ticks[1])
+        newticks = TickCustom[TickCustom(_xfrm(pos[i]), labels[i]) for i in 1:nticks]
+        gridlines = InspectDR.GridLinesCustom(gridlines)
+        gridlines.major = newticks
+        gridlines.minor = []
+        gridlines.displayminor = false
+    elseif ttype == :ticks
+        nticks = length(ticks)
+        gridlines.major = Float64[_xfrm(t) for t in ticks]
+        gridlines.minor = []
+        gridlines.displayminor = false
+    elseif isnothing(ticks)
+        gridlines.major = []
+        gridlines.minor = []
+    else #Assume ticks == :native
+        #keep current
+    end
+
+    return gridlines #keep current
+end
+
+function _inspectdr_setticks(sp::Subplot, plot, strip, xaxis, yaxis)
+    InputXfrm1D = InspectDR.InputXfrm1D
+    _get_ticks(axis) = :native == axis[:ticks] ? (:native) : get_ticks(sp, axis)
+    wantnative(ticks) = (:native == ticks)
+
+    xticks = _get_ticks(xaxis)
+    yticks = _get_ticks(yaxis)
+
+    if wantnative(xticks) && wantnative(yticks)
+        #Don't "eval" tick values
+        return
+    end
+
+    #TODO: Allow InspectDR to independently "eval" x or y ticks
+    ext = InspectDR.getextents_aloc(plot, 1)
+    grid = InspectDR._eval(strip.grid, plot.xscale, strip.yscale, ext)
+    grid.xlines = _inspectdr_getaxisticks(xticks, grid.xlines, InputXfrm1D(plot.xscale))
+    grid.ylines = _inspectdr_getaxisticks(yticks, grid.ylines, InputXfrm1D(strip.yscale))
+    strip.grid = grid
+end
+
+# ---------------------------------------------------------------------------
+
 function _inspectdr_getscale(s::Symbol, yaxis::Bool)
 #TODO: Support :asinh, :sqrt
     kwargs = yaxis ? (:tgtmajor=>8, :tgtminor=>2) : () #More grid lines on y-axis
@@ -167,6 +219,7 @@ function _series_added(plt::Plot{InspectDRBackend}, series::Series)
     st = series[:seriestype]
     sp = series[:subplot]
     plot = sp.o
+    clims = get_clims(sp, series)
 
     #Don't do anything without a "subplot" object:  Will process later.
     if nothing == plot; return; end
@@ -256,8 +309,8 @@ For st in :shape:
         wfrm.glyph = InspectDR.glyph(
             shape = _inspectdr_mapglyph(series[:markershape]),
             size = _inspectdr_mapglyphsize(series[:markersize]),
-            color = _inspectdr_mapcolor(plot_color(series[:markerstrokecolor], series[:markerstrokealpha])),
-            fillcolor = _inspectdr_mapcolor(plot_color(series[:markercolor], series[:markeralpha])),
+            color = _inspectdr_mapcolor(plot_color(get_markerstrokecolor(series), get_markerstrokealpha(series))),
+            fillcolor = _inspectdr_mapcolor(plot_color(get_markercolor(series, clims), get_markeralpha(series))),
         )
     end
 
@@ -288,8 +341,8 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
     ygrid_show = yaxis[:grid]
 
     strip.grid = InspectDR.GridRect(
-    	vmajor=xgrid_show, # vminor=xgrid_show,
-    	hmajor=ygrid_show, # hminor=ygrid_show,
+        vmajor=xgrid_show, # vminor=xgrid_show,
+        hmajor=ygrid_show, # hminor=ygrid_show,
     )
 
         plot.xscale = _inspectdr_getscale(xaxis[:scale], false)
@@ -302,18 +355,27 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
             xmin, xmax = -rmax, rmax
             ymin, ymax = -rmax, rmax
         end
-        plot.xext = InspectDR.PExtents1D() #reset
-        strip.yext = InspectDR.PExtents1D() #reset
         plot.xext_full = InspectDR.PExtents1D(xmin, xmax)
         strip.yext_full = InspectDR.PExtents1D(ymin, ymax)
+        #Set current extents = full extents (needed for _eval(strip.grid,...))
+        plot.xext = plot.xext_full
+        strip.yext = strip.yext_full
+        _inspectdr_setticks(sp, plot, strip, xaxis, yaxis)
+
     a = plot.annotation
         a.title = sp[:title]
         a.xlabel = xaxis[:guide]; a.ylabels = [yaxis[:guide]]
 
     l = plot.layout
+        #IMPORTANT: Don't forget to actually register changes
+        #(TODO: need to find a better way to set layout properties)
         l[:frame_canvas].fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+            l[:frame_canvas] = l[:frame_canvas] #register changes
         l[:frame_data].fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+            l[:frame_data] = l[:frame_data] #register changes
+
         l[:frame_data].line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+            l[:frame_data] = l[:frame_data] #register changes
         l[:font_title] = InspectDR.Font(sp[:titlefontfamily],
             _inspectdr_mapptsize(sp[:titlefontsize]),
             color = _inspectdr_mapcolor(sp[:titlefontcolor])
@@ -334,6 +396,7 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
             color = _inspectdr_mapcolor(sp[:legendfontcolor])
         )
         l[:frame_legend].fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
+            l[:frame_legend] = l[:frame_legend] #register changes
 end
 
 # called just before updating layout bounding boxes... in case you need to prep
@@ -347,8 +410,9 @@ function _before_layout_calcs(plt::Plot{InspectDRBackend})
         #Don't use window_title... probably not what you want.
         #mplot.title = plt[:window_title]
     end
-    mplot.layout[:frame].fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
 
+    mplot.layout[:frame].fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
+        mplot.layout[:frame] = mplot.layout[:frame] #register changes
     resize!(mplot.subplots, length(plt.subplots))
     nsubplots = length(plt.subplots)
     for (i, sp) in enumerate(plt.subplots)

src/backends/pyplot.jl

@@ -372,8 +372,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     vmin, vmax = clims = get_clims(sp, series)
 
     # Dict to store extra kwargs
-    if st == :wireframe
-        extrakw = KW()          # vmin, vmax cause an error for wireframe plot
+    if st == :wireframe || st == :hexbin
+        # vmin, vmax cause an error for wireframe plot
+        # We are not supporting clims for hexbin as calculation of bins is not trivial
+        extrakw = KW()
     else
         extrakw = KW(:vmin => vmin, :vmax => vmax)
     end
@@ -508,16 +510,17 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     end
 
     if st == :hexbin
-        handle = ax."hexbin"(x, y,
+        extrakw[:mincnt] = get(series[:extra_kwargs], :mincnt, nothing)
+        extrakw[:edgecolors] = get(series[:extra_kwargs], :edgecolors, py_color(get_linecolor(series)))
+        handle = ax."hexbin"(x, y;
             label = series[:label],
             C = series[:weights],
             gridsize = series[:bins]==:auto ? 100 : series[:bins],  # 100 is the default value
             linewidths = py_thickness_scale(plt, series[:linewidth]),
-            edgecolors = py_color(get_linecolor(series)),
             alpha = series[:fillalpha],
             cmap = py_fillcolormap(series),  # applies to the pcolorfast object
             zorder = series[:series_plotindex],
-            # extrakw...  # We are not supporting clims for hexbin as calculation of bins is not trivial
+            extrakw...
         )
         push!(handles, handle)
     end
@@ -995,6 +998,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             sp.attr[:cbar_ax] = cbax
         end
 
+
         # framestyle
         if !ispolar(sp) && !RecipesPipeline.is3d(sp)
             for pos in ("left", "right", "top", "bottom")
@@ -1005,16 +1009,20 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             # Then set visible some of them
             if sp[:framestyle] == :semi
                 intensity = 0.5
-                ax.spines["right"]."set_alpha"(intensity)
-                ax.spines["top"]."set_alpha"(intensity)
-                ax.spines["right"]."set_linewidth"(py_thickness_scale(plt, intensity))
-                ax.spines["top"]."set_linewidth"(py_thickness_scale(plt, intensity))
+
+                spine = sp[:yaxis][:mirror] ? "left" : "right"
+                ax.spines[spine]."set_alpha"(intensity)
+                ax.spines[spine]."set_linewidth"(py_thickness_scale(plt, intensity))
+
+                spine = sp[:xaxis][:mirror] ? "bottom" : "top"
+                ax.spines[spine]."set_linewidth"(py_thickness_scale(plt, intensity))
+                ax.spines[spine]."set_alpha"(intensity)
             elseif sp[:framestyle] == :box
                 ax.tick_params(top=true)   # Add ticks too
                 ax.tick_params(right=true) # Add ticks too
             elseif sp[:framestyle] in (:axes, :origin)
-                ax.spines["right"]."set_visible"(false)
-                ax.spines["top"]."set_visible"(false)
+                sp[:xaxis][:mirror] ? ax.spines["bottom"]."set_visible"(false) : ax.spines["top"]."set_visible"(false)
+                sp[:yaxis][:mirror] ? ax.spines["left"]."set_visible"(false) : ax.spines["right"]."set_visible"(false)
                 if sp[:framestyle] == :origin
                     ax.spines["bottom"]."set_position"("zero")
                     ax.spines["left"]."set_position"("zero")
@@ -1028,6 +1036,16 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                     ax."axvline"(x = 0, color = py_color(sp[:yaxis][:foreground_color_axis]), lw = py_thickness_scale(plt, 0.75))
                 end
             end
+
+            if sp[:xaxis][:mirror]
+                ax.xaxis."set_label_position"("top")     # the guides
+                sp[:framestyle] == :box ? nothing : ax.xaxis."tick_top"()
+            end
+
+            if sp[:yaxis][:mirror]
+                ax.yaxis."set_label_position"("right")     # the guides
+                sp[:framestyle] == :box ? nothing : ax.yaxis."tick_right"()
+            end
         end
 
         # axis attributes

src/examples.jl

@@ -1044,8 +1044,10 @@ const _examples = PlotExample[
         "Polar heatmaps",
         "",
         [quote
-            z = (1:4) .+ (1:8)'
-            heatmap(z, projection = :polar)
+        x = range(0, 2π, length=9)
+        y = 0:4
+        z = (1:4) .+ (1:8)'
+        heatmap(x, y, z, projection = :polar)
         end]
     ),
     PlotExample( # 50

src/pipeline.jl

@@ -5,13 +5,24 @@
 function RecipesPipeline.warn_on_recipe_aliases!(
     plt::Plot,
     plotattributes::AKW,
-    recipe_type,
-    signature_string
+    recipe_type::Symbol,
+    @nospecialize(args)
 )
     for k in keys(plotattributes)
         if !is_default_attribute(k)
             dk = get(_keyAliases, k, k)
             if k !== dk
+                if recipe_type == :user
+                    signature_string = RecipesPipeline.userrecipe_signature_string(args)
+                elseif recipe_type == :type
+                    signature_string = RecipesPipeline.typerecipe_signature_string(args)
+                elseif recipe_type == :plot
+                    signature_string = RecipesPipeline.plotrecipe_signature_string(args)
+                elseif recipe_type == :series
+                    signature_string = RecipesPipeline.seriesrecipe_signature_string(args)
+                else
+                    throw(ArgumentError("Invalid recipe type `$recipe_type`"))
+                end
                 @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $signature_string. To ensure expected behavior it is recommended to use the default attribute `$dk`."
             end
             plotattributes[dk] = RecipesPipeline.pop_kw!(plotattributes, k)
@@ -130,7 +141,7 @@ function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW)
 end
 
 
-RecipesPipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter)
+RecipesPipeline.get_axis_limits(plt::Plot, letter) = axis_limits(plt[1], letter)
 
 
 ## Plot recipes

src/plot.jl

@@ -43,8 +43,8 @@ The main plot command. Use `plot` to create a new plot object, and `plot!` to ad
 
 There are lots of ways to pass in data, and lots of keyword arguments... just try it and it will likely work as expected.
 When you pass in matrices, it splits by columns. To see the list of available attributes, use the `plotattr([attr])`
-function, where `attr` is the symbol `:Series:`, `:Subplot:`, `:Plot` or `:Axis`. Pass any attribute to `plotattr`
-as a String to look up its docstring; e.g. `plotattr("seriestype")`.
+function, where `attr` is the symbol `:Series`, `:Subplot`, `:Plot`, or `:Axis`. Pass any attribute to `plotattr`
+as a String to look up its docstring, e.g., `plotattr("seriestype")`.
 """
 function plot(args...; kw...)
     @nospecialize
@@ -218,4 +218,4 @@ function plot!(sp::Subplot, args...; kw...)
     @nospecialize
     plt = sp.plt
     plot!(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots))
-end
+end

src/utils.jl

@@ -212,24 +212,24 @@ createSegments(z) = collect(repeat(reshape(z,1,:),2,1))[2:end]
 
 sortedkeys(plotattributes::Dict) = sort(collect(keys(plotattributes)))
 
-function _heatmap_edges(v::AVec, isedges::Bool = false)
-    length(v) == 1 && return v[1] .+ [-0.5, 0.5]
+function _heatmap_edges(v::AVec, isedges::Bool = false, ispolar::Bool = false)
+    length(v) == 1 && return v[1] .+ [ispolar ? max(-v[1], -0.5) : -0.5, 0.5]
     if isedges return v end
     # `isedges = true` means that v is a vector which already describes edges
     # and does not need to be extended.
     vmin, vmax = ignorenan_extrema(v)
-    extra_min = (v[2] - v[1]) / 2
+    extra_min = ispolar ? min(v[1], (v[2] - v[1]) / 2) : (v[2] - v[1]) / 2
     extra_max = (v[end] - v[end - 1]) / 2
     vcat(vmin-extra_min, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra_max)
 end
 
 "create an (n+1) list of the outsides of heatmap rectangles"
-function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false)
+function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false, ispolar::Bool = false)
     f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
-    map(invf, _heatmap_edges(map(f,v), isedges))
+    map(invf, _heatmap_edges(map(f,v), isedges, ispolar))
 end
 
-function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size::Tuple{Int, Int})
+function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size::Tuple{Int, Int}, ispolar::Bool = false)
     nx, ny = length(x), length(y)
     # ismidpoints = z_size == (ny, nx) # This fails some tests, but would actually be
     # the correct check, since (4, 3) != (3, 4) and a missleading plot is produced.
@@ -241,7 +241,7 @@ function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size:
                 or `size(z) == (length(y)+1, length(x)+1))` (x & y define edges).""")
     end
     x, y = heatmap_edges(x, xscale, isedges),
-           heatmap_edges(y, yscale, isedges)
+           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots 
     return x, y
 end