Merge pull request #1953 from daschw/polar-axis

put radius 0 at the center for polar plots (fix #1813)

REQUIRE

@@ -13,4 +13,4 @@ JSON
 NaNMath
 Requires
 Contour
-GR 0.37.0
+GR 0.38.1

src/arg_desc.jl

@@ -63,6 +63,7 @@ const _arg_desc = KW(
 :link                     => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
 :overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
 :html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
+:tex_output_standalone    => "Bool. When writing tex output, should the source include a preamble for a standalone document class.",
 :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.",

src/args.jl

@@ -298,6 +298,7 @@ const _plot_defaults = KW(
     :link                        => :none,
     :overwrite_figure            => true,
     :html_output_format          => :auto,
+    :tex_output_standalone       => false,
     :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

src/axes.jl

@@ -240,7 +240,7 @@ end
 # return (continuous_values, discrete_values) for the ticks on this axis
 function get_ticks(axis::Axis)
     ticks = _transform_ticks(axis[:ticks])
-    ticks in (nothing, false) && return nothing
+    ticks in (:none, nothing, false) && return nothing
 
     # treat :native ticks as :auto
     ticks = ticks == :native ? :auto : ticks
@@ -287,7 +287,7 @@ _transform_ticks(ticks::AbstractArray{T}) where T <: Dates.TimeType = Dates.valu
 _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
+    axis[:minorticks] in (:none, nothing, false) && !axis[:minorgrid] && return nothing
     ticks = ticks[1]
     length(ticks) < 2 && return nothing
 
@@ -502,7 +502,7 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
             amin, amax = 0, 2pi
         elseif lims == :auto
             #widen max radius so ticks dont overlap with theta axis
-            amin, amax + 0.1 * abs(amax - amin)
+            0, amax + 0.1 * abs(amax - amin)
         else
             amin, amax
         end
@@ -614,14 +614,14 @@ function axis_drawing_info(sp::Subplot)
                 end
                 push!(xaxis_segs, (xmin, y1), (xmax, y1))
                 # don't show the 0 tick label for the origin framestyle
-                if sp[:framestyle] == :origin && !(xticks in (nothing,false)) && length(xticks) > 1
+                if sp[:framestyle] == :origin && !(xticks in (:none, nothing, false)) && length(xticks) > 1
                     showticks = xticks[1] .!= 0
                     xticks = (xticks[1][showticks], xticks[2][showticks])
                 end
             end
             sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2), (xmax, y2)) # top spine
         end
-        if !(xaxis[:ticks] in (nothing, false))
+        if !(xaxis[:ticks] in (:none, nothing, false))
             f = scalefunc(yaxis[:scale])
             invf = invscalefunc(yaxis[:scale])
             ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
@@ -642,7 +642,7 @@ 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]
+        if !(xaxis[:minorticks] in (:none, nothing, false)) || xaxis[:minorgrid]
             f = scalefunc(yaxis[:scale])
             invf = invscalefunc(yaxis[:scale])
             ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
@@ -675,14 +675,14 @@ function axis_drawing_info(sp::Subplot)
                 end
                 push!(yaxis_segs, (x1, ymin), (x1, ymax))
                 # don't show the 0 tick label for the origin framestyle
-                if sp[:framestyle] == :origin && !(yticks in (nothing,false)) && length(yticks) > 1
+                if sp[:framestyle] == :origin && !(yticks in (:none, nothing,false)) && length(yticks) > 1
                     showticks = yticks[1] .!= 0
                     yticks = (yticks[1][showticks], yticks[2][showticks])
                 end
             end
             sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin), (x2, ymax)) # right spine
         end
-        if !(yaxis[:ticks] in (nothing, false))
+        if !(yaxis[:ticks] in (:none, nothing, false))
             f = scalefunc(xaxis[:scale])
             invf = invscalefunc(xaxis[:scale])
             ticks_in = yaxis[:tick_direction] == :out ? -1 : 1
