Merge pull request #2612 from daschw/savefig

fix savefig extensions

Project.toml

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

src/args.jl

@@ -681,10 +681,14 @@ function default(k::Symbol, v)
 end
 
 function default(; kw...)
-    kw = KW(kw)
-    RecipesPipeline.preprocess_attributes!(kw)
-    for (k,v) in kw
-        default(k, v)
+    if isempty(kw)
+        reset_defaults()
+    else
+        kw = KW(kw)
+        RecipesPipeline.preprocess_attributes!(kw)
+        for (k,v) in kw
+            default(k, v)
+        end
     end
 end
 

src/axes.jl

@@ -283,7 +283,7 @@ function get_minor_ticks(sp, axis, ticks)
     minorticks = typeof(ticks[1])[]
     for (i,hi) in enumerate(ticks[2:end])
         lo = ticks[i]
-        if isfinite(lo) && hi > lo
+        if isfinite(lo) && isfinite(hi) && hi > lo
             append!(minorticks,collect(lo + (hi-lo)/n :(hi-lo)/n: hi - (hi-lo)/2n))
         end
     end
@@ -462,11 +462,12 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
     lims = axis[:lims]
     has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
     if has_user_lims
-        if isfinite(lims[1])
-            amin = lims[1]
+        lmin, lmax = lims
+        if lmin != :auto && isfinite(lmin)
+            amin = lmin
         end
-        if isfinite(lims[2])
-            amax = lims[2]
+        if lmax != :auto && isfinite(lmax)
+            amax = lmax
         end
     end
     if amax <= amin && isfinite(amin)

src/backends/gr.jl

@@ -67,6 +67,11 @@ const gr_font_family = Dict(
     "palatino" => 26
 )
 
+const gr_vector_font = Dict(
+    "serif-roman" => 232,
+    "sans-serif" => 233
+)
+
 # --------------------------------------------------------------------------------------
 
 gr_color(c) = gr_color(c, color_type(c))
@@ -390,6 +395,8 @@ function gr_set_font(f::Font; halign = f.halign, valign = f.valign,
     GR.setcharup(sind(-rotation), cosd(-rotation))
     if haskey(gr_font_family, family)
         GR.settextfontprec(100 + gr_font_family[family], GR.TEXT_PRECISION_STRING)
+    elseif haskey(gr_vector_font, family)
+        GR.settextfontprec(gr_vector_font[family], 3)
     end
     gr_set_textcolor(color)
     GR.settextalign(gr_halign[halign], gr_valign[valign])
@@ -815,6 +822,7 @@ end
 
 function _update_min_padding!(sp::Subplot{GRBackend})
     dpi = sp.plt[:thickness_scaling]
+    ENV["GKS_ENCODING"] = "utf8"
     if !haskey(ENV, "GKSwstype")
         if isijulia()
             ENV["GKSwstype"] = "svg"
@@ -1938,6 +1946,7 @@ gr_set_output(wstype::String) = (_gr_wstype[] = wstype)
 
 for (mime, fmt) in _gr_mimeformats
     @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
+        ENV["GKS_ENCODING"] = "utf8"
         GR.emergencyclosegks()
         filepath = tempname() * "." * $fmt
         env = get(ENV, "GKSwstype", "0")
@@ -1956,6 +1965,7 @@ for (mime, fmt) in _gr_mimeformats
 end
 
 function _display(plt::Plot{GRBackend})
+    ENV["GKS_ENCODING"] = "utf8"
     if plt[:display_type] == :inline
         GR.emergencyclosegks()
         filepath = tempname() * ".pdf"

src/backends/pgfplotsx.jl

@@ -224,9 +224,9 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                 axis_opt,
                 "colorbar style" => PGFPlotsX.Options(
                     "title" => sp[:colorbar_title],
-                    "point meta max" => get_clims(sp)[2],
-                    "point meta min" => get_clims(sp)[1],
                 ),
+                "point meta max" => get_clims(sp)[2],
+                "point meta min" => get_clims(sp)[1],
             )
             if RecipesPipeline.is3d(sp)
                 azim, elev = sp[:camera]
