Merge pull request #1615 from pfitzseb/sp/junodisplay

Fix display on Juno 0.7

.travis.yml

@@ -4,10 +4,11 @@ os:
   - linux
   # - osx
 julia:
-  - 0.7
-matrix:
-  allow_failures:
-    - julia: nightly
+  # - 0.7
+  - nightly
+# matrix:
+#   allow_failures:
+#     - julia: nightly
 
 # # before install:
 # #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update          ; fi

NEWS.md

@@ -12,6 +12,9 @@
 ## (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

appveyor.yml

@@ -1,15 +1,14 @@
 environment:
   matrix:
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
+  # - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.7/julia-0.7-latest-win32.exe"
+  # - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.7/julia-0.7-latest-win64.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
 
-matrix:
-  allow_failures:
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe" #check and address
-  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
-  - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
+# matrix:
+#   allow_failures:
+#   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
+#   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
 
 notifications:
   - provider: Email

src/arg_desc.jl

@@ -139,6 +139,12 @@ const _arg_desc = KW(
 :gridalpha                => "Number in [0,1]. The alpha/opacity override for the grid lines.",
 :gridstyle                => "Symbol. Style of the grid lines. Choose from $(_allStyles)",
 :gridlinewidth            => "Number. Width of the grid lines (in pixels)",
+:foreground_color_minor_grid => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of minor grid lines.",
+:minorgrid                => "Bool. Adds minor grid lines and ticks to the plot. Set minorticks to change number of gridlines",
+:minorticks               => "Integer. Intervals to divide the gap between major ticks into",
+:minorgridalpha           => "Number in [0,1]. The alpha/opacity override for the minorgrid lines.",
+:minorgridstyle           => "Symbol. Style of the minor grid lines. Choose from $(_allStyles)",
+:minorgridlinewidth       => "Number. Width of the minor 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`",
 :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

@@ -380,7 +380,13 @@ const _axis_defaults = KW(
     :gridalpha                => 0.1,
     :gridstyle                => :solid,
     :gridlinewidth            => 0.5,
+    :foreground_color_minor_grid => :match,            # grid color
+    :minorgridalpha           => 0.05,
+    :minorgridstyle           => :solid,
+    :minorgridlinewidth       => 0.5,
     :tick_direction           => :in,
+    :minorticks               => false,
+    :minorgrid                => false,
     :showaxis                 => true,
     :widen                    => true,
 )
@@ -498,6 +504,8 @@ add_aliases(:foreground_color_subplot, :fg_subplot, :fgsubplot, :fgcolor_subplot
                             :foreground_colour_subplot, :fgcolour_subplot, :fg_colour_subplot)
 add_aliases(:foreground_color_grid, :fg_grid, :fggrid, :fgcolor_grid, :fg_color_grid, :foreground_grid,
                             :foreground_colour_grid, :fgcolour_grid, :fg_colour_grid, :gridcolor)
+add_aliases(:foreground_color_minor_grid, :fg_minor_grid, :fgminorgrid, :fgcolor_minorgrid, :fg_color_minorgrid, :foreground_minorgrid,
+                            :foreground_colour_minor_grid, :fgcolour_minorgrid, :fg_colour_minor_grid, :minorgridcolor)
 add_aliases(:foreground_color_title, :fg_title, :fgtitle, :fgcolor_title, :fg_color_title, :foreground_title,
                             :foreground_colour_title, :fgcolour_title, :fg_colour_title, :titlecolor)
 add_aliases(:foreground_color_axis, :fg_axis, :fgaxis, :fgcolor_axis, :fg_color_axis, :foreground_axis,
@@ -574,6 +582,8 @@ add_aliases(:inset_subplots, :inset, :floating)
 add_aliases(:stride, :wirefame_stride, :surface_stride, :surf_str, :str)
 add_aliases(:gridlinewidth, :gridwidth, :grid_linewidth, :grid_width, :gridlw, :grid_lw)
 add_aliases(:gridstyle, :grid_style, :gridlinestyle, :grid_linestyle, :grid_ls, :gridls)
+add_aliases(:minorgridlinewidth, :minorgridwidth, :minorgrid_linewidth, :minorgrid_width, :minorgridlw, :minorgrid_lw)
+add_aliases(:minorgridstyle, :minorgrid_style, :minorgridlinestyle, :minorgrid_linestyle, :minorgrid_ls, :minorgridls)
 add_aliases(:framestyle, :frame_style, :frame, :axesstyle, :axes_style, :boxstyle, :box_style, :box, :borderstyle, :border_style, :border)
 add_aliases(:tick_direction, :tickdirection, :tick_dir, :tickdir, :tick_orientation, :tickorientation, :tick_or, :tickor)
 add_aliases(:camera, :cam, :viewangle, :view_angle)
@@ -795,6 +805,39 @@ function processGridArg!(d::KW, arg, letter)
     end
 end
 
+function processMinorGridArg!(d::KW, arg, letter)
+    if arg in _allGridArgs || isa(arg, Bool)
+        d[Symbol(letter, :minorgrid)] = hasgrid(arg, letter)
+
+    elseif allStyles(arg)
+        d[Symbol(letter, :minorgridstyle)] = arg
+        d[Symbol(letter, :minorgrid)] = true
+
+    elseif typeof(arg) <: Stroke
+        arg.width == nothing || (d[Symbol(letter, :minorgridlinewidth)] = arg.width)
+        arg.color == nothing || (d[Symbol(letter, :foreground_color_minor_grid)] = arg.color in (:auto, :match) ? :match : plot_color(arg.color))
+        arg.alpha == nothing || (d[Symbol(letter, :minorgridalpha)] = arg.alpha)
+        arg.style == nothing || (d[Symbol(letter, :minorgridstyle)] = arg.style)
+        d[Symbol(letter, :minorgrid)] = true
+
+    # linealpha
+    elseif allAlphas(arg)
+        d[Symbol(letter, :minorgridalpha)] = arg
+        d[Symbol(letter, :minorgrid)] = true
+
+    # linewidth
+    elseif allReals(arg)
+        d[Symbol(letter, :minorgridlinewidth)] = arg
+        d[Symbol(letter, :minorgrid)] = true
+
+    # color
+    elseif handleColors!(d, arg, Symbol(letter, :foreground_color_minor_grid))
+        d[Symbol(letter, :minorgrid)] = true
+    else
+        warn("Skipped grid arg $arg.")
+    end
+end
+
 function processFontArg!(d::KW, fontname::Symbol, arg)
     T = typeof(arg)
     if T <: Font
@@ -894,7 +937,21 @@ function preprocessArgs!(d::KW)
             processGridArg!(d, arg, letter)
         end
     end
-
+    # handle minor grid args common to all axes
+    args = pop!(d, :minorgrid, ())
+    for arg in wraptuple(args)
+        for letter in (:x, :y, :z)
+            processMinorGridArg!(d, arg, letter)
+        end
+    end
+    # handle individual axes grid args
+    for letter in (:x, :y, :z)
+        gridsym = Symbol(letter, :minorgrid)
+        args = pop!(d, gridsym, ())
+        for arg in wraptuple(args)
+            processMinorGridArg!(d, arg, letter)
+        end
+    end
     # fonts
     for fontname in (:titlefont, :legendfont)
         args = pop!(d, fontname, ())
@@ -1222,6 +1279,7 @@ const _match_map2 = KW(
     :foreground_color_axis    => :foreground_color_subplot,
     :foreground_color_border  => :foreground_color_subplot,
     :foreground_color_grid    => :foreground_color_subplot,
+    :foreground_color_minor_grid=> :foreground_color_subplot,
     :foreground_color_guide   => :foreground_color_subplot,
     :foreground_color_text    => :foreground_color_subplot,
     :fontfamily_subplot       => :fontfamily,
@@ -1409,6 +1467,7 @@ function _update_axis_colors(axis::Axis)
     color_or_nothing!(axis.d, :foreground_color_guide)
     color_or_nothing!(axis.d, :foreground_color_text)
     color_or_nothing!(axis.d, :foreground_color_grid)
+    color_or_nothing!(axis.d, :foreground_color_minor_grid)
     return
 end
 
@@ -1518,7 +1577,7 @@ function _update_series_attributes!(d::KW, plt::Plot, sp::Subplot)
         elseif d[csym] == :match
             plot_color.(d[:seriescolor])
         else
-            getSeriesRGBColor.(d[csym], sp, plotIndex)
+            getSeriesRGBColor.(d[csym], Ref(sp), plotIndex)
         end
     end
 
@@ -1526,9 +1585,9 @@ function _update_series_attributes!(d::KW, plt::Plot, sp::Subplot)
     d[:markerstrokecolor] = if d[:markerstrokecolor] == :match
         plot_color(sp[:foreground_color_subplot])
     elseif d[:markerstrokecolor] == :auto
-        getSeriesRGBColor.(d[:markercolor], sp, plotIndex)
+        getSeriesRGBColor.(d[:markercolor], Ref(sp), plotIndex)
     else
-        getSeriesRGBColor.(d[:markerstrokecolor], sp, plotIndex)
+        getSeriesRGBColor.(d[:markerstrokecolor], Ref(sp), plotIndex)
     end
 
     # if marker_z, fill_z or line_z are set, ensure we have a gradient

src/axes.jl

@@ -286,6 +286,34 @@ _transform_ticks(ticks) = ticks
 _transform_ticks(ticks::AbstractArray{T}) where T <: Dates.TimeType = Dates.value.(ticks)
 _transform_ticks(ticks::NTuple{2, Any}) = (_transform_ticks(ticks[1]), ticks[2])
 
+function get_minor_ticks(axis,ticks)
+    axis[:minorticks] in (nothing, false) && !axis[:minorgrid] && return nothing
+    ticks = ticks[1]
+    length(ticks) < 2 && return nothing
+    
+    amin, amax = axis_limits(axis)
+    #Add one phantom tick either side of the ticks to ensure minor ticks extend to the axis limits 
+    if length(ticks) > 2
+        ratio = (ticks[3] - ticks[2])/(ticks[2] - ticks[1])
+    elseif axis[:scale] == :none
+        ratio = 1
+    else
+        return nothing
+    end
+    first_step = ticks[2] - ticks[1]
+    last_step = ticks[end] - ticks[end-1]
+    ticks =  [ticks[1] - first_step/ratio; ticks; ticks[end] + last_step*ratio]
+
+    #Default to 5 intervals between major ticks
+    n = typeof(axis[:minorticks]) <: Integer && axis[:minorticks] > 1 ? axis[:minorticks] : 5
+    minorticks = typeof(ticks[1])[]
+    for (i,hi) in enumerate(ticks[2:end])
+        lo = ticks[i]
+        append!(minorticks,collect(lo + (hi-lo)/n :(hi-lo)/n: hi - (hi-lo)/2n))
+    end
+    minorticks[amin .<= minorticks .<= amax]
+end
+
 # -------------------------------------------------------------------------
 
 
@@ -562,12 +590,16 @@ function axis_drawing_info(sp::Subplot)
     ymin, ymax = axis_limits(yaxis)
     xticks = get_ticks(xaxis)
     yticks = get_ticks(yaxis)
+    xminorticks = get_minor_ticks(xaxis,xticks)
+    yminorticks = get_minor_ticks(yaxis,yticks)
     xaxis_segs = Segments(2)
     yaxis_segs = Segments(2)
     xtick_segs = Segments(2)
     ytick_segs = Segments(2)
     xgrid_segs = Segments(2)
     ygrid_segs = Segments(2)
+    xminorgrid_segs = Segments(2)
+    yminorgrid_segs = Segments(2)
     xborder_segs = Segments(2)
     yborder_segs = Segments(2)
 
@@ -610,6 +642,28 @@ function axis_drawing_info(sp::Subplot)
                 xaxis[:grid] && push!(xgrid_segs, (xtick, ymin), (xtick, ymax)) # vertical grid
             end
         end
+        if !(xaxis[:minorticks] in (nothing, false)) || xaxis[:minorgrid]
+            f = scalefunc(yaxis[:scale])
+            invf = invscalefunc(yaxis[:scale])
+            ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
+            t1 = invf(f(ymin) + 0.01 * (f(ymax) - f(ymin)) * ticks_in)
+            t2 = invf(f(ymax) - 0.01 * (f(ymax) - f(ymin)) * ticks_in)
+            t3 = invf(f(0) + 0.01 * (f(ymax) - f(ymin)) * ticks_in)
+
+            for xminortick in xminorticks
+                if xaxis[:showaxis]
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        (0, t3)
+                    else
+                        xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, t2) : (ymin, t1)
+                    end
+                    push!(xtick_segs, (xminortick, tick_start), (xminortick, tick_stop)) # bottom tick
+                end
+                # sp[:draw_axes_border] && push!(xaxis_segs, (xtick, ymax), (xtick, t2)) # top tick
+                xaxis[:minorgrid] && push!(xminorgrid_segs, (xminortick, ymin), (xminortick, ymax)) # vertical grid
+            end
+        end
+
 
         # yaxis
         if yaxis[:showaxis]
@@ -649,7 +703,28 @@ function axis_drawing_info(sp::Subplot)
                 yaxis[:grid] && push!(ygrid_segs, (xmin, ytick), (xmax, ytick)) # horizontal grid
             end
         end
+        if !(yaxis[:minorticks] in (nothing, false)) || yaxis[:minorgrid]
+            f = scalefunc(xaxis[:scale])
+            invf = invscalefunc(xaxis[:scale])
+            ticks_in = yaxis[:tick_direction] == :out ? -1 : 1
+            t1 = invf(f(xmin) + 0.01 * (f(xmax) - f(xmin)) * ticks_in)
+            t2 = invf(f(xmax) - 0.01 * (f(xmax) - f(xmin)) * ticks_in)
+            t3 = invf(f(0) + 0.01 * (f(xmax) - f(xmin)) * ticks_in)
+
+            for ytick in yminorticks
+                if yaxis[:showaxis]
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        (0, t3)
+                    else
+                        xor(yaxis[:mirror], xaxis[:flip]) ? (xmax, t2) : (xmin, t1)
+                    end
+                    push!(ytick_segs, (tick_start, ytick), (tick_stop, ytick)) # left tick
+                end
+                # sp[:draw_axes_border] && push!(yaxis_segs, (xmax, ytick), (t2, ytick)) # right tick
+                yaxis[:minorgrid] && push!(yminorgrid_segs, (xmin, ytick), (xmax, ytick)) # horizontal grid
+            end
+        end
     end
 
-    xticks, yticks, xaxis_segs, yaxis_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xborder_segs, yborder_segs
+    xticks, yticks, xaxis_segs, yaxis_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xminorgrid_segs, yminorgrid_segs, xborder_segs, yborder_segs
 end

src/backends/glvisualize.jl

@@ -696,7 +696,7 @@ function text_model(font, pivot)
     end
 end
 function gl_draw_axes_2d(sp::Plots.Subplot{Plots.GLVisualizeBackend}, model, area)
-    xticks, yticks, xspine_segs, yspine_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xborder_segs, yborder_segs = Plots.axis_drawing_info(sp)
+    xticks, yticks, xspine_segs, yspine_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xminorgrid_segs, yminorgrid_segs, xborder_segs, yborder_segs = Plots.axis_drawing_info(sp)
     xaxis = sp[:xaxis]; yaxis = sp[:yaxis]
 
     xgc = Colors.color(Plots.gl_color(xaxis[:foreground_color_grid]))
@@ -710,6 +710,14 @@ function gl_draw_axes_2d(sp::Plots.Subplot{Plots.GLVisualizeBackend}, model, are
         grid = draw_grid_lines(sp, ygrid_segs, yaxis[:gridlinewidth], yaxis[:gridstyle], model, RGBA(ygc, yaxis[:gridalpha]))
         push!(axis_vis, grid)
     end
+    if xaxis[:minorgrid]
+        minorgrid = draw_minorgrid_lines(sp, xminorgrid_segs, xaxis[:minorgridlinewidth], xaxis[:minorgridstyle], model, RGBA(xgc, xaxis[:minorgridalpha]))
+        push!(axis_vis, minorgrid)
+    end
+    if yaxis[:minorgrid]
+        minorgrid = draw_minorgrid_lines(sp, yminorgrid_segs, yaxis[:minorgridlinewidth], yaxis[:minorgridstyle], model, RGBA(ygc, yaxis[:minorgridalpha]))
+        push!(axis_vis, minorgrid)
+    end
 
     xac = Colors.color(Plots.gl_color(xaxis[:foreground_color_axis]))
     yac = Colors.color(Plots.gl_color(yaxis[:foreground_color_axis]))

src/backends/gr.jl

@@ -624,7 +624,7 @@ end
 function _update_min_padding!(sp::Subplot{GRBackend})
     dpi = sp.plt[:thickness_scaling]
     if !haskey(ENV, "GKSwstype")
-        if isijulia() || (isdefined(Main, :Juno) && Juno.isactive())
+        if isijulia()
             ENV["GKSwstype"] = "svg"
         end
     end
@@ -818,7 +818,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             GR.setwindow(xmin, xmax, ymin, ymax)
         end
 
-        xticks, yticks, xspine_segs, yspine_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xborder_segs, yborder_segs = axis_drawing_info(sp)
+        xticks, yticks, xspine_segs, yspine_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xminorgrid_segs, yminorgrid_segs, xborder_segs, yborder_segs = axis_drawing_info(sp)
         # @show xticks yticks #spine_segs grid_segs
 
         # draw the grid lines
@@ -834,6 +834,18 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             gr_set_transparency(yaxis[:gridalpha])
             gr_polyline(coords(ygrid_segs)...)
         end
+        if xaxis[:minorgrid]
+            # gr_set_linecolor(sp[:foreground_color_grid])
+            # GR.grid(xtick, ytick, 0, 0, majorx, majory)
+            gr_set_line(xaxis[:minorgridlinewidth], xaxis[:minorgridstyle], xaxis[:foreground_color_minor_grid])
+            gr_set_transparency(xaxis[:minorgridalpha])
+            gr_polyline(coords(xminorgrid_segs)...)
+        end
+        if yaxis[:minorgrid]
+            gr_set_line(yaxis[:minorgridlinewidth], yaxis[:minorgridstyle], yaxis[:foreground_color_minor_grid])
+            gr_set_transparency(yaxis[:minorgridalpha])
+            gr_polyline(coords(yminorgrid_segs)...)
+        end
         gr_set_transparency(1.0)
 
         # axis lines

src/backends/pyplot.jl

@@ -394,8 +394,8 @@ function py_bbox_title(ax)
     bb
 end
 
-function py_dpi_scale(plt::Plot{PyPlotBackend}, ptsz)
-    ptsz
+function py_thickness_scale(plt::Plot{PyPlotBackend}, ptsz)
+    ptsz * plt[:thickness_scaling]
 end
 
 # ---------------------------------------------------------------------------
@@ -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
                 )
@@ -955,8 +955,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
     w, h = plt[:size]
     fig = plt.o
     fig[:clear]()
-    dpi = plt[:thickness_scaling] * plt[:dpi]
-    fig[:set_size_inches](w/DPI/plt[:thickness_scaling], h/DPI/plt[:thickness_scaling], forward = true)
+    dpi = plt[:dpi]
+    fig[:set_size_inches](w/DPI, h/DPI, forward = true)
     fig[set_facecolor_sym](py_color(plt[:background_color_outside]))
     fig[:set_dpi](plt[:dpi])
 
@@ -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,7 @@ function _update_min_padding!(sp::Subplot{PyPlotBackend})
     rightpad  += sp[:right_margin]
     bottompad += sp[:bottom_margin]
 
-    dpi_factor = sp.plt[:thickness_scaling] * Plots.DPI / sp.plt[:dpi]
+    dpi_factor = Plots.DPI / sp.plt[:dpi]
 
     sp.minpad = Tuple(dpi_factor .* [leftpad, toppad, rightpad, bottompad])
 end
@@ -1232,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
@@ -1263,13 +1265,13 @@ 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_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
@@ -1288,11 +1290,13 @@ 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]),
+                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])
 