@@ -703,7 +703,7 @@ 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]
+        if !(yaxis[:minorticks] in (:none, nothing, false)) || yaxis[:minorgrid]
             f = scalefunc(xaxis[:scale])
             invf = invscalefunc(xaxis[:scale])
             ticks_in = yaxis[:tick_direction] == :out ? -1 : 1

src/backends.jl

@@ -351,7 +351,7 @@ const _gr_attr = merge_with_base_supported([
 const _gr_seriestype = [
     :path, :scatter, :straightline,
     :heatmap, :pie, :image,
-    :contour, :path3d, :scatter3d, :surface, :wireframe,
+    :contour, :path3d, :scatter3d, :surface, :wireframe, :volume,
     :shape
 ]
 const _gr_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
@@ -417,6 +417,8 @@ const _plotly_marker = [
 ]
 const _plotly_scale = [:identity, :log10]
 
+defaultOutputFormat(plt::Plot{Plots.PlotlyBackend}) = "html"
+
 # ------------------------------------------------------------------------------
 # pgfplots
 
@@ -457,7 +459,7 @@ const _pgfplots_attr = merge_with_base_supported([
 ])
 const _pgfplots_seriestype = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour, :shape, :straightline,]
 const _pgfplots_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-const _pgfplots_marker = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon, :hline] #vcat(_allMarkers, Shape)
+const _pgfplots_marker = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon, :hline, :vline] #vcat(_allMarkers, Shape)
 const _pgfplots_scale = [:identity, :ln, :log2, :log10]
 
 # ------------------------------------------------------------------------------

src/backends/gr.jl

@@ -415,16 +415,24 @@ function gr_set_viewport_polar()
 end
 
 # add the colorbar
-function gr_colorbar(sp::Subplot, clims)
+function gr_colorbar(sp::Subplot, clims, levels)
+    GR.savestate()
     xmin, xmax = gr_xy_axislims(sp)[1:2]
+    zmin, zmax = clims[1:2]
     gr_set_viewport_cmap(sp)
-    l = zeros(Int32, 1, 256)
-    l[1,:] = Int[round(Int, _i) for _i in range(1000, stop=1255, length=256)]
+    l = if levels === nothing
+       (1000:1255)'
+    elseif length(levels) > 1
+        min_level, max_level = ignorenan_minimum(levels), ignorenan_maximum(levels)
+        round.(Int32, 1000 .+ (levels .- min_level) ./ (max_level - min_level) .* 255)
+    else
+        Int32[1000, 1255]
+    end
     GR.setscale(0)
-    GR.setwindow(xmin, xmax, clims[1], clims[2])
-    GR.cellarray(xmin, xmax, clims[2], clims[1], 1, length(l), l)
-    ztick = 0.5 * GR.tick(clims[1], clims[2])
-    GR.axes(0, ztick, xmax, clims[1], 0, 1, 0.005)
+    GR.setwindow(xmin, xmax, zmin, zmax)
+    GR.cellarray(xmin, xmax, zmax, zmin, 1, length(l), l)
+    ztick = 0.5 * GR.tick(zmin, zmax)
+    GR.axes(0, ztick, xmax, zmin, 0, 1, 0.005)
 
     gr_set_font(guidefont(sp[:yaxis]))
     GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
@@ -432,7 +440,7 @@ function gr_colorbar(sp::Subplot, clims)
     gr_text(viewport_plotarea[2] + gr_colorbar_ratio,
             gr_view_ycenter(), sp[:colorbar_title])
 
-    gr_set_viewport_plotarea()
+    GR.restorestate()
 end
 
 gr_view_xcenter() = 0.5 * (viewport_plotarea[1] + viewport_plotarea[2])
@@ -471,7 +479,7 @@ end
 const _gr_gradient_alpha = ones(256)
 
 function gr_set_gradient(c)
-    grad = isa(c, ColorGradient) ? c : cgrad()
+    grad = c isa ColorGradient ? c : cgrad()
     for (i,z) in enumerate(range(0, stop=1, length=256))
         c = grad[z]
         GR.setcolorrep(999+i, red(c), green(c), blue(c))