@@ -240,6 +240,16 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                 PGFPlotsX.Axis
             end
             axis = axisf(axis_opt)
+            if sp[:legendtitle] !== nothing
+                push!(axis, PGFPlotsX.Options("\\addlegendimage{empty legend}" => nothing))
+                push!(
+                    axis,
+                    PGFPlotsX.LegendEntry(
+                        string("\\hspace{-.6cm}{\\textbf{", sp[:legendtitle], "}}"),
+                        false,
+                    ),
+                )
+            end
             for (series_index, series) in enumerate(series_list(sp))
                 # give each series a uuid for fillbetween
                 series_id = uuid4()
@@ -758,7 +768,7 @@ function pgfx_marker(plotattributes, i = 1)
     a_stroke = alpha(cstr_stroke)
     mark_size =
         pgfx_thickness_scaling(plotattributes) *
-        0.5 *
+        0.75 *
         _cycle(plotattributes[:markersize], i)
     return PGFPlotsX.Options(
         "mark" =>
@@ -770,7 +780,7 @@ function pgfx_marker(plotattributes, i = 1)
             "fill" => cstr,
             "fill opacity" => a,
             "line width" =>
-                pgfx_thickness_scaling(plotattributes) *
+                pgfx_thickness_scaling(plotattributes) * 0.75 *
                 _cycle(plotattributes[:markerstrokewidth], i),
             "rotate" => if shape == :dtriangle
                 180
@@ -1123,7 +1133,7 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
                         axis[:minorgridalpha],
                         axis[:minorgridstyle],
                     ),
-                    "major tick length" => axis[:minorticks] ? "0.1cm" : "0"
+                    "major tick length" => typeof(axis[:minorticks]) <: Integer && axis[:minorticks] > 1 || axis[:minorticks] ? "0.1cm" : "0"
                 ),
             )
         end

src/backends/plotly.jl

@@ -176,7 +176,7 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
     lims = axis_limits(sp, letter)
 
     if axis[:ticks] != :native || axis[:lims] != :auto
-        ax[:range] = map(scalefunc(axis[:scale]), lims)
+        ax[:range] = map(RecipesPipeline.scale_func(axis[:scale]), lims)
     end
 
     if !(axis[:ticks] in (nothing, :none, false))

src/backends/plotlyjs.jl

@@ -40,11 +40,9 @@ _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standal
 
 _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
 
-@require WebIO = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" begin
-    function WebIO.render(plt::Plot{PlotlyJSBackend})
-        plt_html = sprint(show, MIME("text/html"), plt)
-        return WebIO.render(WebIO.dom"div"(innerHTML=plt_html))
-    end
+function PlotlyJS.WebIO.render(plt::Plot{PlotlyJSBackend})
+    plt_html = sprint(show, MIME("text/html"), plt)
+    return PlotlyJS.WebIO.render(PlotlyJS.WebIO.dom"div"(innerHTML=plt_html))
 end
 
 function closeall(::PlotlyJSBackend)

src/backends/pyplot.jl

@@ -229,11 +229,6 @@ function fix_xy_lengths!(plt::Plot{PyPlotBackend}, series::Series)
     end
 end
 
-py_linecolor(series::Series)          = py_color(series[:linecolor])
-py_markercolor(series::Series)        = py_color(series[:markercolor])
-py_markerstrokecolor(series::Series)  = py_color(series[:markerstrokecolor])
-py_fillcolor(series::Series)          = py_color(series[:fillcolor])
-
 py_linecolormap(series::Series)       = py_colormap(series[:linecolor])
 py_markercolormap(series::Series)     = py_colormap(series[:markercolor])
 py_fillcolormap(series::Series)       = py_colormap(series[:fillcolor])
@@ -486,8 +481,8 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                         :arrowstyle => "simple,head_length=$(a.headlength),head_width=$(a.headwidth)",
                         :shrinkA => 0,
                         :shrinkB => 0,
-                        :edgecolor => py_linecolor(series),
-                        :facecolor => py_linecolor(series),
+                        :edgecolor => py_color(get_linecolor(series)),
+                        :facecolor => py_color(get_linecolor(series)),
                         :linewidth => py_thickness_scale(plt, get_linewidth(series)),
                         :linestyle => py_linestyle(st, get_linestyle(series)),
                     )
