Merge pull request #2102 from daschw/release

release

NEWS.md

@@ -11,6 +11,32 @@
 ---
 ## (current master)
 
+## 0.26.0
+- use FFMPEG.jl
+- add missing method for convertToAnyVector
+
+## 0.25.3
+- add areaplot
+- allow missing in z_color arguments
+- more general tuple recipe
+- stephist logscale improvements
+
+## 0.25.2
+- improvements to handle missings
+- pyplot: allow setting the color gradient for z values
+- document :colorbar_entry
+- limit number of automatic bins
+- fix ENV['PLOTS_DEFAULT_BACKEND']
+- don't let aspect_ratio impact subplot size
+- implement arrowstyle for GR
+- fix bug in plotly_convert_to_datetime
+- improve missing support
+- gr: polar heatmaps
+- make sure show returns nothing
+
+## 0.25.1
+- fix gr_display
+
 ## 0.25.0
 - Replace StaticArrays with GeometryTypes
 - Contour fixes for GR

Project.toml

@@ -1,12 +1,13 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "0.25.0"
+version = "0.26.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 Contour = "d38c429a-6771-53c6-b99e-75d170b6e991"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+FFMPEG = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
 FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
 GR = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
 GeometryTypes = "4d00f742-c7ba-57c2-abde-4428a4b178cb"

README.md

@@ -11,7 +11,7 @@
 
 #### Created by Tom Breloff (@tbreloff)
 
-#### Maintained by the [JuliaPlot members](https://github.com/orgs/JuliaPlots/people)
+#### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)
 
 Plots is a plotting API and toolset.  My goals with the package are:
 

src/Plots.jl

@@ -8,6 +8,8 @@ import GeometryTypes
 using Dates, Printf, Statistics, Base64, LinearAlgebra, Random
 import SparseArrays: findnz
 
+using FFMPEG
+
 @reexport using RecipesBase
 import RecipesBase: plot, plot!, animate
 using Base.Meta

src/animation.jl

@@ -76,15 +76,15 @@ function buildanimation(animdir::AbstractString, fn::AbstractString,
         if variable_palette
             # generate a colorpalette for each frame for highest quality, but larger filesize
             palette="palettegen=stats_mode=single[pal],[0:v][pal]paletteuse=new=1"
-            run(`ffmpeg -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -lavfi "$palette" -y $fn`)
+            ffmpeg_exe(`-v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -lavfi "$palette" -y $fn`)
         else
             # generate a colorpalette first so ffmpeg does not have to guess it
-            run(`ffmpeg -v 0 -i $(animdir)/%06d.png -vf "palettegen=stats_mode=diff" -y "$(animdir)/palette.bmp"`)
+            ffmpeg_exe(`-v 0 -i $(animdir)/%06d.png -vf "palettegen=stats_mode=diff" -y "$(animdir)/palette.bmp"`)
             # then apply the palette to get better results
-            run(`ffmpeg -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -y $fn`)
+            ffmpeg_exe(` -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -y $fn`)
         end
     else
-        run(`ffmpeg -v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -pix_fmt yuv420p -y $fn`)
+        ffmpeg_exe(`-v 0 -framerate $fps -loop $loop -i $(animdir)/%06d.png -pix_fmt yuv420p -y $fn`)
     end
 
     show_msg && @info("Saved animation to ", fn)
@@ -103,6 +103,7 @@ function Base.show(io::IO, ::MIME"text/html", agif::AnimatedGif)
     else
         error("Cannot show animation with extension $ext: $agif")
     end)
+    return nothing
 end
 
 

src/arg_desc.jl

@@ -49,7 +49,8 @@ const _arg_desc = KW(
 :series_annotations     => "AbstractVector of String or PlotText.  These are annotations which are mapped to data points/positions.",
 :primary                => "Bool.  Does this count as a 'real series'?  For example, you could have a path (primary), and a scatter (secondary) as 2 separate series, maybe with different data (see sticks recipe for an example).  The secondary series will get the same color, etc as the primary.",
 :hover 	        	=> "nothing or vector of strings. Text to display when hovering over each data point.",
-
+:colorbar_entry   => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",
+  
 # plot args
 :plot_title               => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
 :background_color         => "Color Type.  Base color for all backgrounds.",

src/args.jl

@@ -1030,7 +1030,7 @@ function preprocessArgs!(plotattributes::KW)
             arrow()
         elseif a in (false, nothing, :none)
             nothing
-        elseif !(typeof(a) <: Arrow)
+        elseif !(typeof(a) <: Arrow || typeof(a) <: AbstractArray{Arrow})
             arrow(wraptuple(a)...)
         else
             a

src/axes.jl

@@ -152,8 +152,8 @@ scalefunc(scale::Symbol) = x -> get(_scale_funcs, scale, identity)(Float64(x))
 invscalefunc(scale::Symbol) = x -> get(_inv_scale_funcs, scale, identity)(Float64(x))
 labelfunc(scale::Symbol, backend::AbstractBackend) = get(_label_func, scale, string)
 
-function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
-    amin,amax = axis_limits(axis)
+function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
+    amin, amax = axis_limits(sp, axis[:letter])
 
     # scale the limits
     scale = axis[:scale]
@@ -238,7 +238,7 @@ function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
 end
 
 # return (continuous_values, discrete_values) for the ticks on this axis
-function get_ticks(axis::Axis)
+function get_ticks(sp::Subplot, axis::Axis)
     ticks = _transform_ticks(axis[:ticks])
     ticks in (:none, nothing, false) && return nothing
 
@@ -261,7 +261,7 @@ function get_ticks(axis::Axis)
             (collect(0:pi/4:7pi/4), string.(0:45:315))
         else
             # compute optimal ticks and labels
-            optimal_ticks_and_labels(axis)
+            optimal_ticks_and_labels(sp, axis)
         end
     elseif typeof(ticks) <: Union{AVec, Int}
         if !isempty(dvals) && typeof(ticks) <: Int
@@ -269,7 +269,7 @@ function get_ticks(axis::Axis)
             axis[:continuous_values][rng], dvals[rng]
         else
             # override ticks, but get the labels
-            optimal_ticks_and_labels(axis, ticks)
+            optimal_ticks_and_labels(sp, axis, ticks)
         end
     elseif typeof(ticks) <: NTuple{2, Any}
         # assuming we're passed (ticks, labels)
@@ -286,12 +286,12 @@ _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)
+function get_minor_ticks(sp, axis, ticks)
     axis[:minorticks] in (:none, nothing, false) && !axis[:minorgrid] && return nothing
     ticks = ticks[1]
     length(ticks) < 2 && return nothing
 
-    amin, amax = axis_limits(axis)
+    amin, amax = axis_limits(sp, axis[:letter])
     #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])
@@ -479,11 +479,13 @@ function round_limits(amin,amax)
 end
 
 # using the axis extrema and limit overrides, return the min/max value for this axis
-function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis))
+function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(letter, :axis)]), consider_aspect = true)
+    axis = sp[Symbol(letter, :axis)]
     ex = axis[:extrema]
     amin, amax = ex.emin, ex.emax
     lims = axis[:lims]
-    if (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
+    has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
+    if has_user_lims
         if isfinite(lims[1])
             amin = lims[1]
         end
@@ -497,7 +499,7 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
     if !isfinite(amin) && !isfinite(amax)
         amin, amax = 0.0, 1.0
     end
-    if ispolar(axis.sps[1])
+    amin, amax = if ispolar(axis.sps[1])
         if axis[:letter] == :x
             amin, amax = 0, 2pi
         elseif lims == :auto
@@ -513,6 +515,32 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
     else
         amin, amax
     end
+
+    if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || is3d(:sp))
+        aspect_ratio = isa(sp[:aspect_ratio], Number) ? sp[:aspect_ratio] : 1
+        plot_ratio = height(plotarea(sp)) / width(plotarea(sp))
+        dist = amax - amin
+
+        if letter == :x
+            yamin, yamax = axis_limits(sp, :y, default_should_widen(sp[:yaxis]), false)
+            ydist = yamax - yamin
+            axis_ratio = aspect_ratio * ydist / dist
+            factor = axis_ratio / plot_ratio
+        else
+            xamin, xamax = axis_limits(sp, :x, default_should_widen(sp[:xaxis]), false)
+            xdist = xamax - xamin
+            axis_ratio = aspect_ratio * dist / xdist
+            factor = plot_ratio / axis_ratio
+        end
+
+        if factor > 1
+            center = (amin + amax) / 2
+            amin = center + factor * (amin - center)
+            amax = center + factor * (amax - center)
+        end
+    end
+
+    return amin, amax
 end
 
 # -------------------------------------------------------------------------
