Merge pull request #819 from mkborregaard/switch_off_precompile

Switch off precompilation for release

NEWS.md

@@ -3,14 +3,47 @@
 
 #### notes on release changes, ongoing development, and future planned work
 
-- All new development should target 0.9!
-- Minor version 0.8 is the last one to support Julia 0.4!!
+- All new development should target 0.12!
+- Minor version 0.11 is the last one to support Julia 0.5!!
 	- Critical bugfixes only
     - `backports` branch is for Julia 0.4
 
 ---
 
-## 0.9 (current master/dev)
+## 0.11 (current master/dev)
+
+#### 0.11.0
+
+- julia 0.6 compatibility
+- matplotlib 0.2.0 compatibility
+- add inspectdr backend
+- improved histogram functionality:
+- added a `:stephist` and `:scatterhist` series type as well as ``:barhist` (the default)
+- support for log scale axes with histograms
+- support for plotting `StatsBase.Histogram`
+- allowing bins to be specified as `:sturges`, `:rice`, `:scott` or :fd
+- allow `normalization` to be specified as :density (for unequal bins) or :pdf (sum to 1)
+- add a `plotattr` function to access documentation for Plots attribute
+- add `fill_z` attribute for pyplot
+- add colorbar_title to plotlyjs
+- enable standalone window for plotlyjs
+- improved support for pgfplots, ticks rotation, clims, series_annotations
+- restore colorbars for GR
+- better axis labels for heatmap in GR
+- better marker sizes in GR
+- fix color representation in GR
+- update GR legend
+- fix image bug on GR
+- fix glvisualize dependencies
+- set dotted grid lines for pyplot
+- several improvements to inspectdr
+- improved tick positions for TimeType x axes
+- support for improved color gradient capability in PlotUtils
+- add a showlibrary recipe to display color libraries
+- add a showgradient recipe to display color gradients
+- add `vectorfield` as an alias for `quiver`
+- use `PlotUtils.adaptedgrid` for functions
+
 
 #### 0.9.5
 

README.md

@@ -1,6 +1,6 @@
 # Plots
 
-[![Build Status](https://travis-ci.org/tbreloff/Plots.jl.svg?branch=master)](https://travis-ci.org/tbreloff/Plots.jl)
+[![Build Status](https://travis-ci.org/JuliaPlots/Plots.jl.svg?branch=master)](https://travis-ci.org/JuliaPlots/Plots.jl)
 [![Join the chat at https://gitter.im/tbreloff/Plots.jl](https://badges.gitter.im/tbreloff/Plots.jl.svg)](https://gitter.im/tbreloff/Plots.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 <!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.3.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.3) -->
 <!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.4.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.4) -->

REQUIRE

@@ -1,10 +1,10 @@
 julia 0.5
 
 RecipesBase
-PlotUtils
-PlotThemes
+PlotUtils 0.4.1
+PlotThemes 0.1.3
 Reexport
 FixedSizeArrays
 Measures
 Showoff
-StatsBase
+StatsBase 0.14.0

src/Plots.jl

@@ -1,4 +1,4 @@
-__precompile__(true)
+__precompile__(false)
 
 module Plots
 

src/animation.jl

@@ -80,7 +80,8 @@ function buildanimation(animdir::AbstractString, fn::AbstractString;
 
     catch err
         warn("""Tried to create gif using convert (ImageMagick), but got error: $err
-            ImageMagick can be installed by executing `Pkg.add("ImageMagick")`
+            ImageMagick can be installed by executing `Pkg.add("ImageMagick")`.
+            You may also need to install the imagemagick c++ library through your operating system. 
             Will try ffmpeg, but it's lower quality...)""")
 
         # low quality

src/arg_desc.jl

@@ -21,7 +21,7 @@ const _arg_desc = KW(
 :markerstrokewidth 	=> "Number. Width of the marker stroke (border. in pixels)",
 :markerstrokecolor 	=> "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:foreground_color_subplot`.",
 :markerstrokealpha 	=> "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
-:bins              	=> "Integer, NTuple{2,Integer}, AbstractVector. For histogram-types, defines the number of bins, or the edges, of the histogram.",
+:bins              	=> "Integer, NTuple{2,Integer}, AbstractVector or Symbol. Default is :auto. For histogram-types, defines the number of bins, or the edges, of the histogram, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd)",
 :smooth            	=> "Bool.  Add a regression line?",
 :group             	=> "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
 :x                 	=> "Various. Input data. First Dimension",