@@ -533,16 +528,19 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             handle = []
             x,y = xyargs
             shapes = series[:markershape]
-            msc = py_markerstrokecolor(series)
+            msc = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series))
             lw = py_thickness_scale(plt, series[:markerstrokewidth])
             for i=eachindex(y)
-                extrakw[:c] = _cycle(markercolor, i)
+                if series[:marker_z] !== nothing
+                    extrakw[:c] = [py_color(get_markercolor(series, i), get_markercoloralpha(series, i))]
+                end
 
                 push!(handle, ax."scatter"(_cycle(x,i), _cycle(y,i);
                     label = series[:label],
                     zorder = series[:series_plotindex] + 0.5,
                     marker = py_marker(_cycle(shapes,i)),
                     s =  py_thickness_scale(plt, _cycle(series[:markersize],i) .^ 2),
+                    facecolors = py_color(get_markercolor(series, i), get_markercoloralpha(series, i)),
                     edgecolors = msc,
                     linewidths = lw,
                     extrakw...
@@ -582,7 +580,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                   zorder = series[:series_plotindex] + 0.5,
                   marker = prev_marker,
                   s = cur_scale_list,
-                  edgecolors = py_markerstrokecolor(series),
+                  edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),  # Do we need include i?
                   linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                   facecolors = cur_color_list,
                   extrakw...
@@ -603,7 +601,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex] + 0.5,
                 marker = prev_marker,
                 s = cur_scale_list,
-                edgecolors = py_markerstrokecolor(series),
+                edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
                 linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                 facecolors = cur_color_list,
                 extrakw...
@@ -618,7 +616,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex] + 0.5,
                 marker = py_marker(series[:markershape]),
                 s = py_thickness_scale(plt, series[:markersize] .^ 2),
-                edgecolors = py_markerstrokecolor(series),
+                edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
                 linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                 extrakw...
             )
@@ -632,7 +630,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             zorder = series[:series_plotindex],
             gridsize = series[:bins],
             linewidths = py_thickness_scale(plt, series[:linewidth]),
-            edgecolors = py_linecolor(series),
+            edgecolors = py_color(get_linecolor(series)),
             cmap = py_fillcolormap(series),  # applies to the pcolorfast object
             extrakw...
         )
@@ -705,7 +703,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 rstride = series[:stride][1],
                 cstride = series[:stride][2],
                 linewidth = py_thickness_scale(plt, series[:linewidth]),
-                edgecolor = py_linecolor(series),
+                edgecolor = py_color(get_linecolor(series)),
                 extrakw...
             )
             push!(handles, handle)
@@ -731,7 +729,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex],
                 cmap = py_fillcolormap(series),
                 linewidth = py_thickness_scale(plt, series[:linewidth]),
-                edgecolor = py_linecolor(series),
+                edgecolor = py_color(get_linecolor(series)),
                 extrakw...
             )
             push!(handles, handle)
@@ -1103,13 +1101,23 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 ticks[2][ticks[1] .== 0] .= ""
             end
             axis[:ticks] != :native ? py_set_ticks(ax, ticks, letter) : nothing
-            pyaxis."set_tick_params"(direction = axis[:tick_direction] == :out ? "out" : "in")
+
+            intensity = 0.5  # This value corresponds to scaling of other grid elements
+            pyaxis."set_tick_params"(direction = axis[:tick_direction] == :out ? "out" : "in", width=py_thickness_scale(plt, intensity))
+
             getproperty(ax, Symbol("set_", letter, "label"))(axis[:guide])
             if get(axis.plotattributes, :flip, false)
                 getproperty(ax, Symbol("invert_", letter, "axis"))()
             end
             pyaxis."label"."set_fontsize"(py_thickness_scale(plt, axis[:guidefontsize]))
             pyaxis."label"."set_family"(axis[:guidefontfamily])
