bump version [skip ci]

Fix nightly tests

.gitignore

@@ -4,7 +4,7 @@
 .DS_Store
 examples/.ipynb_checkpoints/*
 examples/meetup/.ipynb_checkpoints/*
-deps/plotly-latest.min.js
+deps/plotly-*
 deps/build.log
 deps/deps.jl
 Manifest.toml

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.4.0"
+version = "1.4.4"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -10,6 +10,7 @@ Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 FFMPEG = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
 FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
 GR = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
+GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
 GeometryTypes = "4d00f742-c7ba-57c2-abde-4428a4b178cb"
 JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
@@ -35,6 +36,7 @@ Contour = "0.5"
 FFMPEG = "0.2, 0.3"
 FixedPointNumbers = "0.6, 0.7, 0.8"
 GR = "0.46, 0.47, 0.48, 0.49, 0.50"
+GeometryBasics = "0.2"
 GeometryTypes = "0.7, 0.8"
 JSON = "0.21"
 Measures = "0.3"
@@ -47,10 +49,12 @@ RecipesPipeline = "0.1.7"
 Reexport = "0.2"
 Requires = "1"
 Showoff = "0.3.1"
+StableRNGs = "0.1.1"
 StatsBase = "0.32, 0.33"
 julia = "1"
 
 [extras]
+Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
 Gtk = "4c0ca9eb-093a-5379-98c5-f87ac0bbbf44"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
@@ -60,6 +64,7 @@ LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
 RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b"
+StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
@@ -67,4 +72,4 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
 
 [targets]
-test = ["FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "RDatasets", "StaticArrays", "StatsPlots", "Test", "UnicodePlots", "VisualRegressionTests"]
+test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "UnicodePlots", "VisualRegressionTests"]

deps/build.jl

@@ -1,12 +1,12 @@
 
-#TODO: download https://cdn.plot.ly/plotly-latest.min.js to deps/ if it doesn't exist
+#TODO: download https://cdn.plot.ly/plotly-1.54.2.min.js to deps/ if it doesn't exist
 file_path = ""
 if get(ENV, "PLOTS_HOST_DEPENDENCY_LOCAL", "false") == "true"
     global file_path
-    local_fn = joinpath(dirname(@__FILE__), "plotly-latest.min.js")
+    local_fn = joinpath(dirname(@__FILE__), "plotly-1.54.2.min.js")
     if !isfile(local_fn)
-        @info("Cannot find deps/plotly-latest.min.js... downloading latest version.")
-        download("https://cdn.plot.ly/plotly-latest.min.js", local_fn)
+        @info("Cannot find deps/plotly-1.54.2.min.js... downloading latest version.")
+        download("https://cdn.plot.ly/plotly-1.54.2.min.js", local_fn)
         isfile(local_fn) && (file_path = local_fn)
     else
         file_path = local_fn

src/Plots.jl

@@ -8,7 +8,7 @@ const _current_plots_version = VersionNumber(split(first(filter(line -> occursin
 
 using Reexport
 
-import GeometryTypes
+import GeometryTypes, GeometryBasics
 using Dates, Printf, Statistics, Base64, LinearAlgebra, Random
 import SparseArrays: AbstractSparseMatrix, findnz
 

src/args.jl

@@ -20,7 +20,14 @@ function add_non_underscore_aliases!(aliases::Dict{Symbol,Symbol})
     end
 end
 
-
+function add_non_underscore_aliases!(aliases::Dict{Symbol,Symbol}, args::Vector{Symbol}) 
+    for arg in args 
+        s = string(arg) 
+        if '_' in s 
+            aliases[Symbol(replace(s, "_" => ""))] = arg 
+        end 
+    end 
+end 
 # ------------------------------------------------------------
 
 const _allAxes = [:auto, :left, :right]
@@ -502,6 +509,13 @@ end
 # -----------------------------------------------------------------------------
 
 
+# margin
+add_aliases(:left_margin , :leftmargin )
+add_aliases(:top_margin , :topmargin)
+add_aliases(:bottom_margin , :bottommargin)
+add_aliases(:right_margin ,:rightmargin)
+
+
 # colors
 add_aliases(:seriescolor, :c, :color, :colour)
 add_aliases(:linecolor, :lc, :lcolor, :lcolour, :linecolour)
@@ -623,7 +637,7 @@ for arg in keys(_series_defaults)
     _keyAliases[makeplural(arg)] = arg
 end
 
-
+add_non_underscore_aliases!(_keyAliases)
 
 # -----------------------------------------------------------------------------
 

src/axes.jl

@@ -181,16 +181,10 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
 
     labels = if any(isfinite, unscaled_ticks)
         formatter = axis[:formatter]
-        if formatter == :auto
-            # the default behavior is to make strings of the scaled values and then apply the labelfunc
-            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, :auto))
-        elseif formatter == :plain
-            # Leave the numbers in plain format
-            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, :plain))
-        elseif formatter == :scientific
-            Showoff.showoff(unscaled_ticks, :scientific)
-	elseif formatter == :latex
-	    map(x -> string("\$", replace(convert_sci_unicode(x), '×' => "\\times"), "\$"), Showoff.showoff(unscaled_ticks, :auto))
+        if formatter in (:auto, :plain, :scientific, :engineering)
+            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, formatter))
+        elseif formatter == :latex
+            map(x -> string("\$", replace(convert_sci_unicode(x), '×' => "\\times"), "\$"), Showoff.showoff(unscaled_ticks, :auto))
         else
             # there was an override for the formatter... use that on the unscaled ticks
             map(formatter, unscaled_ticks)

src/backends/gr.jl

@@ -590,7 +590,7 @@ function gr_legend_pos(sp::Subplot, w, h, viewport_plotarea)
             xpos = viewport_plotarea[1] + 0.11
         end
     else
-        xpos = (viewport_plotarea[2]-viewport_plotarea[1])/2 - w/2 +.04
+        xpos = (viewport_plotarea[2]-viewport_plotarea[1])/2 - w/2 +.04 + viewport_plotarea[1]
     end
     if occursin("top", str)
         if s == :outertop
@@ -605,7 +605,8 @@ function gr_legend_pos(sp::Subplot, w, h, viewport_plotarea)
             ypos = viewport_plotarea[3] + h + 0.06
         end
     else
-        ypos = (viewport_plotarea[4]-viewport_plotarea[3])/2 + h/2
+        # Adding min y to shift legend pos to correct graph (#2377)
+        ypos = (viewport_plotarea[4]-viewport_plotarea[3])/2 + h/2 + viewport_plotarea[3]
     end
     (xpos,ypos)
 end
@@ -751,7 +752,10 @@ function gr_convert_sci_tick_label(label)
         base, exponent = caret_split
         label = "$base^{$exponent}"
     end
-    convert_sci_unicode(label)
+    if occursin("×10", label)
+        label = string(replace(label, "×10" => "×10^{"), "}")
+    end
+    label
 end
 
 function gr_axis_height(sp, axis)
@@ -1734,10 +1738,11 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 if series[:y][end] != ny
                     @warn "Right now only the maximum value of y (r) is taken into account."
                 end
-                colors = get(fillgrad, z, clims)
-                z_normalized = map(c -> c == invisible() ? 256/255 : PlotUtils.getinverse(fillgrad.colors, c), colors)
-                rgba = Int32[round(Int32, 1000 + _i * 255) for _i in z_normalized]
+                # colors = get(fillgrad, z, clims)
                 # GR.polarcellarray(0, 0, phimin, phimax, ymin, ymax, nx, ny, colors)
+                z_normalized = get_z_normalized.(z, zmin, zmax)
+                # z_normalized = map(c -> c == invisible() ? 256/255 : PlotUtils.getinverse(fillgrad.colors, c), colors)
+                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
@@ -1876,7 +1881,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                     st == :shape && gr_polyline(x, y)
                 end
 
-                if st in (:path, :straightline)
+                if st in (:path, :straightline, :path3d)
                     gr_set_transparency(lc, get_linealpha(series))
                     if series[:fillrange] === nothing || series[:ribbon] !== nothing
                         GR.polyline([xpos - 0.07, xpos - 0.01], [ypos, ypos])

src/backends/pgfplotsx.jl

@@ -988,6 +988,7 @@ end
     function pgfx_sanitize_string(s::LaTeXString)
         s = replace(s, r"\\?\#" => "\\#")
         s = replace(s, r"\\?\%" => "\\%")
+        return LaTeXString(s)
     end
 end
 function pgfx_sanitize_plot!(plt)

src/backends/plotly.jl

@@ -335,18 +335,32 @@ end
 function plotly_legend_pos(pos::Symbol)
     xleft = 0.07
     ybot = 0.07
-    ycenter = 0.52
+    ytop = 1.0
     xcenter = 0.55
+    ycenter = 0.52    
+    center = 0.5
+    youtertop = 1.1
+    youterbot = -0.15
+    xouterright = 1.05
+    xouterleft = -0.15
     plotly_legend_position_mapping = (
         right       = (coords = [1.0, ycenter], xanchor = "right", yanchor = "middle"),
         left        = (coords = [xleft, ycenter], xanchor = "left",  yanchor = "middle"),
-        top         = (coords = [xcenter, 1.0], xanchor = "center",  yanchor = "top"),
+        top         = (coords = [xcenter, ytop], xanchor = "center",  yanchor = "top"),
         bottom      = (coords = [xcenter, ybot], xanchor = "center",  yanchor = "bottom"),
         bottomleft  = (coords = [xleft, ybot], xanchor = "left",  yanchor = "bottom"),
         bottomright = (coords = [1.0, ybot], xanchor = "right", yanchor = "bottom"),
         topright    = (coords = [1.0, 1.0], xanchor = "right", yanchor = "top"),
         topleft     = (coords = [xleft, 1.0], xanchor = "left",  yanchor = "top"),
-        default     = (coords = [1.02, 1.0], xanchor = "auto",  yanchor = "auto")
+        outertop =(coords = [center, youtertop ], xanchor = "upper",  yanchor = "middle"), 
+        outerbottom =(coords = [center, youterbot], xanchor = "lower",  yanchor = "middle"), 
+        outerleft =(coords = [xouterleft, center], xanchor = "left",  yanchor = "top"), 
+        outerright =(coords = [xouterright, center], xanchor = "right",  yanchor = "top"),
+        outertopleft =(coords = [xouterleft, ytop], xanchor = "upper",  yanchor = "left"),
+        outertopright = (coords = [xouterright, ytop], xanchor = "upper",  yanchor = "right"),
+        outerbottomleft =(coords = [xouterleft, ybot], xanchor = "lower",  yanchor = "left"),
+        outerbottomright =(coords = [xouterright, ybot], xanchor = "lower",  yanchor = "right"),
+        default = (coords = [1.0, 1.0], xanchor = "auto",  yanchor = "auto")
     )
 
     legend_position = get(plotly_legend_position_mapping, pos, plotly_legend_position_mapping.default)
@@ -828,7 +842,7 @@ const ijulia_initialized = Ref(false)
 function plotly_html_head(plt::Plot)
     local_file = ("file:///" * plotly_local_file_path)
     plotly =
-        use_local_dependencies[] ? local_file : "https://cdn.plot.ly/plotly-latest.min.js"
+        use_local_dependencies[] ? local_file : "https://cdn.plot.ly/plotly-1.54.2.min.js"
 
     include_mathjax = get(plt[:extra_plot_kwargs], :include_mathjax, "")
     mathjax_file = include_mathjax != "cdn" ? ("file://" * include_mathjax) : "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-MML-AM_CHTML"

src/backends/pyplot.jl

@@ -182,7 +182,7 @@ function labelfunc(scale::Symbol, backend::PyPlotBackend)
     elseif scale == :ln
         x -> PyPlot.LaTeXStrings.latexstring("e^{$x}")
     else
-        string
+        x -> PyPlot.LaTeXStrings.latexstring(convert_sci_unicode(x))
     end
 end
 
@@ -437,18 +437,19 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             #     end
             #     push!(handles, handle)
             # else
-                for (i, rng) in enumerate(iter_segments(series))
-                    handle = ax."plot"((arg[rng] for arg in xyargs)...;
-                        label = i == 1 ? series[:label] : "",
-                        zorder = series[:series_plotindex],
-                        color = py_color(single_color(get_linecolor(series, clims, i)), get_linealpha(series, i)),
-                        linewidth = py_thickness_scale(plt, get_linewidth(series, i)),
-                        linestyle = py_linestyle(st, get_linestyle(series, i)),
-                        solid_capstyle = "round",
-                        drawstyle = py_stepstyle(st)
-                    )[1]
-                    push!(handles, handle)
-                end
+            for (i, rng) in enumerate(iter_segments(series))
+                handle = ax."plot"((arg[rng] for arg in xyargs)...;
+                                   label = i == 1 ? series[:label] : "",
+                                   zorder = series[:series_plotindex],
+                                   color = py_color(single_color(get_linecolor(series, clims, i)), get_linealpha(series, i)),
+                                   linewidth = py_thickness_scale(plt, get_linewidth(series, i)),
+                                   linestyle = py_linestyle(st, get_linestyle(series, i)),
+                                   solid_capstyle = "butt",
+                                   dash_capstyle = "butt",
+                                   drawstyle = py_stepstyle(st)
+                                   )[1]
+                push!(handles, handle)
+            end
             # end
 
             a = series[:arrow]
@@ -1016,8 +1017,34 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 # width = axes_grid1.axes_size.AxesY(ax, aspect=1.0 / 3.5)
                 # pad = axes_grid1.axes_size.Fraction(0.5, width)  # Colorbar is spaced 0.5 of its size away from the ax
                 # cbax = divider.append_axes("right", size=width, pad=pad)   # This approach does not work well in subplots
-                cbax = divider.append_axes("right", size="5%", pad="2.5%")  # Reasonable value works most of the usecases
-                cb = fig."colorbar"(handle; cax=cbax, kw...)
+                colorbar_position = "right"
+                colorbar_pad = "2.5%"
+                colorbar_orientation="vertical"
+
+                if sp[:colorbar] == :left
+                    colorbar_position = string(sp[:colorbar])
+                    colorbar_pad = "5%"
+                elseif sp[:colorbar] == :top
+                    colorbar_position = string(sp[:colorbar])
+                    colorbar_pad = "2.5%"
+                    colorbar_orientation="horizontal"
+                elseif sp[:colorbar] == :bottom
+                    colorbar_position = string(sp[:colorbar])
+                    colorbar_pad = "5%"
+                    colorbar_orientation="horizontal"
+                end
+
+                cbax = divider.append_axes(colorbar_position, size="5%", pad=colorbar_pad)  # Reasonable value works most of the usecases
+                cb = fig."colorbar"(handle; cax=cbax, orientation = colorbar_orientation, kw...)
+
+                if sp[:colorbar] == :left
+                    cbax.yaxis.set_ticks_position("left")
+                elseif sp[:colorbar] == :top
+                    cbax.xaxis.set_ticks_position("top")
+                elseif sp[:colorbar] == :bottom
+                    cbax.xaxis.set_ticks_position("bottom")
+                end
+
             end
 
             cb."set_label"(sp[:colorbar_title],size=py_thickness_scale(plt, sp[:yaxis][:guidefontsize]),family=sp[:yaxis][:guidefontfamily], color = py_color(sp[:yaxis][:guidefontcolor]))
@@ -1334,14 +1361,17 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                             edgecolor = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
                             facecolor = py_color(single_color(get_fillcolor(series, clims)), get_fillalpha(series)),
                             linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
-                            linestyle = py_linestyle(series[:seriestype], get_linestyle(series))
+                            linestyle = py_linestyle(series[:seriestype], get_linestyle(series)),
+                            capstyle = "butt"
                         )
                     elseif series[:seriestype] in (:path, :straightline, :scatter, :steppre, :steppost)
                         hasline = get_linewidth(series) > 0
-                        PyPlot.plt."Line2D"((0,1),(0,0),
+                        PyPlot.plt."Line2D"((0, 1),(0,0),
                             color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
                             linewidth = py_thickness_scale(plt, hasline * sp[:legendfontsize] / 8),
                             linestyle = py_linestyle(:path, get_linestyle(series)),
+                            solid_capstyle = "butt", solid_joinstyle = "miter",
+                            dash_capstyle = "butt", dash_joinstyle = "miter",
                             marker = py_marker(_cycle(series[:markershape], 1)),
                             markersize = py_thickness_scale(plt, 0.8 * sp[:legendfontsize]),
                             markeredgecolor = py_color(single_color(get_markerstrokecolor(series)), get_markerstrokealpha(series)),
@@ -1367,7 +1397,8 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                 facecolor = py_color(sp[:background_color_legend]),
                 edgecolor = py_color(sp[:foreground_color_legend]),
                 framealpha = alpha(plot_color(sp[:background_color_legend])),
-                fancybox = false  # makes the legend box square
+                fancybox = false,  # makes the legend box square
+                borderpad=0.8      # to match GR legendbox
             )
             frame = leg."get_frame"()
             frame."set_linewidth"(py_thickness_scale(plt, 1))

src/examples.jl

@@ -983,6 +983,17 @@ const _examples = PlotExample[
             end,
         ],
     ),
+    PlotExample(
+        "Tuples and `Point`s as data",
+        "",
+        [quote
+            using GeometryBasics
+            using Distributions
+            d = MvNormal([1.0 0.75; 0.75 2.0])
+            plot([(1,2),(3,2),(2,1),(2,3)])
+            scatter!(Point2.(eachcol(rand(d,1000))), alpha=0.25)
+        end]
+    ),
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages

src/recipes.jl

@@ -1309,10 +1309,10 @@ end
 end
 
 # --------------------------------------------------------------------
-# Lists of tuples and GeometryTypes.Points
+# Lists of tuples and GeometryBasics.Points
 # --------------------------------------------------------------------
-@recipe f(v::AVec{<:GeometryTypes.Point}) = RecipesPipeline.unzip(v)
-@recipe f(p::GeometryTypes.Point) = [p]
+@recipe f(v::AVec{<:_Point}) = RecipesPipeline.unzip(v)
+@recipe f(p::_Point) = [p]
 
 # Special case for 4-tuples in :ohlc series
 @recipe f(xyuv::AVec{<:Tuple{R1, R2, R3, R4}}) where {R1, R2, R3, R4} =

src/utils.jl

@@ -149,16 +149,17 @@ makevec(v::T) where {T} = T[v]
 maketuple(x::Real)                     = (x,x)
 maketuple(x::Tuple{T,S}) where {T,S} = x
 
+const _Point{N,T} = Union{GeometryTypes.Point{N,T}, GeometryBasics.Point{N,T}}
 for i in 2:4
     @eval begin
         RecipesPipeline.unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}},
-                   AVec{<:GeometryTypes.Point{$i}}}) = $(Expr(:tuple, (:([t[$j] for t in v]) for j=1:i)...))
+                   AVec{<:_Point{$i}}}) = $(Expr(:tuple, (:([t[$j] for t in v]) for j=1:i)...))
     end
 end
 
-RecipesPipeline.unzip(v::Union{AVec{<:GeometryTypes.Point{N}},
+RecipesPipeline.unzip(v::Union{AVec{<:_Point{N}},
                AVec{<:Tuple{Vararg{T,N} where T}}}) where N = error("$N-dimensional unzip not implemented.")
-RecipesPipeline.unzip(v::Union{AVec{<:GeometryTypes.Point},
+RecipesPipeline.unzip(v::Union{AVec{<:_Point},
                AVec{<:Tuple}}) = error("Can't unzip points of different dimensions.")
 
 # given 2-element lims and a vector of data x, widen lims to account for the extrema of x

test/imgcomp.jl

@@ -1,5 +1,21 @@
 import Plots._current_plots_version
 
+# replace `f(args...)` with `f(rng, args...)` for `f ∈ (rand, randn)`
+function replace_rand!(ex) end
+function replace_rand!(ex::Expr)
+   for arg in ex.args
+       replace_rand!(arg)
+   end
+   if ex.head === :call && ex.args[1] ∈ (:rand, :randn)
+       pushfirst!(ex.args, ex.args[1])
+       ex.args[2] = :rng
+   end
+end
+function fix_rand!(ex)
+    replace_rand!(ex)
+    pushfirst!(ex.args[1].args, :(rng = StableRNG(1234)))
+end
+
 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = !is_ci(), sigma = [1,1], tol = 1e-2)
     Plots._debugMode.on = debug
     example = Plots._examples[idx]
@@ -8,8 +24,6 @@ function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = !i
     backend(pkg)
     backend()
     default(size=(500,300))
-    # ensure consistent results
-    Random.seed!(1234)
 
     fn = "ref$idx.png"
     reffn = reference_file(pkg, idx, _current_plots_version)
@@ -19,6 +33,7 @@ function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = !i
     func = (fn, idx) -> begin
         expr = Expr(:block)
         append!(expr.args, example.exprs)
+        fix_rand!(expr)
         eval(expr)
         png(fn)
     end

test/runtests.jl

@@ -2,11 +2,12 @@ import ImageMagick
 using VisualRegressionTests
 using Plots
 using Random
+using StableRNGs
 using Test
 using FileIO
 using Gtk
 using LibGit2
-using GeometryTypes
+import GeometryTypes, GeometryBasics
 using Dates
 
 include("test_axes.jl")
@@ -178,6 +179,7 @@ end
     for z in zipped
         @test isequal(collect(zip(Plots.unzip(z)...)), z)
         @test isequal(collect(zip(Plots.unzip(GeometryTypes.Point.(z))...)), z)
+        @test isequal(collect(zip(Plots.unzip(GeometryBasics.Point.(z))...)), z)
     end
     op1 = Plots.process_clims((1.0, 2.0))
     op2 = Plots.process_clims((1, 2.0))