@@ -660,7 +668,10 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     # reduced from before... set some flags based on the series in this subplot
     # TODO: can these be generic flags?
     outside_ticks = false
-    cmap = hascolorbar(sp)
+    # calculate the colorbar limits once for a subplot
+    clims = get_clims(sp)
+    clevels = nothing
+
     draw_axes = sp[:framestyle] != :none
     # axes_2d = true
     for series in series_list(sp)
@@ -682,6 +693,9 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             expand_extrema!(sp[:yaxis], y)
             data_lims = gr_xy_axislims(sp)
         end
+
+        # color levels overwritten by the last relevant series
+        hascolorbar(series) && (clevels = colorbar_levels(series, clims))
     end
 
     # set our plot area view
@@ -730,11 +744,13 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     GR.setlinewidth(sp.plt[:thickness_scaling])
 
     if is3d(sp)
+        # TODO do we really need a different clims computation here from the one
+        #      computed above using get_clims(sp)?
         zmin, zmax = gr_lims(zaxis, true)
-        clims = sp[:clims]
-        if is_2tuple(clims)
-            isfinite(clims[1]) && (zmin = clims[1])
-            isfinite(clims[2]) && (zmax = clims[2])
+        clims3d = sp[:clims]
+        if is_2tuple(clims3d)
+            isfinite(clims3d[1]) && (zmin = clims3d[1])
+            isfinite(clims3d[2]) && (zmax = clims3d[2])
         end
         GR.setspace(zmin, zmax, round.(Int, sp[:camera])...)
         xtick = GR.tick(xmin, xmax) / 2
@@ -909,27 +925,31 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         GR.settextalign(halign, GR.TEXT_VALIGN_TOP)
         gr_text(xpos, viewport_subplot[4], sp[:title])
     end
-
-    if xaxis[:guide] != ""
+    if is3d(sp)
         gr_set_font(guidefont(xaxis))
-        if xaxis[:guide_position] == :top || (xaxis[:guide_position] == :auto && xaxis[:mirror] == true)
-            GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
-            gr_text(gr_view_xcenter(), viewport_subplot[4], xaxis[:guide])
-        else
-            GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
-            gr_text(gr_view_xcenter(), viewport_subplot[3], xaxis[:guide])
+        GR.titles3d(xaxis[:guide], yaxis[:guide], zaxis[:guide])
+    else
+        if xaxis[:guide] != ""
+            gr_set_font(guidefont(xaxis))
+            if xaxis[:guide_position] == :top || (xaxis[:guide_position] == :auto && xaxis[:mirror] == true)
+                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
+                gr_text(gr_view_xcenter(), viewport_subplot[4], xaxis[:guide])
+            else
+                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
+                gr_text(gr_view_xcenter(), viewport_subplot[3], xaxis[:guide])
+            end
         end
-    end
 
-    if yaxis[:guide] != ""
-        gr_set_font(guidefont(yaxis))
-        GR.setcharup(-1, 0)
-        if yaxis[:guide_position] == :right || (yaxis[:guide_position] == :auto && yaxis[:mirror] == true)
-            GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
-            gr_text(viewport_subplot[2], gr_view_ycenter(), yaxis[:guide])
-        else
-            GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
-            gr_text(viewport_subplot[1], gr_view_ycenter(), yaxis[:guide])
+        if yaxis[:guide] != ""
+            gr_set_font(guidefont(yaxis))
+            GR.setcharup(-1, 0)
+            if yaxis[:guide_position] == :right || (yaxis[:guide_position] == :auto && yaxis[:mirror] == true)
+                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
+                gr_text(viewport_subplot[2], gr_view_ycenter(), yaxis[:guide])
+            else
+                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
+                gr_text(viewport_subplot[1], gr_view_ycenter(), yaxis[:guide])
+            end
         end
     end
     GR.restorestate()
@@ -939,15 +959,15 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     # this needs to be here to point the colormap to the right indices
     GR.setcolormap(1000 + GR.COLORMAP_COOLWARM)
 