+
+            if (letter == :y && !RecipesPipeline.is3d(sp))
+                pyaxis."label"."set_rotation"(axis[:guidefontrotation] + 90)
+            else
+                pyaxis."label"."set_rotation"(axis[:guidefontrotation])
+            end
+
             for lab in getproperty(ax, Symbol("get_", letter, "ticklabels"))()
                 lab."set_fontsize"(py_thickness_scale(plt, axis[:tickfontsize]))
                 lab."set_family"(axis[:tickfontfamily])
@@ -1298,25 +1306,29 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
             if should_add_to_legend(series)
                 clims = get_clims(sp, series)
                 # add a line/marker and a label
-                push!(handles, if series[:seriestype] == :shape || series[:fillrange] !== nothing
-                    pypatches."Patch"(
-                        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))
-                    )
-                elseif series[:seriestype] in (:path, :straightline, :scatter)
-                    PyPlot.plt."Line2D"((0,1),(0,0),
-                        color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
-                        linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
-                        linestyle = py_linestyle(:path, get_linestyle(series)),
-                        marker = py_marker(first(series[:markershape])),
-                        markeredgecolor = py_color(single_color(get_markerstrokecolor(series)), get_markerstrokealpha(series)),
-                        markerfacecolor = py_color(single_color(get_markercolor(series, clims)), get_markeralpha(series))
-                    )
-                else
-                    series[:serieshandle][1]
-                end)
+                push!(handles,
+                    if series[:seriestype] == :shape || series[:fillrange] !== nothing
+                        pypatches."Patch"(
+                            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))
+                        )
+                    elseif series[:seriestype] in (:path, :straightline, :scatter)
+                        PyPlot.plt."Line2D"((0,1),(0,0),
+                            color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
+                            linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
+                            linestyle = py_linestyle(:path, get_linestyle(series)),
+                            marker = py_marker(_cycle(series[:markershape], 1)),
+                            # markersize = py_thickness_scale(plt, series[:markersize]), # In case we decide that markersize needs to be scaled in the legend too
+                            markeredgecolor = py_color(single_color(get_markerstrokecolor(series)), get_markerstrokealpha(series)),
+                            markerfacecolor = py_color(single_color(get_markercolor(series, clims)), get_markeralpha(series)),
+                            markeredgewidth = py_thickness_scale(plt, series[:markerstrokewidth])
+                        )
+                    else
+                        series[:serieshandle][1]
+                    end
+                )
                 push!(labels, series[:label])
             end
         end
@@ -1332,6 +1344,7 @@ 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
             )
             frame = leg."get_frame"()
             frame."set_linewidth"(py_thickness_scale(plt, 1))

src/examples.jl

@@ -986,21 +986,26 @@ const _examples = PlotExample[
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages
-_animation_examples = [2, 30]
+_animation_examples = [2, 31]
 _backend_skips = Dict(
     :gr => [25, 30],
-    :pyplot => [25, 30],
+    :pyplot => [2, 25, 30, 31],
     :plotlyjs => [2, 21, 24, 25, 30, 31],
     :plotly => [2, 21, 24, 25, 30, 31],
     :pgfplots => [2, 5, 6, 10, 16, 20, 22, 23, 25, 28, 30, 31, 34, 37, 38, 39],
-    :pgfplotsx => [ 6, # images
-                    10, # histogram2d
-                    16, # pgfplots thinks the upper panel is too small
-                    22, # contourf
-                    23, # pie
-                    32, # spy
-                    38, # histogram2d
-                  ] )
+    :pgfplotsx => [
+        2, # animation
+        6, # images
+        10, # histogram2d
+        16, # pgfplots thinks the upper panel is too small
+        22, # contourf
+        23, # pie
+        31, # animation
+        32, # spy
+        38, # histogram2d
+        45, # wireframe
+    ],
+)
 
 
 

src/output.jl

@@ -1,54 +1,51 @@
 
-
 defaultOutputFormat(plt::Plot) = "png"
 
 function png(plt::Plot, fn::AbstractString)