@@ -1360,7 +1364,7 @@ for (mime, fmt) in _pyplot_mimeformats
             # figsize = map(px2inch, plt[:size]),
             facecolor = fig[:get_facecolor](),
             edgecolor = "none",
-            dpi = plt[:dpi] * plt[:thickness_scaling]
+            dpi = plt[:dpi]
         )
     end
 end

src/output.jl

@@ -199,8 +199,12 @@ 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)
+        if haskey(io, :juno_plotsize)
+          showjuno(io, m, plt)
+        else
+          prepare_output(plt)
+          _show(io, m, plt)
+        end
     end
 end
 
@@ -311,52 +315,22 @@ end
 # ---------------------------------------------------------
 # Atom PlotPane
 # ---------------------------------------------------------
-@require Juno = "e5e0dc1b-0480-54bc-9374-aad01c23163d" begin
-    import Hiccup, Media
+function showjuno(io::IO, m, plt)
+    sz = plt[:size]
+    dpi = plt[:dpi]
+    thickness_scaling = plt[:thickness_scaling]
 
-    if Juno.isactive()
-        Media.media(Plot, Media.Plot)
+    jsize = get(io, :juno_plotsize, [400, 500])
 
-        function Juno.render(e::Juno.Editor, plt::Plot)
-            Juno.render(e, nothing)
-        end
+    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
 
-        if get(ENV, "PLOTS_USE_ATOM_PLOTPANE", true) in (true, 1, "1", "true", "yes")
-            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)
+    prepare_output(plt)
+    _show(io, m, plt)
 
-                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})
-                display(Plots.PlotsDisplay(), plt)
-            end
-        else
-            function Juno.render(pane::Juno.PlotPane, plt::Plot)
-                display(Plots.PlotsDisplay(), plt)
-                s = "PlotPane turned off.  Unset ENV[\"PLOTS_USE_ATOM_PLOTPANE\"] and restart Julia to enable it."
-                Juno.render(pane, HTML(s))
-            end
-        end
-
-        # special handling for plotly... use PlotsDisplay
-        function Juno.render(pane::Juno.PlotPane, plt::Plot{PlotlyBackend})
-            display(Plots.PlotsDisplay(), plt)
-            s = "PlotPane turned off.  The plotly backend cannot render in the PlotPane due to javascript issues. Plotlyjs is similar to plotly and is compatible with the plot pane."
-            Juno.render(pane, HTML(s))
-        end
-    end
+    plt[:size] = sz
+    plt[:dpi] = dpi
+    plt[:thickness_scaling] = thickness_scaling
 end

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.3"
+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)