-    # calculate the colorbar limits once for a subplot
-    clims = get_clims(sp)
-
     for (idx, series) in enumerate(series_list(sp))
         st = series[:seriestype]
 
         # update the current stored gradient
-        if st in (:contour, :surface, :wireframe, :heatmap)
+        if st in (:surface, :heatmap) ||
+                (st == :contour && series[:fillrange] !== nothing)
             gr_set_gradient(series[:fillcolor]) #, series[:fillalpha])
+        elseif st in (:contour, :wireframe)
+            gr_set_gradient(series[:linecolor])
         elseif series[:marker_z] != nothing
             series[:markercolor] = gr_set_gradient(series[:markercolor])
         elseif series[:line_z] !=  nothing
@@ -1023,34 +1043,23 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             end
 
         elseif st == :contour
-            zmin, zmax = clims
-            GR.setspace(zmin, zmax, 0, 90)
-            if typeof(series[:levels]) <: AbstractArray
-                h = series[:levels]
-            else
-                h = series[:levels] > 1 ? range(zmin, stop=zmax, length=series[:levels]) : [(zmin + zmax) / 2]
-            end
+            GR.setspace(clims[1], clims[2], 0, 90)
+            h = colorbar_levels(series, clims)
             GR.setlinetype(gr_linetype[get_linestyle(series)])
             GR.setlinewidth(max(0, get_linewidth(series) / (sum(gr_plot_size) * 0.001)))
+            is_lc_black = let black=plot_color(:black)
+                plot_color(series[:linecolor]) in (black,[black])
+            end
             if series[:fillrange] != nothing
+                if series[:fillcolor] != series[:linecolor] && !is_lc_black
+                    @warn("GR: filled contour only supported with black contour lines")
+                end
                 GR.contourf(x, y, h, z, series[:contour_labels] == true ? 1 : 0)
             else
-                coff = plot_color(series[:linecolor]) == [plot_color(:black)] ? 0 : 1000
+                coff = is_lc_black ? 0 : 1000
                 GR.contour(x, y, h, z, coff + (series[:contour_labels] == true ? 1 : 0))
             end
 
-            # create the colorbar of contour levels
-            if cmap
-                gr_set_line(1, :solid, yaxis[:foreground_color_axis])
-                gr_set_viewport_cmap(sp)
-                l = (length(h) > 1) ? round.(Int32, 1000 .+ (h .- ignorenan_minimum(h)) ./ (ignorenan_maximum(h) - ignorenan_minimum(h)) .* 255) : Int32[1000, 1255]
-                GR.setwindow(xmin, xmax, zmin, zmax)
-                GR.cellarray(xmin, xmax, zmax, zmin, 1, length(l), l)
-                ztick = 0.5 * GR.tick(zmin, zmax)
-                GR.axes(0, ztick, xmax, zmin, 0, 1, 0.005)
-                gr_set_viewport_plotarea()
-            end
-
         elseif st in [:surface, :wireframe]
             if st == :surface
                 if length(x) == length(y) == length(z)
@@ -1067,6 +1076,11 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 GR.surface(x, y, z, GR.OPTION_FILLED_MESH)
             end
 
+        elseif st == :volume
+            sp[:legend] = :none
+            GR.gr3.clear()
+            dmin, dmax = GR.gr3.volume(y.v, 0)
+
         elseif st == :heatmap
             xmin, xmax, ymin, ymax = xy_lims
             zmin, zmax = clims
@@ -1177,19 +1191,19 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         elseif st == :image
             z = transpose_z(series, series[:z].surf, true)'
-            w, h = length(x), length(y)
+            w, h = size(z)
             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)
+                grey = round.(UInt8, clamp.(float(z) * 255, 0, 255))
                 rgba = map(c -> UInt32( 0xff000000 + UInt(c)<<16 + UInt(c)<<8 + UInt(c) ), grey)
             else