-  fn = addExtension(fn, "png")
-  io = open(fn, "w")
-  show(io, MIME("image/png"), plt)
-  close(io)
+    fn = addExtension(fn, "png")
+    io = open(fn, "w")
+    show(io, MIME("image/png"), plt)
+    close(io)
 end
 png(fn::AbstractString) = png(current(), fn)
 
 function svg(plt::Plot, fn::AbstractString)
-  fn = addExtension(fn, "svg")
-  io = open(fn, "w")
-  show(io, MIME("image/svg+xml"), plt)
-  close(io)
+    fn = addExtension(fn, "svg")
+    io = open(fn, "w")
+    show(io, MIME("image/svg+xml"), plt)
+    close(io)
 end
 svg(fn::AbstractString) = svg(current(), fn)
 
-
 function pdf(plt::Plot, fn::AbstractString)
-  fn = addExtension(fn, "pdf")
-  io = open(fn, "w")
-  show(io, MIME("application/pdf"), plt)
-  close(io)
+    fn = addExtension(fn, "pdf")
+    io = open(fn, "w")
+    show(io, MIME("application/pdf"), plt)
+    close(io)
 end
 pdf(fn::AbstractString) = pdf(current(), fn)
 
-
 function ps(plt::Plot, fn::AbstractString)
-  fn = addExtension(fn, "ps")
-  io = open(fn, "w")
-  show(io, MIME("application/postscript"), plt)
-  close(io)
+    fn = addExtension(fn, "ps")
+    io = open(fn, "w")
+    show(io, MIME("application/postscript"), plt)
+    close(io)
 end
 ps(fn::AbstractString) = ps(current(), fn)
 
 function eps(plt::Plot, fn::AbstractString)
-  fn = addExtension(fn, "eps")
-  io = open(fn, "w")
-  show(io, MIME("image/eps"), plt)
-  close(io)
+    fn = addExtension(fn, "eps")
+    io = open(fn, "w")
+    show(io, MIME("image/eps"), plt)
+    close(io)
 end
 eps(fn::AbstractString) = eps(current(), fn)
 
 function tex(plt::Plot, fn::AbstractString)
-  fn = addExtension(fn, "tex")
-  io = open(fn, "w")
-  show(io, MIME("application/x-tex"), plt)
-  close(io)
+    fn = addExtension(fn, "tex")
+    io = open(fn, "w")
+    show(io, MIME("application/x-tex"), plt)
+    close(io)
 end
 tex(fn::AbstractString) = tex(current(), fn)
 
@@ -69,48 +66,39 @@ end
 html(fn::AbstractString) = html(current(), fn)
 
 function txt(plt::Plot, fn::AbstractString)
-  fn = addExtension(fn, "txt")
-  io = open(fn, "w")
-  show(io, MIME("text/plain"), plt)
-  close(io)
+    fn = addExtension(fn, "txt")
+    io = open(fn, "w")
+    show(io, MIME("text/plain"), plt)
+    close(io)
 end
 txt(fn::AbstractString) = txt(current(), fn)
 
-# ----------------------------------------------------------------
 
+# ----------------------------------------------------------------
 
 const _savemap = Dict(
     "png" => png,
     "svg" => svg,
     "pdf" => pdf,
-    "ps"  => ps,
+    "ps" => ps,
     "eps" => eps,
     "tex" => tex,
     "json" => json,
     "html" => html,
     "tikz" => tex,
     "txt" => txt,
-  )
+)
 
-function getExtension(fn::AbstractString)
-  pieces = split(fn, ".")
-  length(pieces) > 1 || error("Can't extract file extension: ", fn)
-  ext = pieces[end]
-  haskey(_savemap, ext) || error("Invalid file extension: ", fn)
-  ext
-end
+const _extension_map = Dict("tikz" => "tex")
 
 function addExtension(fn::AbstractString, ext::AbstractString)
-  try
-    oldext = getExtension(fn)
-    if oldext == ext
-      return fn
+    oldfn, oldext = splitext(fn)
+    oldext = chop(oldext, head = 1, tail = 0)
+    if get(_extension_map, oldext, oldext) == ext
+        return fn
     else
-      return "$fn.$ext"
+        return string(fn, ".", ext)
     end
