gr: use correct text bounding box for mathtex

Fix pyplot thickness and 0.6 backports release

NEWS.md

@@ -3,13 +3,36 @@
 
 #### notes on release changes, ongoing development, and future planned work
 
-- All new development should target 0.15!
+- Minor version 0.17 is the last one to support Julia 0.6!!
 - Minor version 0.11 is the last one to support Julia 0.5!!
 	- Critical bugfixes only
     - `backports` branch is for Julia 0.5
 
 ---
 ## (current master)
+- All new development should target Julia 0.7!
+
+## 0.17.4
+- fix thickness_scaling for pyplot
+
+## 0.17.3
+- Log-scale heatmap edge computation
+- Fix size and dpi for GR and PyPlot
+- Fix fillrange with line segments on PyPlot and Plotly
+- fix flip for heatmap and image on GR
+- New attributes for PGFPlots
+- Widen axes for most series types and log scales
+- Plotly: fix log scale with no ticks
+- Fix axis flip on Plotly
+- Fix hover and zcolor interaction in Plotly
+- WebIO integration for PlotlyJS backend
+
+## 0.17.2
+- fix single subplot in plotly
+- implement `(xyz)lims = :round`
+- PyPlot: fix bg_legend = invisible()
+- set fallback tick specification for axes with discrete values
+- restructure of show methods
 
 ## 0.17.1
 - Fix contour for PGFPlots

src/arg_desc.jl