-                rgba = map(c -> UInt32( round(UInt, alpha(c) * 255) << 24 +
-                                        round(UInt,  blue(c) * 255) << 16 +
-                                        round(UInt, green(c) * 255) << 8  +
-                                        round(UInt,   red(c) * 255) ), z)
+                rgba = map(c -> UInt32( round(UInt, clamp(alpha(c) * 255, 0, 255)) << 24 +
+                                        round(UInt,  clamp(blue(c) * 255, 0, 255)) << 16 +
+                                        round(UInt, clamp(green(c) * 255, 0, 255)) << 8  +
+                                        round(UInt,   clamp(red(c) * 255, 0, 255)) ), z)
             end
             GR.drawimage(xmin, xmax, ymax, ymin, w, h, rgba)
         end
@@ -1205,14 +1219,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     end
 
     # draw the colorbar
-    GR.savestate()
-    # special colorbar with steps is drawn for contours
-    if cmap && any(series[:seriestype] != :contour for series in series_list(sp))
-        gr_set_line(1, :solid, yaxis[:foreground_color_axis])
-        gr_set_transparency(1)
-        gr_colorbar(sp, clims)
-    end
-    GR.restorestate()
+    hascolorbar(sp) && gr_colorbar(sp, clims, clevels)
 
     # add the legend
     if sp[:legend] != :none

src/backends/pgfplots.jl

@@ -26,7 +26,8 @@ const _pgfplots_markers = KW(
     :star6 => "asterisk",
     :diamond => "diamond*",
     :pentagon => "pentagon*",
-    :hline => "-"
+    :hline => "-",
+    :vline => "|"
 )
 
 const _pgfplots_legend_pos = KW(
@@ -563,7 +564,7 @@ end
 
 function _show(io::IO, mime::MIME"application/x-tex", plt::Plot{PGFPlotsBackend})
     fn = tempname()*".tex"
-    PGFPlots.save(fn, backend_object(plt), include_preamble=false)
+    PGFPlots.save(fn, backend_object(plt), include_preamble=plt.attr[:tex_output_standalone])
     write(io, read(open(fn), String))
 end
 

src/backends/plotly.jl

@@ -186,11 +186,6 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
         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[:range] = reverse(ax[:range])
-        end
-
         # ticks
         if axis[:ticks] != :native
             ticks = get_ticks(axis)
@@ -208,6 +203,10 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
         ax[:showgrid] = false
     end
 
+    # flip
+    if axis[:flip]
+        ax[:range] = reverse(ax[:range])
+    end
 
     ax
 end
@@ -854,11 +853,16 @@ end
 
 # ----------------------------------------------------------------
 
-
-function _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyBackend})
-    write(io, html_head(plt) * html_body(plt))
+function _show(io::IO, ::MIME"application/vnd.plotly.v1+json", plot::Plot{PlotlyBackend})
+    data = []
+    for series in plot.series_list
+        append!(data, plotly_series(plot, series))
+    end
+    layout = plotly_layout(plot)
+    JSON.print(io, Dict(:data => data, :layout => layout))
 end
 
+
 function _display(plt::Plot{PlotlyBackend})
     standalone_html_window(plt)
 end

src/backends/plotlyjs.jl