-  catch
-    return "$fn.$ext"
-  end
 end
 
 """
@@ -121,27 +109,28 @@ type is inferred from the file extension. All backends support png and pdf
 file types, some also support svg, ps, eps, html and tex.
 """
 function savefig(plt::Plot, fn::AbstractString)
-  fn = abspath(expanduser(fn))
-  # get the extension
-  local ext
-  try
-    ext = getExtension(fn)
-  catch
-    # if we couldn't extract the extension, add the default
-    ext = defaultOutputFormat(plt)
-    fn = addExtension(fn, ext)
-  end
+    fn = abspath(expanduser(fn))
 
-  # save it
-  func = get(_savemap, ext) do
-    error("Unsupported extension $ext with filename ", fn)
-  end
-  func(plt, fn)
+    # get the extension
+    fn, ext = splitext(fn)
+    ext = chop(ext, head = 1, tail = 0)
+    if isempty(ext)
+        ext = defaultOutputFormat(plt)
+    end
+
+    # save it
+    if haskey(_savemap, ext)
+        func = _savemap[ext]
+        return func(plt, fn)
+    else
+        error("Invalid file extension: ", fn)
+    end
 end
 savefig(fn::AbstractString) = savefig(current(), fn)
 
 
 # ---------------------------------------------------------
+
 """
     gui([plot])
 
@@ -164,17 +153,13 @@ end
 _do_plot_show(plt, showval::Bool) = showval && gui(plt)
 function _do_plot_show(plt, showval::Symbol)
     showval == :gui && gui(plt)
-    showval in (:inline,:ijulia) && inline(plt)
+    showval in (:inline, :ijulia) && inline(plt)
 end
 
 # ---------------------------------------------------------
 
-const _best_html_output_type = KW(
-    :pyplot => :png,
-    :unicodeplots => :txt,
-    :plotlyjs => :html,
-    :plotly => :html
-)
+const _best_html_output_type =
+    KW(:pyplot => :png, :unicodeplots => :txt, :plotlyjs => :html, :plotly => :html)
 
 # a backup for html... passes to svg or png depending on the html_output_format arg
 function _show(io::IO, ::MIME"text/html", plt::Plot)
@@ -184,7 +169,12 @@ function _show(io::IO, ::MIME"text/html", plt::Plot)
     end
     if output_type == :png
         # @info("writing png to html output")
-        print(io, "<img src=\"data:image/png;base64,", base64encode(show, MIME("image/png"), plt), "\" />")
+        print(
+            io,
+            "<img src=\"data:image/png;base64,",
+            base64encode(show, MIME("image/png"), plt),
+            "\" />",
+        )
     elseif output_type == :svg
         # @info("writing svg to html output")
         show(io, MIME("image/svg+xml"), plt)
@@ -196,7 +186,7 @@ function _show(io::IO, ::MIME"text/html", plt::Plot)
 end
 
 # delegate showable to _show instead
-function Base.showable(m::M, plt::P) where {M<:MIME, P<:Plot}
+function Base.showable(m::M, plt::P) where {M <: MIME, P <: Plot}
     return hasmethod(_show, Tuple{IO, M, P})
 end
 
@@ -205,21 +195,31 @@ function _display(plt::Plot)
 end
 
 # for writing to io streams... first prepare, then callback
-for mime in ("text/plain", "text/html", "image/png", "image/eps", "image/svg+xml",
-             "application/eps", "application/pdf", "application/postscript",
-             "application/x-tex", "application/vnd.plotly.v1+json")
+for mime in (
+    "text/plain",
+    "text/html",
+    "image/png",
+    "image/eps",
+    "image/svg+xml",
+    "application/eps",
+    "application/pdf",
+    "application/postscript",
+    "application/x-tex",
+    "application/vnd.plotly.v1+json",
+)
     @eval function Base.show(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
         if haskey(io, :juno_plotsize)
-          showjuno(io, m, plt)
+            showjuno(io, m, plt)
         else
-          prepare_output(plt)
-          _show(io, m, plt)
+            prepare_output(plt)
+            _show(io, m, plt)
         end
         return nothing
     end
 end
 
-Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) = showjuno(io, MIME("text/html"), plt)
+Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) =
+    showjuno(io, MIME("text/html"), plt)
 
 # default text/plain for all backends
 _show(io::IO, ::MIME{Symbol("text/plain")}, plt::Plot) = show(io, plt)
@@ -258,25 +258,25 @@ function showjuno(io::IO, m, plt)
 
     scale = minimum(jsize[i] / sz[i] for i in 1:2)
     plt[:size] = [s * scale for s in sz]
-    plt[:dpi] = jratio*Plots.DPI
+    plt[:dpi] = jratio * Plots.DPI
     plt[:thickness_scaling] *= scale
 
     prepare_output(plt)
     try
-      _showjuno(io, m, plt)
+        _showjuno(io, m, plt)
     finally
-      plt[:size] = sz
-      plt[:dpi] = dpi
-      plt[:thickness_scaling] = thickness_scaling
+        plt[:size] = sz
+        plt[:dpi] = dpi
+        plt[:thickness_scaling] = thickness_scaling
     end
 end
 
 function _showjuno(io::IO, m::MIME"image/svg+xml", plt)
-  if Symbol(plt.attr[:html_output_format]) ≠ :svg
-    throw(MethodError(show, (typeof(m), typeof(plt))))
-  else
-    _show(io, m, plt)
-  end
+    if Symbol(plt.attr[:html_output_format]) ≠ :svg
+        throw(MethodError(show, (typeof(m), typeof(plt))))
+    else
+        _show(io, m, plt)
+    end
 end
 
 Base.showable(::MIME"application/prs.juno.plotpane+html", plt::Plot) = false

src/shorthands.jl

@@ -438,8 +438,9 @@ julia> plot(1:10)
 julia> annotate!([(7,3,"(7,3)"),(3,7,text("hey", 14, :left, :top, :green))])
 ```
 """