@@ -40,7 +40,7 @@ const _arg_desc = KW(
 :ribbon            	=> "Number or AbstractVector.  Creates a fillrange around the data points.",
 :quiver            	=> "AbstractVector or 2-Tuple of vectors.  The directional vectors U,V which specify velocity/gradient vectors for a quiver plot.",
 :arrow             	=> "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
-:normalize         	=> "Bool. Should normalize histogram types?  Trying for area == 1.",
+:normalize         	=> "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a PDF with integral of 1) and :density (only normalize in respect to bin sizes).",
 :weights           	=> "AbstractVector. Used in histogram types for weighted counts.",
 :contours          	=> "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
 :match_dimensions  	=> "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",

src/args.jl

@@ -35,7 +35,9 @@ const _3dTypes = [
 ]
 const _allTypes = vcat([
     :none, :line, :path, :steppre, :steppost, :sticks, :scatter,
-    :heatmap, :hexbin, :histogram, :histogram2d, :histogram3d, :density, :bar, :hline, :vline,
+    :heatmap, :hexbin, :barbins, :barhist, :histogram, :scatterbins,
+    :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :histogram3d,
+    :density, :bar, :hline, :vline,
     :contour, :pie, :shape, :image
 ], _3dTypes)
 
@@ -65,6 +67,7 @@ const _typeAliases = Dict{Symbol,Symbol}(
     :polygon       => :shape,
     :box           => :boxplot,
     :velocity      => :quiver,
+    :vectorfield   => :quiver,
     :gradient      => :quiver,
     :img           => :image,
     :imshow        => :image,
@@ -77,7 +80,7 @@ const _typeAliases = Dict{Symbol,Symbol}(
 
 add_non_underscore_aliases!(_typeAliases)
 
-like_histogram(seriestype::Symbol) = seriestype in (:histogram, :barhist, :barbins, :density)
+like_histogram(seriestype::Symbol) = seriestype in (:histogram, :barhist, :barbins)
 like_line(seriestype::Symbol)      = seriestype in (:line, :path, :steppre, :steppost)
 like_surface(seriestype::Symbol)   = seriestype in (:contour, :contourf, :contour3d, :heatmap, :surface, :wireframe, :image)
 
@@ -153,6 +156,8 @@ const _markerAliases = Dict{Symbol,Symbol}(
 )
 
 const _allScales = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
+const _logScales = [:ln, :log2, :log10]
+const _logScaleBases = Dict(:ln => e, :log2 => 2.0, :log10 => 10.0)
 const _scaleAliases = Dict{Symbol,Symbol}(
     :none => :identity,
     :log  => :log10,
@@ -180,7 +185,7 @@ const _series_defaults = KW(
     :markerstrokewidth => 1,
     :markerstrokecolor => :match,
     :markerstrokealpha => nothing,
-    :bins              => 30,        # number of bins for hists
+    :bins              => :auto,        # number of bins for hists
     :smooth            => false,     # regression line?
     :group             => nothing,   # groupby vector
     :x                 => nothing,
@@ -445,7 +450,7 @@ add_aliases(:color_palette, :palette)
 add_aliases(:overwrite_figure, :clf, :clearfig, :overwrite, :reuse)
 add_aliases(:xerror, :xerr, :xerrorbar)
 add_aliases(:yerror, :yerr, :yerrorbar, :err, :errorbar)
-add_aliases(:quiver, :velocity, :quiver2d, :gradient)
+add_aliases(:quiver, :velocity, :quiver2d, :gradient, :vectorfield)
 add_aliases(:normalize, :norm, :normed, :normalized)
 add_aliases(:aspect_ratio, :aspectratio, :axis_ratio, :axisratio, :ratio)
 add_aliases(:match_dimensions, :transpose, :transpose_z)

src/axes.jl

@@ -156,6 +156,30 @@ function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
     scale = axis[:scale]
     sf = scalefunc(scale)
 
+    # If the axis input was a Date or DateTime use a special logic to find
+    # "round" Date(Time)s as ticks
+    # This bypasses the rest of optimal_ticks_and_labels, because
+    # optimize_datetime_ticks returns ticks AND labels: the label format (Date
+    # or DateTime) is chosen based on the time span between amin and amax
+    # rather than on the input format
+    # TODO: maybe: non-trivial scale (:ln, :log2, :log10) for date/datetime
+    if ticks == nothing && scale == :identity
+        if axis[:formatter] == dateformatter
+            # optimize_datetime_ticks returns ticks and labels(!) based on
+            # integers/floats corresponding to the DateTime type. Thus, the axes
+            # limits, which resulted from converting the Date type to integers,
+            # are converted to 'DateTime integers' (actually floats) before
+            # being passed to optimize_datetime_ticks.
+            # (convert(Int, convert(DateTime, convert(Date, i))) == 87600000*i)
+            ticks, labels = optimize_datetime_ticks(864e5 * amin, 864e5 * amax;
+                k_min = 2, k_max = 4)
+            # Now the ticks are converted back to floats corresponding to Dates.
+            return ticks / 864e5, labels
+        elseif axis[:formatter] == datetimeformatter
+            return optimize_datetime_ticks(amin, amax; k_min = 2, k_max = 4)
+        end
+    end
+
     # get a list of well-laid-out ticks
     scaled_ticks = if ticks == nothing
         optimize_ticks(
@@ -214,7 +238,7 @@ function get_ticks(axis::Axis)
     # @show ticks dvals cv dv
 
     # TODO: better/smarter cutoff values for sampling ticks
-    if length(cv) > 30
+    if length(cv) > 30 && ticks == :auto
         rng = Int[round(Int,i) for i in linspace(1, length(cv), 15)]
         cv[rng], dv[rng]
     else

src/backends/glvisualize.jl

@@ -1,4 +1,4 @@
-``#=
+#=
 TODO
     * move all gl_ methods to GLPlot
     * integrate GLPlot UI
@@ -7,7 +7,6 @@ TODO
     * polar plots
     * labes and axis
     * fix units in all visuals (e.g dotted lines, marker scale, surfaces)
-    * why is there so little unicode supported in the font!??!?
 =#
 
 const _glvisualize_attr = merge_with_base_supported([
@@ -134,11 +133,6 @@ function empty_screen!(screen)
     end
     nothing
 end
-function poll_reactive()
-    # run_till_now blocks when message queue is empty!
-    Base.n_avail(Reactive._messages) > 0 && Reactive.run_till_now()
-end
-
 
 function get_plot_screen(list::Vector, name, result = [])
     for elem in list
@@ -155,19 +149,20 @@ function get_plot_screen(screen, name, result = [])
 end
 
 function create_window(plt::Plot{GLVisualizeBackend}, visible)
-    name = Symbol("Plots.jl")
+    name = Symbol("__Plots.jl")
     # make sure we have any screen open
     if isempty(GLVisualize.get_screens())
         # create a fresh, new screen
         parent_screen = GLVisualize.glscreen(
-            "Plot",
+            "Plots",
             resolution = plt[:size],
             visible = visible
         )
         @async GLWindow.waiting_renderloop(parent_screen)
+        GLVisualize.add_screen(parent_screen)
     end
     # now lets get ourselves a permanent Plotting screen
-    plot_screens = get_plot_screen(GLVisualize.get_screens(), name)
+    plot_screens = get_plot_screen(GLVisualize.current_screen(), name)
     screen = if isempty(plot_screens) # no screen with `name`
         parent = GLVisualize.current_screen()
         screen = GLWindow.Screen(
@@ -183,7 +178,7 @@ function create_window(plt::Plot{GLVisualizeBackend}, visible)
     else
         # okay this is silly! Lets see if we can. There is an ID we could use
         # will not be fine for more than 255 screens though -.-.
-        error("multiple Plot screens. Please don't use any screen with the name Plots.jl")
+        error("multiple Plot screens. Please don't use any screen with the name $name")
     end
     # Since we own this window, we can do deep cleansing
     empty_screen!(screen)
@@ -1141,8 +1136,7 @@ function _display(plt::Plot{GLVisualizeBackend}, visible = true)
                 vis = gl_bar(d, kw_args)
             elseif st == :image
                 extract_extrema(d, kw_args)
-                z = transpose_z(series, d[:z].surf, false)
-                vis = GL.gl_image(z, kw_args)
+                vis = GL.gl_image(d[:z].surf, kw_args)
             elseif st == :boxplot
                  extract_c(d, kw_args, :fill)
                  vis = gl_boxplot(d, kw_args)
@@ -1182,7 +1176,7 @@ function _display(plt::Plot{GLVisualizeBackend}, visible = true)
         if _3d
             GLAbstraction.center!(sp_screen)
         end
-        Reactive.post_empty()
+        GLAbstraction.post_empty()
         yield()
     end
 end
@@ -1422,6 +1416,8 @@ function label_scatter(d, w, ho)
         color = get(kw, :color, nothing)
         kw[:color] = isa(color, Array) ? first(color) : color
     end
+    strcolor = get(kw, :stroke_color, RGBA{Float32}(0,0,0,0))
+    kw[:stroke_color] = isa(strcolor, Array) ? first(strcolor) : strcolor
     p = get(kw, :primitive, GeometryTypes.Circle)
     if isa(p, GLNormalMesh)
         bb = GeometryTypes.AABB{Float32}(GeometryTypes.vertices(p))
@@ -1436,6 +1432,9 @@ function label_scatter(d, w, ho)
         kw[:scale] = Vec3f0(w/2)
         delete!(kw, :offset)
     end
+    if isa(p, Array)
+        kw[:primitive] = GeometryTypes.Circle
+    end
     GL.gl_scatter(Point2f0[(w/2, ho)], kw)
 end
 

src/backends/gr.jl

@@ -172,6 +172,8 @@ function gr_polyline(x, y, func = GR.polyline; arrowside=:none)
     end
 end
 
+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])
@@ -182,6 +184,8 @@ function gr_inqtext(x, y, s)
     end
 end
 
+gr_text(x, y, s::Symbol) = gr_text(x, y, string(s))
+
 function gr_text(x, y, s)
     if length(s) >= 2 && s[1] == '$' && s[end] == '$'
         GR.mathtex(x, y, s[2:end-1])
@@ -283,7 +287,8 @@ end
 # draw ONE symbol marker
 function gr_draw_marker(xi, yi, msize::Number, shape::Symbol)
     GR.setmarkertype(gr_markertype[shape])
-    GR.setmarkersize(0.3msize)
+    w, h = gr_plot_size
+    GR.setmarkersize(0.3msize / ((w + h) * 0.001))
     GR.polymarker([xi], [yi])
 end
 
@@ -330,9 +335,10 @@ end
 
 # ---------------------------------------------------------
 
-function gr_set_line(w, style, c) #, a)
+function gr_set_line(lw, style, c) #, a)
     GR.setlinetype(gr_linetype[style])
-    GR.setlinewidth(w)
+    w, h = gr_plot_size
+    GR.setlinewidth(max(0, lw / ((w + h) * 0.001)))
     gr_set_linecolor(c) #, a)
 end
 
@@ -421,7 +427,7 @@ end
 function gr_colorbar(sp::Subplot)
     if sp[:colorbar] != :none
         gr_set_viewport_cmap(sp)
-        GR.colormap()
+        GR.colorbar()
         gr_set_viewport_plotarea()
     end
 end
@@ -545,6 +551,10 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         end
         if st == :heatmap
             outside_ticks = true
+            x, y = heatmap_edges(series[:x]), heatmap_edges(series[:y])
+            expand_extrema!(sp[:xaxis], x)
+            expand_extrema!(sp[:yaxis], y)
+            data_lims = gr_xy_axislims(sp)
         end
     end
 
@@ -759,10 +769,6 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         # recompute data
         if typeof(z) <: Surface
-            # if st == :heatmap
-            #     expand_extrema!(sp[:xaxis], (x[1]-0.5*(x[2]-x[1]), x[end]+0.5*(x[end]-x[end-1])))
-            #     expand_extrema!(sp[:yaxis], (y[1]-0.5*(y[2]-y[1]), y[end]+0.5*(y[end]-y[end-1])))
-            # end
             z = vec(transpose_z(series, z.surf, false))
         elseif ispolar(sp)
             if frng != nothing
@@ -807,12 +813,12 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 isfinite(clims[1]) && (zmin = clims[1])
                 isfinite(clims[2]) && (zmax = clims[2])
             end
+            GR.setspace(zmin, zmax, 0, 90)
             if typeof(series[:levels]) <: Array
                 h = series[:levels]
             else
                 h = linspace(zmin, zmax, series[:levels])
             end
-            GR.setspace(zmin, zmax, 0, 90)
             if series[:fillrange] != nothing
                 GR.surface(x, y, z, GR.OPTION_CELL_ARRAY)
             else
@@ -850,6 +856,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 isfinite(clims[1]) && (zmin = clims[1])
                 isfinite(clims[2]) && (zmax = clims[2])
             end
+            GR.setspace(zmin, zmax, 0, 90)
             grad = isa(series[:fillcolor], ColorGradient) ? series[:fillcolor] : cgrad()
             colors = [grad[clamp((zi-zmin) / (zmax-zmin), 0, 1)] for zi=z]
             rgba = map(c -> UInt32( round(Int, alpha(c) * 255) << 24 +
@@ -944,7 +951,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         elseif st == :image
             z = transpose_z(series, series[:z].surf, true)
-            h, w = size(z)
+            w, h = size(z)
             if eltype(z) <: Colors.AbstractGray
                 grey = round(UInt8, float(z) * 255)
                 rgba = map(c -> UInt32( 0xff000000 + Int(c)<<16 + Int(c)<<8 + Int(c) ), grey)
@@ -1103,7 +1110,7 @@ function _display(plt::Plot{GRBackend})
         ENV["GKS_FILEPATH"] = filepath
         gr_display(plt)
         GR.emergencyclosegks()
-        content = string("\033]1337;File=inline=1;preserveAspectRatio=0:", base64encode(open(readbytes, filepath)), "\a")
+        content = string("\033]1337;File=inline=1;preserveAspectRatio=0:", base64encode(open(read, filepath)), "\a")
         println(content)
         rm(filepath)
     else

src/backends/inspectdr.jl

@@ -213,14 +213,10 @@ end
 # Set up the subplot within the backend object.
 function _initialize_subplot(plt::Plot{InspectDRBackend}, sp::Subplot{InspectDRBackend})
     plot = sp.o
-
     #Don't do anything without a "subplot" object:  Will process later.
     if nothing == plot; return; end
     plot.data = []
-    plot.markers = [] #Clear old markers
-    plot.atext = [] #Clear old annotation
-    plot.apline = [] #Clear old poly lines
-
+    plot.userannot = [] #Clear old markers/text annotation/polyline "annotation"
     return plot
 end
 
@@ -277,7 +273,7 @@ For st in :shape:
                 apline = InspectDR.PolylineAnnotation(
                     x[rng], y[rng], line=line, fillcolor=fillcolor
                 )
-                push!(plot.apline, apline)
+                InspectDR.add(plot, apline)
             end
         end
 
@@ -415,8 +411,6 @@ function _before_layout_calcs(plt::Plot{InspectDRBackend})
         plot = sp.o
         _initialize_subplot(plt, sp)
         _inspectdr_setupsubplot(sp)
-        graphbb = _inspectdr_to_pixels(plotarea(sp))
-        plot.plotbb = InspectDR.plotbounds(plot.layout, graphbb)
 
         # add the annotations
         for ann in sp[:annotations]
@@ -471,7 +465,11 @@ function _update_plot_object(plt::Plot{InspectDRBackend})
     mplot = _inspectdr_getmplot(plt.o)
     if nothing == mplot; return; end
 
-    #TODO: should plotbb be computed here??
+    for (i, sp) in enumerate(plt.subplots)
+        graphbb = _inspectdr_to_pixels(plotarea(sp))
+        plot = mplot.subplots[i]
+        plot.plotbb = InspectDR.plotbounds(plot.layout, graphbb)
+    end
 
     gplot = _inspectdr_getgui(plt.o)
     if nothing == gplot; return; end

src/backends/pgfplots.jl

@@ -22,8 +22,8 @@ const _pgfplots_attr = merge_with_base_supported([
     :guide, :lims, :ticks, :scale, :flip, :rotation,
     :tickfont, :guidefont, :legendfont,
     :grid, :legend,
-    # :colorbar,
-    # :marker_z, :levels,
+    :colorbar,
+    :marker_z, #:levels,
     # :ribbon, :quiver, :arrow,
     # :orientation,
     # :overwrite_figure,
@@ -98,6 +98,8 @@ const _pgf_series_extrastyle = KW(
     :xsticks => "xcomb",
 )
 
+# PGFPlots uses the anchors to define orientations for example to align left 
+# one needs to use the right edge as anchor
 const _pgf_annotation_halign = KW(
     :center => "",
     :left => "right",
@@ -107,11 +109,24 @@ const _pgf_annotation_halign = KW(
 # --------------------------------------------------------------------------------------
 
 # takes in color,alpha, and returns color and alpha appropriate for pgf style
-function pgf_color(c)
+function pgf_color(c::Colorant)
     cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", red(c), green(c), blue(c))
     cstr, alpha(c)
 end
 
+function pgf_color(grad::ColorGradient)
+    # Can't handle ColorGradient here, fallback to defaults.
+    cstr = @sprintf("{rgb,1:red,%.8f;green,%.8f;blue,%.8f}", 0.0, 0.60560316,0.97868012)
+    cstr, 1
+end
+
+# Generates a colormap for pgfplots based on a ColorGradient
+function pgf_colormap(grad::ColorGradient) 
+    join(map(grad.colors) do c
+        @sprintf("rgb=(%.8f,%.8f,%.8f)", red(c), green(c),blue(c))
+    end,", ")
+end
+
 function pgf_fillstyle(d::KW)
     cstr,a = pgf_color(d[:fillcolor])
     "fill = $cstr, fill opacity=$a"
@@ -162,7 +177,6 @@ function pgf_series(sp::Subplot, series::Series)
     st = d[:seriestype]
     style = []
     kw = KW()
-
     push!(style, pgf_linestyle(d))
     push!(style, pgf_marker(d))
 
@@ -182,6 +196,10 @@ function pgf_series(sp::Subplot, series::Series)
         d[:z].surf, d[:x], d[:y]
     elseif is3d(st)
         d[:x], d[:y], d[:z]
+    elseif d[:marker_z] != nothing
+        # If a marker_z is used pass it as third coordinate to a 2D plot.
+        # See "Scatter Plots" in PGFPlots documentation
+        d[:x], d[:y], d[:marker_z]
     else
         d[:x], d[:y]
     end
@@ -274,6 +292,7 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
     # Obtain the total height of the plot by extracting the maximal bottom
     # coordinate from the bounding box.
     total_height = bottom(bbox(plt.layout))
+
     for sp in plt.subplots
        # first build the PGFPlots.Axis object
         style = ["unbounded coords=jump"]
@@ -319,6 +338,34 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
         if sp[:projection] == :polar
             axisf = PGFPlots.PolarAxis
         end
+
+        # Search series for any gradient. In case one series uses a gradient set
+        # the colorbar and colomap.
+        # The reasoning behind doing this on the axis level is that pgfplots
+        # colorbar seems to only works on axis level and needs the proper colormap for
+        # correctly displaying it.
+        # It's also possible to assign the colormap to the series itself but
+        # then the colormap needs to be added twice, once for the axis and once for the
+        # series.
+        # As it is likely that all series within the same axis use the same
+        # colormap this should not cause any problem.
+        for series in series_list(sp)
+            for col in (:markercolor, :fillcolor)
+                if typeof(series.d[col]) == ColorGradient
+                    push!(style,"colormap={plots}{$(pgf_colormap(series.d[col]))}")
+
+                    if sp[:colorbar] == :none
+                        kw[:colorbar] = "false"
+                    else
+                        kw[:colorbar] = "true"
+                    end
+                    # goto is needed to break out of col and series for
+                    @goto colorbar_end 
+                end
+            end
+        end
+        @label colorbar_end
+
         o = axisf(; style = style, kw...)
 
         # add the series object to the PGFPlots.Axis

src/backends/plotly.jl

@@ -19,7 +19,7 @@ const _plotly_attr = merge_with_base_supported([
     :window_title,
     :guide, :lims, :ticks, :scale, :flip, :rotation,
     :tickfont, :guidefont, :legendfont,
-    :grid, :legend, :colorbar,
+    :grid, :legend, :colorbar, :colorbar_title,
     :marker_z, :fill_z, :levels,
     :ribbon, :quiver,
     :orientation,
@@ -269,7 +269,7 @@ function plotly_layout(plt::Plot)
     w, h = plt[:size]
     d_out[:width], d_out[:height] = w, h
     d_out[:paper_bgcolor] = rgba_string(plt[:background_color_outside])
-    d_out[:margin] = KW(:l=>0, :b=>0, :r=>0, :t=>20)
+    d_out[:margin] = KW(:l=>0, :b=>20, :r=>0, :t=>20)
 
     d_out[:annotations] = KW[]
 
@@ -409,6 +409,10 @@ plotly_surface_data(series::Series, a::AbstractVector) = a
 plotly_surface_data(series::Series, a::AbstractMatrix) = transpose_z(series, a, false)
 plotly_surface_data(series::Series, a::Surface) = plotly_surface_data(series, a.surf)
 
+#ensures that a gradient is called if a single color is supplied where a gradient is needed (e.g. if a series recipe defines marker_z)
+as_gradient(grad::ColorGradient, α) = grad
+as_gradient(grad, α) = cgrad(alpha = α)
+
 # get a dictionary representing the series params (d is the Plots-dict, d_out is the Plotly-dict)
 function plotly_series(plt::Plot, series::Series)
     st = series[:seriestype]
@@ -439,6 +443,8 @@ function plotly_series(plt::Plot, series::Series)
         end
     end
 
+    d_out[:colorbar] = KW(:title => sp[:colorbar_title])
+
     clims = sp[:clims]
     if is_2tuple(clims)
         d_out[:zmin], d_out[:zmax] = clims
@@ -539,9 +545,10 @@ function plotly_series(plt::Plot, series::Series)
             rgba_string(series[:markercolor])
         else
             # grad = ColorGradient(series[:markercolor], alpha=series[:markeralpha])
-            grad = series[:markercolor]
+            grad = as_gradient(series[:markercolor], series[:markeralpha])
             zmin, zmax = extrema(series[:marker_z])
-            [rgba_string(grad[(zi - zmin) / (zmax - zmin)]) for zi in series[:marker_z]]
+            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)
+            [rgba_string(grad[(zi - zmin) / zrange]) for zi in series[:marker_z]]
         end
     end
 

src/backends/pyplot.jl

@@ -85,17 +85,7 @@ function _initialize_backend(::PyPlotBackend)
         const pycollections = PyPlot.pywrap(PyPlot.pyimport("matplotlib.collections"))
         const pyart3d = PyPlot.pywrap(PyPlot.pyimport("mpl_toolkits.mplot3d.art3d"))
     end
-    if is_linux()
-      @eval begin
-        # avoid Conda update that causes Segfault with qt >=4.8.6 on Ubuntu https://github.com/JuliaPy/PyPlot.jl/issues/234
-        import Conda
-        kw = Conda._installed_packages_dict()
-        if (!haskey(kw,"qt") || (qt_version=get(kw,"qt",0)[1]!=v"4.8.5"))
-          print("\n If the code has a Segmentation fault error switch to qt v4.8.5 by pasting the following code into julia: \n \n")
-          print(add_backend_string(PyPlotBackend()))
-        end
-      end
-    end
+
     # we don't want every command to update the figure
     PyPlot.ioff()
 end
@@ -683,6 +673,11 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             end
             z = transpose_z(series, z)
             if st == :surface
+                clims = sp[:clims]
+                if is_2tuple(clims)
+                    isfinite(clims[1]) && (extrakw[:vmin] = clims[1])
+                    isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
+                end
                 if series[:fill_z] != nothing
                     # the surface colors are different than z-value
                     extrakw[:facecolors] = py_shading(series[:fillcolor], transpose_z(series, series[:fill_z].surf))
@@ -1059,7 +1054,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             end
             if sp[:grid]
                 fgcolor = py_color(sp[:foreground_color_grid])
-                pyaxis[:grid](true, color = fgcolor)
+                pyaxis[:grid](true, color = fgcolor, linestyle = ":")
                 ax[:set_axisbelow](true)
             end
             py_set_axis_colors(ax, axis)
@@ -1075,7 +1070,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
         py_add_legend(plt, sp, ax)
 
         # this sets the bg color inside the grid
-        ax[:set_axis_bgcolor](py_color(sp[:background_color_inside]))
+        ax[:set_facecolor](py_color(sp[:background_color_inside]))
     end
     py_drawfig(fig)
 end
@@ -1107,7 +1102,7 @@ function _update_min_padding!(sp::Subplot{PyPlotBackend})
     # optionally add the width of colorbar labels and colorbar to rightpad
     if haskey(sp.attr, :cbar_ax)
         bb = py_bbox(sp.attr[:cbar_handle][:ax][:get_yticklabels]())
-        sp.attr[:cbar_width] = _cbar_width + width(bb) + 1mm + (sp[:colorbar_title] == "" ? 0px : 30px)
+        sp.attr[:cbar_width] = _cbar_width + width(bb) + 2.3mm + (sp[:colorbar_title] == "" ? 0px : 30px)
         rightpad = rightpad + sp.attr[:cbar_width]
     end
 

src/backends/web.jl

@@ -23,7 +23,7 @@ function open_browser_window(filename::AbstractString)
     @static if is_apple()
         return run(`open $(filename)`)
     end
-    @static if is_linux()
+    @static if is_linux() || is_bsd()    # is_bsd() addition is as yet untested, but based on suggestion in https://github.com/JuliaPlots/Plots.jl/issues/681
         return run(`xdg-open $(filename)`)
     end
     @static if is_windows()

src/components.jl

@@ -174,7 +174,7 @@ function center(shape::Shape)
     Cx / 6A, Cy / 6A
 end
 
-function Base.scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
+function scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
     sx, sy = coords(shape)
     cx, cy = c
     for i=1:length(sx)
@@ -184,7 +184,7 @@ function Base.scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
     shape
 end
 
-function Base.scale(shape::Shape, x::Real, y::Real = x, c = center(shape))
+function scale(shape::Shape, x::Real, y::Real = x, c = center(shape))
     shapecopy = deepcopy(shape)
     scale!(shapecopy, x, y, c)
 end
@@ -521,7 +521,7 @@ Base.Array(surf::Surface) = surf.surf
 for f in (:length, :size)
   @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
 end
-Base.copy(surf::Surface) = Surface{typeof(surf.surf)}(copy(surf.surf))
+Base.copy(surf::Surface) = Surface(copy(surf.surf))
 Base.eltype{T}(surf::Surface{T}) = eltype(T)
 
 function expand_extrema!(a::Axis, surf::Surface)

src/examples.jl

@@ -172,6 +172,24 @@ PlotExample("",
     end)]
 ),
 
+PlotExample("Animation with subplots",
+    "The `layout` macro can be used to create an animation with subplots.",
+    [:(begin
+        l = @layout([[a; b] c])
+        p = plot(plot([sin,cos],1,leg=false),
+        scatter([atan,cos],1,leg=false),
+        plot(log,1,xlims=(1,10π),ylims=(0,5),leg=false),layout=l)
+
+        anim = Animation()
+        for x = linspace(1,10π,100)
+          plot(push!(p,x,Float64[sin(x),cos(x),atan(x),cos(x),log(x)]))
+          frame(anim)
+        end
+    end)]
+),
+
+
+
 PlotExample("Open/High/Low/Close",
     "Create an OHLC chart.  Pass in a list of (open,high,low,close) tuples as your `y` argument.  This uses recipes to first convert the tuples to OHLC objects, and subsequently create a :path series with the appropriate line segments.",
     [:(begin

src/output.jl

@@ -318,7 +318,7 @@ function setup_atom()
         # special handling for plotly... use PlotsDisplay
         function Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyBackend})
             display(Plots.PlotsDisplay(), plt)
-            s = "PlotPane turned off.  The plotly and plotlyjs backends cannot render in the PlotPane due to javascript issues."
+            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."
             Media.render(pane, Atom.div(Atom.HTML(s)))
         end
     end

src/pipeline.jl

@@ -277,6 +277,13 @@ function _subplot_setup(plt::Plot, d::KW, kw_list::Vector{KW})
                     attr[Symbol(letter,k)] = v
                 end
             end
+            for k in (:scale,), letter in (:x,:y,:z)
+                # Series recipes may need access to this information
+                lk = Symbol(letter,k)
+                if haskey(attr, lk)
+                    kw[lk] = attr[lk]
+                end
+            end
         end
         sp_attrs[sp] = attr
     end
@@ -357,7 +364,7 @@ function _expand_subplot_extrema(sp::Subplot, d::KW, st::Symbol)
         expand_extrema!(sp[:xaxis], (0,w))
         expand_extrema!(sp[:yaxis], (0,h))
         sp[:yaxis].d[:flip] = true
-    elseif !(st in (:pie, :histogram, :histogram2d))
+    elseif !(st in (:pie, :histogram, :bins2d, :histogram2d))
         expand_extrema!(sp, d)
     end
 end

src/recipes.jl

@@ -323,10 +323,11 @@ end
 
 # create a bar plot as a filled step function
 @recipe function f(::Type{Val{:bar}}, x, y, z)
-    nx, ny = length(x), length(y)
+    procx, procy, xscale, yscale, baseline, wautolims = _preprocess_barlike(d, x, y)
+    nx, ny = length(procx), length(procy)
     axis = d[:subplot][isvertical(d) ? :xaxis : :yaxis]
-    cv = [discrete_value!(axis, xi)[1] for xi=x]
-    x = if nx == ny
+    cv = [discrete_value!(axis, xi)[1] for xi=procx]
+    procx = if nx == ny
         cv
     elseif nx == ny + 1
         0.5diff(cv) + cv[1:end-1]
@@ -337,9 +338,9 @@ end
     # compute half-width of bars
     bw = d[:bar_width]
     hw = if bw == nothing
-        0.5mean(diff(x))
+        0.5mean(diff(procx))
     else
-        Float64[0.5cycle(bw,i) for i=1:length(x)]
+        Float64[0.5cycle(bw,i) for i=1:length(procx)]
     end
 
     # make fillto a vector... default fills to 0
@@ -347,16 +348,21 @@ end
     if fillto == nothing
         fillto = 0
     end
+    if (yscale in _logScales) && !all(_is_positive, fillto)
+        fillto = map(x -> _is_positive(x) ? typeof(baseline)(x) : baseline, fillto)
+    end
 
     # create the bar shapes by adding x/y segments
     xseg, yseg = Segments(), Segments()
     for i=1:ny
-        center = x[i]
-        hwi = cycle(hw,i)
-        yi = y[i]
-        fi = cycle(fillto,i)
-        push!(xseg, center-hwi, center-hwi, center+hwi, center+hwi, center-hwi)
-        push!(yseg, yi, fi, fi, yi, yi)
+        yi = procy[i]
+        if !isnan(yi)
+            center = procx[i]
+            hwi = cycle(hw,i)
+            fi = cycle(fillto,i)
+            push!(xseg, center-hwi, center-hwi, center+hwi, center+hwi, center-hwi)
+            push!(yseg, yi, fi, fi, yi, yi)
+        end
     end
 
     # widen limits out a bit
@@ -374,6 +380,7 @@ end
     x := xseg.pts
     y := yseg.pts
     seriestype := :shape
+    ylims --> wautolims
     ()
 end
 @deps bar shape
@@ -384,9 +391,76 @@ end
 
 _bin_centers(v::AVec) = (v[1:end-1] + v[2:end]) / 2
 
+_is_positive(x) = (x > 0) && !(x ≈ 0)
+
+_positive_else_nan{T}(::Type{T}, x::Real) = _is_positive(x) ? T(x) : T(NaN)
+
+function _scale_adjusted_values{T<:AbstractFloat}(::Type{T}, V::AbstractVector, scale::Symbol)
+    if scale in _logScales
+        [_positive_else_nan(T, x) for x in V]
+    else
+        [T(x) for x in V]
+    end
+end
+
+
+function _binbarlike_baseline{T<:Real}(min_value::T, scale::Symbol)
+    if (scale in _logScales)
+        !isnan(min_value) ? min_value / T(_logScaleBases[scale]^log10(2)) : T(1E-3)
+    else
+        zero(T)
+    end
+end
+
+function _binbarlike_autolims{T<:Real}(min_value::T, max_value::T, scale::Symbol)
+    lo = if (scale in _logScales)
+        _binbarlike_baseline(min_value, scale)
+    else
+        min(min_value * T(1.1), zero(T))
+    end::T
+
+    hi = if !isnan(max_value)
+        if (scale in _logScales)
+            max_value * T(_logScaleBases[scale]^log10(2))
+        else
+            max(max_value * T(1.1), zero(T))
+        end
+    else
+        one(T)
+    end::T
+
+    (lo, hi)
+end
+
+
+function _preprocess_binbarlike_weights{T<:AbstractFloat}(::Type{T}, w, wscale::Symbol)
+    w_adj = _scale_adjusted_values(T, w, wscale)
+    w_min = minimum(w_adj)
+    w_max = maximum(w_adj)
+    baseline = _binbarlike_baseline(w_min, wscale)
+    autolims = _binbarlike_autolims(w_min, w_max,wscale)
+    w_adj, baseline, autolims
+end
+
+function _preprocess_barlike(d, x, y)
+    xscale = get(d, :xscale, :identity)
+    yscale = get(d, :yscale, :identity)
+    weights, baseline, wautolims = _preprocess_binbarlike_weights(float(eltype(y)), y, yscale)
+    x, weights, xscale, yscale, baseline, wautolims
+end
+
+function _preprocess_binlike(d, x, y)
+    xscale = get(d, :xscale, :identity)
+    yscale = get(d, :yscale, :identity)
+    T = float(promote_type(eltype(x), eltype(y)))
+    edge = T.(x)
+    weights, baseline, wautolims = _preprocess_binbarlike_weights(T, y, yscale)
+    edge, weights, xscale, yscale, baseline, wautolims
+end
+
 
 @recipe function f(::Type{Val{:barbins}}, x, y, z)
-    edge, weights = x, y
+    edge, weights, xscale, yscale, baseline, wautolims = _preprocess_binlike(d, x, y)
     if (d[:bar_width] == nothing)
         bar_width := diff(edge)
     end
@@ -395,11 +469,11 @@ _bin_centers(v::AVec) = (v[1:end-1] + v[2:end]) / 2
     seriestype := :bar
     ()
 end
-@deps barbins bins
+@deps barbins bar
 
 
 @recipe function f(::Type{Val{:scatterbins}}, x, y, z)
-    edge, weights = x, y
+    edge, weights, xscale, yscale, baseline, wautolims = _preprocess_binlike(d, x, y)
     xerror := diff(edge)/2
     x := _bin_centers(edge)
     y := weights
@@ -409,43 +483,65 @@ end
 @deps scatterbins scatter
 
 
-function _stepbins_path(edge, weights)
+function _stepbins_path(edge, weights, baseline::Real, xscale::Symbol, yscale::Symbol)
+    log_scale_x = xscale in _logScales
+    log_scale_y = yscale in _logScales
+
     nbins = length(linearindices(weights))
     if length(linearindices(edge)) != nbins + 1
         error("Edge vector must be 1 longer than weight vector")
     end
 
+    x = eltype(edge)[]
+    y = eltype(weights)[]
+
     it_e, it_w = start(edge), start(weights)
-    px, it_e = next(edge, it_e)
-    py = zero(eltype(weights))
+    a, it_e = next(edge, it_e)
+    last_w = eltype(weights)(NaN)
+    i = 1
+    while (!done(edge, it_e) && !done(edge, it_e))
+        b, it_e = next(edge, it_e)
+        w, it_w = next(weights, it_w)
 
-    npathpts = 2 * nbins + 2
-    x = Vector{eltype(px)}(npathpts)
-    y = Vector{eltype(py)}(npathpts)
+        if (log_scale_x && a ≈ 0)
+            a = b/_logScaleBases[xscale]^3
+        end
 
-    x[1], y[1] = px, py
-    i = 2
-    while (i < npathpts - 1)
-        py, it_w = next(weights, it_w)
-        x[i], y[i] = px, py
-        i += 1
-        px, it_e = next(edge, it_e)
-        x[i], y[i] = px, py
-        i += 1
+        if isnan(w)
+            if !isnan(last_w)
+                push!(x, a)
+                push!(y, baseline)
+            end
+        else
+            if isnan(last_w)
+                push!(x, a)
+                push!(y, baseline)
+            end
+            push!(x, a)
+            push!(y, w)
+            push!(x, b)
+            push!(y, w)
+        end
+
+        a = b
+        last_w = w
+    end
+    if (last_w != baseline)
+        push!(x, a)
+        push!(y, baseline)
     end
-    assert(i == npathpts)
-    x[end], y[end] = px, zero(py)
 
     (x, y)
 end
 
-@recipe function f(::Type{Val{:stepbins}}, x, y, z)
-    edge, weights = x, y
 
+@recipe function f(::Type{Val{:stepbins}}, x, y, z)
     axis = d[:subplot][Plots.isvertical(d) ? :xaxis : :yaxis]
 
-    xpts, ypts = _stepbins_path(edge, weights)
-    if !Plots.isvertical(d)
+    edge, weights, xscale, yscale, baseline, wautolims = _preprocess_binlike(d, x, y)
+
+    xpts, ypts = _stepbins_path(edge, weights, baseline, xscale, yscale)
+    if !isvertical(d)
         xpts, ypts = ypts, xpts
     end
 
@@ -453,7 +549,7 @@ end
     if d[:markershape] != :none
         @series begin
             seriestype := :scatter
-            x := Plots._bin_centers(edge)
+            x := _bin_centers(edge)
             y := weights
             fillrange := nothing
             label := ""
@@ -468,7 +564,8 @@ end
     x := xpts
     y := ypts
     seriestype := :path
-    ylims --> [0, 1.1 * maximum(weights)]
+
+    ylims --> wautolims
     ()
 end
 Plots.@deps stepbins path
@@ -485,9 +582,11 @@ function _auto_binning_nbins{N}(vs::NTuple{N,AbstractVector}, dim::Integer; mode
 
     v = vs[dim]
 
-    if mode == :sqrt  # Square-root choice
+    if mode == :auto
+        30
+    elseif mode == :sqrt  # Square-root choice
         _cl(sqrt(n))
-    elseif mode == :sturges || mode ==:auto  # Sturges' formula
+    elseif mode == :sturges  # Sturges' formula
         _cl(log2(n)) + 1
     elseif mode == :rice  # Rice Rule
         _cl(2 * n^(1/3))
@@ -497,7 +596,7 @@ function _auto_binning_nbins{N}(vs::NTuple{N,AbstractVector}, dim::Integer; mode
         _cl(_span(v) / (2 * _iqr(v) / n^(1/3)))
     else
         error("Unknown auto-binning mode $mode")
-    end
+    end::Int
 end
 
 _hist_edge{N}(vs::NTuple{N,AbstractVector}, dim::Integer, binning::Integer) = StatsBase.histrange(vs[dim], binning, :left)
@@ -511,13 +610,14 @@ _hist_edges{N}(vs::NTuple{N,AbstractVector}, binning::Union{Integer, Symbol, Abs
     map(dim -> _hist_edge(vs, dim, binning), (1:N...))
 
 _hist_norm_mode(mode::Symbol) = mode
-_hist_norm_mode(mode::Bool) = mode ? :norm : :none
+_hist_norm_mode(mode::Bool) = mode ? :pdf : :none
 
 function _make_hist{N}(vs::NTuple{N,AbstractVector}, binning; normed = false, weights = nothing)
+    info("binning = $binning")
     edges = _hist_edges(vs, binning)
     h = float( weights == nothing ?
-        StatsBase.fit(StatsBase.Histogram, vs, edges) :
-        StatsBase.fit(StatsBase.Histogram, vs, weights, edges)
+        StatsBase.fit(StatsBase.Histogram, vs, edges, closed = :left) :
+        StatsBase.fit(StatsBase.Histogram, vs, weights, edges, closed = :left)
     )
     normalize!(h, mode = _hist_norm_mode(normed))
 end
@@ -568,9 +668,10 @@ end
 
     if d[:seriestype] == :scatterbins
         # Workaround, error bars currently not set correctly by scatterbins
+        edge, weights, xscale, yscale, baseline, wautolims = _preprocess_binlike(d, h.edges[1], h.weights)
         xerror --> diff(h.edges[1])/2
         seriestype := :scatter
-        (Plots._bin_centers(h.edges[1]), h.weights)
+        (Plots._bin_centers(edge), weights)
     else
         (h.edges[1], h.weights)
     end
@@ -939,16 +1040,70 @@ abline!(args...; kw...) = abline!(current(), args...; kw...)
 # -------------------------------------------------
 # Dates
 
-@recipe f(::Type{Date}, dt::Date) = (dt -> convert(Int,dt), dt -> string(convert(Date,dt)))
-@recipe f(::Type{DateTime}, dt::DateTime) = (dt -> convert(Int,dt), dt -> string(convert(DateTime,dt)))
+dateformatter(dt) = string(convert(Date, dt))
+datetimeformatter(dt) = string(convert(DateTime, dt))
+
+@recipe f(::Type{Date}, dt::Date) = (dt -> convert(Int, dt), dateformatter)
+@recipe f(::Type{DateTime}, dt::DateTime) = (dt -> convert(Int, dt), datetimeformatter)
 
 # -------------------------------------------------
 # Complex Numbers
 
-@userplot ComplexPlot
-@recipe function f(cp::ComplexPlot)
-    xguide --> "Real Part"
-    yguide --> "Imaginary Part"
-    seriestype --> :scatter
-    real(cp.args[1]), imag(cp.args[1])
+@recipe function f{T<:Number}(A::Array{Complex{T}})
+    xguide --> "Re(x)"
+    yguide --> "Im(x)"
+    real.(A), imag.(A)
+end
+
+# Splits a complex matrix to its real and complex parts
+# Reals defaults solid, imaginary defaults dashed
+# Label defaults are changed to match the real-imaginary reference / indexing
+@recipe function f{T<:Real,T2}(x::AbstractArray{T},y::Array{Complex{T2}})
+  ylabel --> "Re(y)"
+  zlabel --> "Im(y)"
+  x,real.(y),imag.(y)
+end
+
+
+# --------------------------------------------------
+# Color Gradients
+
+@userplot ShowLibrary
+@recipe function f(cl::ShowLibrary)
+    if !(length(cl.args) == 1 && isa(cl.args[1], Symbol))
+        error("showlibrary takes the name of a color library as a Symbol")
+    end
+
+    library = PlotUtils.color_libraries[cl.args[1]]
+    z = sqrt.((1:15)*(1:20)')
+
+    seriestype := :heatmap
+    ticks := nothing
+    legend := false
+
+    layout --> length(library.lib)
+
+    i = 0
+    for grad in sort(collect(keys(library.lib)))
+        @series begin
+            seriescolor := cgrad(grad, cl.args[1])
+            title := string(grad)
+            subplot := i += 1
+            z
+        end
+    end
+end
+
+@userplot ShowGradient
+@recipe function f(grad::ShowGradient)
+    if !(length(grad.args) == 1 && isa(grad.args[1], Symbol))
+        error("showgradient takes the name of a color gradient as a Symbol")
+    end
+    z = sqrt.((1:15)*(1:20)')
+    seriestype := :heatmap
+    ticks := nothing
+    legend := false
+    seriescolor := grad.args[1]
+    title := string(grad.args[1])
+    z
 end

src/subplots.jl

@@ -39,7 +39,7 @@ series_list(sp::Subplot) = sp.series_list # filter(series -> series.d[:subplot]
 function should_add_to_legend(series::Series)
     series.d[:primary] && series.d[:label] != "" &&
         !(series.d[:seriestype] in (
-            :hexbin,:histogram2d,:hline,:vline,
+            :hexbin,:bins2d,:histogram2d,:hline,:vline,
             :contour,:contourf,:contour3d,:surface,:wireframe,
             :heatmap, :pie, :image
         ))

src/themes.jl

@@ -2,7 +2,8 @@
 function theme(s::Symbol; kw...)
     # reset?
     if s == :none || s == :default
-        PlotUtils._default_gradient[] = :inferno
+        PlotUtils.clibrary(:Plots)
+        PlotUtils.default_cgrad(default = :sequential, sequential = :inferno)
         default(;
             bg        = :white,
             bglegend  = :match,
@@ -23,7 +24,8 @@ function theme(s::Symbol; kw...)
     # update the default gradient and other defaults
     thm = PlotThemes._themes[s]
     if thm.gradient != nothing
-        PlotUtils._default_gradient[] = PlotThemes.gradient_name(s)
+        PlotUtils.clibrary(:misc)
+        PlotUtils.default_cgrad(default = :sequential, sequential = PlotThemes.gradient_name(s))
     end
     default(;
         bg       = thm.bg_secondary,

test/imgcomp.jl

@@ -24,7 +24,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.9.6"
+const _current_plots_version = v"0.11.1"
 
 
 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)