@@ -586,12 +614,12 @@ end
 # compute the line segments which should be drawn for this axis
 function axis_drawing_info(sp::Subplot)
     xaxis, yaxis = sp[:xaxis], sp[:yaxis]
-    xmin, xmax = axis_limits(xaxis)
-    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)
+    xmin, xmax = axis_limits(sp, :x)
+    ymin, ymax = axis_limits(sp, :y)
+    xticks = get_ticks(sp, xaxis)
+    yticks = get_ticks(sp, yaxis)
+    xminorticks = get_minor_ticks(sp, xaxis, xticks)
+    yminorticks = get_minor_ticks(sp, yaxis, yticks)
     xaxis_segs = Segments(2)
     yaxis_segs = Segments(2)
     xtick_segs = Segments(2)

src/backends.jl

@@ -75,8 +75,8 @@ end
 text_size(lab::AbstractString, sz::Number, rot::Number = 0) = text_size(length(lab), sz, rot)
 
 # account for the size/length/rotation of tick labels
-function tick_padding(axis::Axis)
-    ticks = get_ticks(axis)
+function tick_padding(sp::Subplot, axis::Axis)
+    ticks = get_ticks(sp, axis)
     if ticks == nothing
         0mm
     else
@@ -106,10 +106,10 @@ end
 # to fit ticks, tick labels, guides, colorbars, etc.
 function _update_min_padding!(sp::Subplot)
     # TODO: something different when `is3d(sp) == true`
-    leftpad   = tick_padding(sp[:yaxis]) + sp[:left_margin]   + guide_padding(sp[:yaxis])
+    leftpad   = tick_padding(sp, sp[:yaxis]) + sp[:left_margin]   + guide_padding(sp[:yaxis])
     toppad    = sp[:top_margin]    + title_padding(sp)
     rightpad  = sp[:right_margin]
-    bottompad = tick_padding(sp[:xaxis]) + sp[:bottom_margin] + guide_padding(sp[:xaxis])
+    bottompad = tick_padding(sp, sp[:xaxis]) + sp[:bottom_margin] + guide_padding(sp[:xaxis])
 
     # switch them?
     if sp[:xaxis][:mirror]
@@ -143,12 +143,7 @@ function _pick_default_backend()
     if env_default != ""
         sym = Symbol(lowercase(env_default))
         if sym in _backends
-            if sym in _initialized_backends
-                backend(sym)
-            else
-                @warn("You have set `PLOTS_DEFAULT_BACKEND=$env_default` but `$(backend_package_name(sym))` is not loaded.")
-                _fallback_default_backend()
-            end
+            backend(sym)
         else
             @warn("You have set PLOTS_DEFAULT_BACKEND=$env_default but it is not a valid backend package.  Choose from:\n\t" *
                  join(sort(_backends), "\n\t"))

src/backends/gr.jl

@@ -84,12 +84,23 @@ gr_set_transparency(c, α) = gr_set_transparency(α)
 gr_set_transparency(c::Colorant, ::Nothing) = gr_set_transparency(c)
 gr_set_transparency(c::Colorant) = GR.settransparency(alpha(c))
 
+const _gr_arrow_map = Dict(
+    :simple => 1,
+    :hollow => 3,
+    :filled => 4,
+    :triangle => 5,
+    :filledtriangle => 6,
+    :closed => 6,
+    :open => 5,
+)
+gr_set_arrowstyle(s::Symbol) = GR.setarrowstyle(get(_gr_arrow_map, s, 1))
+
 # --------------------------------------------------------------------------------------
 
 
 # draw line segments, splitting x/y into contiguous/finite segments
 # note: this can be used for shapes by passing func `GR.fillarea`
-function gr_polyline(x, y, func = GR.polyline; arrowside=:none)
+function gr_polyline(x, y, func = GR.polyline; arrowside = :none, arrowstyle = :simple)
     iend = 0
     n = length(x)
     while iend < n-1
@@ -118,9 +129,11 @@ function gr_polyline(x, y, func = GR.polyline; arrowside=:none)
         if istart > 0 && iend > 0
             func(x[istart:iend], y[istart:iend])
             if arrowside in (:head,:both)
+                gr_set_arrowstyle(arrowstyle)
                 GR.drawarrow(x[iend-1], y[iend-1], x[iend], y[iend])
             end
             if arrowside in (:tail,:both)
+                gr_set_arrowstyle(arrowstyle)
                 GR.drawarrow(x[istart+1], y[istart+1], x[istart], y[istart])
             end
         else
@@ -162,7 +175,7 @@ function gr_polaraxes(rmin::Real, rmax::Real, sp::Subplot)
     a = α .+ 90
     sinf = sind.(a)
     cosf = cosd.(a)
-    rtick_values, rtick_labels = get_ticks(yaxis)
+    rtick_values, rtick_labels = get_ticks(sp, yaxis)
     if yaxis[:formatter] in (:scientific, :auto) && yaxis[:ticks] in (:auto, :native)
         rtick_labels = convert_sci_unicode.(rtick_labels)
     end
@@ -218,16 +231,16 @@ end
 
 
 # using the axis extrema and limit overrides, return the min/max value for this axis
-gr_x_axislims(sp::Subplot) = axis_limits(sp[:xaxis])
-gr_y_axislims(sp::Subplot) = axis_limits(sp[:yaxis])
-gr_z_axislims(sp::Subplot) = axis_limits(sp[:zaxis])
+gr_x_axislims(sp::Subplot) = axis_limits(sp, :x)
+gr_y_axislims(sp::Subplot) = axis_limits(sp, :y)
+gr_z_axislims(sp::Subplot) = axis_limits(sp, :z)
 gr_xy_axislims(sp::Subplot) = gr_x_axislims(sp)..., gr_y_axislims(sp)...
 
-function gr_lims(axis::Axis, adjust::Bool, expand = nothing)
+function gr_lims(sp::Subplot, axis::Axis, adjust::Bool, expand = nothing)
     if expand != nothing
         expand_extrema!(axis, expand)
     end
-    lims = axis_limits(axis)
+    lims = axis_limits(sp, axis[:letter])
     if adjust
         GR.adjustrange(lims...)
     else
@@ -421,23 +434,20 @@ function gr_set_viewport_polar()
 end
 
 struct GRColorbar
-    gradient::Ref{Union{Series,Nothing}}
-    fill::Ref{Union{Series,Nothing}}
-    lines::Ref{Union{Series,Nothing}}
-    GRColorbar() = new(nothing,nothing,nothing)
+    gradients
+    fills
+    lines
+    GRColorbar() = new([],[],[])
 end
 
 function gr_update_colorbar!(cbar::GRColorbar, series::Series)
     style = colorbar_style(series)
     style === nothing && return
-    ref = style == cbar_gradient ? cbar.gradient :
-          style == cbar_fill ? cbar.fill :
+    list = style == cbar_gradient ? cbar.gradients :
+          style == cbar_fill ? cbar.fills :
           style == cbar_lines ? cbar.lines :
           error("Unknown colorbar style: $style.")
-    if ref[] !== nothing
-        @warn "Overwriting colorbar entry"
-    end
-    ref[] = series
+    push!(list, series)
 end
 
 function gr_contour_levels(series::Series, clims)
@@ -466,6 +476,16 @@ function gr_colorbar_colors(series::Series, clims)
     round.(Int,colors)
 end
 
+
+function _cbar_unique(values, propname)
+    out = last(values)
+    if any(x != out for x in values)
+        @warn "Multiple series with different $propname share a colorbar. " *
+              "Colorbar may not refelct all series correctly."
+    end
+    out
+end
+
 # add the colorbar
 function gr_draw_colorbar(cbar::GRColorbar, sp::Subplot, clims)
     GR.savestate()
@@ -474,16 +494,19 @@ function gr_draw_colorbar(cbar::GRColorbar, sp::Subplot, clims)
     gr_set_viewport_cmap(sp)
     GR.setscale(0)
     GR.setwindow(xmin, xmax, zmin, zmax)
-    if (series = cbar.gradient[]) !== nothing
-        gr_set_gradient(series)
-        gr_set_transparency(get_fillalpha(series))
+    if !isempty(cbar.gradients)
+        series = cbar.gradients
+        gr_set_gradient(_cbar_unique(gr_get_color.(series),"color"))
+        gr_set_transparency(_cbar_unique(get_fillalpha.(series), "fill alpha"))
         GR.cellarray(xmin, xmax, zmax, zmin, 1, 256, 1000:1255)
     end
 
-    if (series = cbar.fill[]) !== nothing
-        gr_set_gradient(series)
+    if !isempty(cbar.fills)
+        series = cbar.fills
         GR.setfillintstyle(GR.INTSTYLE_SOLID)
-        levels = contour_levels(series, clims)
+        gr_set_gradient(_cbar_unique(gr_get_color.(series), "color"))
+        gr_set_transparency(_cbar_unique(get_fillalpha.(series), "fill alpha"))
+        levels = _cbar_unique(contour_levels.(series, Ref(clims)), "levels")
         # GR implicitly uses the maximal z value as the highest level
         if levels[end] < clims[2]
             @warn("GR: highest contour level less than maximal z value is not supported.")
@@ -491,20 +514,22 @@ function gr_draw_colorbar(cbar::GRColorbar, sp::Subplot, clims)
             # promotion in case levels is an integer array
             levels = [levels[1:end-1]; clims[2]]
         end
-        colors = gr_colorbar_colors(series, clims)
+        colors = gr_colorbar_colors(last(series), clims)
         for (from, to, color) in zip(levels[1:end-1], levels[2:end], colors)
             GR.setfillcolorind(color)
-            gr_set_transparency(get_fillalpha(series))
             GR.fillrect( xmin, xmax, from, to )
         end
     end
 
-    if (series = cbar.lines[]) !== nothing
-        gr_set_gradient(series)
-        gr_set_line(get_linewidth(series), get_linestyle(series), get_linecolor(series, clims))
-        gr_set_transparency(get_linealpha(series))
-        levels = contour_levels(series, clims)
-        colors = gr_colorbar_colors(series, clims)
+    if !isempty(cbar.lines)
+        series = cbar.lines
+        gr_set_gradient(_cbar_unique(gr_get_color.(series),"color"))
+        gr_set_line(_cbar_unique(get_linewidth.(series), "line width"),
+                    _cbar_unique(get_linestyle.(series), "line style"),
+                    _cbar_unique(get_linecolor.(series, Ref(clims)), "line color"))
+        gr_set_transparency(_cbar_unique(get_linealpha.(series), "line alpha"))
+        levels = _cbar_unique(contour_levels.(series, Ref(clims)), "levels")
+        colors = gr_colorbar_colors(last(series), clims)
         for (line, color) in zip(levels, colors)
             GR.setlinecolorind(color)
             GR.polyline([xmin,xmax], [line,line] )
@@ -594,17 +619,22 @@ function gr_set_gradient(c)
 end
 
 function gr_set_gradient(series::Series)
+    color = gr_get_color(series)
+    color !== nothing && gr_set_gradient(color)
+end
+
+function gr_get_color(series::Series)
     st = series[:seriestype]
     if st in (:surface, :heatmap) || isfilledcontour(series)
-        gr_set_gradient(series[:fillcolor])
+        series[:fillcolor]
     elseif st in (:contour, :wireframe)
-        gr_set_gradient(series[:linecolor])
+        series[:linecolor]
     elseif series[:marker_z] != nothing
-        gr_set_gradient(series[:markercolor])
+        series[:markercolor]
     elseif series[:line_z] !=  nothing
-        gr_set_gradient(series[:linecolor])
+        series[:linecolor]
     elseif series[:fill_z] != nothing
-        gr_set_gradient(series[:fillcolor])
+        series[:fillcolor]
     end
 end
 
@@ -860,7 +890,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             legendn += 1
             if typeof(series[:label]) <: Array
                 legendi += 1
-                lab = series[:label][i]
+                lab = series[:label][legendi]
             else
                 lab = series[:label]
             end
@@ -972,7 +1002,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     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)
+        zmin, zmax = gr_lims(sp, zaxis, true)
         clims3d = sp[:clims]
         if is_2tuple(clims3d)
             isfinite(clims3d[1]) && (zmin = clims3d[1])
@@ -1007,7 +1037,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     elseif ispolar(sp)
         r = gr_set_viewport_polar()
         #rmin, rmax = GR.adjustrange(ignorenan_minimum(r), ignorenan_maximum(r))
-        rmin, rmax = axis_limits(sp[:yaxis])
+        rmin, rmax = axis_limits(sp, :y)
         gr_polaraxes(rmin, rmax, sp)
 
     elseif draw_axes
@@ -1250,9 +1280,11 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                     for (i, rng) in enumerate(segments)
                         lc = get_linecolor(series, clims, i)
                         gr_set_line(get_linewidth(series, i), get_linestyle(series, i), lc) #, series[:linealpha])
-                        gr_set_transparency(lc, get_linealpha(series, i))
                         arrowside = isa(series[:arrow], Arrow) ? series[:arrow].side : :none
-                        gr_polyline(x[rng], y[rng]; arrowside = arrowside)
+                        arrowstyle = isa(series[:arrow], Arrow) ? series[:arrow].style : :simple
+                        gr_set_fillcolor(lc)
+                        gr_set_transparency(lc, get_linealpha(series, i))
+                        gr_polyline(x[rng], y[rng]; arrowside = arrowside, arrowstyle = arrowstyle)
                     end
                 end
             end
@@ -1301,21 +1333,29 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             dmin, dmax = GR.gr3.volume(y.v, 0)
 
         elseif st == :heatmap
-            xmin, xmax, ymin, ymax = xy_lims
             zmin, zmax = clims
-            m, n = length(x), length(y)
-            xinds = sort(1:m, rev = xaxis[:flip])
-            yinds = sort(1:n, rev = yaxis[:flip])
-            z = reshape(reshape(z, m, n)[xinds, yinds], m*n)
-            GR.setspace(zmin, zmax, 0, 90)
-            grad = isa(series[:fillcolor], ColorGradient) ? series[:fillcolor] : cgrad()
-            colors = [plot_color(grad[clamp((zi-zmin) / (zmax-zmin), 0, 1)], series[:fillalpha]) for zi=z]
-            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) ), colors)
-            w, h = length(x), length(y)
-            GR.drawimage(xmin, xmax, ymax, ymin, w, h, rgba)
+            if !ispolar(sp)
+                xmin, xmax, ymin, ymax = xy_lims
+                m, n = length(x), length(y)
+                xinds = sort(1:m, rev = xaxis[:flip])
+                yinds = sort(1:n, rev = yaxis[:flip])
+                z = reshape(reshape(z, m, n)[xinds, yinds], m*n)
+                GR.setspace(zmin, zmax, 0, 90)
+                grad = isa(series[:fillcolor], ColorGradient) ? series[:fillcolor] : cgrad()
+                colors = [plot_color(grad[clamp((zi-zmin) / (zmax-zmin), 0, 1)], series[:fillalpha]) for zi=z]
+                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) ), colors)
+                w, h = length(x), length(y)
+                GR.drawimage(xmin, xmax, ymax, ymin, w, h, rgba)
+            else
+                h, w = length(x), length(y)
+                z = reshape(z, h, w)
+                colors = Int32[round(Int32, 1000 + _i * 255) for _i in z']
+                GR.setwindow(-1, 1, -1, 1)
+                GR.polarcellarray(0, 0, 0, 360, 0, 1, w, h, colors)
+            end
 
         elseif st in (:path3d, :scatter3d)
             # draw path

src/backends/inspectdr.jl

@@ -294,8 +294,8 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
 
         plot.xscale = _inspectdr_getscale(xaxis[:scale], false)
         strip.yscale = _inspectdr_getscale(yaxis[:scale], true)
-        xmin, xmax  = axis_limits(xaxis)
-        ymin, ymax  = axis_limits(yaxis)
+        xmin, xmax  = axis_limits(sp, :x)
+        ymin, ymax  = axis_limits(sp, :y)
         if ispolar(sp)
             #Plots.jl appears to give (xmin,xmax) ≜ (Θmin,Θmax) & (ymin,ymax) ≜ (rmin,rmax)
             rmax = NaNMath.max(abs(ymin), abs(ymax))

src/backends/pgfplots.jl

@@ -361,13 +361,13 @@ function pgf_axis(sp::Subplot, letter)
     # limits
     # TODO: support zlims
     if letter != :z
-        lims = ispolar(sp) && letter == :x ? rad2deg.(axis_limits(axis)) : axis_limits(axis)
+        lims = ispolar(sp) && letter == :x ? rad2deg.(axis_limits(sp, :x)) : axis_limits(sp, letter)
         kw[Symbol(letter,:min)] = lims[1]
         kw[Symbol(letter,:max)] = lims[2]
     end
 
     if !(axis[:ticks] in (nothing, false, :none, :native)) && framestyle != :none
-        ticks = get_ticks(axis)
+        ticks = get_ticks(sp, axis)
         #pgf plot ignores ticks with angle below 90 when xmin = 90 so shift values
         tick_values = ispolar(sp) && letter == :x ? [rad2deg.(ticks[1])[3:end]..., 360, 405] : ticks[1]
         push!(style, string(letter, "tick = {", join(tick_values,","), "}"))

src/backends/plotly.jl

@@ -114,8 +114,8 @@ function plotly_apply_aspect_ratio(sp::Subplot, plotarea, pcts)
         if aspect_ratio == :equal
             aspect_ratio = 1.0
         end
-        xmin,xmax = axis_limits(sp[:xaxis])
-        ymin,ymax = axis_limits(sp[:yaxis])
+        xmin,xmax = axis_limits(sp, :x)
+        ymin,ymax = axis_limits(sp, :y)
         want_ratio = ((xmax-xmin) / (ymax-ymin)) / aspect_ratio
         parea_ratio = width(plotarea) / height(plotarea)
         if want_ratio > parea_ratio
@@ -174,7 +174,7 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
 
     ax[:tickangle] = -axis[:rotation]
     ax[:type] = plotly_scale(axis[:scale])
-    lims = axis_limits(axis)
+    lims = axis_limits(sp, letter)
 
     if axis[:ticks] != :native || axis[:lims] != :auto
         ax[:range] = map(scalefunc(axis[:scale]), lims)
@@ -188,7 +188,7 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
 
         # ticks
         if axis[:ticks] != :native
-            ticks = get_ticks(axis)
+            ticks = get_ticks(sp, axis)
             ttype = ticksType(ticks)
             if ttype == :ticks
                 ax[:tickmode] = "array"
@@ -211,16 +211,16 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
     ax
 end
 
-function plotly_polaraxis(axis::Axis)
+function plotly_polaraxis(sp::Subplot, axis::Axis)
     ax = KW(
         :visible => axis[:showaxis],
         :showline => axis[:grid],
     )
 
     if axis[:letter] == :x
-        ax[:range] = rad2deg.(axis_limits(axis))
+        ax[:range] = rad2deg.(axis_limits(sp, :x))
     else
-        ax[:range] = axis_limits(axis)
+        ax[:range] = axis_limits(sp, :y)
         ax[:orientation] = -90
     end
 
@@ -283,8 +283,8 @@ function plotly_layout(plt::Plot)
                 ),
             )
         elseif ispolar(sp)
-            plotattributes_out[Symbol("angularaxis$(spidx)")] = plotly_polaraxis(sp[:xaxis])
-            plotattributes_out[Symbol("radialaxis$(spidx)")] = plotly_polaraxis(sp[:yaxis])
+            plotattributes_out[Symbol("angularaxis$(spidx)")] = plotly_polaraxis(sp, sp[:xaxis])
+            plotattributes_out[Symbol("radialaxis$(spidx)")] = plotly_polaraxis(sp, sp[:yaxis])
         else
             plotattributes_out[Symbol("xaxis$(x_idx)")] = plotly_axis(plt, sp[:xaxis], sp)
             # don't allow yaxis to be reupdated/reanchored in a linked subplot
@@ -436,7 +436,7 @@ plotly_native_data(axis::Axis, a::Surface) = Surface(plotly_native_data(axis, a.
 
 function plotly_convert_to_datetime(x::AbstractArray, formatter::Function)
     if formatter == datetimeformatter
-        map(xi -> replace(formatter(xi), "T", " "), x)
+        map(xi -> replace(formatter(xi), "T" => " "), x)
     elseif formatter == dateformatter
         map(xi -> string(formatter(xi), " 00:00:00"), x)
     elseif formatter == timeformatter

src/backends/pyplot.jl

@@ -467,7 +467,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                     handle = ax."plot"((arg[rng] for arg in xyargs)...;
                         label = i == 1 ? series[:label] : "",
                         zorder = series[:series_plotindex],
-                        color = py_color(get_linecolor(series, clims, i), get_linealpha(series, i)),
+                        color = py_color(single_color(get_linecolor(series, clims, i)), get_linealpha(series, i)),
                         linewidth = py_thickness_scale(plt, get_linewidth(series, i)),
                         linestyle = py_linestyle(st, get_linestyle(series, i)),
                         solid_capstyle = "round",
@@ -862,9 +862,9 @@ end
 
 # --------------------------------------------------------------------------
 
-function py_set_lims(ax, axis::Axis)
+function py_set_lims(ax, sp::Subplot, axis::Axis)
     letter = axis[:letter]
-    lfrom, lto = axis_limits(axis)
+    lfrom, lto = axis_limits(sp, letter)
     getproperty(ax, Symbol("set_", letter, "lim"))(lfrom, lto)
 end
 
@@ -891,7 +891,7 @@ function py_set_ticks(ax, ticks, letter)
     end
 end
 
-function py_compute_axis_minval(axis::Axis)
+function py_compute_axis_minval(sp::Subplot, axis::Axis)
     # compute the smallest absolute value for the log scale's linear threshold
     minval = 1.0
     sps = axis.sps
@@ -905,13 +905,13 @@ function py_compute_axis_minval(axis::Axis)
     end
 
     # now if the axis limits go to a smaller abs value, use that instead
-    vmin, vmax = axis_limits(axis)
+    vmin, vmax = axis_limits(sp, axis[:letter])
     minval = NaNMath.min(minval, abs(vmin), abs(vmax))
 
     minval
 end
 
-function py_set_scale(ax, axis::Axis)
+function py_set_scale(ax, sp::Subplot, axis::Axis)
     scale = axis[:scale]
     letter = axis[:letter]
     scale in supported_scales() || return @warn("Unhandled scale value in pyplot: $scale")
@@ -927,7 +927,7 @@ function py_set_scale(ax, axis::Axis)
         elseif scale == :log10
             10
         end
-        kw[Symbol(:linthresh,letter)] = NaNMath.min(1e-16, py_compute_axis_minval(axis))
+        kw[Symbol(:linthresh,letter)] = NaNMath.min(1e-16, py_compute_axis_minval(sp, axis))
         "symlog"
     end
     func(arg; kw...)
@@ -1092,12 +1092,12 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             if axis[:guide_position] != :auto && letter != :z
                 pyaxis."set_label_position"(axis[:guide_position])
             end
-            py_set_scale(ax, axis)
-            axis[:ticks] != :native ? py_set_lims(ax, axis) : nothing
+            py_set_scale(ax, sp, axis)
+            axis[:ticks] != :native ? py_set_lims(ax, sp, axis) : nothing
             if ispolar(sp) && letter == :y
                 ax."set_rlabel_position"(90)
             end
-            ticks = sp[:framestyle] == :none ? nothing : get_ticks(axis)
+            ticks = sp[:framestyle] == :none ? nothing : get_ticks(sp, axis)
             # don't show the 0 tick label for the origin framestyle
             if sp[:framestyle] == :origin && length(ticks) > 1
                 ticks[2][ticks[1] .== 0] .= ""
@@ -1132,11 +1132,12 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
         # showaxis
         if !sp[:xaxis][:showaxis]
             kw = KW()
+            if ispolar(sp)
+                ax.spines["polar"].set_visible(false)
+            end
             for dir in (:top, :bottom)
-                if ispolar(sp)
-                    ax."spines"."polar"."set_visible"(false)
-                else
-                    getproperty(ax.spines, dir).set_visible(false)
+                if !ispolar(sp)
+                    ax.spines[string(dir)].set_visible(false)
                 end
                 kw[dir] = kw[Symbol(:label,dir)] = false
             end
@@ -1146,7 +1147,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             kw = KW()
             for dir in (:left, :right)
                 if !ispolar(sp)
-                    getproperty(ax.spines, dir).set_visible(false)
+                    ax.spines[string(dir)].set_visible(false)
                 end
                 kw[dir] = kw[Symbol(:label,dir)] = false
             end
@@ -1298,19 +1299,19 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                 # add a line/marker and a label
                 push!(handles, if series[:seriestype] == :shape || series[:fillrange] != nothing
                     pypatches."Patch"(
-                        edgecolor = py_color(get_linecolor(series, clims), get_linealpha(series)),
-                        facecolor = py_color(get_fillcolor(series, clims), get_fillalpha(series)),
+                        edgecolor = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
+                        facecolor = py_color(single_color(get_fillcolor(series, clims)), get_fillalpha(series)),
                         linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
                         linestyle = py_linestyle(series[:seriestype], get_linestyle(series))
                     )
                 elseif series[:seriestype] in (:path, :straightline, :scatter)
                     PyPlot.plt."Line2D"((0,1),(0,0),
-                        color = py_color(get_linecolor(series, clims), get_linealpha(series)),
+                        color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
                         linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
                         linestyle = py_linestyle(:path, get_linestyle(series)),
                         marker = py_marker(first(series[:markershape])),
-                        markeredgecolor = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
-                        markerfacecolor = series[:marker_z] == nothing ? py_color(get_markercolor(series, clims), get_markeralpha(series)) : py_color(series[:markercolor][0.5])
+                        markeredgecolor = py_color(single_color(get_markerstrokecolor(series)), get_markerstrokealpha(series)),
+                        markerfacecolor = py_color(single_color(get_markercolor(series, clims)), get_markeralpha(series))
                     )
                 else
                     series[:serieshandle][1]

src/backends/unicodeplots.jl

@@ -27,8 +27,8 @@ function rebuildUnicodePlot!(plt::Plot, width, height)
     for sp in plt.subplots
         xaxis = sp[:xaxis]
         yaxis = sp[:yaxis]
-        xlim =  axis_limits(xaxis)
-        ylim =  axis_limits(yaxis)
+        xlim =  axis_limits(sp, :x)
+        ylim =  axis_limits(sp, :y)
 
         # make vectors
         xlim = [xlim[1], xlim[2]]

src/layouts.jl

@@ -111,7 +111,7 @@ function resolve_mixed(mix::MixedMeasures, sp::Subplot, letter::Symbol)
         pct += mix.len / totlen
     end
     if pct != 0
-        amin, amax = axis_limits(sp[Symbol(letter,:axis)])
+        amin, amax = axis_limits(sp, letter)
         xy += pct * (amax-amin)
     end
     xy

src/output.jl

@@ -197,6 +197,7 @@ for mime in ("text/plain", "text/html", "image/png", "image/eps", "image/svg+xml
           prepare_output(plt)
           _show(io, m, plt)
         end
+        return nothing
     end
 end
 

src/recipes.jl

@@ -96,19 +96,6 @@ const POTENTIAL_VECTOR_ARGUMENTS = [
 end
 @deps line path
 
-
-function hvline_limits(axis::Axis)
-    vmin, vmax = axis_limits(axis)
-    if vmin >= vmax
-        if isfinite(vmin)
-            vmax = vmin + 1
-        else
-            vmin, vmax = 0.0, 1.1
-        end
-    end
-    vmin, vmax
-end
-
 @recipe function f(::Type{Val{:hline}}, x, y, z)
     n = length(y)
     newx = repeat(Float64[-1, 1, NaN], n)
@@ -253,11 +240,12 @@ end
     n = length(x)
     fr = plotattributes[:fillrange]
     if fr == nothing
-        yaxis = plotattributes[:subplot][:yaxis]
+        sp = plotattributes[:subplot]
+        yaxis = sp[:yaxis]
         fr = if yaxis[:scale] == :identity
             0.0
         else
-            NaNMath.min(axis_limits(yaxis)[1], ignorenan_minimum(y))
+            NaNMath.min(axis_limits(sp, :y)[1], ignorenan_minimum(y))
         end
     end
     newx, newy = zeros(3n), zeros(3n)
@@ -550,13 +538,15 @@ function _stepbins_path(edge, weights, baseline::Real, xscale::Symbol, yscale::S
         w, it_state_w = it_tuple_w
 
         if (log_scale_x && a ≈ 0)
-            a = b/_logScaleBases[xscale]^3
+            a = oftype(a, b/_logScaleBases[xscale]^3)
         end
 
         if isnan(w)
             if !isnan(last_w)
                 push!(x, a)
                 push!(y, baseline)
+                push!(x, NaN)
+                push!(y, NaN)
             end
         else
             if isnan(last_w)
@@ -569,8 +559,8 @@ function _stepbins_path(edge, weights, baseline::Real, xscale::Symbol, yscale::S
             push!(y, w)
         end
 
-        a = b
-        last_w = w
+        a = oftype(a, b)
+        last_w = oftype(last_w, w)
 
         it_tuple_e = iterate(edge, it_state_e)
         it_tuple_w = iterate(weights, it_state_w)
@@ -620,7 +610,8 @@ Plots.@deps stepbins path
 wand_edges(x...) = (@warn("Load the StatsPlots package in order to use :wand bins. Defaulting to :auto", once = true); :auto)
 
 function _auto_binning_nbins(vs::NTuple{N,AbstractVector}, dim::Integer; mode::Symbol = :auto) where N
-    _cl(x) = ceil(Int, max(x, one(x)))
+    max_bins = 10_000
+    _cl(x) = min(ceil(Int, max(x, one(x))), max_bins)
     _iqr(v) = (q = quantile(v, 0.75) - quantile(v, 0.25); q > 0 ? q : oftype(q, 1))
     _span(v) = maximum(v) - minimum(v)
 
@@ -647,7 +638,7 @@ function _auto_binning_nbins(vs::NTuple{N,AbstractVector}, dim::Integer; mode::S
     elseif mode == :fd  # Freedman–Diaconis rule
         _cl(_span(v) / (2 * _iqr(v) / nd))
     elseif mode == :wand
-        wand_edges(v)  # this makes this function not type stable, but the type instability does not propagate
+        _cl(wand_edges(v))  # this makes this function not type stable, but the type instability does not propagate
     else
         error("Unknown auto-binning mode $mode")
     end
@@ -1192,3 +1183,27 @@ end
         @series Plots.isvertical(plotattributes) ? (sx, sy) : (sy, sx)
     end
 end
+
+"""
+    areaplot([x,] y)
+    areaplot!([x,] y)
+
+Draw a stacked area plot of the matrix y.
+# Examples
+```julia-repl
+julia> areaplot(1:3, [1 2 3; 7 8 9; 4 5 6], seriescolor = [:red :green :blue], fillalpha = [0.2 0.3 0.4])
+```
+"""
+@userplot AreaPlot
+
+@recipe function f(a::AreaPlot)
+    data = cumsum(a.args[end], dims=2)
+    x = length(a.args) == 1 ? (1:size(data, 1)) : a.args[1]
+    seriestype := :line
+    for i in 1:size(data, 2)
+        @series begin
+            fillrange := i > 1 ? data[:,i-1] : 0
+            x, data[:,i]
+        end
+    end
+end

src/series.jl

@@ -19,13 +19,8 @@ convertToAnyVector(v::Nothing, plotattributes::KW) = Any[nothing], nothing
 # fixed number of blank series
 convertToAnyVector(n::Integer, plotattributes::KW) = Any[zeros(0) for i in 1:n], nothing
 
-# numeric vector
-convertToAnyVector(v::AVec{T}, plotattributes::KW) where {T<:Number} = Any[v], nothing
-convertToAnyVector(v::AVec{Union{Missing, T}}, plotattributes::KW) where {T<:Number} = Any[replace(v, missing => NaN)], nothing
-
-# string vector
-convertToAnyVector(v::AVec{T}, plotattributes::KW) where {T<:AbstractString} = Any[v], nothing
-convertToAnyVector(v::AVec{Union{Missing, T}}, plotattributes::KW) where {T<:AbstractString} = Any[replace(v, missing => "")], nothing
+# numeric/string vector
+convertToAnyVector(v::AVec{T}, plotattributes::KW) where {T<:Union{Number,AbstractString,Missing}} = Any[handlemissings(v)], nothing
 
 function convertToAnyVector(v::AMat, plotattributes::KW)
     v = handlemissings(v)
@@ -36,9 +31,9 @@ function convertToAnyVector(v::AMat, plotattributes::KW)
     end, nothing
 end
 
-handlemissings(v::AMat) = v
-handlemissings(v::AMat{T}) where T <: Number = replace(v, missing => NaN)
-handlemissings(v::AMat{T}) where T <: String = replace(v, missing => "")
+handlemissings(v) = v
+handlemissings(v::AbstractArray{Union{T,Missing}}) where T <: Number = replace(v, missing => NaN)
+handlemissings(v::AbstractArray{Union{T,Missing}}) where T <: AbstractString = replace(v, missing => "")
 
 # function
 convertToAnyVector(f::Function, plotattributes::KW) = Any[f], nothing
@@ -193,8 +188,9 @@ _apply_type_recipe(plotattributes, v) = RecipesBase.apply_recipe(plotattributes,
 # This sort of recipe should return a pair of functions... one to convert to number,
 # and one to format tick values.
 function _apply_type_recipe(plotattributes, v::AbstractArray)
-    isempty(v) && return Float64[]
-    args = RecipesBase.apply_recipe(plotattributes, typeof(v[1]), v[1])[1].args
+    isempty(skipmissing(v)) && return Float64[]
+    x = first(skipmissing(v))
+    args = RecipesBase.apply_recipe(plotattributes, typeof(x), x)[1].args
     if length(args) == 2 && typeof(args[1]) <: Function && typeof(args[2]) <: Function
         numfunc, formatter = args
         Formatted(map(numfunc, v), formatter)
@@ -391,7 +387,7 @@ end
 @recipe function f(f::FuncOrFuncs{F}) where F<:Function
     plt = plotattributes[:plot_object]
     xmin, xmax = try
-        axis_limits(plt[1][:xaxis])
+        axis_limits(plt[1], :x)
     catch
         xinv = invscalefunc(get(plotattributes, :xscale, :identity))
         xm = tryrange(f, xinv.([-5,-1,0,0.01]))
@@ -557,33 +553,14 @@ end
 # # Lists of tuples and GeometryTypes.Points
 # # --------------------------------------------------------------------
 #
-# # if we get an unhandled tuple, just splat it in
-@recipe f(tup::Tuple) = tup
 
-#
-# # (x,y) tuples
-@recipe f(xy::AVec{Tuple{R1,R2}}) where {R1<:Number,R2<:Number} = unzip(xy)
-@recipe f(xy::Tuple{R1,R2}) where {R1<:Number,R2<:Number}       = [xy[1]], [xy[2]]
+@recipe f(v::AVec{<:Tuple})               = unzip(v)
+@recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v)
+@recipe f(tup::Tuple)             = [tup]
+@recipe f(p::GeometryTypes.Point) = [p]
 
-#
-# # (x,y,z) tuples
-@recipe f(xyz::AVec{Tuple{R1,R2,R3}}) where {R1<:Number,R2<:Number,R3<:Number} = unzip(xyz)
-@recipe f(xyz::Tuple{R1,R2,R3}) where {R1<:Number,R2<:Number,R3<:Number}       = [xyz[1]], [xyz[2]], [xyz[3]]
-
-# these might be points+velocity, or OHLC or something else
-@recipe f(xyuv::AVec{Tuple{R1,R2,R3,R4}}) where {R1<:Number,R2<:Number,R3<:Number,R4<:Number} = get(plotattributes,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
-@recipe f(xyuv::Tuple{R1,R2,R3,R4}) where {R1<:Number,R2<:Number,R3<:Number,R4<:Number}       = [xyuv[1]], [xyuv[2]], [xyuv[3]], [xyuv[4]]
-
-
-#
-# # 2D Points
-@recipe f(xy::AVec{GeometryTypes.Point{2,T}}) where {T<:Number} = unzip(xy)
-@recipe f(xy::GeometryTypes.Point{2,T}) where {T<:Number}       = [xy[1]], [xy[2]]
-
-#
-# # 3D Points
-@recipe f(xyz::AVec{GeometryTypes.Point{3,T}}) where {T<:Number} = unzip(xyz)
-@recipe f(xyz::GeometryTypes.Point{3,T}) where {T<:Number}       = [xyz[1]], [xyz[2]], [xyz[3]]
+# Special case for 4-tuples in :ohlc series
+@recipe f(xyuv::AVec{<:Tuple{R1,R2,R3,R4}}) where {R1,R2,R3,R4} = get(plotattributes,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
 
 #
 # # --------------------------------------------------------------------

src/shorthands.jl

@@ -2,10 +2,10 @@
     scatter(x,y)
     scatter!(x,y)
 
-Make a scatter plot of y vs x. 
+Make a scatter plot of y vs x.
 
 # Examples
-```julia-repl 
+```julia-repl
 julia> scatter([1,2,3],[4,5,6],markersize=[3,4,5],markercolor=[:red,:green,:blue])
 julia> scatter([(1,4),(2,5),(3,6)])
 ```
@@ -16,9 +16,9 @@ julia> scatter([(1,4),(2,5),(3,6)])
     bar(x,y)
     bar!(x,y)
 
-Make a bar plot of y vs x. 
+Make a bar plot of y vs x.
 
-# Arguments 
+# Arguments
 
 - $(_document_argument("bar_position"))
 - $(_document_argument("bar_width"))
@@ -26,7 +26,7 @@ Make a bar plot of y vs x.
 - $(_document_argument("orientation"))
 
 # Examples
-```julia-repl 
+```julia-repl
 julia> bar([1,2,3],[4,5,6],fillcolor=[:red,:green,:blue],fillalpha=[0.2,0.4,0.6])
 julia> bar([(1,4),(2,5),(3,6)])
 ```
@@ -41,7 +41,7 @@ julia> bar([(1,4),(2,5),(3,6)])
 
 Plot a histogram.
 
-# Arguments 
+# Arguments
 
 - `x`: AbstractVector of values to be binned
 - $(_document_argument("bins"))
@@ -53,7 +53,7 @@ Plot a histogram.
 - $(_document_argument("orientation"))
 
 # Example
-```julia-repl 
+```julia-repl
 julia> histogram([1,2,1,1,4,3,8],bins=0:8)
 ```
 """
@@ -63,7 +63,7 @@ julia> histogram([1,2,1,1,4,3,8],bins=0:8)
     barhist(x)
     barhist!(x)
 
-Make a histogram bar plot. See `histogram`. 
+Make a histogram bar plot. See `histogram`.
 """
 @shorthands barhist
 
@@ -72,7 +72,7 @@ Make a histogram bar plot. See `histogram`.
     stephist(x)
 
 Make a histogram step plot (bin counts are represented using horizontal lines
-instead of bars). See `histogram`. 
+instead of bars). See `histogram`.
 """
 @shorthands stephist
 
@@ -80,8 +80,8 @@ instead of bars). See `histogram`.
     scatterhist(x)
     scatterhist!(x)
 
-Make a histogram scatter plot (bin counts are represented using points 
-instead of bars). See `histogram`. 
+Make a histogram scatter plot (bin counts are represented using points
+instead of bars). See `histogram`.
 """
 @shorthands scatterhist
 
@@ -91,14 +91,14 @@ instead of bars). See `histogram`.
 
 Plot a two-dimensional histogram.
 
-# Arguments 
+# Arguments
 
-- `bins`: Number of bins (if an `Integer`) or bin edges (if an `AbtractVector`) 
-- `weights`: Vector of weights for the values in `x`. Each entry of x contributes 
-             its weight to the height of its bin. 
+- `bins`: Number of bins (if an `Integer`) or bin edges (if an `AbtractVector`)
+- `weights`: Vector of weights for the values in `x`. Each entry of x contributes
+             its weight to the height of its bin.
 
 # Example
-```julia-repl 
+```julia-repl
 julia> histogram2d(randn(10_000),randn(10_000))
 ```
 """
@@ -108,14 +108,14 @@ julia> histogram2d(randn(10_000),randn(10_000))
     density(x)
     density!(x)
 
-Make a line plot of a kernel density estimate of x. 
+Make a line plot of a kernel density estimate of x.
 
 # Arguments
 
-- `x`: AbstractVector of samples for probability density estimation 
+- `x`: AbstractVector of samples for probability density estimation
 
 # Example
-```julia-repl 
+```julia-repl
 julia> using StatsPlots
 julia> density(randn(100_000))
 ```
@@ -126,10 +126,10 @@ julia> density(randn(100_000))
     heatmap(x,y,z)
     heatmap!(x,y,z)
 
-Plot a heatmap of the rectangular array `z`. 
+Plot a heatmap of the rectangular array `z`.
 
 # Example
-```julia-repl 
+```julia-repl
 julia> heatmap(randn(10,10))
 ```
 """
@@ -140,7 +140,7 @@ julia> heatmap(randn(10,10))
     hexbin(x,y)
     hexbin!(x,y)
 
-Make a hexagonal binning plot (a histogram of the observations `(x[i],y[i])` 
+Make a hexagonal binning plot (a histogram of the observations `(x[i],y[i])`
 with hexagonal bins)
 
 # Example
@@ -154,11 +154,11 @@ julia> hexbin(randn(10_000), randn(10_000))
     sticks(x,y)
     sticks!(x,y)
 
-Draw a stick plot of y vs x. 
+Draw a stick plot of y vs x.
 
 # Example
 ```julia-repl
-julia> sticks(1:10) 
+julia> sticks(1:10)
 ```
 """
 @shorthands sticks
@@ -167,11 +167,11 @@ julia> sticks(1:10)
     hline(y)
     hline!(y)
 
-Draw horizontal lines at positions specified by the values in 
+Draw horizontal lines at positions specified by the values in
 the AbstractVector `y`
 
 # Example
-```julia-repl 
+```julia-repl
 julia> hline([-1,0,2])
 ```
 """
@@ -181,11 +181,11 @@ julia> hline([-1,0,2])
     vline(x)
     vline!(x)
 
-Draw vertical lines at positions specified by the values in 
+Draw vertical lines at positions specified by the values in
 the AbstractVector `x`
 
 # Example
-```julia-repl 
+```julia-repl
 julia> vline([-1,0,2])
 ```
 """
@@ -194,13 +194,13 @@ julia> vline([-1,0,2])
 """
     hspan(y)
 
-Draw a rectangle between the horizontal line at position `y[1]` 
-and the horizontal line at position `y[2]`. If `length(y) ≥ 4`, 
-then further rectangles are drawn between `y[3]` and `y[4]`, 
-`y[5]` and `y[6]`, and so on. If `length(y)` is odd, then the 
-last entry of `y` is ignored. 
+Draw a rectangle between the horizontal line at position `y[1]`
+and the horizontal line at position `y[2]`. If `length(y) ≥ 4`,
+then further rectangles are drawn between `y[3]` and `y[4]`,
+`y[5]` and `y[6]`, and so on. If `length(y)` is odd, then the
+last entry of `y` is ignored.
 # Example
-```julia-repl 
+```julia-repl
 julia> hspan(1:6)
 ```
 """
@@ -209,13 +209,13 @@ julia> hspan(1:6)
 """
     vspan(x)
 
-Draw a rectangle between the vertical line at position `x[1]` 
-and the vertical line at position `x[2]`. If `length(x) ≥ 4`, 
-then further rectangles are drawn between `x[3]` and `x[4]`, 
-`x[5]` and `x[6]`, and so on. If `length(x)` is odd, then the 
-last entry of `x` is ignored. 
+Draw a rectangle between the vertical line at position `x[1]`
+and the vertical line at position `x[2]`. If `length(x) ≥ 4`,
+then further rectangles are drawn between `x[3]` and `x[4]`,
+`x[5]` and `x[6]`, and so on. If `length(x)` is odd, then the
+last entry of `x` is ignored.
 # Example
-```julia-repl 
+```julia-repl
 julia> vspan(1:6)
 ```
 """
@@ -225,9 +225,9 @@ julia> vspan(1:6)
     ohlc(x,y::Vector{OHLC})
     ohlc!(x,y::Vector{OHLC})
 
-Make open-high-low-close plot. Each entry of y is represented by a vertical 
-segment extending from the low value to the high value, with short horizontal 
-segments on the left and right indicating the open and close values, respectively. 
+Make open-high-low-close plot. Each entry of y is represented by a vertical
+segment extending from the low value to the high value, with short horizontal
+segments on the left and right indicating the open and close values, respectively.
 
 # Example
 ```julia-repl
@@ -240,16 +240,16 @@ julia> ohlc(y)
 
 
 """
-    contour(x,y,z) 
-    contour!(x,y,z) 
+    contour(x,y,z)
+    contour!(x,y,z)
 
-Draw contour lines of the `Surface` z. 
+Draw contour lines of the `Surface` z.
 
 # Arguments
 - `levels`: Contour levels (if `AbstractVector`) or number of levels (if `Integer`)
 - `fill`: Bool. Fill area between contours or draw contours only (false by default)
 
-# Example 
+# Example
 ```julia-repl
 julia> x = y = range(-20, 20, length = 100)
 julia> contour(x, y, (x, y) -> x^2 + y^2)
@@ -267,10 +267,10 @@ julia> contour(x, y, (x, y) -> x^2 + y^2)
     surface(x,y,z)
     surface!(x,y,z)
 
-Draw a 3D surface plot. 
+Draw a 3D surface plot.
 
 # Example
-```julia-repl 
+```julia-repl
 julia> x = y = range(-3, 3, length = 100)
 julia> surface(x, y, (x, y) -> sinc(norm([x, y])))
 ```
@@ -281,10 +281,10 @@ julia> surface(x, y, (x, y) -> sinc(norm([x, y])))
     wireframe(x,y,z)
     wireframe!(x,y,z)
 
-Draw a 3D wireframe plot. 
+Draw a 3D wireframe plot.
 
 # Example
-```julia-repl 
+```julia-repl
 julia> wireframe(1:10,1:10,randn(10,10))
 ```
 """
@@ -295,10 +295,10 @@ julia> wireframe(1:10,1:10,randn(10,10))
     path3d!(x,y,z)
 
 Plot a 3D path from `(x[1],y[1],z[1])` to `(x[2],y[2],z[2])`,
-..., to `(x[end],y[end],z[end])`. 
+..., to `(x[end],y[end],z[end])`.
 
 # Example
-```julia-repl 
+```julia-repl
 julia> path3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
 ```
 """
@@ -308,10 +308,10 @@ julia> path3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
     scatter3d(x,y,z)
     scatter3d!(x,y,z)
 
-Make a 3D scatter plot. 
+Make a 3D scatter plot.
 
 # Example
-```julia-repl 
+```julia-repl
 julia> scatter3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
 ```
 """
@@ -321,17 +321,17 @@ julia> scatter3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
     boxplot(x, y)
     boxplot!(x, y)
 
-Make a box and whisker plot. 
+Make a box and whisker plot.
 
 # Keyword arguments
 - `notch`: Bool. Notch the box plot? (false)
 - `range`: Real. Values more than range*IQR below the first quartile
-           or above the third quartile are shown as outliers (1.5) 
-- `outliers`: Bool. Show outliers? (true) 
-- `whisker_width`: Real or Symbol. Length of whiskers (:match) 
+           or above the third quartile are shown as outliers (1.5)
+- `outliers`: Bool. Show outliers? (true)
+- `whisker_width`: Real or Symbol. Length of whiskers (:match)
 
 # Example
-```julia-repl 
+```julia-repl
 julia> using StatsPlots
 julia> boxplot(repeat([1,2,3],outer=100),randn(300))
 ```
@@ -342,10 +342,10 @@ julia> boxplot(repeat([1,2,3],outer=100),randn(300))
     violin(x,y,z)
     violin!(x,y,z)
 
-Make a violin plot. 
+Make a violin plot.
 
 # Example
-```julia-repl 
+```julia-repl
 julia> violin(repeat([1,2,3],outer=100),randn(300))
 ```
 """
@@ -355,11 +355,11 @@ julia> violin(repeat([1,2,3],outer=100),randn(300))
     quiver(x,y,quiver=(u,v))
     quiver!(x,y,quiver=(u,v))
 
-Make a quiver (vector field) plot. The `i`th vector extends 
-from `(x[i],y[i])` to `(x[i] + u[i], y[i] + v[i])`. 
+Make a quiver (vector field) plot. The `i`th vector extends
+from `(x[i],y[i])` to `(x[i] + u[i], y[i] + v[i])`.
 
 # Example
-```julia-repl 
+```julia-repl
 julia> quiver([1,2,3],[3,2,1],quiver=([1,1,1],[1,2,3]))
 ```
 """
@@ -369,11 +369,11 @@ julia> quiver([1,2,3],[3,2,1],quiver=([1,1,1],[1,2,3]))
     curves(x,y)
     curves!(x,y)
 
-Draw a Bezier curve from `(x[1],y[1])` to `(x[end],y[end])` 
+Draw a Bezier curve from `(x[1],y[1])` to `(x[end],y[end])`
 with control points `(x[2],y[2]), ..., (x[end-1],y[end]-1)`
 
 # Example
-```julia-repl 
+```julia-repl
 julia> curves([1,2,3,4],[1,1,2,4])
 ```
 """
@@ -424,9 +424,9 @@ ticks::AVec{T}, labels::AVec{S}; kw...) where {T<:Real,S<:AbstractString}     =
 """
     annotate!(anns...)
 
-Add annotations to an existing plot. 
+Add annotations to an existing plot.
 
-# Arguments 
+# Arguments
 
 - `anns`: An `AbstractVector` of tuples of the form (x,y,text). The text object
           can be an String or PlotText

src/utils.jl

@@ -214,36 +214,19 @@ end
 
 # helpers to figure out if there are NaN values in a list of array types
 anynan(i::Int, args::Tuple) = any(a -> try isnan(_cycle(a,i)) catch MethodError false end, args)
-anynan(istart::Int, iend::Int, args::Tuple) = any(i -> anynan(i, args), istart:iend)
-allnan(istart::Int, iend::Int, args::Tuple) = all(i -> anynan(i, args), istart:iend)
+anynan(args::Tuple) = i -> anynan(i,args)
+anynan(istart::Int, iend::Int, args::Tuple) = any(anynan(args), istart:iend)
+allnan(istart::Int, iend::Int, args::Tuple) = all(anynan(args), istart:iend)
 
 function Base.iterate(itr::SegmentsIterator, nextidx::Int = 1)
-    nextidx > itr.n && return nothing
-    if nextidx == 1 && !any(isempty,itr.args) && anynan(1, itr.args)
-        nextidx = 2
-    end
+    i = findfirst(!anynan(itr.args), nextidx:itr.n)
+    i === nothing && return nothing
+    nextval = nextidx + i - 1
 
-    i = istart = iend = nextidx
+    j = findfirst(anynan(itr.args), nextval:itr.n)
+    nextnan = j === nothing ? itr.n + 1 : nextval + j - 1
 
-    # find the next NaN, and iend is the one before
-    while i <= itr.n + 1
-        if i > itr.n || anynan(i, itr.args)
-            # done... array end or found NaN
-            iend = i-1
-            break
-        end
-        i += 1
-    end
-
-    # find the next non-NaN, and set nextidx
-    while i <= itr.n
-        if !anynan(i, itr.args)
-            break
-        end
-        i += 1
-    end
-
-    istart:iend, i
+    nextval:nextnan-1, nextnan
 end
 
 # Find minimal type that can contain NaN and x
@@ -288,18 +271,17 @@ maketuple(x::Tuple{T,S}) where {T,S} = x
 mapFuncOrFuncs(f::Function, u::AVec)        = map(f, u)
 mapFuncOrFuncs(fs::AVec{F}, u::AVec) where {F<:Function} = [map(f, u) for f in fs]
 
-unzip(xy::AVec{Tuple{X,Y}}) where {X,Y}              = [t[1] for t in xy], [t[2] for t in xy]
-unzip(xyz::AVec{Tuple{X,Y,Z}}) where {X,Y,Z}         = [t[1] for t in xyz], [t[2] for t in xyz], [t[3] for t in xyz]
-unzip(xyuv::AVec{Tuple{X,Y,U,V}}) where {X,Y,U,V}    = [t[1] for t in xyuv], [t[2] for t in xyuv], [t[3] for t in xyuv], [t[4] for t in xyuv]
+for i in 2:4
+  @eval begin
+    unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}},
+                   AVec{<:GeometryTypes.Point{$i}}}) = $(Expr(:tuple, (:([t[$j] for t in v]) for j=1:i)...))
+  end
+end
 
-unzip(xy::AVec{GeometryTypes.Point{2,T}}) where {T}  = T[t[1] for t in xy], T[t[2] for t in xy]
-unzip(xy::GeometryTypes.Point{2,T}) where {T}        = T[xy[1]], T[xy[2]]
-
-unzip(xyz::AVec{GeometryTypes.Point{3,T}}) where {T} = T[t[1] for t in xyz], T[t[2] for t in xyz], T[t[3] for t in xyz]
-unzip(xyz::GeometryTypes.Point{3,T}) where {T}       = T[xyz[1]], T[xyz[2]], T[xyz[3]]
-
-unzip(xyuv::AVec{GeometryTypes.Point{4,T}}) where {T} = T[t[1] for t in xyuv], T[t[2] for t in xyuv], T[t[3] for t in xyuv], T[t[4] for t in xyuv]
-unzip(xyuv::GeometryTypes.Point{4,T}) where {T}       = T[xyuv[1]], T[xyuv[2]], T[xyuv[3]], T[xyuv[4]]
+unzip(v::Union{AVec{<:GeometryTypes.Point{N}},
+               AVec{<:Tuple{Vararg{T,N} where T}}}) where N = error("$N-dimensional unzip not implemented.")
+unzip(v::Union{AVec{<:GeometryTypes.Point},
+               AVec{<:Tuple}}) = error("Can't unzip points of different dimensions.")
 
 # given 2-element lims and a vector of data x, widen lims to account for the extrema of x
 function _expand_limits(lims, x)
@@ -508,7 +490,7 @@ function concatenate_fillrange(x,y::Tuple)
 end
 
 function get_sp_lims(sp::Subplot, letter::Symbol)
-    axis_limits(sp[Symbol(letter, :axis)])
+    axis_limits(sp, letter)
 end
 
 """
@@ -545,9 +527,9 @@ function get_clims(sp::Subplot)
     z_colored_series = (:contour, :contour3d, :heatmap, :histogram2d, :surface)
     for series in series_list(sp)
         for vals in (series[:seriestype] in z_colored_series ? series[:z] : nothing, series[:line_z], series[:marker_z], series[:fill_z])
-            if (typeof(vals) <: AbstractSurface) && (eltype(vals.surf) <: Real)
+            if (typeof(vals) <: AbstractSurface) && (eltype(vals.surf) <: Union{Missing, Real})
                 zmin, zmax = _update_clims(zmin, zmax, ignorenan_extrema(vals.surf)...)
-            elseif (vals != nothing) && (eltype(vals) <: Real)
+            elseif (vals != nothing) && (eltype(vals) <: Union{Missing, Real})
                 zmin, zmax = _update_clims(zmin, zmax, ignorenan_extrema(vals)...)
             end
         end
@@ -642,6 +624,9 @@ for comp in (:line, :fill, :marker)
     end
 end
 
+single_color(c, v = 0.5) = c
+single_color(grad::ColorGradient, v = 0.5) = grad[v]
+
 function get_linewidth(series, i::Int = 1)
     _cycle(series[:linewidth], i)
 end
@@ -669,7 +654,7 @@ function has_attribute_segments(series::Series)
     end
     series[:seriestype] == :shape && return false
     # ... else we check relevant attributes if they have multiple inputs
-    return any((typeof(series[attr]) <: AbstractVector && length(series[attr]) > 1) for attr in [:seriescolor, :seriesalpha, :linecolor, :linealpha, :linewidth, :fillcolor, :fillalpha, :markercolor, :markeralpha, :markerstrokecolor, :markerstrokealpha]) || any(typeof(series[attr]) <: AbstractArray{<:Real} for attr in (:line_z, :fill_z, :marker_z))
+    return any((typeof(series[attr]) <: AbstractVector && length(series[attr]) > 1) for attr in [:seriescolor, :seriesalpha, :linecolor, :linealpha, :linewidth, :fillcolor, :fillalpha, :markercolor, :markeralpha, :markerstrokecolor, :markerstrokealpha]) || any(typeof(series[attr]) <: AbstractArray for attr in (:line_z, :fill_z, :marker_z))
 end
 
 # ---------------------------------------------------------------

test/runtests.jl

@@ -4,6 +4,7 @@ using Random
 using BinaryProvider
 using Test
 using FileIO
+using GeometryTypes
 
 include("imgcomp.jl")
 # don't actually show the plots
@@ -51,5 +52,44 @@ end
 end
 
 @testset "NoFail" begin
-    histogram([1, 0, 0, 0, 0, 0])
+    plots = [histogram([1, 0, 0, 0, 0, 0]),
+             plot([missing]),
+             plot([missing; 1:4]),
+             plot([fill(missing,10); 1:4]),
+             plot([1 1; 1 missing]),
+             plot(["a" "b"; missing "d"], [1 2; 3 4])]
+    for plt in plots
+        display(plt)
+    end
+end
+
+@testset "Segments" begin
+    function segments(args...)
+        segs = UnitRange{Int}[]
+        for seg in iter_segments(args...)
+            push!(segs,seg)
+        end
+        segs
+    end
+
+    nan10 = fill(NaN,10)
+    @test segments(11:20) == [1:10]
+    @test segments([NaN]) == []
+    @test segments(nan10) == []
+    @test segments([nan10; 1:5]) == [11:15]
+    @test segments([1:5;nan10]) == [1:5]
+    @test segments([nan10; 1:5; nan10; 1:5; nan10]) == [11:15, 26:30]
+    @test segments([NaN; 1], 1:10) == [2:2, 4:4, 6:6, 8:8, 10:10]
+    @test segments([nan10; 1:15], [1:15; nan10]) == [11:15]
+end
+
+@testset "Utils" begin
+    zipped = ([(1,2)], [("a","b")], [(1,"a"),(2,"b")],
+              [(1,2),(3,4)], [(1,2,3),(3,4,5)], [(1,2,3,4),(3,4,5,6)],
+              [(1,2.0),(missing,missing)], [(1,missing),(missing,"a")],
+              [(missing,missing)], [(missing,missing,missing),("a","b","c")])
+    for z in zipped
+        @test isequal(collect(zip(Plots.unzip(z)...)), z)
+        @test isequal(collect(zip(Plots.unzip(Point.(z))...)), z)
+    end
 end