-annotate!(anns...; kw...)                                        = plot!(; annotation = collect(anns), kw...)
-annotate!(anns::AVec{T}; kw...) where {T<:Tuple}                 = plot!(; annotation = anns, kw...)
+annotate!(anns...; kw...)             = plot!(; annotation = anns, kw...)
+annotate!(anns::Tuple...; kw...)      = plot!(; annotation = collect(anns), kw...)
+annotate!(anns::AVec{<:Tuple}; kw...) = plot!(; annotation = anns, kw...)
 
 "Flip the current plots' x axis"
 xflip!(flip::Bool = true; kw...)                          = plot!(; xflip = flip, kw...)

src/utils.jl

@@ -1071,7 +1071,7 @@ end
 function shape_data(series, expansion_factor = 1)
     sp = series[:subplot]
     xl, yl = isvertical(series) ? (xlims(sp), ylims(sp)) : (ylims(sp), xlims(sp))
-    x, y = series[:x], series[:y]
+    x, y = copy(series[:x]), copy(series[:y])
     factor = 100
     for i in eachindex(x)
         if x[i] == -Inf

test/runtests.jl

@@ -62,9 +62,9 @@ pyplot()
     image_comparison_facts(:pyplot, tol=img_tol, skip = Plots._backend_skips[:pyplot])
 end
 
-pgfplots()
-@testset "PGFPlots" begin
-    image_comparison_facts(:pgfplots, tol=img_tol, skip = Plots._backend_skips[:pgfplots])
+pgfplotsx()
+@testset "PGFPlotsX" begin
+    image_comparison_facts(:pgfplotsx, tol=img_tol, skip = Plots._backend_skips[:pgfplotsx])
 end
 =#
 ##

test/test_pgfplotsx.jl

@@ -84,7 +84,7 @@ end
       @test marker.options["mark"] == "*"
       @test marker.options["mark options"]["color"] ==
             RGBA{Float64}(colorant"green", 0.8)
-      @test marker.options["mark options"]["line width"] == 1
+      @test marker.options["mark options"]["line width"] == 0.75 # 1px is 0.75pt
    end # testset
    @testset "Plot in pieces" begin
       pic = plot(rand(100) / 3, reg = true, fill = (0, :green))