Merge pull request #2498 from daschw/copy

Don't copy input data

deps/generateprecompiles.jl

@@ -26,13 +26,15 @@
 
 using SnoopCompile
 
+project_flag = string("--project=", joinpath(homedir(), ".julia", "dev", "Plots"))
 log_path = joinpath(tempdir(), "compiles.log")
 precompiles_path = joinpath(tempdir(), "precompile")
 
 # run examples with GR backend, logging what needs to be compiled
-SnoopCompile.@snoopc log_path begin
+SnoopCompile.@snoopc project_flag log_path begin
     using Plots
-    Plots.test_examples(:gr, disp=true)
+    Plots.test_examples(:gr)
+    Plots.test_examples(:plotly, skip = Plots._backend_skips[:plotly])
 end
 
 # precompile calls containing the following strings are dropped

src/series.jl

@@ -70,23 +70,19 @@ process_ribbon(ribbon::Tuple{Any,Any}, plotattributes) = collect(zip(convertToAn
 
 # --------------------------------------------------------------------
 
-# TODO: can we avoid the copy here?  one error that crops up is that mapping functions over the same array
-#       result in that array being shared.  push!, etc will add too many items to that array
-
 compute_x(x::Nothing, y::Nothing, z)    = axes(z,1)
 compute_x(x::Nothing, y, z)             = axes(y,1)
 compute_x(x::Function, y, z)            = map(x, y)
-compute_x(x, y, z)                  = copy(x)
+compute_x(x, y, z)                      = x
 
-# compute_y(x::Void, y::Function, z)  = error()
 compute_y(x::Nothing, y::Nothing, z)    = axes(z,2)
 compute_y(x, y::Function, z)            = map(y, x)
-compute_y(x, y, z)                  = copy(y)
+compute_y(x, y, z)                      = y
 
 compute_z(x, y, z::Function)            = map(z, x, y)
 compute_z(x, y, z::AbstractMatrix)      = Surface(z)
 compute_z(x, y, z::Nothing)             = nothing
-compute_z(x, y, z)                  = copy(z)
+compute_z(x, y, z)                      = z
 
 nobigs(v::AVec{BigFloat}) = map(Float64, v)
 nobigs(v::AVec{BigInt}) = map(Int64, v)

src/utils.jl

@@ -1,119 +1,4 @@
 
-calcMidpoints(edges::AbstractVector) = Float64[0.5 * (edges[i] + edges[i+1]) for i in 1:length(edges)-1]
-
-"Make histogram-like bins of data"
-function binData(data, nbins)
-  lo, hi = ignorenan_extrema(data)
-  edges = collect(range(lo, stop=hi, length=nbins+1))
-  midpoints = calcMidpoints(edges)
-  buckets = Int[max(2, min(searchsortedfirst(edges, x), length(edges)))-1 for x in data]
-  counts = zeros(Int, length(midpoints))
-  for b in buckets
-    counts[b] += 1
-  end
-  edges, midpoints, buckets, counts
-end
-
-"""
-A hacky replacement for a histogram when the backend doesn't support histograms directly.
-Convert it into a bar chart with the appropriate x/y values.
-"""
-function histogramHack(; kw...)
-  plotattributes = KW(kw)
-
-  # we assume that the y kwarg is set with the data to be binned, and nbins is also defined
-  edges, midpoints, buckets, counts = binData(plotattributes[:y], plotattributes[:bins])
-  plotattributes[:x] = midpoints
-  plotattributes[:y] = float(counts)
-  plotattributes[:seriestype] = :bar
-  plotattributes[:fillrange] = plotattributes[:fillrange] === nothing ? 0.0 : plotattributes[:fillrange]
-  plotattributes
-end
-
-"""
-A hacky replacement for a bar graph when the backend doesn't support bars directly.
-Convert it into a line chart with fillrange set.
-"""
-function barHack(; kw...)
-  plotattributes = KW(kw)
-  midpoints = plotattributes[:x]
-  heights = plotattributes[:y]
-  fillrange = plotattributes[:fillrange] === nothing ? 0.0 : plotattributes[:fillrange]
-
-  # estimate the edges
-  dists = diff(midpoints) * 0.5
-  edges = zeros(length(midpoints)+1)
-  for i in eachindex(edges)
-    if i == 1
-      edge = midpoints[1] - dists[1]
-    elseif i == length(edges)
-      edge = midpoints[i-1] + dists[i-2]
-    else
-      edge = midpoints[i-1] + dists[i-1]
-    end
-    edges[i] = edge
-  end
-
-  x = Float64[]
-  y = Float64[]
-  for i in eachindex(heights)
-    e1, e2 = edges[i:i+1]
-    append!(x, [e1, e1, e2, e2])
-    append!(y, [fillrange, heights[i], heights[i], fillrange])
-  end
-
-  plotattributes[:x] = x
-  plotattributes[:y] = y
-  plotattributes[:seriestype] = :path
-  plotattributes[:fillrange] = fillrange
-  plotattributes
-end
-
-
-"""
-A hacky replacement for a sticks graph when the backend doesn't support sticks directly.
-Convert it into a line chart that traces the sticks, and a scatter that sets markers at the points.
-"""
-function sticksHack(; kw...)
-  plotattributesLine = KW(kw)
-  plotattributesScatter = copy(plotattributesLine)
-
-  # these are the line vertices
-  x = Float64[]
-  y = Float64[]
-  fillrange = plotattributesLine[:fillrange] === nothing ? 0.0 : plotattributesLine[:fillrange]
-
-  # calculate the vertices
-  yScatter = plotattributesScatter[:y]
-  for (i,xi) in enumerate(plotattributesScatter[:x])
-    yi = yScatter[i]
-    for j in 1:3 push!(x, xi) end
-    append!(y, [fillrange, yScatter[i], fillrange])
-  end
-
-  # change the line args
-  plotattributesLine[:x] = x
-  plotattributesLine[:y] = y
-  plotattributesLine[:seriestype] = :path
-  plotattributesLine[:markershape] = :none
-  plotattributesLine[:fillrange] = nothing
-
-  # change the scatter args
-  plotattributesScatter[:seriestype] = :none
-
-  plotattributesLine, plotattributesScatter
-end
-
-function regressionXY(x, y)
-  # regress
-  β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y)
-
-  # make a line segment
-  regx = [ignorenan_minimum(x), ignorenan_maximum(x)]
-  regy = β * regx + α
-  regx, regy
-end
-
 function replace_image_with_heatmap(z::Array{T}) where T<:Colorant
     n, m = size(z)
     colors = ColorGradient(vec(z))
@@ -279,8 +164,6 @@ function _expand_limits(lims, x)
         e1, e2 = ignorenan_extrema(x)
         lims[1] = NaNMath.min(lims[1], e1)
         lims[2] = NaNMath.max(lims[2], e2)
-  # catch err
-  #   @warn(err)
     catch
     end
     nothing
@@ -771,9 +654,9 @@ function with(f::Function, args...; kw...)
             backend(arg)
         end
 
-    # # TODO: generalize this strategy to allow args as much as possible
+        # TODO: generalize this strategy to allow args as much as possible
-    # #       as in:  with(:gr, :scatter, :legend, :grid) do; ...; end
+        #       as in:  with(:gr, :scatter, :legend, :grid) do; ...; end
-    # # TODO: can we generalize this enough to also do something similar in the plot commands??
+        # TODO: can we generalize this enough to also do something similar in the plot commands??
 
         # k = :seriestype
         # if arg in _allTypes
@@ -853,18 +736,6 @@ function dumpcallstack()
     error()  # well... you wanted the stacktrace, didn't you?!?
 end
 
-# ---------------------------------------------------------------
-# ---------------------------------------------------------------
-# used in updating an existing series
-
-extendSeriesByOne(v::UnitRange{Int}, n::Int = 1) = isempty(v) ? (1:n) : (minimum(v):maximum(v)+n)
-extendSeriesByOne(v::AVec, n::Integer = 1)       = isempty(v) ? (1:n) : vcat(v, (1:n) + ignorenan_maximum(v))
-extendSeriesData(v::AbstractRange{T}, z::Real) where {T}        = extendSeriesData(float(collect(v)), z)
-extendSeriesData(v::AbstractRange{T}, z::AVec) where {T}        = extendSeriesData(float(collect(v)), z)
-extendSeriesData(v::AVec{T}, z::Real) where {T}         = (push!(v, convert(T, z)); v)
-extendSeriesData(v::AVec{T}, z::AVec) where {T}         = (append!(v, convert(Vector{T}, z)); v)
-
-
 # -------------------------------------------------------
 # NOTE: backends should implement the following methods to get/set the x/y/z data objects
 
@@ -908,33 +779,60 @@ Base.setindex!(plt::Plot, xy::Tuple{X,Y}, i::Integer) where {X,Y} = (setxy!(plt,
 Base.setindex!(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer) where {X,Y,Z} = (setxyz!(plt, xyz, i); plt)
 
 # -------------------------------------------------------
-
 # operate on individual series
 
-function push_x!(series::Series, xi)
+Base.push!(series::Series, args...) = extend_series!(series, args...)
-    push!(series[:x], xi)
+Base.append!(series::Series, args...) = extend_series!(series, args...)
-    expand_extrema!(series[:subplot][:xaxis], xi)
+
-    return
+function extend_series!(series::Series, yi)
-end
+    y = extend_series_data!(series, yi, :y)
-function push_y!(series::Series, yi)
+    x = extend_to_length!(series[:x], length(y))
-    push!(series[:y], yi)
+    expand_extrema!(series[:subplot][:xaxis], x)
-    expand_extrema!(series[:subplot][:yaxis], yi)
+    return x, y
-    return
-end
-function push_z!(series::Series, zi)
-    push!(series[:z], zi)
-    expand_extrema!(series[:subplot][:zaxis], zi)
-    return
 end
 
-function Base.push!(series::Series, yi)
+function extend_series!(series::Series, xi, yi)
-    x = extendSeriesByOne(series[:x])
+    x = extend_series_data!(series, xi, :x)
-    expand_extrema!(series[:subplot][:xaxis], x[end])
+    y = extend_series_data!(series, yi, :y)
-    series[:x] = x
+    return x, y
-    push_y!(series, yi)
+end
+
+function extend_series!(series::Series, xi, yi, zi)
+    x = extend_series_data!(series, xi, :x)
+    y = extend_series_data!(series, yi, :y)
+    z = extend_series_data!(series, zi, :z)
+    return x, y, z
+end
+
+function extend_series_data!(series::Series, v, letter)
+    copy_series!(series, letter)
+    d = extend_by_data!(series[letter], v)
+    expand_extrema!(series[:subplot][Symbol(letter, :axis)], d)
+    return d
+end
+
+function copy_series!(series, letter)
+    plt = series[:plot_object]
+    for s in plt.series_list
+        for l in (:x, :y, :z)
+            if s !== series || l !== letter
+                if s[l] === series[letter]
+                    series[letter] = copy(series[letter])
+                end
+            end
+        end
+    end
+end
+
+extend_to_length!(v::AbstractRange, n) = range(first(v), step = step(v), length = n)
+function extend_to_length!(v::AbstractVector, n)
+    vmax = isempy(v) ? 0 : ignorenan_maximum(v)
+    extend_by_data!(v, vmax .+ (1:(n - length(v))))
+end
+extend_by_data!(v::AbstractVector, x) = isimmutable(v) ? vcat(v, x) : push!(v, x)
+function extend_by_data!(v::AbstractVector, x::AbstractVector)
+    isimmutable(v) ? vcat(v, x) : append!(v, x)
 end
-Base.push!(series::Series, xi, yi) = (push_x!(series,xi); push_y!(series,yi))
-Base.push!(series::Series, xi, yi, zi) = (push_x!(series,xi); push_y!(series,yi); push_z!(series,zi))
 
 # -------------------------------------------------------
 
@@ -968,59 +866,16 @@ end
 # -------------------------------------------------------
 # push/append for one series
 
-# push value to first series
+Base.push!(plt::Plot, args::Real...) = push!(plt, 1, args...)
-Base.push!(plt::Plot, y::Real) = push!(plt, 1, y)
+Base.push!(plt::Plot, i::Integer, args::Real...) = push!(plt.series_list[i], args...)
-Base.push!(plt::Plot, x::Real, y::Real) = push!(plt, 1, x, y)
+Base.append!(plt::Plot, args::AbstractVector...) = append!(plt, 1, args...)
-Base.push!(plt::Plot, x::Real, y::Real, z::Real) = push!(plt, 1, x, y, z)
+Base.append!(plt::Plot, i::Integer, args::Real...) = append!(plt.series_list[i], args...)
-
-# y only
-function Base.push!(plt::Plot, i::Integer, y::Real)
-    xdata, ydata = getxy(plt, i)
-    setxy!(plt, (extendSeriesByOne(xdata), extendSeriesData(ydata, y)), i)
-    plt
-end
-function Base.append!(plt::Plot, i::Integer, y::AVec)
-    xdata, ydata = plt[i]
-    if !isa(xdata, UnitRange{Int})
-        error("Expected x is a UnitRange since you're trying to push a y value only")
-    end
-    plt[i] = (extendSeriesByOne(xdata, length(y)), extendSeriesData(ydata, y))
-    plt
-end
-
-# x and y
-function Base.push!(plt::Plot, i::Integer, x::Real, y::Real)
-    xdata, ydata = getxy(plt, i)
-    setxy!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y)), i)
-    plt
-end
-function Base.append!(plt::Plot, i::Integer, x::AVec, y::AVec)
-    @assert length(x) == length(y)
-    xdata, ydata = getxy(plt, i)
-    setxy!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y)), i)
-    plt
-end
-
-# x, y, and z
-function Base.push!(plt::Plot, i::Integer, x::Real, y::Real, z::Real)
-    # @show i, x, y, z
-    xdata, ydata, zdata = getxyz(plt, i)
-    # @show xdata, ydata, zdata
-    setxyz!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y), extendSeriesData(zdata, z)), i)
-    plt
-end
-function Base.append!(plt::Plot, i::Integer, x::AVec, y::AVec, z::AVec)
-    @assert length(x) == length(y) == length(z)
-    xdata, ydata, zdata = getxyz(plt, i)
-    setxyz!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y), extendSeriesData(zdata, z)), i)
-    plt
-end
 
 # tuples
-Base.push!(plt::Plot, xy::Tuple{X,Y}) where {X,Y}                  = push!(plt, 1, xy...)
+Base.push!(plt::Plot, t::Tuple) = push!(plt, 1, t...)
-Base.push!(plt::Plot, xyz::Tuple{X,Y,Z}) where {X,Y,Z}             = push!(plt, 1, xyz...)
+Base.push!(plt::Plot, i::Integer, t::Tuple) = push!(plt, i, t...)
-Base.push!(plt::Plot, i::Integer, xy::Tuple{X,Y}) where {X,Y}      = push!(plt, i, xy...)
+Base.append!(plt::Plot, t::Tuple) = append!(plt, 1, t...)
-Base.push!(plt::Plot, i::Integer, xyz::Tuple{X,Y,Z}) where {X,Y,Z} = push!(plt, i, xyz...)
+Base.append!(plt::Plot, i::Integer, t::Tuple) = append!(plt, i, t...)
 
 # -------------------------------------------------------
 # push/append for all series