@@ -55,6 +55,11 @@ _show(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(
 _show(io::IO, ::MIME"application/pdf", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="pdf")
 _show(io::IO, ::MIME"image/eps", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="eps")
 
+function _show(io::IO, m::MIME"application/vnd.plotly.v1+json", plt::Plot{PlotlyJSBackend})
+    show(io, m, plt.o)
+end
+
+
 function write_temp_html(plt::Plot{PlotlyJSBackend})
     filename = string(tempname(), ".html")
     savefig(plt, filename)

src/backends/pyplot.jl

@@ -1321,7 +1321,7 @@ end
 # display/output
 
 function _display(plt::Plot{PyPlotBackend})
-    plt.o[:show]()
+    isdefined(PyCall, :_setproperty!) ? plt.o.show() : plot.o[:show]()
 end
 
 
@@ -1332,7 +1332,8 @@ const _pyplot_mimeformats = Dict(
     "application/pdf"         => "pdf",
     "image/png"               => "png",
     "application/postscript"  => "ps",
-    "image/svg+xml"           => "svg"
+    "image/svg+xml"           => "svg",
+    "application/x-tex"       => "pgf"
 )
 
 

src/backends/unicodeplots.jl

@@ -116,7 +116,7 @@ function addUnicodeSeries!(o, plotattributes::KW, addlegend::Bool, xlim, ylim)
     x, y = if st == :straightline
         straightline_data(plotattributes)
     elseif st == :shape
-        shape_data(series)
+        shape_data(plotattributes)
     else
         [collect(float(plotattributes[s])) for s in (:x, :y)]
     end

src/output.jl

@@ -55,9 +55,7 @@ tex(fn::AbstractString) = tex(current(), fn)
 function html(plt::Plot, fn::AbstractString)
     fn = addExtension(fn, "html")
     io = open(fn, "w")
-    _use_remote[] = true
     show(io, MIME("text/html"), plt)
-    _use_remote[] = false
     close(io)
 end
 html(fn::AbstractString) = html(current(), fn)
@@ -191,7 +189,7 @@ 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/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)

src/recipes.jl

@@ -47,7 +47,7 @@ end
 num_series(x::AMat) = size(x,2)
 num_series(x) = 1
 
-RecipesBase.apply_recipe(plotattributes::KW, ::Type{T}, plt::AbstractPlot) where {T} = throw(MethodError("Unmatched plot recipe: $T"))
+RecipesBase.apply_recipe(plotattributes::KW, ::Type{T}, plt::AbstractPlot) where {T} = throw(MethodError(T, "Unmatched plot recipe: $T"))
 
 # ---------------------------------------------------------------------------
 

src/utils.jl

@@ -431,7 +431,7 @@ isvertical(series::Series) = isvertical(series.plotattributes)
 
 ticksType(ticks::AVec{T}) where {T<:Real}                      = :ticks
 ticksType(ticks::AVec{T}) where {T<:AbstractString}            = :labels
-ticksType(ticks::Tuple{T,S}) where {T<:AVec,S<:AVec}  = :ticks_and_labels
+ticksType(ticks::Tuple{T,S}) where {T<:Union{AVec,Tuple},S<:Union{AVec,Tuple}} = :ticks_and_labels
 ticksType(ticks)                                        = :invalid
 
 limsType(lims::Tuple{T,S}) where {T<:Real,S<:Real}    = :limits
@@ -610,6 +610,22 @@ function hascolorbar(sp::Subplot)
     hascbar
 end
 
+function colorbar_levels(series::Series, clims)
+    if series[:seriestype] == :contour
+        zmin, zmax = clims
+        levels = series[:levels]
+        levels isa AbstractArray ?
+            levels :
+            levels > 1 ?
+                range(zmin, stop=zmax, length=levels) : 
+                [(zmin + zmax) / 2]
+    else # including heatmap, surface
+        nothing
+    end
+end
+
+  
+
 for comp in (:line, :fill, :marker)
 
     compcolor = string(comp, :color)
@@ -1208,8 +1224,8 @@ function _fmt_paragraph(io::IOBuffer,
                         fillwidth=60,
                         leadingspaces=0)
 
-    kwargs = (fillwidth = fillwidth, leadingspaces = leadingspaces) 
-    
+    kwargs = (fillwidth = fillwidth, leadingspaces = leadingspaces)
+
     m = match(r"(.*?) (.*)",remaining_text)
     if isa(m,Nothing)
         if column_count + length(remaining_text) ≤ fillwidth

test/runtests.jl

@@ -33,7 +33,12 @@ end
     @test backend() == Plots.UnicodePlotsBackend()
 
     # lets just make sure it runs without error
-    @test isa(plot(rand(10)), Plots.Plot) == true
+    p = plot(rand(10))
+    @test isa(p, Plots.Plot) == true
+    @test isa(display(p), Nothing) == true
+    p = bar(randn(10))
+    @test isa(p, Plots.Plot) == true
+    @test isa(display(p), Nothing) == true
 end
 
 # The plotlyjs testimages return a connection error on travis: