Merge pull request #1534 from daschw/release

prepare release

NEWS.md

@@ -11,6 +11,15 @@
 ---
 ## (current master)
 
+## 0.17.1
+- Fix contour for PGFPlots
+- 32Bit fix: Int64 -> Int
+- Make series of shapes and segments toggle together in Plotly(JS)
+- Fix marker arguments
+- Fix processing order of series recipes
+- Fix Plotly(JS) ribbon
+- Contour plots with x,y in grid form on PyPlot
+
 ## 0.17.0
 - Add GR dependency to make it the default backend
 - Improve histogram2d bin estimation

src/args.jl

@@ -1473,26 +1473,19 @@ function _replace_linewidth(d::KW)
 end
 
 function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
-    pkg = plt.backend
-    globalIndex = d[:series_plotindex]
-
     # add default values to our dictionary, being careful not to delete what we just added!
     for (k,v) in _series_defaults
         slice_arg!(d, d, k, v, commandIndex, false)
     end
 
-    # this is how many series belong to this subplot
-    # plotIndex = count(series -> series.d[:subplot] === sp && series.d[:primary], plt.series_list)
-    plotIndex = 0
-    for series in sp.series_list
-        if series[:primary]
-            plotIndex += 1
-        end
-    end
-    # plotIndex = count(series -> series[:primary], sp.series_list)
-    if get(d, :primary, true)
-        plotIndex += 1
-    end
+    return d
+end
+
+
+function _update_series_attributes!(d::KW, plt::Plot, sp::Subplot)
+    pkg = plt.backend
+    globalIndex = d[:series_plotindex]
+    plotIndex = _series_index(d, sp)
 
     aliasesAndAutopick(d, :linestyle, _styleAliases, supported_styles(pkg), plotIndex)
     aliasesAndAutopick(d, :markershape, _markerAliases, supported_markers(pkg), plotIndex)
@@ -1528,9 +1521,11 @@ function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
 
     # update markerstrokecolor
     d[:markerstrokecolor] = if d[:markerstrokecolor] == :match
-        plot_color(sp[:foreground_color_subplot], d[:markerstrokealpha])
+        plot_color(sp[:foreground_color_subplot])
+    elseif d[:markerstrokecolor] == :auto
+        getSeriesRGBColor.(d[:markercolor], sp, plotIndex)
     else
-        getSeriesRGBColor(plot_color(d[:markerstrokecolor], d[:markerstrokealpha]), sp, plotIndex)
+        getSeriesRGBColor.(d[:markerstrokecolor], sp, plotIndex)
     end
 
     # if marker_z, fill_z or line_z are set, ensure we have a gradient
@@ -1560,3 +1555,19 @@ function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
     _replace_linewidth(d)
     d
 end
+
+function _series_index(d, sp)
+    idx = 0
+    for series in series_list(sp)
+        if series[:primary]
+            idx += 1
+        end
+        if series == d
+            return idx
+        end
+    end
+    if get(d, :primary, true)
+        idx += 1
+    end
+    return idx
+end

src/backends/gr.jl

@@ -353,25 +353,18 @@ function gr_draw_markers(series::Series, x, y, msize, mz)
             msi = _cycle(msize, i)
             shape = _cycle(shapes, i)
             cfunc = isa(shape, Shape) ? gr_set_fillcolor : gr_set_markercolor
-            cfuncind = isa(shape, Shape) ? GR.setfillcolorind : GR.setmarkercolorind
 
             # draw a filled in shape, slightly bigger, to estimate a stroke
             if series[:markerstrokewidth] > 0
-                cfunc(_cycle(series[:markerstrokecolor], i)) #, series[:markerstrokealpha])
+                cfunc(get_markerstrokecolor(series, i))
+                gr_set_transparency(get_markerstrokealpha(series, i))
                 gr_draw_marker(x[i], y[i], msi + series[:markerstrokewidth], shape)
             end
 
-            # draw the shape
-            if mz == nothing
-                cfunc(_cycle(series[:markercolor], i)) #, series[:markeralpha])
-            else
-                # pick a color from the pre-loaded gradient
-                ci = round(Int, 1000 + _cycle(mz, i) * 255)
-                cfuncind(ci)
-                gr_set_transparency(_gr_gradient_alpha[ci-999])
-            end
-            # don't draw filled area if marker shape is 1D
+            # draw the shape - don't draw filled area if marker shape is 1D
             if !(shape in (:hline, :vline, :+, :x))
+                cfunc(get_markercolor(series, i))
+                gr_set_transparency(get_markeralpha(series, i))
                 gr_draw_marker(x[i], y[i], msi, shape)
             end
         end
@@ -1046,10 +1039,6 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             end
 
             if series[:markershape] != :none
-                if series[:marker_z] != nothing
-                    zmin, zmax = extrema(series[:marker_z])
-                    GR.setspace(zmin, zmax, 0, 90)
-                end
                 gr_draw_markers(series, x, y, clims)
             end
 

src/backends/hdf5.jl

@@ -167,6 +167,7 @@ function _initialize_backend(::HDF5Backend)
 #                "PLOTTEXT" => PlotText,
                 "COLORGRADIENT" => ColorGradient,
                 "AXIS" => Axis,
+                "SURFACE" => Surface,
                 "SUBPLOT" => Subplot,
                 "NULLABLE" => Nullable,
             )
@@ -407,6 +408,11 @@ function _hdf5plot_gwrite(grp, k::String, v::Axis)
     _hdf5plot_writetype(grp, Axis)
     return
 end
+function _hdf5plot_gwrite(grp, k::String, v::Surface)
+	grp = HDF5.g_create(grp, k)
+	_hdf5plot_gwrite(grp, "data2d", v.surf)
+	_hdf5plot_writetype(grp, Surface)
+end
 #TODO: "Properly" support Nullable using _hdf5plot_writetype?
 function _hdf5plot_gwrite(grp, k::String, v::Nullable)
     if isnull(v)
@@ -577,6 +583,11 @@ function _hdf5plot_read(grp, k::String, T::Type{Axis}, dtid)
     _hdf5plot_read(grp, kwlist)
     return Axis([], kwlist)
 end
+function _hdf5plot_read(grp, k::String, T::Type{Surface}, dtid)
+    grp = HDF5.g_open(grp, k)
+    data2d = _hdf5plot_read(grp, "data2d")
+    return Surface(data2d)
+end
 function _hdf5plot_read(grp, k::String, T::Type{Subplot}, dtid)
     grp = HDF5.g_open(grp, k)
     idx = _hdf5plot_read(grp, "index")

src/backends/pgfplots.jl

@@ -27,7 +27,7 @@ const _pgfplots_attr = merge_with_base_supported([
     :tickfont, :guidefont, :legendfont,
     :grid, :legend,
     :colorbar,
-    :fill_z, :line_z, :marker_z, #:levels,
+    :fill_z, :line_z, :marker_z, :levels,
     # :ribbon, :quiver, :arrow,
     # :orientation,
     # :overwrite_figure,
@@ -38,6 +38,7 @@ const _pgfplots_attr = merge_with_base_supported([
     :tick_direction,
     :framestyle,
     :camera,
+    :contour_labels,
   ])
 const _pgfplots_seriestype = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour, :shape, :straightline,]
 const _pgfplots_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
@@ -172,14 +173,8 @@ end
 
 function pgf_marker(d, i = 1)
     shape = _cycle(d[:markershape], i)
-    cstr, a = pgf_color(_cycle(d[:markercolor], i))
-    if d[:markeralpha] != nothing
-        a = _cycle(d[:markeralpha], i)
-    end
-    cstr_stroke, a_stroke = pgf_color(_cycle(d[:markerstrokecolor], i))
-    if d[:markerstrokealpha] != nothing
-        a_stroke = _cycle(d[:markerstrokealpha], i)
-    end
+    cstr, a = pgf_color(plot_color(get_markercolor(d, i), get_markeralpha(d, i)))
+    cstr_stroke, a_stroke = pgf_color(plot_color(get_markerstrokecolor(d, i), get_markerstrokealpha(d, i)))
     """
     mark = $(get(_pgfplots_markers, shape, "*")),
     mark size = $(0.5 * _cycle(d[:markersize], i)),
@@ -221,10 +216,6 @@ function pgf_series(sp::Subplot, series::Series)
         straightline_data(series)
     elseif st == :shape
         shape_data(series)
-    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]
     elseif ispolar(sp)
         theta, r = filter_radial_data(d[:x], d[:y], axis_limits(sp[:yaxis]))
         rad2deg.(theta), r
@@ -250,6 +241,8 @@ function pgf_series(sp::Subplot, series::Series)
         func = if st == :histogram2d
             PGFPlots.Histogram2
         else
+            kw[:labels] = series[:contour_labels]
+            kw[:levels] = series[:levels]
             PGFPlots.Contour
         end
         push!(series_collection, func(args...; kw...))
@@ -509,7 +502,10 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
             kw[:legendPos] = _pgfplots_legend_pos[legpos]
         end
 
-        if is3d(sp)
+        if any(s[:seriestype] == :contour for s in series_list(sp))
+            kw[:view] = "{0}{90}"
+            kw[:colorbar] = !(sp[:colorbar] in (:none, :off, :hide, false))
+        elseif is3d(sp)
             azim, elev = sp[:camera]
             kw[:view] = "{$(azim)}{$(elev)}"
         end

src/backends/plotly.jl

@@ -264,7 +264,10 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
 
     ax[:tickangle] = -axis[:rotation]
     lims = axis_limits(axis)
-    axis[:ticks] != :native ? ax[:range] = map(scalefunc(axis[:scale]), lims) : nothing
+
+    if axis[:ticks] != :native || axis[:lims] != :auto
+        ax[:range] = map(scalefunc(axis[:scale]), lims)
+    end
 
     if !(axis[:ticks] in (nothing, :none, false))
         ax[:titlefont] = plotly_font(guidefont(axis))
@@ -385,6 +388,7 @@ function plotly_layout(plt::Plot)
                 :bgcolor  => rgba_string(sp[:background_color_legend]),
                 :bordercolor => rgba_string(sp[:foreground_color_legend]),
                 :font     => plotly_font(legendfont(sp)),
+                :tracegroupgap => 0,
                 :x => xpos,
                 :y => ypos
             )
@@ -485,6 +489,21 @@ function plotly_close_shapes(x, y)
     nanvcat(xs), nanvcat(ys)
 end
 
+function plotly_data(series::Series, letter::Symbol, data)
+    axis = series[:subplot][Symbol(letter, :axis)]
+
+    data = if axis[:ticks] == :native && data != nothing
+        plotly_native_data(axis, data)
+    else
+       data
+    end
+
+    if series[:seriestype] in (:heatmap, :contour, :surface, :wireframe)
+        plotly_surface_data(series, data)
+    else
+        plotly_data(data)
+    end
+end
 plotly_data(v) = v != nothing ? collect(v) : v
 plotly_data(surf::Surface) = surf.surf
 plotly_data(v::AbstractArray{R}) where {R<:Rational} = float(v)
@@ -493,6 +512,28 @@ 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)
 
+function plotly_native_data(axis::Axis, data::AbstractArray)
+    if !isempty(axis[:discrete_values])
+        construct_categorical_data(data, axis)
+    elseif axis[:formatter] in (datetimeformatter, dateformatter, timeformatter)
+        plotly_convert_to_datetime(data, axis[:formatter])
+    else
+        data
+    end
+end
+plotly_native_data(axis::Axis, a::Surface) = Surface(plotly_native_data(axis, a.surf))
+
+function plotly_convert_to_datetime(x::AbstractArray, formatter::Function)
+    if formatter == datetimeformatter
+        map(xi -> replace(formatter(xi), "T", " "), x)
+    elseif formatter == dateformatter
+        map(xi -> string(formatter(xi), " 00:00:00"), x)
+    elseif formatter == timeformatter
+        map(xi -> string(Dates.Date(Dates.now()), " ", formatter(xi)), x)
+    else
+        error("Invalid DateTime formatter. Expected Plots.datetime/date/time formatter but got $formatter")
+    end
+end
 #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 = α)
@@ -513,20 +554,17 @@ function plotly_series(plt::Plot, series::Series)
     d_out[:yaxis] = "y$(y_idx)"
     d_out[:showlegend] = should_add_to_legend(series)
 
-
-    x, y, z = map(letter -> (axis = sp[Symbol(letter, :axis)];
-        if axis[:ticks] == :native && !isempty(axis[:discrete_values])
-            axis[:discrete_values]
-        elseif st in (:heatmap, :contour, :surface, :wireframe)
-            plotly_surface_data(series, series[letter])
-        else
-            plotly_data(series[letter])
-        end), (:x, :y, :z))
-
     if st == :straightline
         x, y = straightline_data(series)
+        z = series[:z]
+    else
+        x, y, z  = series[:x], series[:y], series[:z]
     end
 
+    x, y, z = (plotly_data(series, letter, data)
+        for (letter, data) in zip((:x, :y, :z), (x, y, z))
+    )
+
     d_out[:name] = series[:label]
 
     isscatter = st in (:scatter, :scatter3d, :scattergl)
@@ -595,31 +633,17 @@ function plotly_series(plt::Plot, series::Series)
 
     # add "marker"
     if hasmarker
+        inds = eachindex(x)
         d_out[:marker] = KW(
             :symbol => get(_plotly_markers, series[:markershape], string(series[:markershape])),
             # :opacity => series[:markeralpha],
-            :size => 2 * series[:markersize],
-            # :color => rgba_string(series[:markercolor]),
+            :size => 2 * _cycle(series[:markersize], inds),
+            :color => rgba_string.(plot_color.(get_markercolor.(series, inds), get_markeralpha.(series, inds))),
             :line => KW(
-                :color => _cycle(rgba_string.(series[:markerstrokecolor]),eachindex(series[:x])),
-                :width => series[:markerstrokewidth],
+                :color => rgba_string.(plot_color.(get_markerstrokecolor.(series, inds), get_markerstrokealpha.(series, inds))),
+                :width => _cycle(series[:markerstrokewidth], inds),
             ),
         )
-
-        # gotta hack this (for now?) since plotly can't handle rgba values inside the gradient
-        if series[:marker_z] == nothing
-            d_out[:marker][:color] = _cycle(rgba_string.(series[:markercolor]),eachindex(series[:x]))
-        else
-            # grad = ColorGradient(series[:markercolor], alpha=series[:markeralpha])
-            # grad = as_gradient(series[:markercolor], series[:markeralpha])
-            cmin, cmax = get_clims(sp)
-            # zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line)
-            d_out[:marker][:color] = [clamp(zi, cmin, cmax) for zi in series[:marker_z]]
-            d_out[:marker][:cmin] = cmin
-            d_out[:marker][:cmax] = cmax
-            d_out[:marker][:colorscale] = plotly_colorscale(series[:markercolor], series[:markeralpha])
-            d_out[:marker][:showscale] = hascolorbar(sp)
-        end
     end
 
     plotly_polar!(d_out, series)
@@ -637,18 +661,22 @@ function plotly_series_shapes(plt::Plot, series::Series)
 
     # these are the axes that the series should be mapped to
     x_idx, y_idx = plotly_link_indicies(plt, series[:subplot])
-    base_d = KW()
-    base_d[:xaxis] = "x$(x_idx)"
-    base_d[:yaxis] = "y$(y_idx)"
-    base_d[:name] = series[:label]
-    # base_d[:legendgroup] = series[:label]
+    d_base = KW(
+        :xaxis => "x$(x_idx)",
+        :yaxis => "y$(y_idx)",
+        :name => series[:label],
+        :legendgroup => series[:label],
+    )
+
+    x, y = (plotly_data(series, letter, data)
+        for (letter, data) in zip((:x, :y), shape_data(series))
+    )
 
-    x, y = shape_data(series)
     for (i,rng) in enumerate(segments)
         length(rng) < 2 && continue
 
         # to draw polygons, we actually draw lines with fill
-        d_out = merge(base_d, KW(
+        d_out = merge(d_base, KW(
             :type => "scatter",
             :mode => "lines",
             :x => vcat(x[rng], x[rng[1]]),
@@ -669,9 +697,11 @@ function plotly_series_shapes(plt::Plot, series::Series)
         d_outs[i] = d_out
     end
     if series[:fill_z] != nothing
-        push!(d_outs, plotly_colorbar_hack(series, base_d, :fill))
+        push!(d_outs, plotly_colorbar_hack(series, d_base, :fill))
     elseif series[:line_z] != nothing
-        push!(d_outs, plotly_colorbar_hack(series, base_d, :line))
+        push!(d_outs, plotly_colorbar_hack(series, d_base, :line))
+    elseif series[:marker_z] != nothing
+        push!(d_outs, plotly_colorbar_hack(series, d_base, :marker))
     end
     d_outs
 end
@@ -689,10 +719,11 @@ function plotly_series_segments(series::Series, d_base::KW, x, y, z)
     d_outs = Vector{KW}((hasfillrange ? 2 : 1 ) * length(segments))
 
     for (i,rng) in enumerate(segments)
-        length(rng) < 2 && continue
+        !isscatter && length(rng) < 2 && continue
 
         d_out = deepcopy(d_base)
         d_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        d_out[:legendgroup] = series[:label]
 
         # set the type
         if st in (:path, :scatter, :scattergl, :straightline)
@@ -726,30 +757,15 @@ function plotly_series_segments(series::Series, d_base::KW, x, y, z)
         # add "marker"
         if hasmarker
             d_out[:marker] = KW(
-                :symbol => get(_plotly_markers, series[:markershape], string(series[:markershape])),
+                :symbol => get(_plotly_markers, _cycle(series[:markershape], i), string(_cycle(series[:markershape], i))),
                 # :opacity => series[:markeralpha],
-                :size => 2 * series[:markersize],
-                # :color => rgba_string(series[:markercolor]),
+                :size => 2 * _cycle(series[:markersize], i),
+                :color => rgba_string(plot_color(get_markercolor(series, i), get_markeralpha(series, i))),
                 :line => KW(
-                    :color => _cycle(rgba_string.(series[:markerstrokecolor]), eachindex(rng)),
-                    :width => series[:markerstrokewidth],
+                    :color => rgba_string(plot_color(get_markerstrokecolor(series, i), get_markerstrokealpha(series, i))),
+                    :width => _cycle(series[:markerstrokewidth], i),
                 ),
             )
-
-            # gotta hack this (for now?) since plotly can't handle rgba values inside the gradient
-            if series[:marker_z] == nothing
-                d_out[:marker][:color] = _cycle(rgba_string.(series[:markercolor]), eachindex(rng))
-            else
-                # grad = ColorGradient(series[:markercolor], alpha=series[:markeralpha])
-                # grad = as_gradient(series[:markercolor], series[:markeralpha])
-                cmin, cmax = get_clims(sp)
-                # zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line)
-                d_out[:marker][:color] = [clamp(zi, cmin, cmax) for zi in _cycle(series[:marker_z], rng)]
-                d_out[:marker][:cmin] = cmin
-                d_out[:marker][:cmax] = cmax
-                d_out[:marker][:colorscale] = plotly_colorscale(series[:markercolor], series[:markeralpha])
-                d_out[:marker][:showscale] = hascolorbar(sp)
-            end
         end
 
         # add "line"
@@ -791,8 +807,8 @@ function plotly_series_segments(series::Series, d_base::KW, x, y, z)
             else
                 # if fillrange is a tuple with upper and lower limit, d_out_fillrange
                 # is the series that will do the filling
-                d_out_fillrange[:x], d_out_fillrange[:y] =
-                    concatenate_fillrange(x[rng], series[:fillrange][rng])
+                fillrng = Tuple(series[:fillrange][i][rng] for i in 1:2)
+                d_out_fillrange[:x], d_out_fillrange[:y] = concatenate_fillrange(x[rng], fillrng)
                 d_out_fillrange[:line][:width] = 0
                 delete!(d_out, :fill)
                 delete!(d_out, :fillcolor)
@@ -808,6 +824,8 @@ function plotly_series_segments(series::Series, d_base::KW, x, y, z)
         push!(d_outs, plotly_colorbar_hack(series, d_base, :line))
     elseif series[:fill_z] != nothing
         push!(d_outs, plotly_colorbar_hack(series, d_base, :fill))
+    elseif series[:marker_z] != nothing
+        push!(d_outs, plotly_colorbar_hack(series, d_base, :marker))
     end
 
     d_outs

src/backends/pyplot.jl

@@ -570,12 +570,12 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     if series[:markershape] != :none && st in (:path, :scatter, :path3d,
                                           :scatter3d, :steppre, :steppost,
                                           :bar)
-        if series[:marker_z] == nothing
-            extrakw[:c] = series[:markershape] in (:+, :x, :hline, :vline) ? py_markerstrokecolor(series) : py_color_fix(py_markercolor(series), x)
+        markercolor = if any(typeof(series[arg]) <: AVec for arg in (:markercolor, :markeralpha)) || series[:marker_z] != nothing
+            py_color(plot_color.(get_markercolor.(series, eachindex(x)), get_markeralpha.(series, eachindex(x))))
         else
-            extrakw[:c] = convert(Vector{Float64}, series[:marker_z])
-            extrakw[:cmap] = py_markercolormap(series)
+            py_color(plot_color(series[:markercolor], series[:markeralpha]))
         end
+        extrakw[:c] = py_color_fix(markercolor, x)
         xyargs = if st == :bar && !isvertical(series)
             (y, x)
         else
@@ -591,11 +591,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             msc = py_markerstrokecolor(series)
             lw = py_dpi_scale(plt, series[:markerstrokewidth])
             for i=1:length(y)
-                extrakw[:c] = if series[:marker_z] == nothing
-                    py_color_fix(py_color(_cycle(series[:markercolor],i)), x)
-                else
-                    extrakw[:c]
-                end
+                extrakw[:c] = _cycle(markercolor, i)
 
                 push!(handle, ax[:scatter](_cycle(x,i), _cycle(y,i);
                     label = series[:label],
@@ -638,6 +634,12 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
     if st in (:contour, :contour3d)
         z = transpose_z(series, z.surf)
+	if typeof(x)<:Plots.Surface
+            x = Plots.transpose_z(series, x.surf)
+        end
+        if typeof(y)<:Plots.Surface
+            y = Plots.transpose_z(series, y.surf)
+        end
 
         if st == :contour3d
             extrakw[:extend3d] = true
@@ -1014,10 +1016,16 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 kw[:ticks] = locator
                 kw[:format] = formatter
                 kw[:boundaries] = vcat(0, kw[:values] + 0.5)
-            elseif any(colorbar_series[attr] != nothing for attr in (:line_z, :fill_z))
+            elseif any(colorbar_series[attr] != nothing for attr in (:line_z, :fill_z, :marker_z))
                 cmin, cmax = get_clims(sp)
                 norm = pycolors[:Normalize](vmin = cmin, vmax = cmax)
-                f = colorbar_series[:line_z] != nothing ? py_linecolormap : py_fillcolormap
+                f = if colorbar_series[:line_z] != nothing
+                    py_linecolormap
+                elseif colorbar_series[:fill_z] != nothing
+                    py_fillcolormap
+                else
+                    py_markercolormap
+                end
                 cmap = pycmap[:ScalarMappable](norm = norm, cmap = f(colorbar_series))
                 cmap[:set_array]([])
                 handle = cmap

src/pipeline.jl

@@ -327,7 +327,7 @@ end
 
 function _override_seriestype_check(d::KW, st::Symbol)
     # do we want to override the series type?
-    if !is3d(st)
+    if !is3d(st) && !(st in (:contour,:contour3d))
         z = d[:z]
         if !isa(z, Void) && (size(d[:x]) == size(d[:y]) == size(z))
             st = (st == :scatter ? :scatter3d : :path3d)
@@ -398,6 +398,7 @@ function _process_seriesrecipe(plt::Plot, d::KW)
         sp = _prepare_subplot(plt, d)
         _prepare_annotations(sp, d)
         _expand_subplot_extrema(sp, d, st)
+        _update_series_attributes!(d, plt, sp)
         _add_the_series(plt, sp, d)
 
     else

src/series.jl

@@ -627,7 +627,7 @@ group_as_matrix(t) = false
     else
         g = args[1]
         if length(g.args) == 1
-            x = zeros(Int64, lengthGroup)
+            x = zeros(Int, lengthGroup)
             for indexes in groupby.groupIds
                 x[indexes] = 1:length(indexes)
             end

src/utils.jl

@@ -195,9 +195,13 @@ end
 function iter_segments(series::Series)
     x, y, z = series[:x], series[:y], series[:z]
     if has_attribute_segments(series)
-        return [i:(i + 1) for i in 1:(length(y) - 1)]
+        if series[:seriestype] in (:scatter, :scatter3d)
+            return [[i] for i in 1:length(y)]
+        else
+            return [i:(i + 1) for i in 1:(length(y) - 1)]
+        end
     else
-        segs = UnitRange{Int64}[]
+        segs = UnitRange{Int}[]
         args = is3d(series) ? (x, y, z) : (x, y)
         for seg in iter_segments(args...)
             push!(segs, seg)
@@ -207,7 +211,7 @@ function iter_segments(series::Series)
 end
 
 # helpers to figure out if there are NaN values in a list of array types
-anynan(i::Int, args::Tuple) = any(a -> !isfinite(_cycle(a,i)), args)
+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)
 
@@ -620,7 +624,7 @@ function get_linecolor(series, i::Int = 1)
     lc = series[:linecolor]
     lz = series[:line_z]
     if lz == nothing
-        isa(lc, ColorGradient) ? lc : _cycle(lc, i)
+        isa(lc, ColorGradient) ? lc : plot_color(_cycle(lc, i))
     else
         cmin, cmax = get_clims(series[:subplot])
         grad = isa(lc, ColorGradient) ? lc : cgrad()
@@ -644,7 +648,7 @@ function get_fillcolor(series, i::Int = 1)
     fc = series[:fillcolor]
     fz = series[:fill_z]
     if fz == nothing
-        isa(fc, ColorGradient) ? fc : _cycle(fc, i)
+        isa(fc, ColorGradient) ? fc : plot_color(_cycle(fc, i))
     else
         cmin, cmax = get_clims(series[:subplot])
         grad = isa(fc, ColorGradient) ? fc : cgrad()
@@ -656,6 +660,31 @@ function get_fillalpha(series, i::Int = 1)
     _cycle(series[:fillalpha], i)
 end
 
+function get_markercolor(series, i::Int = 1)
+    mc = series[:markercolor]
+    mz = series[:marker_z]
+    if mz == nothing
+        isa(mc, ColorGradient) ? mc : plot_color(_cycle(mc, i))
+    else
+        cmin, cmax = get_clims(series[:subplot])
+        grad = isa(mc, ColorGradient) ? mc : cgrad()
+        grad[clamp((_cycle(mz, i) - cmin) / (cmax - cmin), 0, 1)]
+    end
+end
+
+function get_markeralpha(series, i::Int = 1)
+    _cycle(series[:markeralpha], i)
+end
+
+function get_markerstrokecolor(series, i::Int = 1)
+    msc = series[:markerstrokecolor]
+    isa(msc, ColorGradient) ? msc : _cycle(msc, i)
+end
+
+function get_markerstrokealpha(series, i::Int = 1)
+    _cycle(series[:markerstrokealpha], i)
+end
+
 function has_attribute_segments(series::Series)
     # we want to check if a series needs to be split into segments just because
     # of its attributes
@@ -666,7 +695,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]) || any(typeof(series[attr]) <: AbstractArray{<:Real} for attr in (:line_z, :fill_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{<:Real} for attr in (:line_z, :fill_z, :marker_z))
 end
 
 # ---------------------------------------------------------------
@@ -1188,3 +1217,7 @@ function shape_data(series)
     end
     return x, y
 end
+
+function construct_categorical_data(x::AbstractArray, axis::Axis)
+    map(xi -> axis[:discrete_values][searchsortedfirst(axis[:continuous_values], xi)], x)
+end

test/imgcomp.jl

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