@@ -65,6 +65,7 @@ const _arg_desc = KW(
 :html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
 :inset_subplots 		  => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
 :dpi 					  => "Number.  Dots Per Inch of output figures",
+:thickness_scaling        => "Number. Scale for the thickness of all line elements like lines, borders, axes, grid lines, ... defaults to 1.",
 :display_type 			  => "Symbol (`:auto`, `:gui`, or `:inline`).  When supported, `display` will either open a GUI window or plot inline.",
 :extra_kwargs 			  => "KW (Dict{Symbol,Any}).  Pass a map of extra keyword args which may be specific to a backend.",
 :fontfamily               => "String or Symbol.  Default font family for title, legend entries, tick labels and guides",
@@ -110,7 +111,7 @@ const _arg_desc = KW(
 
 # axis args
 :guide     				  => "String. Axis guide (label).",
-:lims      				  => "NTuple{2,Number}. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example).",
+:lims      				  => "NTuple{2,Number} or Symbol. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example). `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]",
 :ticks     				  => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
 :scale     				  => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
 :rotation  				  => "Number. Degrees rotation of tick labels.",
@@ -139,5 +140,6 @@ const _arg_desc = KW(
 :gridstyle                => "Symbol. Style of the grid lines. Choose from $(_allStyles)",
 :gridlinewidth            => "Number. Width of the grid lines (in pixels)",
 :tick_direction           => "Symbol.  Direction of the ticks. `:in` or `:out`",
-:showaxis                 => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`"
+:showaxis                 => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
+:widen                    => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
 )

src/args.jl

@@ -301,6 +301,7 @@ const _plot_defaults = KW(
     :inset_subplots              => nothing,   # optionally pass a vector of (parent,bbox) tuples which are
                                                # the parent layout and the relative bounding box of inset subplots
     :dpi                         => DPI,        # dots per inch for images, etc
+    :thickness_scaling           => 1,
     :display_type                => :auto,
     :extra_kwargs                => KW(),
 )
@@ -381,6 +382,7 @@ const _axis_defaults = KW(
     :gridlinewidth            => 0.5,
     :tick_direction           => :in,
     :showaxis                 => true,
+    :widen                    => true,
 )
 
 const _suppress_warnings = Set{Symbol}([

src/axes.jl

@@ -246,19 +246,17 @@ function get_ticks(axis::Axis)
     ticks = ticks == :native ? :auto : ticks
 
     dvals = axis[:discrete_values]
-    cv, dv = if !isempty(dvals)
-        # discrete ticks...
-        n = length(dvals)
-        rng = if ticks == :auto
-            Int[round(Int,i) for i in linspace(1, n, 15)]
-        elseif ticks == :all
-            1:n
-        elseif typeof(ticks) <: Int
-            Int[round(Int,i) for i in linspace(1, n, ticks)]
-        end
-        axis[:continuous_values][rng], dvals[rng]
-    elseif typeof(ticks) <: Symbol
-        if ispolar(axis.sps[1]) && axis[:letter] == :x
+    cv, dv = if typeof(ticks) <: Symbol
+        if !isempty(dvals)
+            # discrete ticks...
+            n = length(dvals)
+            rng = if ticks == :auto
+                Int[round(Int,i) for i in linspace(1, n, 15)]
+            else # if ticks == :all
+                1:n
+            end
+            axis[:continuous_values][rng], dvals[rng]
+        elseif ispolar(axis.sps[1]) && axis[:letter] == :x
             #force theta axis to be full circle
             (collect(0:pi/4:7pi/4), string.(0:45:315))
         else
@@ -266,8 +264,13 @@ function get_ticks(axis::Axis)
             optimal_ticks_and_labels(axis)
         end
     elseif typeof(ticks) <: Union{AVec, Int}
-        # override ticks, but get the labels
-        optimal_ticks_and_labels(axis, ticks)
+        if !isempty(dvals) && typeof(ticks) <: Int
+            rng = Int[round(Int,i) for i in linspace(1, length(dvals), ticks)]
+            axis[:continuous_values][rng], dvals[rng]
+        else
+            # override ticks, but get the labels
+            optimal_ticks_and_labels(axis, ticks)
+        end
     elseif typeof(ticks) <: NTuple{2, Any}
         # assuming we're passed (ticks, labels)
         ticks
@@ -415,21 +418,23 @@ end
 # -------------------------------------------------------------------------
 
 # push the limits out slightly
-function widen(lmin, lmax)
-    span = lmax - lmin
+function widen(lmin, lmax, scale = :identity)
+    f, invf = scalefunc(scale), invscalefunc(scale)
+    span = f(lmax) - f(lmin)
     # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10))
     eps = NaNMath.max(1e-16, 0.03span)
-    lmin-eps, lmax+eps
+    invf(f(lmin)-eps), invf(f(lmax)+eps)
 end
 
-# figure out if widening is a good idea.  if there's a scale set it's too tricky,
-# so lazy out and don't widen
+# figure out if widening is a good idea.
+const _widen_seriestypes = (:line, :path, :steppre, :steppost, :sticks, :scatter, :barbins, :barhist, :histogram, :scatterbins, :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :bar, :shape, :path3d, :scatter3d)
+
 function default_should_widen(axis::Axis)
     should_widen = false
-    if axis[:scale] == :identity && !is_2tuple(axis[:lims])
+    if !is_2tuple(axis[:lims])
         for sp in axis.sps
             for series in series_list(sp)
-                if series.d[:seriestype] in (:scatter,) || series.d[:markershape] != :none
+                if series.d[:seriestype] in _widen_seriestypes
                     should_widen = true
                 end
             end
@@ -438,6 +443,13 @@ function default_should_widen(axis::Axis)
     should_widen
 end
 
+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
+
 # using the axis extrema and limit overrides, return the min/max value for this axis
 function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis))
     ex = axis[:extrema]
@@ -466,8 +478,10 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
         else
             amin, amax
         end
-    elseif should_widen
-        widen(amin, amax)
+    elseif should_widen && axis[:widen]
+        widen(amin, amax, axis[:scale])
+    elseif lims == :round
+        round_limits(amin,amax)
     else
         amin, amax
     end

src/backends/gr.jl

@@ -195,7 +195,7 @@ gr_inqtext(x, y, s::Symbol) = gr_inqtext(x, y, string(s))
 
 function gr_inqtext(x, y, s)
     if length(s) >= 2 && s[1] == '$' && s[end] == '$'
-        GR.inqtextext(x, y, s[2:end-1])
+        GR.inqmathtex(x, y, s[2:end-1])
     elseif search(s, '\\') != 0 || contains(s, "10^{")
         GR.inqtextext(x, y, s)
     else
@@ -383,7 +383,7 @@ end
 function gr_set_line(lw, style, c) #, a)
     GR.setlinetype(gr_linetype[style])
     w, h = gr_plot_size
-    GR.setlinewidth(max(0, lw / ((w + h) * 0.001)))
+    GR.setlinewidth(_gr_thickness_scaling[1] * max(0, lw / ((w + h) * 0.001)))
     gr_set_linecolor(c) #, a)
 end
 
@@ -396,6 +396,7 @@ end
 
 # this stores the conversion from a font pointsize to "percentage of window height" (which is what GR uses)
 const _gr_point_mult = 0.0018 * ones(1)
+const _gr_thickness_scaling = ones(1)
 
 # set the font attributes... assumes _gr_point_mult has been populated already
 function gr_set_font(f::Font; halign = f.halign, valign = f.valign,
@@ -542,6 +543,9 @@ end
 function gr_display(plt::Plot, fmt="")
     GR.clearws()
 
+    _gr_thickness_scaling[1] = plt[:thickness_scaling]
+    dpi_factor = plt[:dpi] / Plots.DPI
+
     # collect some monitor/display sizes in meters and pixels
     display_width_meters, display_height_meters, display_width_px, display_height_px = GR.inqdspsize()
     display_width_ratio = display_width_meters / display_width_px
@@ -550,14 +554,6 @@ function gr_display(plt::Plot, fmt="")
     # compute the viewport_canvas, normalized to the larger dimension
     viewport_canvas = Float64[0,1,0,1]
     w, h = plt[:size]
-    if !haskey(ENV, "PLOTS_TEST")
-        dpi_factor = plt[:dpi] / DPI
-        if fmt == "png"
-            dpi_factor *= 6
-        end
-    else
-        dpi_factor = 1
-    end
     gr_plot_size[:] = [w, h]
     if w > h
         ratio = float(h) / w
@@ -580,7 +576,7 @@ function gr_display(plt::Plot, fmt="")
 
     # update point mult
     px_per_pt = px / pt
-    _gr_point_mult[1] = 1.5 * px_per_pt / max(h,w)
+    _gr_point_mult[1] = 1.5 * _gr_thickness_scaling[1] * px_per_pt / max(h,w)
 
     # subplots:
     for sp in plt.subplots
@@ -626,13 +622,14 @@ function gr_get_ticks_size(ticks, i)
 end
 
 function _update_min_padding!(sp::Subplot{GRBackend})
+    dpi = sp.plt[:thickness_scaling]
     if !haskey(ENV, "GKSwstype")
         if isijulia() || (isdefined(Main, :Juno) && Juno.isactive())
             ENV["GKSwstype"] = "svg"
         end
     end
     # Add margin given by the user
-    leftpad   = 2mm  + sp[:left_margin]
+    leftpad   = 4mm  + sp[:left_margin]
     toppad    = 2mm  + sp[:top_margin]
     rightpad  = 4mm  + sp[:right_margin]
     bottompad = 2mm  + sp[:bottom_margin]
@@ -668,7 +665,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
     if sp[:yaxis][:guide] != ""
         leftpad += 4mm
     end
-    sp.minpad = (leftpad, toppad, rightpad, bottompad)
+    sp.minpad = Tuple(dpi * [leftpad, toppad, rightpad, bottompad])
 end
 
 function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
@@ -718,6 +715,12 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         end
         if st == :heatmap
             outside_ticks = true
+            for ax in (sp[:xaxis], sp[:yaxis])
+                v = series[ax[:letter]]
+                if diff(collect(extrema(diff(v))))[1] > 1e-6*std(v)
+                    warn("GR: heatmap only supported with equally spaced data.")
+                end
+            end
             x, y = heatmap_edges(series[:x], sp[:xaxis][:scale]), heatmap_edges(series[:y], sp[:yaxis][:scale])
             xy_lims = x[1], x[end], y[1], y[end]
             expand_extrema!(sp[:xaxis], x)
@@ -769,7 +772,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
     # draw the axes
     gr_set_font(tickfont(xaxis))
-    GR.setlinewidth(1)
+    GR.setlinewidth(sp.plt[:thickness_scaling])
 
     if is3d(sp)
         zmin, zmax = gr_lims(zaxis, true)
@@ -1089,6 +1092,10 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         elseif st == :heatmap
             xmin, xmax, ymin, ymax = xy_lims
             zmin, zmax = clims
+            m, n = length(x), length(y)
+            xinds = sort(1:m, rev = xaxis[:flip])
+            yinds = sort(1:n, rev = yaxis[:flip])
+            z = reshape(reshape(z, m, n)[xinds, yinds], m*n)
             GR.setspace(zmin, zmax, 0, 90)
             grad = isa(series[:fillcolor], ColorGradient) ? series[:fillcolor] : cgrad()
             colors = [plot_color(grad[clamp((zi-zmin) / (zmax-zmin), 0, 1)], series[:fillalpha]) for zi=z]
@@ -1192,7 +1199,10 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         elseif st == :image
             z = transpose_z(series, series[:z].surf, true)'
-            w, h = size(z)
+            w, h = length(x), length(y)
+            xinds = sort(1:w, rev = xaxis[:flip])
+            yinds = sort(1:h, rev = yaxis[:flip])
+            z = z[xinds, yinds]
             xmin, xmax = ignorenan_extrema(series[:x]); ymin, ymax = ignorenan_extrema(series[:y])
             if eltype(z) <: Colors.AbstractGray
                 grey = round.(UInt8, float(z) * 255)

src/backends/hdf5.jl

@@ -240,10 +240,6 @@ end
 
 # ----------------------------------------------------------------
 
-_show(io::IO, mime::MIME"text/plain", plt::Plot{HDF5Backend}) = nothing #Don't show
-
-# ----------------------------------------------------------------
-
 # Display/show the plot (open a GUI window, or browser page, for example).
 function _display(plt::Plot{HDF5Backend})
     msg = "HDF5 interface does not support `display()` function."

src/backends/inspectdr.jl

@@ -523,7 +523,6 @@ for (mime, fmt) in _inspectdr_mimeformats_nodpi
         _inspectdr_show(io, mime, _inspectdr_getmplot(plt.o), plt[:size]...)
     end
 end
-_show(io::IO, mime::MIME"text/plain", plt::Plot{InspectDRBackend}) = nothing #Don't show
 
 # ----------------------------------------------------------------
 

src/backends/pgfplots.jl

@@ -8,11 +8,12 @@ end
 
 const _pgfplots_attr = merge_with_base_supported([
     :annotations,
-    # :background_color_legend,
+    :background_color_legend,
     :background_color_inside,
     # :background_color_outside,
-    # :foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
-    #     :foreground_color_text, :foreground_color_border,
+    # :foreground_color_legend,
+    :foreground_color_grid, :foreground_color_axis,
+    :foreground_color_text, :foreground_color_border,
     :label,
     :seriescolor, :seriesalpha,
     :linecolor, :linestyle, :linewidth, :linealpha,
@@ -149,6 +150,10 @@ function pgf_colormap(grad::ColorGradient)
     end,", ")
 end
 
+pgf_thickness_scaling(plt::Plot) = plt[:thickness_scaling]
+pgf_thickness_scaling(sp::Subplot) = pgf_thickness_scaling(sp.plt)
+pgf_thickness_scaling(series) = pgf_thickness_scaling(series[:subplot])
+
 function pgf_fillstyle(d, i = 1)
     cstr,a = pgf_color(get_fillcolor(d, i))
     fa = get_fillalpha(d, i)
@@ -158,17 +163,26 @@ function pgf_fillstyle(d, i = 1)
     "fill = $cstr, fill opacity=$a"
 end
 
-function pgf_linestyle(d, i = 1)
-    cstr,a = pgf_color(get_linecolor(d, i))
-    la = get_linealpha(d, i)
-    if la != nothing
-        a = la
-    end
+function pgf_linestyle(linewidth::Real, color, α = 1, linestyle = "solid")
+    cstr, a = pgf_color(plot_color(color, α))
     """
     color = $cstr,
-    draw opacity=$a,
-    line width=$(get_linewidth(d, i)),
-    $(get(_pgfplots_linestyles, get_linestyle(d, i), "solid"))"""
+    draw opacity = $a,
+    line width = $linewidth,
+    $(get(_pgfplots_linestyles, linestyle, "solid"))"""
+end
+
+function pgf_linestyle(d, i = 1)
+    lw = pgf_thickness_scaling(d) * get_linewidth(d, i)
+    lc = get_linecolor(d, i)
+    la = get_linealpha(d, i)
+    ls = get_linestyle(d, i)
+    return pgf_linestyle(lw, lc, la, ls)
+end
+
+function pgf_font(fontsize, thickness_scaling = 1, font = "\\selectfont")
+    fs = fontsize * thickness_scaling
+    return string("{\\fontsize{", fs, " pt}{", 1.3fs, " pt}", font, "}")
 end
 
 function pgf_marker(d, i = 1)
@@ -177,27 +191,28 @@ function pgf_marker(d, i = 1)
     cstr_stroke, a_stroke = pgf_color(plot_color(get_markerstrokecolor(d, i), get_markerstrokealpha(d, i)))
     """
     mark = $(get(_pgfplots_markers, shape, "*")),
-    mark size = $(0.5 * _cycle(d[:markersize], i)),
+    mark size = $(pgf_thickness_scaling(d) * 0.5 * _cycle(d[:markersize], i)),
     mark options = {
         color = $cstr_stroke, draw opacity = $a_stroke,
         fill = $cstr, fill opacity = $a,
-        line width = $(_cycle(d[:markerstrokewidth], i)),
+        line width = $(pgf_thickness_scaling(d) * _cycle(d[:markerstrokewidth], i)),
         rotate = $(shape == :dtriangle ? 180 : 0),
         $(get(_pgfplots_linestyles, _cycle(d[:markerstrokestyle], i), "solid"))
     }"""
 end
 
-function pgf_add_annotation!(o,x,y,val)
+function pgf_add_annotation!(o, x, y, val, thickness_scaling = 1)
     # Construct the style string.
     # Currently supports color and orientation
     cstr,a = pgf_color(val.font.color)
     push!(o, PGFPlots.Plots.Node(val.str, # Annotation Text
-                                 x, y,
-                                 style="""
-                                 $(get(_pgf_annotation_halign,val.font.halign,"")),
-                                 color=$cstr, draw opacity=$(convert(Float16,a)),
-                                 rotate=$(val.font.rotation)
-                                 """))
+        x, y,
+        style="""
+        $(get(_pgf_annotation_halign,val.font.halign,"")),
+        color=$cstr, draw opacity=$(convert(Float16,a)),
+        rotate=$(val.font.rotation),
+        font=$(pgf_font(val.font.pointsize, thickness_scaling))
+        """))
 end
 
 # --------------------------------------------------------------------------------------
@@ -370,8 +385,9 @@ function pgf_axis(sp::Subplot, letter)
     # axis guide
     kw[Symbol(letter,:label)] = axis[:guide]
 
-    # Add ticklabel rotations
-    push!(style, "$(letter)ticklabel style={rotate = $(axis[:rotation])}")
+    # Add label font
+    cstr, α = pgf_color(plot_color(axis[:guidefontcolor]))
+    push!(style, string(letter, "label style = {font = ", pgf_font(axis[:guidefontsize], pgf_thickness_scaling(sp)), ", color = ", cstr, ", draw opacity = ", α, ", rotate = ", axis[:guidefontrotation], "}"))
 
     # flip/reverse?
     axis[:flip] && push!(style, "$letter dir=reverse")
@@ -427,6 +443,9 @@ function pgf_axis(sp::Subplot, letter)
             push!(style, string(letter, "ticklabels = {}"))
         end
         push!(style, string(letter, "tick align = ", (axis[:tick_direction] == :out ? "outside" : "inside")))
+        cstr, α = pgf_color(plot_color(axis[:tickfontcolor]))
+        push!(style, string(letter, "ticklabel style = {font = ", pgf_font(axis[:tickfontsize], pgf_thickness_scaling(sp)), ", color = ", cstr, ", draw opacity = ", α, ", rotate = ", axis[:tickfontrotation], "}"))
+        push!(style, string(letter, " grid style = {", pgf_linestyle(pgf_thickness_scaling(sp) * axis[:gridlinewidth], axis[:foreground_color_grid], axis[:gridalpha], axis[:gridstyle]), "}"))
     end
 
     # framestyle
@@ -439,7 +458,7 @@ function pgf_axis(sp::Subplot, letter)
     if framestyle == :zerolines
         push!(style, string("extra ", letter, " ticks = 0"))
         push!(style, string("extra ", letter, " tick labels = "))
-        push!(style, string("extra ", letter, " tick style = {grid = major, major grid style = {color = black, draw opacity=1.0, line width=0.5), solid}}"))
+        push!(style, string("extra ", letter, " tick style = {grid = major, major grid style = {", pgf_linestyle(pgf_thickness_scaling(sp), axis[:foreground_color_axis], 1.0), "}}"))
     end
 
     if !axis[:showaxis]
@@ -447,6 +466,8 @@ function pgf_axis(sp::Subplot, letter)
     end
     if !axis[:showaxis] || framestyle in (:zerolines, :grid, :none)
         push!(style, string(letter, " axis line style = {draw opacity = 0}"))
+    else
+        push!(style, string(letter, " axis line style = {", pgf_linestyle(pgf_thickness_scaling(sp), axis[:foreground_color_axis], 1.0), "}"))
     end
 
     # return the style list and KW args
@@ -491,6 +512,8 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
 
         if sp[:title] != ""
             kw[:title] = "$(sp[:title])"
+            cstr, α = pgf_color(plot_color(sp[:titlefontcolor]))
+            push!(style, string("title style = {font = ", pgf_font(sp[:titlefontsize], pgf_thickness_scaling(sp)), ", color = ", cstr, ", draw opacity = ", α, ", rotate = ", sp[:titlefontrotation], "}"))
         end
 
         if sp[:aspect_ratio] in (1, :equal)
@@ -501,6 +524,8 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
         if haskey(_pgfplots_legend_pos, legpos)
             kw[:legendPos] = _pgfplots_legend_pos[legpos]
         end
+        cstr, a = pgf_color(plot_color(sp[:background_color_legend]))
+        push!(style, string("legend style = {", pgf_linestyle(pgf_thickness_scaling(sp), sp[:foreground_color_legend], 1.0, "solid"), ",", "fill = $cstr,", "font = ", pgf_font(sp[:legendfontsize], pgf_thickness_scaling(sp)), "}"))
 
         if any(s[:seriestype] == :contour for s in series_list(sp))
             kw[:view] = "{0}{90}"
@@ -554,13 +579,13 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
             # add series annotations
             anns = series[:series_annotations]
             for (xi,yi,str,fnt) in EachAnn(anns, series[:x], series[:y])
-                pgf_add_annotation!(o, xi, yi, PlotText(str, fnt))
+                pgf_add_annotation!(o, xi, yi, PlotText(str, fnt), pgf_thickness_scaling(series))
             end
         end
 
         # add the annotations
         for ann in sp[:annotations]
-            pgf_add_annotation!(o, locate_annotation(sp, ann...)...)
+            pgf_add_annotation!(o, locate_annotation(sp, ann...)..., pgf_thickness_scaling(sp))
         end
 
 

src/backends/plotly.jl

@@ -263,6 +263,7 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
     end
 
     ax[:tickangle] = -axis[:rotation]
+    ax[:type] = plotly_scale(axis[:scale])
     lims = axis_limits(axis)
 
     if axis[:ticks] != :native || axis[:lims] != :auto
@@ -271,14 +272,13 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
 
     if !(axis[:ticks] in (nothing, :none, false))
         ax[:titlefont] = plotly_font(guidefont(axis))
-        ax[:type] = plotly_scale(axis[:scale])
         ax[:tickfont] = plotly_font(tickfont(axis))
         ax[:tickcolor] = framestyle in (:zerolines, :grid) || !axis[:showaxis] ? rgba_string(invisible()) : rgb_string(axis[:foreground_color_axis])
         ax[:linecolor] = rgba_string(axis[:foreground_color_axis])
 
         # flip
         if axis[:flip]
-            ax[:autorange] = "reversed"
+            ax[:range] = reverse(ax[:range])
         end
 
         # ticks
@@ -328,9 +328,11 @@ function plotly_layout(plt::Plot)
 
     d_out[:annotations] = KW[]
 
+    multiple_subplots = length(plt.subplots) > 1
+
     for sp in plt.subplots
-        spidx = sp[:subplot_index]
-        x_idx, y_idx = plotly_link_indicies(plt, sp)
+        spidx = multiple_subplots ? sp[:subplot_index] : ""
+        x_idx, y_idx = multiple_subplots ? plotly_link_indicies(plt, sp) : ("", "")
         # add an annotation for the title... positioned horizontally relative to plotarea,
         # but vertically just below the top of the subplot bounding box
         if sp[:title] != ""
@@ -585,6 +587,8 @@ function plotly_series(plt::Plot, series::Series)
         return plotly_series_segments(series, d_out, x, y, z)
 
     elseif st == :heatmap
+        x = heatmap_edges(x, sp[:xaxis][:scale])
+        y = heatmap_edges(y, sp[:yaxis][:scale])
         d_out[:type] = "heatmap"
         d_out[:x], d_out[:y], d_out[:z] = x, y, z
         d_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
@@ -785,7 +789,7 @@ function plotly_series_segments(series::Series, d_base::KW, x, y, z)
         end
 
         plotly_polar!(d_out, series)
-        plotly_hover!(d_out, series[:hover])
+        plotly_hover!(d_out, _cycle(series[:hover], rng))
 
         if hasfillrange
             # if hasfillrange is true, return two dictionaries (one for original
@@ -801,7 +805,7 @@ function plotly_series_segments(series::Series, d_base::KW, x, y, z)
                 series[:fillrange] = (f1, f2)
             end
             if isa(series[:fillrange], AbstractVector)
-                d_out_fillrange[:y] = series[:fillrange]
+                d_out_fillrange[:y] = series[:fillrange][rng]
                 delete!(d_out_fillrange, :fill)
                 delete!(d_out_fillrange, :fillcolor)
             else
@@ -836,6 +840,7 @@ function plotly_colorbar_hack(series::Series, d_base::KW, sym::Symbol)
     cmin, cmax = get_clims(series[:subplot])
     d_out[:showlegend] = false
     d_out[:type] = is3d(series) ? :scatter3d : :scatter
+    d_out[:hoverinfo] = :none
     d_out[:mode] = :markers
     d_out[:x], d_out[:y] = [series[:x][1]], [series[:y][1]]
     if is3d(series)
@@ -844,6 +849,7 @@ function plotly_colorbar_hack(series::Series, d_base::KW, sym::Symbol)
     # zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line)
     d_out[:marker] = KW(
         :size => 0,
+        :opacity => 0,
         :color => [0.5],
         :cmin => cmin,
         :cmax => cmax,
@@ -922,17 +928,7 @@ end
 # ----------------------------------------------------------------
 
 
-function _show(io::IO, ::MIME"image/png", plt::Plot{PlotlyBackend})
-    # show_png_from_html(io, plt)
-    error("png output from the plotly backend is not supported.  Please use plotlyjs instead.")
-end
-
-function _show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyBackend})
-    error("svg output from the plotly backend is not supported.  Please use plotlyjs instead.")
-end
-
-function Base.show(io::IO, ::MIME"text/html", plt::Plot{PlotlyBackend})
-    prepare_output(plt)
+function _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyBackend})
     write(io, html_head(plt) * html_body(plt))
 end
 

src/backends/plotlyjs.jl

@@ -1,5 +1,5 @@
 @require Revise begin
-    Revise.track(Plots, joinpath(Pkg.dir("Plots"), "src", "backends", "plotlyjs.jl")) 
+    Revise.track(Plots, joinpath(Pkg.dir("Plots"), "src", "backends", "plotlyjs.jl"))
 end
 
 # https://github.com/spencerlyon2/PlotlyJS.jl
@@ -88,8 +88,7 @@ end
 
 # ----------------------------------------------------------------
 
-function Base.show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend})
-    prepare_output(plt)
+function _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend})
     if isijulia() && !_use_remote[]
         write(io, PlotlyJS.html_body(PlotlyJS.JupyterPlot(plt.o)))
     else
@@ -121,6 +120,12 @@ function _display(plt::Plot{PlotlyJSBackend})
     end
 end
 
+@require WebIO begin
+    function WebIO.render(plt::Plot{PlotlyJSBackend})
+        prepare_output(plt)
+        WebIO.render(plt.o)
+    end
+end
 
 function closeall(::PlotlyJSBackend)
     if !isplotnull() && isa(current().o, PlotlyJS.SyncPlot)

src/backends/pyplot.jl

@@ -394,15 +394,15 @@ function py_bbox_title(ax)
     bb
 end
 
-function py_dpi_scale(plt::Plot{PyPlotBackend}, ptsz)
-    ptsz * plt[:dpi] / DPI
+function py_thickness_scale(plt::Plot{PyPlotBackend}, ptsz)
+    ptsz * plt[:thickness_scaling]
 end
 
 # ---------------------------------------------------------------------------
 
 # Create the window/figure for this backend.
 function _create_backend_figure(plt::Plot{PyPlotBackend})
-    w,h = map(px2inch, plt[:size])
+    w,h = map(px2inch, Tuple(s * plt[:dpi] / Plots.DPI for s in plt[:size]))
 
     # # reuse the current figure?
     fig = if plt[:overwrite_figure]
@@ -505,7 +505,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             #         :label => series[:label],
             #         :zorder => plt.n,
             #         :cmap => py_linecolormap(series),
-            #         :linewidths => py_dpi_scale(plt, get_linewidth.(series, 1:n)),
+            #         :linewidths => py_thickness_scale(plt, get_linewidth.(series, 1:n)),
             #         :linestyle => py_linestyle(st, get_linestyle.(series)),
             #         :norm => pycolors["Normalize"](; extrakw...)
             #     )
@@ -530,7 +530,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                         label = i == 1 ? series[:label] : "",
                         zorder = series[:series_plotindex],
                         color = py_color(get_linecolor(series, i), get_linealpha(series, i)),
-                        linewidth = py_dpi_scale(plt, get_linewidth(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)
@@ -550,7 +550,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                         :shrinkB => 0,
                         :edgecolor => py_linecolor(series),
                         :facecolor => py_linecolor(series),
-                        :linewidth => py_dpi_scale(plt, get_linewidth(series)),
+                        :linewidth => py_thickness_scale(plt, get_linewidth(series)),
                         :linestyle => py_linestyle(st, get_linestyle(series)),
                     )
                     add_arrows(x, y) do xyprev, xy
@@ -589,7 +589,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             x,y = xyargs
             shapes = series[:markershape]
             msc = py_markerstrokecolor(series)
-            lw = py_dpi_scale(plt, series[:markerstrokewidth])
+            lw = py_thickness_scale(plt, series[:markerstrokewidth])
             for i=1:length(y)
                 extrakw[:c] = _cycle(markercolor, i)
 
@@ -597,7 +597,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                     label = series[:label],
                     zorder = series[:series_plotindex] + 0.5,
                     marker = py_marker(_cycle(shapes,i)),
-                    s =  py_dpi_scale(plt, _cycle(series[:markersize],i) .^ 2),
+                    s =  py_thickness_scale(plt, _cycle(series[:markersize],i) .^ 2),
                     edgecolors = msc,
                     linewidths = lw,
                     extrakw...
@@ -610,9 +610,9 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 label = series[:label],
                 zorder = series[:series_plotindex] + 0.5,
                 marker = py_marker(series[:markershape]),
-                s = py_dpi_scale(plt, series[:markersize] .^ 2),
+                s = py_thickness_scale(plt, series[:markersize] .^ 2),
                 edgecolors = py_markerstrokecolor(series),
-                linewidths = py_dpi_scale(plt, series[:markerstrokewidth]),
+                linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                 extrakw...
             )
             push!(handles, handle)
@@ -624,7 +624,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             label = series[:label],
             zorder = series[:series_plotindex],
             gridsize = series[:bins],
-            linewidths = py_dpi_scale(plt, series[:linewidth]),
+            linewidths = py_thickness_scale(plt, series[:linewidth]),
             edgecolors = py_linecolor(series),
             cmap = py_fillcolormap(series),  # applies to the pcolorfast object
             extrakw...
@@ -655,7 +655,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
         handle = ax[:contour](x, y, z, levelargs...;
             label = series[:label],
             zorder = series[:series_plotindex],
-            linewidths = py_dpi_scale(plt, series[:linewidth]),
+            linewidths = py_thickness_scale(plt, series[:linewidth]),
             linestyles = py_linestyle(st, series[:linestyle]),
             extrakw...
         )
@@ -697,7 +697,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex],
                 rstride = series[:stride][1],
                 cstride = series[:stride][2],
-                linewidth = py_dpi_scale(plt, series[:linewidth]),
+                linewidth = py_thickness_scale(plt, series[:linewidth]),
                 edgecolor = py_linecolor(series),
                 extrakw...
             )
@@ -728,7 +728,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 label = series[:label],
                 zorder = series[:series_plotindex],
                 cmap = py_fillcolormap(series),
-                linewidth = py_dpi_scale(plt, series[:linewidth]),
+                linewidth = py_thickness_scale(plt, series[:linewidth]),
                 edgecolor = py_linecolor(series),
                 extrakw...
             )
@@ -796,7 +796,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                     zorder = series[:series_plotindex],
                     edgecolor = py_color(get_linecolor(series, i), get_linealpha(series, i)),
                     facecolor = py_color(get_fillcolor(series, i), get_fillalpha(series, i)),
-                    linewidth = py_dpi_scale(plt, get_linewidth(series, i)),
+                    linewidth = py_thickness_scale(plt, get_linewidth(series, i)),
                     linestyle = py_linestyle(st, get_linestyle(series, i)),
                     fill = true
                 )
@@ -837,9 +837,9 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             end
             n = length(dim1)
             args = if typeof(fillrange) <: Union{Real, AVec}
-                dim1, expand_data(fillrange, n), dim2
+                dim1, _cycle(fillrange, rng), dim2
             elseif is_2tuple(fillrange)
-                dim1, expand_data(fillrange[1], n), expand_data(fillrange[2], n)
+                dim1, _cycle(fillrange[1], rng), _cycle(fillrange[2], rng)
             end
 
             handle = ax[f](args..., trues(n), false, py_fillstepstyle(st);
@@ -956,9 +956,9 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
     fig = plt.o
     fig[:clear]()
     dpi = plt[:dpi]
-    fig[:set_size_inches](w/dpi, h/dpi, forward = true)
+    fig[:set_size_inches](w/DPI, h/DPI, forward = true)
     fig[set_facecolor_sym](py_color(plt[:background_color_outside]))
-    fig[:set_dpi](dpi)
+    fig[:set_dpi](plt[:dpi])
 
     # resize the window
     PyPlot.plt[:get_current_fig_manager]()[:resize](w, h)
@@ -996,7 +996,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 :title
             end
             ax[func][:set_text](sp[:title])
-            ax[func][:set_fontsize](py_dpi_scale(plt, sp[:titlefontsize]))
+            ax[func][:set_fontsize](py_thickness_scale(plt, sp[:titlefontsize]))
             ax[func][:set_family](sp[:titlefontfamily])
             ax[func][:set_color](py_color(sp[:titlefontcolor]))
             # ax[:set_title](sp[:title], loc = loc)
@@ -1036,9 +1036,9 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             fig = plt.o
             cbax = fig[:add_axes]([0.8,0.1,0.03,0.8], label = string(gensym()))
             cb = fig[:colorbar](handle; cax = cbax, kw...)
-            cb[:set_label](sp[:colorbar_title],size=py_dpi_scale(plt, sp[:yaxis][:guidefontsize]),family=sp[:yaxis][:guidefontfamily], color = py_color(sp[:yaxis][:guidefontcolor]))
+            cb[:set_label](sp[:colorbar_title],size=py_thickness_scale(plt, sp[:yaxis][:guidefontsize]),family=sp[:yaxis][:guidefontfamily], color = py_color(sp[:yaxis][:guidefontcolor]))
             for lab in cb[:ax][:yaxis][:get_ticklabels]()
-                  lab[:set_fontsize](py_dpi_scale(plt, sp[:yaxis][:tickfontsize]))
+                  lab[:set_fontsize](py_thickness_scale(plt, sp[:yaxis][:tickfontsize]))
                   lab[:set_family](sp[:yaxis][:tickfontfamily])
                   lab[:set_color](py_color(sp[:yaxis][:tickfontcolor]))
             end
@@ -1048,12 +1048,14 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
 
         # framestyle
         if !ispolar(sp) && !is3d(sp)
+            ax[:spines]["left"][:set_linewidth](py_thickness_scale(plt, 1))
+            ax[:spines]["bottom"][:set_linewidth](py_thickness_scale(plt, 1))
             if sp[:framestyle] == :semi
                 intensity = 0.5
                 ax[:spines]["right"][:set_alpha](intensity)
                 ax[:spines]["top"][:set_alpha](intensity)
-                ax[:spines]["right"][:set_linewidth](intensity)
-                ax[:spines]["top"][:set_linewidth](intensity)
+                ax[:spines]["right"][:set_linewidth](py_thickness_scale(plt, intensity))
+                ax[:spines]["top"][:set_linewidth](py_thickness_scale(plt, intensity))
             elseif sp[:framestyle] in (:axes, :origin)
                 ax[:spines]["right"][:set_visible](false)
                 ax[:spines]["top"][:set_visible](false)
@@ -1066,8 +1068,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                     spine[:set_visible](false)
                 end
                 if sp[:framestyle] == :zerolines
-                    ax[:axhline](y = 0, color = py_color(sp[:xaxis][:foreground_color_axis]), lw = 0.75)
-                    ax[:axvline](x = 0, color = py_color(sp[:yaxis][:foreground_color_axis]), lw = 0.75)
+                    ax[:axhline](y = 0, color = py_color(sp[:xaxis][:foreground_color_axis]), lw = py_thickness_scale(plt, 0.75))
+                    ax[:axvline](x = 0, color = py_color(sp[:yaxis][:foreground_color_axis]), lw = py_thickness_scale(plt, 0.75))
                 end
             end
         end
@@ -1100,10 +1102,10 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             if get(axis.d, :flip, false)
                 ax[Symbol("invert_", letter, "axis")]()
             end
-            pyaxis[:label][:set_fontsize](py_dpi_scale(plt, axis[:guidefontsize]))
+            pyaxis[:label][:set_fontsize](py_thickness_scale(plt, axis[:guidefontsize]))
             pyaxis[:label][:set_family](axis[:guidefontfamily])
             for lab in ax[Symbol("get_", letter, "ticklabels")]()
-                lab[:set_fontsize](py_dpi_scale(plt, axis[:tickfontsize]))
+                lab[:set_fontsize](py_thickness_scale(plt, axis[:tickfontsize]))
                 lab[:set_family](axis[:tickfontfamily])
                 lab[:set_rotation](axis[:rotation])
             end
@@ -1112,7 +1114,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 pyaxis[:grid](true,
                     color = fgcolor,
                     linestyle = py_linestyle(:line, axis[:gridstyle]),
-                    linewidth = axis[:gridlinewidth],
+                    linewidth = py_thickness_scale(plt, axis[:gridlinewidth]),
                     alpha = axis[:gridalpha])
                 ax[:set_axisbelow](true)
             else
@@ -1209,7 +1211,9 @@ function _update_min_padding!(sp::Subplot{PyPlotBackend})
     rightpad  += sp[:right_margin]
     bottompad += sp[:bottom_margin]
 
-    sp.minpad = (leftpad, toppad, rightpad, bottompad)
+    dpi_factor = Plots.DPI / sp.plt[:dpi]
+
+    sp.minpad = Tuple(dpi_factor .* [leftpad, toppad, rightpad, bottompad])
 end
 
 
@@ -1230,7 +1234,7 @@ function py_add_annotations(sp::Subplot{PyPlotBackend}, x, y, val::PlotText)
         horizontalalignment = val.font.halign == :hcenter ? "center" : string(val.font.halign),
         verticalalignment = val.font.valign == :vcenter ? "center" : string(val.font.valign),
         rotation = val.font.rotation * 180 / π,
-        size = py_dpi_scale(sp.plt, val.font.pointsize),
+        size = py_thickness_scale(sp.plt, val.font.pointsize),
         zorder = 999
     )
 end
@@ -1261,17 +1265,17 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                     pypatches[:Patch](
                         edgecolor = py_color(get_linecolor(series), get_linealpha(series)),
                         facecolor = py_color(get_fillcolor(series), get_fillalpha(series)),
-                        linewidth = py_dpi_scale(plt, clamp(get_linewidth(series), 0, 5)),
+                        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)
                     PyPlot.plt[:Line2D]((0,1),(0,0),
                         color = py_color(get_linecolor(series), get_linealpha(series)),
-                        linewidth = py_dpi_scale(plt, clamp(get_linewidth(series), 0, 5)),
+                        linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
                         linestyle = py_linestyle(:path, get_linestyle(series)),
                         marker = py_marker(series[:markershape]),
-                        markeredgecolor = py_markerstrokecolor(series),
-                        markerfacecolor = series[:marker_z] == nothing ? py_markercolor(series) : py_color(series[:markercolor][0.5])
+                        markeredgecolor = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
+                        markerfacecolor = series[:marker_z] == nothing ? py_color(get_markercolor(series), get_markeralpha(series)) : py_color(series[:markercolor][0.5])
                     )
                 else
                     series[:serieshandle][1]
@@ -1286,23 +1290,19 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                 labels,
                 loc = get(_pyplot_legend_pos, leg, "best"),
                 scatterpoints = 1,
-                fontsize = py_dpi_scale(plt, sp[:legendfontsize])
-                # family = sp[:legendfont].family
-                # framealpha = 0.6
+                fontsize = py_thickness_scale(plt, sp[:legendfontsize]),
+                facecolor = py_color(sp[:background_color_legend]),
+                edgecolor = py_color(sp[:foreground_color_legend]),
+                framealpha = alpha(plot_color(sp[:background_color_legend])),
             )
+            frame = leg[:get_frame]()
+            frame[:set_linewidth](py_thickness_scale(plt, 1))
             leg[:set_zorder](1000)
             sp[:legendtitle] != nothing && leg[:set_title](sp[:legendtitle])
 
-            fgcolor = py_color(sp[:foreground_color_legend])
-            lfcolor = py_color(sp[:legendfontcolor])
             for txt in leg[:get_texts]()
-                PyPlot.plt[:setp](txt, color = lfcolor, family = sp[:legendfontfamily])
+                PyPlot.plt[:setp](txt, color = py_color(sp[:legendfontcolor]), family = sp[:legendfontfamily])
             end
-
-            # set some legend properties
-            frame = leg[:get_frame]()
-            frame[set_facecolor_sym](py_color(sp[:background_color_legend]))
-            frame[:set_edgecolor](fgcolor)
         end
     end
 end

src/backends/unicodeplots.jl

@@ -212,7 +212,7 @@ end
 
 function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
     unicodeplots_rebuild(plt)
-    map(show, plt.o)
+    foreach(x -> show(io, x), plt.o)
     nothing
 end
 

src/output.jl

@@ -157,17 +157,6 @@ end
 
 # ---------------------------------------------------------
 
-const _mimeformats = Dict(
-    "application/eps"         => "eps",
-    "image/eps"               => "eps",
-    "application/pdf"         => "pdf",
-    "image/png"               => "png",
-    "application/postscript"  => "ps",
-    "image/svg+xml"           => "svg",
-    "text/plain"              => "txt",
-    "application/x-tex"       => "tex",
-)
-
 const _best_html_output_type = KW(
     :pyplot => :png,
     :unicodeplots => :txt,
@@ -177,7 +166,7 @@ const _best_html_output_type = KW(
 )
 
 # a backup for html... passes to svg or png depending on the html_output_format arg
-function Base.show(io::IO, ::MIME"text/html", plt::Plot)
+function _show(io::IO, ::MIME"text/html", plt::Plot)
     output_type = Symbol(plt.attr[:html_output_format])
     if output_type == :auto
         output_type = get(_best_html_output_type, backend_name(plt.backend), :svg)
@@ -191,26 +180,32 @@ function Base.show(io::IO, ::MIME"text/html", plt::Plot)
     elseif output_type == :txt
         show(io, MIME("text/plain"), plt)
     else
-        error("only png or svg allowed. got: $output_type")
+        error("only png or svg allowed. got: $(repr(output_type))")
     end
 end
 
-function _show(io::IO, m, plt::Plot{B}) where B
-    # Base.show_backtrace(STDOUT, backtrace())
-    warn("_show is not defined for this backend. m=", string(m))
+# delegate mimewritable (showable on julia 0.7) to _show instead
+function Base.mimewritable(m::M, plt::P) where {M<:MIME, P<:Plot}
+    return method_exists(_show, Tuple{IO, M, P})
 end
+
 function _display(plt::Plot)
     warn("_display is not defined for this backend.")
 end
 
 # for writing to io streams... first prepare, then callback
-for mime in keys(_mimeformats)
-    @eval function Base.show(io::IO, m::MIME{Symbol($mime)}, plt::Plot{B}) where B
+for mime in ("text/plain", "text/html", "image/png", "image/eps", "image/svg+xml",
+             "application/eps", "application/pdf", "application/postscript",
+             "application/x-tex")
+    @eval function Base.show(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
         prepare_output(plt)
         _show(io, m, plt)
     end
 end
 
+# default text/plain for all backends
+_show(io::IO, ::MIME{Symbol("text/plain")}, plt::Plot) = show(io, plt)
+
 "Close all open gui windows of the current backend"
 closeall() = closeall(backend())
 
@@ -218,9 +213,10 @@ closeall() = closeall(backend())
 # ---------------------------------------------------------
 # A backup, if no PNG generation is defined, is to try to make a PDF and use FileIO to convert
 
+const PDFBackends = Union{PGFPlotsBackend,PlotlyJSBackend,PyPlotBackend,InspectDRBackend,GRBackend}
 if is_installed("FileIO")
     @eval import FileIO
-    function _show(io::IO, ::MIME"image/png", plt::Plot)
+    function _show(io::IO, ::MIME"image/png", plt::Plot{<:PDFBackends})
         fn = tempname()
 
         # first save a pdf file
@@ -288,7 +284,10 @@ end
                 output_type = get(_best_html_output_type, backend_name(plt.backend), :svg)
             end
             out = Dict()
-            if output_type == :png
+            if output_type == :txt
+                mime = "text/plain"
+                out[mime] = sprint(show, MIME(mime), plt)
+            elseif output_type == :png
                 mime = "image/png"
                 out[mime] = base64encode(show, MIME(mime), plt)
             elseif output_type == :svg
@@ -304,11 +303,6 @@ end
             out
         end
 
-        # default text/plain passes to html... handles Interact issues
-        function Base.show(io::IO, m::MIME"text/plain", plt::Plot)
-            show(io, MIME("text/html"), plt)
-        end
-
         ENV["MPLBACKEND"] = "Agg"
     end
 end
@@ -322,9 +316,6 @@ end
     if Juno.isactive()
         Media.media(Plot, Media.Plot)
 
-
-        _show(io::IO, m::MIME"text/plain", plt::Plot{B}) where {B} = print(io, "Plot{$B}()")
-
         function Juno.render(e::Juno.Editor, plt::Plot)
             Juno.render(e, nothing)
         end
@@ -333,13 +324,20 @@ end
             function Juno.render(pane::Juno.PlotPane, plt::Plot)
                 # temporarily overwrite size to be Atom.plotsize
                 sz = plt[:size]
+                dpi = plt[:dpi]
+                thickness_scaling = plt[:thickness_scaling]
                 jsize = Juno.plotsize()
                 jsize[1] == 0 && (jsize[1] = 400)
                 jsize[2] == 0 && (jsize[2] = 500)
 
-                plt[:size] = jsize
+                scale = minimum(jsize[i] / sz[i] for i in 1:2)
+                plt[:size] = (s * scale for s in sz)
+                plt[:dpi] = Plots.DPI
+                plt[:thickness_scaling] *= scale
                 Juno.render(pane, HTML(stringmime(MIME("text/html"), plt)))
                 plt[:size] = sz
+                plt[:dpi] = dpi
+                plt[:thickness_scaling] = thickness_scaling
             end
             # special handling for PlotlyJS
             function Juno.render(pane::Juno.PlotPane, plt::Plot{PlotlyJSBackend})

src/recipes.jl

@@ -413,6 +413,7 @@ end
     z := nothing
     seriestype := :shape
     label := ""
+    widen --> false
     ()
 end
 @deps plots_heatmap shape

src/utils.jl

@@ -358,19 +358,18 @@ const _scale_base = Dict{Symbol, Real}(
     :ln => e,
 )
 
-"create an (n+1) list of the outsides of heatmap rectangles"
-function heatmap_edges(v::AVec, scale::Symbol = :identity)
+function _heatmap_edges(v::AVec)
   vmin, vmax = ignorenan_extrema(v)
-  extra_min = extra_max = 0.5 * (vmax-vmin) / (length(v)-1)
-  if scale in _logScales
-      vmin > 0 || error("The axis values must be positive for a $scale scale")
-      while vmin - extra_min <= 0
-          extra_min /= _scale_base[scale]
-      end
-  end
+  extra_min = (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)
+  f, invf = scalefunc(scale), invscalefunc(scale)
+  map(invf, _heatmap_edges(map(f,v)))
+end
 
 function calc_r_extrema(x, y)
     xmin, xmax = ignorenan_extrema(x)

test/imgcomp.jl

@@ -23,7 +23,7 @@ default(size=(500,300))
 # TODO: use julia's Condition type and the wait() and notify() functions to initialize a Window, then wait() on a condition that
 #       is referenced in a button press callback (the button clicked callback will call notify() on that condition)
 
-const _current_plots_version = v"0.17.1"
+const _current_plots_version = v"0.17.4"
 
 
 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)

test/travis_commands.jl

@@ -9,7 +9,7 @@ Pkg.clone("https://github.com/JuliaPlots/PlotReferenceImages.jl.git")
 # Pkg.clone("https://github.com/JuliaStats/KernelDensity.jl.git")
 
 Pkg.clone("StatPlots")
-Pkg.checkout("PlotUtils")
+# Pkg.checkout("PlotUtils")
 
 # Pkg.clone("Blink")
 # Pkg.build("Blink")