diff --git a/src/backends.jl b/src/backends.jl
index 00ac483a..d64db5e4 100644
--- a/src/backends.jl
+++ b/src/backends.jl
@@ -217,7 +217,7 @@ const _deprecated_backends = [:qwt, :winston, :bokeh, :gadfly, :immerse]
function warn_on_deprecated_backend(bsym::Symbol)
if bsym in _deprecated_backends
- @warn("Backend $bsym has been deprecated. It may not work as originally intended.")
+ @warn("Backend $bsym has been deprecated.")
end
end
@@ -268,13 +268,8 @@ end
-# @init_backend Immerse
-# @init_backend Gadfly
@init_backend PyPlot
-# @init_backend Qwt
@init_backend UnicodePlots
-# @init_backend Winston
-# @init_backend Bokeh
@init_backend Plotly
@init_backend PlotlyJS
@init_backend GR
diff --git a/src/deprecated/backends/bokeh.jl b/src/deprecated/backends/bokeh.jl
deleted file mode 100644
index 9e906b75..00000000
--- a/src/deprecated/backends/bokeh.jl
+++ /dev/null
@@ -1,208 +0,0 @@
-
-# https://github.com/bokeh/Bokeh.jl
-
-
-supported_attrs(::BokehBackend) = merge_with_base_supported([
- # :annotations,
- # :axis,
- # :background_color,
- :linecolor,
- # :color_palette,
- # :fillrange,
- # :fillcolor,
- # :fillalpha,
- # :foreground_color,
- :group,
- # :label,
- # :layout,
- # :legend,
- :seriescolor, :seriesalpha,
- :linestyle,
- :seriestype,
- :linewidth,
- # :linealpha,
- :markershape,
- :markercolor,
- :markersize,
- # :markeralpha,
- # :markerstrokewidth,
- # :markerstrokecolor,
- # :markerstrokestyle,
- # :n,
- # :bins,
- # :nc,
- # :nr,
- # :pos,
- # :smooth,
- # :show,
- :size,
- :title,
- # :window_title,
- :x,
- # :xguide,
- # :xlims,
- # :xticks,
- :y,
- # :yguide,
- # :ylims,
- # :yrightlabel,
- # :yticks,
- # :xscale,
- # :yscale,
- # :xflip,
- # :yflip,
- # :z,
- # :tickfont,
- # :guidefont,
- # :legendfont,
- # :grid,
- # :surface,
- # :levels,
- ])
-supported_types(::BokehBackend) = [:path, :scatter]
-supported_styles(::BokehBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supported_markers(::BokehBackend) = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
-supported_scales(::BokehBackend) = [:identity, :ln]
-is_subplot_supported(::BokehBackend) = false
-
-
-# --------------------------------------------------------------------------------------
-
-
-
-function _initialize_backend(::BokehBackend; kw...)
- @eval begin
- @warn("Bokeh is no longer supported... many features will likely be broken.")
- import Bokeh
- export Bokeh
- end
-end
-
-
-const _glyphtypes = KW(
- :circle => :Circle,
- :rect => :Square,
- :diamond => :Diamond,
- :utriangle => :Triangle,
- :dtriangle => :InvertedTriangle,
- # :pentagon =>
- # :hexagon =>
- # :heptagon =>
- # :octagon =>
- :cross => :Cross,
- :xcross => :X,
- :star5 => :Asterisk,
- )
-
-
-function bokeh_glyph_type(plotattributes::KW)
- st = plotattributes[:seriestype]
- mt = plotattributes[:markershape]
- if st == :scatter && mt == :none
- mt = :circle
- end
-
- # if we have a marker, use that
- if st == :scatter || mt != :none
- return _glyphtypes[mt]
- end
-
- # otherwise return a line
- return :Line
-end
-
-function get_stroke_vector(linestyle::Symbol)
- dash = 12
- dot = 3
- gap = 2
- linestyle == :solid && return Int[]
- linestyle == :dash && return Int[dash, gap]
- linestyle == :dot && return Int[dot, gap]
- linestyle == :dashdot && return Int[dash, gap, dot, gap]
- linestyle == :dashdotdot && return Int[dash, gap, dot, gap, dot, gap]
- error("unsupported linestyle: ", linestyle)
-end
-
-# ---------------------------------------------------------------------------
-
-# function _create_plot(pkg::BokehBackend, plotattributes::KW)
-function _create_backend_figure(plt::Plot{BokehBackend})
- # TODO: create the window/canvas/context that is the plot within the backend (call it `o`)
- # TODO: initialize the plot... title, xlabel, bgcolor, etc
-
- datacolumns = Bokeh.BokehDataSet[]
- tools = Bokeh.tools()
- filename = tempname() * ".html"
- title = plt.attr[:title]
- w, h = plt.attr[:size]
- xaxis_type = plt.attr[:xscale] == :log10 ? :log : :auto
- yaxis_type = plt.attr[:yscale] == :log10 ? :log : :auto
- # legend = plt.attr[:legend] ? xxxx : nothing
- legend = nothing
- extra_args = KW() # TODO: we'll put extra settings (xlim, etc) here
- Bokeh.Plot(datacolumns, tools, filename, title, w, h, xaxis_type, yaxis_type, legend) #, extra_args)
-
- # Plot(bplt, pkg, 0, plotattributes, KW[])
-end
-
-
-# function _series_added(::BokehBackend, plt::Plot, plotattributes::KW)
-function _series_added(plt::Plot{BokehBackend}, series::Series)
- bdata = Dict{Symbol, Vector}(:x => collect(series.plotattributes[:x]), :y => collect(series.plotattributes[:y]))
-
- glyph = Bokeh.Bokehjs.Glyph(
- glyphtype = bokeh_glyph_type(plotattributes),
- linecolor = webcolor(plotattributes[:linecolor]), # shape's stroke or line color
- linewidth = plotattributes[:linewidth], # shape's stroke width or line width
- fillcolor = webcolor(plotattributes[:markercolor]),
- size = ceil(Int, plotattributes[:markersize] * 2.5), # magic number 2.5 to keep in same scale as other backends
- dash = get_stroke_vector(plotattributes[:linestyle])
- )
-
- legend = nothing # TODO
- push!(plt.o.datacolumns, Bokeh.BokehDataSet(bdata, glyph, legend))
-
- # push!(plt.seriesargs, plotattributes)
- # plt
-end
-
-# ----------------------------------------------------------------
-
-# TODO: override this to update plot items (title, xlabel, etc) after creation
-function _update_plot_object(plt::Plot{BokehBackend}, plotattributes::KW)
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-# function getxy(plt::Plot{BokehBackend}, i::Int)
-# series = plt.o.datacolumns[i].data
-# series[:x], series[:y]
-# end
-#
-# function setxy!(plt::Plot{BokehBackend}, xy::Tuple{X,Y}, i::Integer)
-# series = plt.o.datacolumns[i].data
-# series[:x], series[:y] = xy
-# plt
-# end
-
-
-
-# ----------------------------------------------------------------
-
-
-# ----------------------------------------------------------------
-
-function Base.show(io::IO, ::MIME"image/png", plt::AbstractPlot{BokehBackend})
- # TODO: write a png to io
- @warn("mime png not implemented")
-end
-
-function Base.display(::PlotsDisplay, plt::Plot{BokehBackend})
- Bokeh.showplot(plt.o)
-end
-
-# function Base.display(::PlotsDisplay, plt::Subplot{BokehBackend})
-# # TODO: display/show the subplot
-# end
diff --git a/src/deprecated/backends/gadfly.jl b/src/deprecated/backends/gadfly.jl
deleted file mode 100644
index 37dac678..00000000
--- a/src/deprecated/backends/gadfly.jl
+++ /dev/null
@@ -1,744 +0,0 @@
-
-# https://github.com/dcjones/Gadfly.jl
-
-
-supported_attrs(::GadflyBackend) = merge_with_base_supported([
- :annotations,
- :background_color, :foreground_color, :color_palette,
- :group, :label, :seriestype,
- :seriescolor, :seriesalpha,
- :linecolor, :linestyle, :linewidth, :linealpha,
- :markershape, :markercolor, :markersize, :markeralpha,
- :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
- :fillrange, :fillcolor, :fillalpha,
- :bins, :n, :nc, :nr, :layout, :smooth,
- :title, :window_title, :show, :size,
- :x, :xguide, :xlims, :xticks, :xscale, :xflip,
- :y, :yguide, :ylims, :yticks, :yscale, :yflip,
- :z,
- :tickfont, :guidefont, :legendfont,
- :grid, :legend, :colorbar,
- :marker_z, :levels,
- :xerror, :yerror,
- :ribbon, :quiver,
- :orientation,
- ])
-supported_types(::GadflyBackend) = [
- :path,
- :scatter, :hexbin,
- :bar,
- :contour, :shape
- ]
-supported_styles(::GadflyBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-supported_markers(::GadflyBackend) = vcat(_allMarkers, Shape)
-supported_scales(::GadflyBackend) = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
-is_subplot_supported(::GadflyBackend) = true
-
-
-# --------------------------------------------------------------------------------------
-
-function _initialize_backend(::GadflyBackend; kw...)
- @eval begin
- import Gadfly, Compose
- export Gadfly, Compose
- include(joinpath(dirname(@__FILE__), "gadfly_shapes.jl"))
- end
-end
-
-# ---------------------------------------------------------------------------
-
-# immutable MissingVec <: AbstractVector{Float64} end
-# Base.size(v::MissingVec) = (1,)
-# Base.getindex(v::MissingVec, i::Integer) = 0.0
-
-function createGadflyPlotObject(plotattributes::KW)
- gplt = Gadfly.Plot()
- gplt.mapping = Dict()
- gplt.data_source = Gadfly.DataFrames.DataFrame()
- # gplt.layers = gplt.layers[1:0]
- gplt.layers = [Gadfly.layer(Gadfly.Geom.point(tag=:remove), x=zeros(1), y=zeros(1));] # x=MissingVec(), y=MissingVec());]
- gplt.guides = Gadfly.GuideElement[Gadfly.Guide.xlabel(plotattributes[:xguide]),
- Gadfly.Guide.ylabel(plotattributes[:yguide]),
- Gadfly.Guide.title(plotattributes[:title])]
- gplt
-end
-
-# ---------------------------------------------------------------------------
-
-
-function getLineGeom(plotattributes::KW)
- st = plotattributes[:seriestype]
- xbins, ybins = maketuple(plotattributes[:bins])
- if st == :hexb
- Gadfly.Geom.hexbin(xbincount = xbins, ybincount = ybins)
- elseif st == :histogram2d
- Gadfly.Geom.histogram2d(xbincount = xbins, ybincount = ybins)
- elseif st == :histogram
- Gadfly.Geom.histogram(bincount = xbins,
- orientation = isvertical(plotattributes) ? :vertical : :horizontal,
- position = plotattributes[:bar_position] == :stack ? :stack : :dodge)
- elseif st == :path
- Gadfly.Geom.path
- elseif st in (:bar, :sticks)
- Gadfly.Geom.bar
- elseif st == :steppost
- Gadfly.Geom.step
- elseif st == :steppre
- Gadfly.Geom.step(direction = :vh)
- elseif st == :hline
- Gadfly.Geom.hline
- elseif st == :vline
- Gadfly.Geom.vline
- elseif st == :contour
- Gadfly.Geom.contour(levels = plotattributes[:levels])
- # elseif st == :shape
- # Gadfly.Geom.polygon(fill = true, preserve_order = true)
- else
- nothing
- end
-end
-
-function get_extra_theme_args(plotattributes::KW, k::Symbol)
- # gracefully handles old Gadfly versions
- extra_theme_args = KW()
- try
- extra_theme_args[:line_style] = Gadfly.get_stroke_vector(plotattributes[k])
- catch err
- if string(err) == "UndefVarError(:get_stroke_vector)"
- Base.warn_once("Gadfly.get_stroke_vector failed... do you have an old version of Gadfly?")
- else
- rethrow()
- end
- end
- extra_theme_args
-end
-
-function getGadflyLineTheme(plotattributes::KW)
- st = plotattributes[:seriestype]
- lc = convertColor(getColor(plotattributes[:linecolor]), plotattributes[:linealpha])
- fc = convertColor(getColor(plotattributes[:fillcolor]), plotattributes[:fillalpha])
-
- Gadfly.Theme(;
- default_color = (st in (:histogram,:histogram2d,:hexbin,:bar,:sticks) ? fc : lc),
- line_width = (st == :sticks ? 1 : plotattributes[:linewidth]) * Gadfly.px,
- # line_style = Gadfly.get_stroke_vector(plotattributes[:linestyle]),
- lowlight_color = x->RGB(fc), # fill/ribbon
- lowlight_opacity = alpha(fc), # fill/ribbon
- bar_highlight = RGB(lc), # bars
- get_extra_theme_args(plotattributes, :linestyle)...
- )
-end
-
-# add a line as a new layer
-function addGadflyLine!(plt::Plot, numlayers::Int, plotattributes::KW, geoms...)
- gplt = getGadflyContext(plt)
- gfargs = vcat(geoms..., getGadflyLineTheme(plotattributes))
- kwargs = KW()
- st = plotattributes[:seriestype]
-
- # add a fill?
- if plotattributes[:fillrange] != nothing && st != :contour
- fillmin, fillmax = map(makevec, maketuple(plotattributes[:fillrange]))
- nmin, nmax = length(fillmin), length(fillmax)
- kwargs[:ymin] = Float64[min(y, fillmin[mod1(i, nmin)], fillmax[mod1(i, nmax)]) for (i,y) in enumerate(plotattributes[:y])]
- kwargs[:ymax] = Float64[max(y, fillmin[mod1(i, nmin)], fillmax[mod1(i, nmax)]) for (i,y) in enumerate(plotattributes[:y])]
- push!(gfargs, Gadfly.Geom.ribbon)
- end
-
- if st in (:hline, :vline)
- kwargs[st == :hline ? :yintercept : :xintercept] = plotattributes[:y]
-
- else
- if st == :sticks
- w = 0.01 * mean(diff(plotattributes[:x]))
- kwargs[:xmin] = plotattributes[:x] - w
- kwargs[:xmax] = plotattributes[:x] + w
- elseif st == :contour
- kwargs[:z] = plotattributes[:z].surf
- addGadflyContColorScale(plt, plotattributes[:linecolor])
- end
-
- kwargs[:x] = plotattributes[st == :histogram ? :y : :x]
- kwargs[:y] = plotattributes[:y]
-
- end
-
- # # add the layer
- Gadfly.layer(gfargs...; order=numlayers, kwargs...)
-end
-
-
-# ---------------------------------------------------------------------------
-
-get_shape(sym::Symbol) = _shapes[sym]
-get_shape(shape::Shape) = shape
-
-# extract the underlying ShapeGeometry object(s)
-getMarkerGeom(shapes::AVec) = gadflyshape(map(get_shape, shapes))
-getMarkerGeom(other) = gadflyshape(get_shape(other))
-
-# getMarkerGeom(shape::Shape) = gadflyshape(shape)
-# getMarkerGeom(shape::Symbol) = gadflyshape(_shapes[shape])
-# getMarkerGeom(shapes::AVec) = gadflyshape(map(gadflyshape, shapes)) # map(getMarkerGeom, shapes)
-function getMarkerGeom(plotattributes::KW)
- if plotattributes[:seriestype] == :shape
- Gadfly.Geom.polygon(fill = true, preserve_order = true)
- else
- getMarkerGeom(plotattributes[:markershape])
- end
-end
-
-function getGadflyMarkerTheme(plotattributes::KW, attr::KW)
- c = getColor(plotattributes[:markercolor])
- α = plotattributes[:markeralpha]
- if α != nothing
- c = RGBA(RGB(c), α)
- end
-
- ms = plotattributes[:markersize]
- ms = if typeof(ms) <: AVec
- @warn("Gadfly doesn't support variable marker sizes... using the average: $(mean(ms))")
- mean(ms) * Gadfly.px
- else
- ms * Gadfly.px
- end
-
- Gadfly.Theme(;
- default_color = c,
- default_point_size = ms,
- discrete_highlight_color = c -> RGB(getColor(plotattributes[:markerstrokecolor])),
- highlight_width = plotattributes[:markerstrokewidth] * Gadfly.px,
- line_width = plotattributes[:markerstrokewidth] * Gadfly.px,
- # get_extra_theme_args(plotattributes, :markerstrokestyle)...
- )
-end
-
-function addGadflyContColorScale(plt::Plot{GadflyBackend}, c)
- plt.attr[:colorbar] == :none && return
- if !isa(c, ColorGradient)
- c = default_gradient()
- end
- push!(getGadflyContext(plt).scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(c, p))))
-end
-
-function addGadflyMarker!(plt::Plot, numlayers::Int, plotattributes::KW, attr::KW, geoms...)
- gfargs = vcat(geoms..., getGadflyMarkerTheme(plotattributes, attr), getMarkerGeom(plotattributes))
- kwargs = KW()
-
- # handle continuous color scales for the markers
- zcolor = plotattributes[:marker_z]
- if zcolor != nothing && typeof(zcolor) <: AVec
- kwargs[:color] = zcolor
- addGadflyContColorScale(plt, plotattributes[:markercolor])
- end
-
- Gadfly.layer(gfargs...; x = plotattributes[:x], y = plotattributes[:y], order=numlayers, kwargs...)
-end
-
-
-# ---------------------------------------------------------------------------
-
-function addToGadflyLegend(plt::Plot, plotattributes::KW)
- if plt.attr[:legend] != :none && plotattributes[:label] != ""
- gplt = getGadflyContext(plt)
-
- # add the legend if needed
- if all(g -> !isa(g, Gadfly.Guide.ManualColorKey), gplt.guides)
- pushfirst!(gplt.guides, Gadfly.Guide.manual_color_key("", AbstractString[], Color[]))
- end
-
- # now add the series to the legend
- for guide in gplt.guides
- if isa(guide, Gadfly.Guide.ManualColorKey)
- # TODO: there's a BUG in gadfly if you pass in the same color more than once,
- # since gadfly will call unique(colors), but doesn't also merge the rows that match
- # Should ensure from this side that colors which are the same are merged together
-
- c = getColor(plotattributes[plotattributes[:markershape] == :none ? :linecolor : :markercolor])
- foundit = false
-
- # extend the label if we found this color
- for i in 1:length(guide.colors)
- if RGB(c) == guide.colors[i]
- guide.labels[i] *= ", " * plotattributes[:label]
- foundit = true
- end
- end
-
- # didn't find the color, so add a new entry into the legend
- if !foundit
- push!(guide.labels, plotattributes[:label])
- push!(guide.colors, c)
- end
- end
- end
- end
-end
-
-getGadflySmoothing(smooth::Bool) = smooth ? [Gadfly.Geom.smooth(method=:lm)] : Any[]
-getGadflySmoothing(smooth::Real) = [Gadfly.Geom.smooth(method=:loess, smoothing=float(smooth))]
-
-
-function addGadflySeries!(plt::Plot, plotattributes::KW)
- layers = Gadfly.Layer[]
- gplt = getGadflyContext(plt)
-
- # add a regression line?
- # TODO: make more flexible
- smooth = getGadflySmoothing(plotattributes[:smooth])
-
- # lines
- geom = getLineGeom(plotattributes)
- if geom != nothing
- prepend!(layers, addGadflyLine!(plt, length(gplt.layers), plotattributes, geom, smooth...))
- smooth = Any[] # don't add a regression for markers too
- end
-
- # special handling for ohlc and scatter
- st = plotattributes[:seriestype]
- # if st == :ohlc
- # error("Haven't re-implemented after refactoring")
- if st in (:histogram2d, :hexbin) && (isa(plotattributes[:fillcolor], ColorGradient) || isa(plotattributes[:fillcolor], ColorFunction))
- push!(gplt.scales, Gadfly.Scale.ContinuousColorScale(p -> RGB(getColorZ(plotattributes[:fillcolor], p))))
- elseif st == :scatter && plotattributes[:markershape] == :none
- plotattributes[:markershape] = :circle
- end
-
- # markers
- if plotattributes[:markershape] != :none || st == :shape
- prepend!(layers, addGadflyMarker!(plt, length(gplt.layers), plotattributes, plt.attr, smooth...))
- end
-
- st in (:histogram2d, :hexbin, :contour) || addToGadflyLegend(plt, plotattributes)
-
- # now save the layers that apply to this series
- plotattributes[:gadflylayers] = layers
- prepend!(gplt.layers, layers)
-end
-
-
-# ---------------------------------------------------------------------------
-
-# NOTE: I'm leaving this here and commented out just in case I want to implement again... it was hacky code to create multi-colored line segments
-
-# # colorgroup
-# z = plotattributes[:z]
-
-# # handle line segments of different colors
-# cscheme = plotattributes[:linecolor]
-# if isa(cscheme, ColorVector)
-# # create a color scale, and set the color group to the index of the color
-# push!(gplt.scales, Gadfly.Scale.color_discrete_manual(cscheme.v...))
-
-# # this is super weird, but... oh well... for some reason this creates n separate line segments...
-# # create a list of vertices that go: [x1,x2,x2,x3,x3, ... ,xi,xi, ... xn,xn] (same for y)
-# # then the vector passed to the "color" keyword should be a vector: [1,1,2,2,3,3,4,4, ..., i,i, ... , n,n]
-# csindices = Int[mod1(i,length(cscheme.v)) for i in 1:length(plotattributes[:y])]
-# cs = collect(repeat(csindices', 2, 1))[1:end-1]
-# grp = collect(repeat((1:length(plotattributes[:y]))', 2, 1))[1:end-1]
-# plotattributes[:x], plotattributes[:y] = map(createSegments, (plotattributes[:x], plotattributes[:y]))
-# colorgroup = [(:linecolor, cs), (:group, grp)]
-
-
-# ---------------------------------------------------------------------------
-
-
-function addGadflyTicksGuide(gplt, ticks, isx::Bool)
- ticks == :auto && return
-
- # remove the ticks?
- if ticks in (:none, false, nothing)
- return addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
- end
-
- ttype = ticksType(ticks)
-
- # just the values... put ticks here, but use standard labels
- if ttype == :ticks
- gtype = isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks
- replaceType(gplt.guides, gtype(ticks = collect(ticks)))
-
- # set the ticks and the labels
- # Note: this is pretty convoluted, but I think it works. We set the ticks using Gadfly.Guide,
- # and then set the label function (wraps a dict lookup) through a continuous Gadfly.Scale.
- elseif ttype == :ticks_and_labels
- gtype = isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks
- replaceType(gplt.guides, gtype(ticks = collect(ticks[1])))
-
- # # TODO add xtick_label function (given tick, return label??)
- # # Scale.x_discrete(; labels=nothing, levels=nothing, order=nothing)
- # filterGadflyScale(gplt, isx)
- # gfunc = isx ? Gadfly.Scale.x_discrete : Gadfly.Scale.y_discrete
- # labelmap = Dict(zip(ticks...))
- # labelfunc = val -> labelmap[val]
- # push!(gplt.scales, gfunc(levels = collect(ticks[1]), labels = labelfunc))
-
- filterGadflyScale(gplt, isx)
- gfunc = isx ? Gadfly.Scale.x_continuous : Gadfly.Scale.y_continuous
- labelmap = Dict(zip(ticks...))
- labelfunc = val -> labelmap[val]
- push!(gplt.scales, gfunc(labels = labelfunc))
-
- else
- error("Invalid input for $(isx ? "xticks" : "yticks"): ", ticks)
- end
-end
-
-continuousAndSameAxis(scale, isx::Bool) = isa(scale, Gadfly.Scale.ContinuousScale) && scale.vars[1] == (isx ? :x : :y)
-filterGadflyScale(gplt, isx::Bool) = filter!(scale -> !continuousAndSameAxis(scale, isx), gplt.scales)
-
-
-function getGadflyScaleFunction(plotattributes::KW, isx::Bool)
- scalekey = isx ? :xscale : :yscale
- hasScaleKey = haskey(plotattributes, scalekey)
- if hasScaleKey
- scale = plotattributes[scalekey]
- scale == :ln && return isx ? Gadfly.Scale.x_log : Gadfly.Scale.y_log, hasScaleKey, log
- scale == :log2 && return isx ? Gadfly.Scale.x_log2 : Gadfly.Scale.y_log2, hasScaleKey, log2
- scale == :log10 && return isx ? Gadfly.Scale.x_log10 : Gadfly.Scale.y_log10, hasScaleKey, log10
- scale == :asinh && return isx ? Gadfly.Scale.x_asinh : Gadfly.Scale.y_asinh, hasScaleKey, asinh
- scale == :sqrt && return isx ? Gadfly.Scale.x_sqrt : Gadfly.Scale.y_sqrt, hasScaleKey, sqrt
- end
- isx ? Gadfly.Scale.x_continuous : Gadfly.Scale.y_continuous, hasScaleKey, identity
-end
-
-
-function addGadflyLimitsScale(gplt, plotattributes::KW, isx::Bool)
- gfunc, hasScaleKey, func = getGadflyScaleFunction(plotattributes, isx)
-
- # do we want to add min/max limits for the axis?
- limsym = isx ? :xlims : :ylims
- limargs = Any[]
-
- # map :auto to nothing, otherwise add to limargs
- lims = get(plotattributes, limsym, :auto)
- if lims == :auto
- lims = nothing
- else
- if limsType(lims) == :limits
- push!(limargs, (:minvalue, min(lims...)))
- push!(limargs, (:maxvalue, max(lims...)))
- else
- error("Invalid input for $(isx ? "xlims" : "ylims"): ", lims)
- end
- end
-
- # replace any current scales with this one
- if hasScaleKey || !isempty(limargs)
- filterGadflyScale(gplt, isx)
- push!(gplt.scales, gfunc(; limargs...))
- end
-
- lims, func
-end
-
-function updateGadflyAxisFlips(gplt, plotattributes::KW, xlims, ylims, xfunc, yfunc)
- if isa(gplt.coord, Gadfly.Coord.Cartesian)
- gplt.coord = Gadfly.Coord.cartesian(
- gplt.coord.xvars,
- gplt.coord.yvars;
- xmin = xlims == nothing ? gplt.coord.xmin : xfunc(minimum(xlims)),
- xmax = xlims == nothing ? gplt.coord.xmax : xfunc(maximum(xlims)),
- ymin = ylims == nothing ? gplt.coord.ymin : yfunc(minimum(ylims)),
- ymax = ylims == nothing ? gplt.coord.ymax : yfunc(maximum(ylims)),
- xflip = get(plotattributes, :xflip, gplt.coord.xflip),
- yflip = get(plotattributes, :yflip, gplt.coord.yflip),
- fixed = gplt.coord.fixed,
- aspect_ratio = gplt.coord.aspect_ratio,
- raster = gplt.coord.raster
- )
- else
- gplt.coord = Gadfly.Coord.Cartesian(
- xflip = get(plotattributes, :xflip, false),
- yflip = get(plotattributes, :yflip, false)
- )
- end
-end
-
-
-function findGuideAndSet(gplt, t::DataType, args...; kw...)
- for (i,guide) in enumerate(gplt.guides)
- if isa(guide, t)
- gplt.guides[i] = t(args...; kw...)
- end
- end
-end
-
-function updateGadflyGuides(plt::Plot, plotattributes::KW)
- gplt = getGadflyContext(plt)
- haskey(plotattributes, :title) && findGuideAndSet(gplt, Gadfly.Guide.title, string(plotattributes[:title]))
- haskey(plotattributes, :xguide) && findGuideAndSet(gplt, Gadfly.Guide.xlabel, string(plotattributes[:xguide]))
- haskey(plotattributes, :yguide) && findGuideAndSet(gplt, Gadfly.Guide.ylabel, string(plotattributes[:yguide]))
-
- xlims, xfunc = addGadflyLimitsScale(gplt, plotattributes, true)
- ylims, yfunc = addGadflyLimitsScale(gplt, plotattributes, false)
-
- ticks = get(plotattributes, :xticks, :auto)
- if ticks == :none
- _remove_axis(plt, true)
- else
- addGadflyTicksGuide(gplt, ticks, true)
- end
- ticks = get(plotattributes, :yticks, :auto)
- if ticks == :none
- _remove_axis(plt, false)
- else
- addGadflyTicksGuide(gplt, ticks, false)
- end
-
- updateGadflyAxisFlips(gplt, plotattributes, xlims, ylims, xfunc, yfunc)
-end
-
-function updateGadflyPlotTheme(plt::Plot, plotattributes::KW)
- kwargs = KW()
-
- # colors
- insidecolor, gridcolor, textcolor, guidecolor, legendcolor =
- map(s -> getColor(plotattributes[s]), (
- :background_color_inside,
- :foreground_color_grid,
- :foreground_color_text,
- :foreground_color_guide,
- :foreground_color_legend
- ))
-
- # # hide the legend?
- leg = plotattributes[plotattributes[:legend] == :none ? :colorbar : :legend]
- if leg != :best
- kwargs[:key_position] = leg == :inside ? :right : leg
- end
-
- if !get(plotattributes, :grid, true)
- kwargs[:grid_color] = gridcolor
- end
-
- # fonts
- tfont, gfont, lfont = plotattributes[:tickfont], plotattributes[:guidefont], plotattributes[:legendfont]
-
- getGadflyContext(plt).theme = Gadfly.Theme(;
- background_color = insidecolor,
- minor_label_color = textcolor,
- minor_label_font = tfont.family,
- minor_label_font_size = tfont.pointsize * Gadfly.pt,
- major_label_color = guidecolor,
- major_label_font = gfont.family,
- major_label_font_size = gfont.pointsize * Gadfly.pt,
- key_title_color = guidecolor,
- key_title_font = gfont.family,
- key_title_font_size = gfont.pointsize * Gadfly.pt,
- key_label_color = legendcolor,
- key_label_font = lfont.family,
- key_label_font_size = lfont.pointsize * Gadfly.pt,
- plot_padding = 1 * Gadfly.mm,
- kwargs...
- )
-end
-
-# ----------------------------------------------------------------
-
-
-function createGadflyAnnotationObject(x, y, val::AbstractString)
- Gadfly.Guide.annotation(Compose.compose(
- Compose.context(),
- Compose.text(x, y, val)
- ))
-end
-
-function createGadflyAnnotationObject(x, y, txt::PlotText)
- halign = (txt.font.halign == :hcenter ? Compose.hcenter : (txt.font.halign == :left ? Compose.hleft : Compose.hright))
- valign = (txt.font.valign == :vcenter ? Compose.vcenter : (txt.font.valign == :top ? Compose.vtop : Compose.vbottom))
- rotations = (txt.font.rotation == 0.0 ? [] : [Compose.Rotation(txt.font.rotation, Compose.Point(Compose.x_measure(x), Compose.y_measure(y)))])
- Gadfly.Guide.annotation(Compose.compose(
- Compose.context(),
- Compose.text(x, y, txt.str, halign, valign, rotations...),
- Compose.font(string(txt.font.family)),
- Compose.fontsize(txt.font.pointsize * Gadfly.pt),
- Compose.stroke(txt.font.color),
- Compose.fill(txt.font.color)
- ))
-end
-
-function _add_annotations(plt::Plot{GadflyBackend}, anns::AVec{Tuple{X,Y,V}}) where {X,Y,V}
- for ann in anns
- push!(plt.o.guides, createGadflyAnnotationObject(ann...))
- end
-end
-
-
-# ---------------------------------------------------------------------------
-
-# create a blank Gadfly.Plot object
-# function _create_plot(pkg::GadflyBackend, plotattributes::KW)
-# gplt = createGadflyPlotObject(plotattributes)
-# Plot(gplt, pkg, 0, plotattributes, KW[])
-# end
-function _create_backend_figure(plt::Plot{GadflyBackend})
- createGadflyPlotObject(plt.attr)
-end
-
-
-# plot one data series
-# function _series_added(::GadflyBackend, plt::Plot, plotattributes::KW)
-function _series_added(plt::Plot{GadflyBackend}, series::Series)
- # first clear out the temporary layer
- gplt = getGadflyContext(plt)
- if gplt.layers[1].geom.tag == :remove
- gplt.layers = gplt.layers[2:end]
- end
-
- addGadflySeries!(plt, series.plotattributes)
- # push!(plt.seriesargs, plotattributes)
- # plt
-end
-
-
-
-function _update_plot_object(plt::Plot{GadflyBackend}, plotattributes::KW)
- updateGadflyGuides(plt, plotattributes)
- updateGadflyPlotTheme(plt, plotattributes)
-end
-
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-# TODO: need to save all the layer indices which apply to this series
-function getGadflyMappings(plt::Plot, i::Integer)
- @assert i > 0 && i <= plt.n
- mappings = [l.mapping for l in plt.seriesargs[i][:gadflylayers]]
-end
-
-function getxy(plt::Plot{GadflyBackend}, i::Integer)
- mapping = getGadflyMappings(plt, i)[1]
- mapping[:x], mapping[:y]
-end
-
-function setxy!(plt::Plot{GadflyBackend}, xy::Tuple{X,Y}, i::Integer) where {X,Y}
- for mapping in getGadflyMappings(plt, i)
- mapping[:x], mapping[:y] = xy
- end
- plt
-end
-
-# ----------------------------------------------------------------
-
-
-# # create the underlying object (each backend will do this differently)
-# function _create_subplot(subplt::Subplot{GadflyBackend}, isbefore::Bool)
-# isbefore && return false # wait until after plotting to create the subplots
-# subplt.o = nothing
-# true
-# end
-
-
-function _remove_axis(plt::Plot{GadflyBackend}, isx::Bool)
- gplt = getGadflyContext(plt)
- addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
- addOrReplace(gplt.guides, isx ? Gadfly.Guide.xlabel : Gadfly.Guide.ylabel, "")
-end
-
-function _expand_limits(lims, plt::Plot{GadflyBackend}, isx::Bool)
- for l in getGadflyContext(plt).layers
- _expand_limits(lims, l.mapping[isx ? :x : :y])
- end
-end
-
-
-# ----------------------------------------------------------------
-
-
-getGadflyContext(plt::Plot{GadflyBackend}) = plt.o
-# getGadflyContext(subplt::Subplot{GadflyBackend}) = buildGadflySubplotContext(subplt)
-
-# # create my Compose.Context grid by hstacking and vstacking the Gadfly.Plot objects
-# function buildGadflySubplotContext(subplt::Subplot)
-# rows = Any[]
-# row = Any[]
-# for (i,(r,c)) in enumerate(subplt.layout)
-#
-# # add the Plot object to the row
-# push!(row, getGadflyContext(subplt.plts[i]))
-#
-# # add the row
-# if c == ncols(subplt.layout, r)
-# push!(rows, Gadfly.hstack(row...))
-# row = Any[]
-# end
-# end
-#
-# # stack the rows
-# Gadfly.vstack(rows...)
-# end
-
-setGadflyDisplaySize(w,h) = Compose.set_default_graphic_size(w * Compose.px, h * Compose.px)
-setGadflyDisplaySize(plt::Plot) = setGadflyDisplaySize(plt.attr[:size]...)
-# setGadflyDisplaySize(subplt::Subplot) = setGadflyDisplaySize(getattr(subplt, 1)[:size]...)
-# -------------------------------------------------------------------------
-
-
-function doshow(io::IO, func, plt::AbstractPlot{P}) where P<:Union{GadflyBackend,ImmerseBackend}
- gplt = getGadflyContext(plt)
- setGadflyDisplaySize(plt)
- Gadfly.draw(func(io, Compose.default_graphic_width, Compose.default_graphic_height), gplt)
-end
-
-getGadflyWriteFunc(::MIME"image/png") = Gadfly.PNG
-getGadflyWriteFunc(::MIME"image/svg+xml") = Gadfly.SVG
-# getGadflyWriteFunc(::MIME"text/html") = Gadfly.SVGJS
-getGadflyWriteFunc(::MIME"application/pdf") = Gadfly.PDF
-getGadflyWriteFunc(::MIME"application/postscript") = Gadfly.PS
-getGadflyWriteFunc(::MIME"application/x-tex") = Gadfly.PGF
-getGadflyWriteFunc(m::MIME) = error("Unsupported in Gadfly/Immerse: ", m)
-
-for mime in (MIME"image/png", MIME"image/svg+xml", MIME"application/pdf", MIME"application/postscript", MIME"application/x-tex")
- @eval function Base.show(io::IO, ::$mime, plt::AbstractPlot{P}) where P<:Union{GadflyBackend,ImmerseBackend}
- func = getGadflyWriteFunc($mime())
- doshow(io, func, plt)
- end
-end
-
-
-
-function Base.display(::PlotsDisplay, plt::Plot{GadflyBackend})
- setGadflyDisplaySize(plt.attr[:size]...)
- display(plt.o)
-end
-
-
-# function Base.display(::PlotsDisplay, subplt::Subplot{GadflyBackend})
-# setGadflyDisplaySize(getattr(subplt,1)[:size]...)
-# ctx = buildGadflySubplotContext(subplt)
-#
-# # taken from Gadfly since I couldn't figure out how to do it directly
-#
-# filename = string(Gadfly.tempname(), ".html")
-# output = open(filename, "w")
-#
-# plot_output = IOBuffer()
-# Gadfly.draw(Gadfly.SVGJS(plot_output, Compose.default_graphic_width,
-# Compose.default_graphic_height, false), ctx)
-# plotsvg = takebuf_string(plot_output)
-#
-# write(output,
-# """
-#
-#
-#
-# Gadfly Plot
-#
-#
-#
-#
-#
-# $(plotsvg)
-#
-#
-# """)
-# close(output)
-# Gadfly.open_file(filename)
-# end
diff --git a/src/deprecated/backends/gadfly_shapes.jl b/src/deprecated/backends/gadfly_shapes.jl
deleted file mode 100644
index 1a818993..00000000
--- a/src/deprecated/backends/gadfly_shapes.jl
+++ /dev/null
@@ -1,93 +0,0 @@
-
-
-# Geometry which displays arbitrary shapes at given (x, y) positions.
-# note: vertices is a list of shapes
-struct ShapeGeometry <: Gadfly.GeometryElement
- vertices::AbstractVector #{Tuple{Float64,Float64}}
- tag::Symbol
-
- function ShapeGeometry(shape; tag::Symbol=Gadfly.Geom.empty_tag)
- new(shape, tag)
- end
-end
-
-# TODO: add for PR
-# const shape = ShapeGeometry
-
-
-function Gadfly.element_aesthetics(::ShapeGeometry)
- [:x, :y, :size, :color]
-end
-
-
-# Generate a form for a shape geometry.
-#
-# Args:
-# geom: shape geometry.
-# theme: the plot's theme.
-# aes: aesthetics.
-#
-# Returns:
-# A compose Form.
-#
-function Gadfly.render(geom::ShapeGeometry, theme::Gadfly.Theme, aes::Gadfly.Aesthetics)
-
- # TODO: add for PR
- # Gadfly.assert_aesthetics_defined("Geom.shape", aes, :x, :y)
- # Gadfly.assert_aesthetics_equal_length("Geom.shape", aes,
- # element_aesthetics(geom)...)
-
- default_aes = Gadfly.Aesthetics()
- default_aes.color = Gadfly.DataFrames.PooledDataArray(RGBA{Float32}[theme.default_color])
- default_aes.size = Compose.Measure[theme.default_point_size]
- aes = Gadfly.inherit(aes, default_aes)
-
- lw_hover_scale = 10
- lw_ratio = theme.line_width / aes.size[1]
-
- aes_x, aes_y = Gadfly.concretize(aes.x, aes.y)
-
- ctx = Compose.compose!(
- Compose.context(),
- make_polygon(geom, aes.x, aes.y, aes.size),
- Compose.fill(aes.color),
- Compose.linewidth(theme.highlight_width))
-
- if aes.color_key_continuous != nothing && aes.color_key_continuous
- Compose.compose!(ctx,
- Compose.stroke(map(theme.continuous_highlight_color, aes.color)))
- else
- Compose.compose!(ctx,
- Compose.stroke(map(theme.discrete_highlight_color, aes.color)),
- Compose.svgclass([Gadfly.svg_color_class_from_label(Gadfly.escape_id(aes.color_label([c])[1]))
- for c in aes.color]))
- end
-
- return Compose.compose!(Compose.context(order=4), Compose.svgclass("geometry"), ctx)
-end
-
-function gadflyshape(sv::Shape)
- ShapeGeometry(Any[vertices(sv)])
-end
-
-function gadflyshape(sv::AVec{Shape})
- ShapeGeometry(Any[vertices(s) for s in sv])
-end
-
-
-# create a Compose context given a ShapeGeometry and the xs/ys/sizes
-function make_polygon(geom::ShapeGeometry, xs::AbstractArray, ys::AbstractArray, rs::AbstractArray)
- n = max(length(xs), length(ys), length(rs))
- T = Tuple{Compose.Measure, Compose.Measure}
- polys = Array(Vector{T}, n)
- for i in 1:n
- x = Compose.x_measure(xs[mod1(i, length(xs))])
- y = Compose.y_measure(ys[mod1(i, length(ys))])
- r = rs[mod1(i, length(rs))]
- polys[i] = T[(x + r * sx, y + r * sy) for (sx,sy) in _cycle(geom.vertices, i)]
- end
- Gadfly.polygon(polys, geom.tag)
-end
-
-
-# ---------------------------------------------------------------------------------------------
diff --git a/src/deprecated/backends/immerse.jl b/src/deprecated/backends/immerse.jl
deleted file mode 100644
index 754f55de..00000000
--- a/src/deprecated/backends/immerse.jl
+++ /dev/null
@@ -1,186 +0,0 @@
-
-# https://github.com/JuliaGraphics/Immerse.jl
-
-supported_attrs(::ImmerseBackend) = supported_attrs(GadflyBackend())
-supported_types(::ImmerseBackend) = supported_types(GadflyBackend())
-supported_styles(::ImmerseBackend) = supported_styles(GadflyBackend())
-supported_markers(::ImmerseBackend) = supported_markers(GadflyBackend())
-supported_scales(::ImmerseBackend) = supported_scales(GadflyBackend())
-is_subplot_supported(::ImmerseBackend) = true
-
-# --------------------------------------------------------------------------------------
-
-function _initialize_backend(::ImmerseBackend; kw...)
- @eval begin
- import Immerse, Gadfly, Compose, Gtk
- export Immerse, Gadfly, Compose, Gtk
- include(joinpath(dirname(@__FILE__), "gadfly_shapes.jl"))
- end
-end
-
-function createImmerseFigure(plotattributes::KW)
- w,h = plotattributes[:size]
- figidx = Immerse.figure(; name = plotattributes[:window_title], width = w, height = h)
- Immerse.Figure(figidx)
-end
-
-# ----------------------------------------------------------------
-
-
-# create a blank Gadfly.Plot object
-# function _create_plot(pkg::ImmerseBackend, plotattributes::KW)
-# # create the underlying Gadfly.Plot object
-# gplt = createGadflyPlotObject(plotattributes)
-#
-# # save both the Immerse.Figure and the Gadfly.Plot
-# Plot((nothing,gplt), pkg, 0, plotattributes, KW[])
-# end
-function _create_backend_figure(plt::Plot{ImmerseBackend})
- (nothing, createGadflyPlotObject(plt.attr))
-end
-
-
-# # plot one data series
-# function _series_added(::ImmerseBackend, plt::Plot, plotattributes::KW)
-# addGadflySeries!(plt, plotattributes)
-# push!(plt.seriesargs, plotattributes)
-# plt
-# end
-
-function _series_added(plt::Plot{ImmerseBackend}, series::Series)
- addGadflySeries!(plt, series.plotattributes)
-end
-
-
-function _update_plot_object(plt::Plot{ImmerseBackend}, plotattributes::KW)
- updateGadflyGuides(plt, plotattributes)
- updateGadflyPlotTheme(plt, plotattributes)
-end
-
-
-
-# ----------------------------------------------------------------
-
-function _add_annotations(plt::Plot{ImmerseBackend}, anns::AVec{Tuple{X,Y,V}}) where {X,Y,V}
- for ann in anns
- push!(getGadflyContext(plt).guides, createGadflyAnnotationObject(ann...))
- end
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-function getxy(plt::Plot{ImmerseBackend}, i::Integer)
- mapping = getGadflyMappings(plt, i)[1]
- mapping[:x], mapping[:y]
-end
-
-function setxy!(plt::Plot{ImmerseBackend}, xy::Tuple{X,Y}, i::Integer) where {X,Y}
- for mapping in getGadflyMappings(plt, i)
- mapping[:x], mapping[:y] = xy
- end
- plt
-end
-
-
-# ----------------------------------------------------------------
-
-
-# function _create_subplot(subplt::Subplot{ImmerseBackend}, isbefore::Bool)
-# return false
-# # isbefore && return false
-# end
-#
-# function showSubplotObject(subplt::Subplot{ImmerseBackend})
-# # create the Gtk window with vertical box vsep
-# plotattributes = getattr(subplt,1)
-# w,h = plotattributes[:size]
-# vsep = Gtk.GtkBoxLeaf(:v)
-# win = Gtk.GtkWindowLeaf(vsep, plotattributes[:window_title], w, h)
-#
-# figindices = []
-# row = Gtk.GtkBoxLeaf(:h)
-# push!(vsep, row)
-# for (i,(r,c)) in enumerate(subplt.layout)
-# plt = subplt.plts[i]
-#
-# # get the components... box is the main plot GtkBox, and canvas is the GtkCanvas where it's plotted
-# box, toolbar, canvas = Immerse.createPlotGuiComponents()
-#
-# # add the plot's box to the row
-# push!(row, box)
-#
-# # create the figure and store the index returned for destruction later
-# figidx = Immerse.figure(canvas)
-# push!(figindices, figidx)
-#
-# fig = Immerse.figure(figidx)
-# plt.o = (fig, plt.o[2])
-#
-# # add the row
-# if c == ncols(subplt.layout, r)
-# row = Gtk.GtkBoxLeaf(:h)
-# push!(vsep, row)
-# end
-#
-# end
-#
-# # destructor... clean up plots
-# Gtk.on_signal_destroy((x...) -> ([Immerse.dropfig(Immerse._display,i) for i in figindices]; subplt.o = nothing), win)
-#
-# subplt.o = win
-# true
-# end
-
-
-function _remove_axis(plt::Plot{ImmerseBackend}, isx::Bool)
- gplt = getGadflyContext(plt)
- addOrReplace(gplt.guides, isx ? Gadfly.Guide.xticks : Gadfly.Guide.yticks; label=false)
- addOrReplace(gplt.guides, isx ? Gadfly.Guide.xlabel : Gadfly.Guide.ylabel, "")
-end
-
-function _expand_limits(lims, plt::Plot{ImmerseBackend}, isx::Bool)
- for l in getGadflyContext(plt).layers
- _expand_limits(lims, l.mapping[isx ? :x : :y])
- end
-end
-
-
-# ----------------------------------------------------------------
-
-getGadflyContext(plt::Plot{ImmerseBackend}) = plt.o[2]
-# getGadflyContext(subplt::Subplot{ImmerseBackend}) = buildGadflySubplotContext(subplt)
-
-
-function Base.display(::PlotsDisplay, plt::Plot{ImmerseBackend})
-
- fig, gplt = plt.o
- if fig == nothing
- fig = createImmerseFigure(plt.attr)
- Gtk.on_signal_destroy((x...) -> (Immerse.dropfig(Immerse._display, fig.figno); plt.o = (nothing,gplt)), fig.canvas)
- plt.o = (fig, gplt)
- end
-
- Immerse.figure(fig.figno; displayfig = false)
- display(gplt)
-end
-
-
-# function Base.display(::PlotsDisplay, subplt::Subplot{ImmerseBackend})
-#
-# # if we haven't created the window yet, do it
-# if subplt.o == nothing
-# showSubplotObject(subplt)
-# end
-#
-# # display the plots by creating a fresh Immerse.Figure object from the GtkCanvas and Gadfly.Plot
-# for plt in subplt.plts
-# fig, gplt = plt.o
-# Immerse.figure(fig.figno; displayfig = false)
-# display(gplt)
-# end
-#
-# # o is the window... show it
-# showall(subplt.o)
-# end
diff --git a/src/deprecated/backends/qwt.jl b/src/deprecated/backends/qwt.jl
deleted file mode 100644
index 0546b3db..00000000
--- a/src/deprecated/backends/qwt.jl
+++ /dev/null
@@ -1,308 +0,0 @@
-
-# https://github.com/tbreloff/Qwt.jl
-
-
-supported_attrs(::QwtBackend) = merge_with_base_supported([
- :annotations,
- :linecolor,
- :fillrange,
- :fillcolor,
- :label,
- :legend,
- :seriescolor, :seriesalpha,
- :linestyle,
- :linewidth,
- :markershape,
- :markercolor,
- :markersize,
- :bins,
- :pos,
- :title,
- :window_title,
- :guide, :lims, :ticks, :scale,
- ])
-supported_types(::QwtBackend) = [:path, :scatter, :hexbin, :bar]
-supported_markers(::QwtBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :star8, :hexagon]
-supported_scales(::QwtBackend) = [:identity, :log10]
-is_subplot_supported(::QwtBackend) = true
-
-
-# --------------------------------------------------------------------------------------
-
-function _initialize_backend(::QwtBackend; kw...)
- @eval begin
- @warn("Qwt is no longer supported... many features will likely be broken.")
- import Qwt
- export Qwt
- end
-end
-
-# -------------------------------
-
-const _qwtAliases = KW(
- :bins => :heatmap_n,
- :fillrange => :fillto,
- :linewidth => :width,
- :markershape => :marker,
- :hexbin => :heatmap,
- :path => :line,
- :steppost => :step,
- :steppre => :stepinverted,
- :star5 => :star1,
- :star8 => :star2,
- )
-
-function fixcolors(plotattributes::KW)
- for (k,v) in plotattributes
- if typeof(v) <: ColorScheme
- plotattributes[k] = getColor(v)
- end
- end
-end
-
-function replaceQwtAliases(plotattributes, s)
- if haskey(_qwtAliases, plotattributes[s])
- plotattributes[s] = _qwtAliases[plotattributes[s]]
- end
-end
-
-function adjustQwtKeywords(plt::Plot{QwtBackend}, iscreating::Bool; kw...)
- plotattributes = KW(kw)
- st = plotattributes[:seriestype]
- if st == :scatter
- plotattributes[:seriestype] = :none
- if plotattributes[:markershape] == :none
- plotattributes[:markershape] = :circle
- end
-
- elseif st in (:hline, :vline)
- addLineMarker(plt, plotattributes)
- plotattributes[:seriestype] = :none
- plotattributes[:markershape] = :circle
- plotattributes[:markersize] = 1
- if st == :vline
- plotattributes[:x], plotattributes[:y] = plotattributes[:y], plotattributes[:x]
- end
-
- elseif !iscreating && st == :bar
- plotattributes = barHack(; kw...)
- elseif !iscreating && st == :histogram
- plotattributes = barHack(; histogramHack(; kw...)...)
- end
-
- replaceQwtAliases(plotattributes, :seriestype)
- replaceQwtAliases(plotattributes, :markershape)
-
- for k in keys(plotattributes)
- if haskey(_qwtAliases, k)
- plotattributes[_qwtAliases[k]] = plotattributes[k]
- end
- end
-
- plotattributes[:x] = collect(plotattributes[:x])
- plotattributes[:y] = collect(plotattributes[:y])
-
- plotattributes
-end
-
-# function _create_plot(pkg::QwtBackend, plotattributes::KW)
-function _create_backend_figure(plt::Plot{QwtBackend})
- fixcolors(plt.attr)
- dumpdict(plt.attr,"\n\n!!! plot")
- o = Qwt.plot(zeros(0,0); plt.attr..., show=false)
- # plt = Plot(o, pkg, 0, plotattributes, KW[])
- # plt
-end
-
-# function _series_added(::QwtBackend, plt::Plot, plotattributes::KW)
-function _series_added(plt::Plot{QwtBackend}, series::Series)
- plotattributes = adjustQwtKeywords(plt, false; series.plotattributes...)
- fixcolors(plotattributes)
- dumpdict(plotattributes,"\n\n!!! plot!")
- Qwt.oplot(plt.o; plotattributes...)
- # push!(plt.seriesargs, plotattributes)
- # plt
-end
-
-
-# ----------------------------------------------------------------
-
-function updateLimsAndTicks(plt::Plot{QwtBackend}, plotattributes::KW, isx::Bool)
- lims = get(plotattributes, isx ? :xlims : :ylims, nothing)
- ticks = get(plotattributes, isx ? :xticks : :yticks, nothing)
- w = plt.o.widget
- axisid = Qwt.QWT.QwtPlot[isx ? :xBottom : :yLeft]
-
- if typeof(lims) <: Union{Tuple,AVec} && length(lims) == 2
- if isx
- plt.o.autoscale_x = false
- else
- plt.o.autoscale_y = false
- end
- w[:setAxisScale](axisid, lims...)
- end
-
- if typeof(ticks) <: AbstractRange
- if isx
- plt.o.autoscale_x = false
- else
- plt.o.autoscale_y = false
- end
- w[:setAxisScale](axisid, float(minimum(ticks)), float(maximum(ticks)), float(step(ticks)))
- elseif !(ticks in (nothing, :none, :auto))
- @warn("Only Range types are supported for Qwt xticks/yticks. typeof(ticks)=$(typeof(ticks))")
- end
-
- # change the scale
- scalesym = isx ? :xscale : :yscale
- if haskey(plotattributes, scalesym)
- scaletype = plotattributes[scalesym]
- scaletype == :identity && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLinearScaleEngine())
- # scaletype == :log && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLogScaleEngine(e))
- # scaletype == :log2 && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLogScaleEngine(2))
- scaletype == :log10 && w[:setAxisScaleEngine](axisid, Qwt.QWT.QwtLog10ScaleEngine())
- scaletype in supported_scales() || @warn("Unsupported scale type: ", scaletype)
- end
-
-end
-
-
-function _update_plot_object(plt::Plot{QwtBackend}, plotattributes::KW)
- haskey(plotattributes, :title) && Qwt.title(plt.o, plotattributes[:title])
- haskey(plotattributes, :xguide) && Qwt.xlabel(plt.o, plotattributes[:xguide])
- haskey(plotattributes, :yguide) && Qwt.ylabel(plt.o, plotattributes[:yguide])
- updateLimsAndTicks(plt, plotattributes, true)
- updateLimsAndTicks(plt, plotattributes, false)
-end
-
-function _update_plot_pos_size(plt::AbstractPlot{QwtBackend}, plotattributes::KW)
- haskey(plotattributes, :size) && Qwt.resizewidget(plt.o, plotattributes[:size]...)
- haskey(plotattributes, :pos) && Qwt.movewidget(plt.o, plotattributes[:pos]...)
-end
-
-
-# ----------------------------------------------------------------
-
- # curve.setPen(Qt.QPen(Qt.QColor(color), linewidth, self.getLineStyle(linestyle)))
-function addLineMarker(plt::Plot{QwtBackend}, plotattributes::KW)
- for yi in plotattributes[:y]
- marker = Qwt.QWT.QwtPlotMarker()
- ishorizontal = (plotattributes[:seriestype] == :hline)
- marker[:setLineStyle](ishorizontal ? 1 : 2)
- marker[ishorizontal ? :setYValue : :setXValue](yi)
- qcolor = Qwt.convertRGBToQColor(getColor(plotattributes[:linecolor]))
- linestyle = plt.o.widget[:getLineStyle](string(plotattributes[:linestyle]))
- marker[:setLinePen](Qwt.QT.QPen(qcolor, plotattributes[:linewidth], linestyle))
- marker[:attach](plt.o.widget)
- end
-
- # marker[:setValue](x, y)
- # marker[:setLabel](Qwt.QWT.QwtText(val))
- # marker[:attach](plt.o.widget)
-end
-
-function createQwtAnnotation(plt::Plot, x, y, val::PlotText)
- marker = Qwt.QWT.QwtPlotMarker()
- marker[:setValue](x, y)
- qwttext = Qwt.QWT.QwtText(val.str)
- qwttext[:setFont](Qwt.QT.QFont(val.font.family, val.font.pointsize))
- qwttext[:setColor](Qwt.convertRGBToQColor(getColor(val.font.color)))
- marker[:setLabel](qwttext)
- marker[:attach](plt.o.widget)
-end
-
-function createQwtAnnotation(plt::Plot, x, y, val::AbstractString)
- marker = Qwt.QWT.QwtPlotMarker()
- marker[:setValue](x, y)
- marker[:setLabel](Qwt.QWT.QwtText(val))
- marker[:attach](plt.o.widget)
-end
-
-function _add_annotations(plt::Plot{QwtBackend}, anns::AVec{Tuple{X,Y,V}}) where {X,Y,V}
- for ann in anns
- createQwtAnnotation(plt, ann...)
- end
-end
-
-# ----------------------------------------------------------------
-
-# accessors for x/y data
-
-function getxy(plt::Plot{QwtBackend}, i::Int)
- series = plt.o.lines[i]
- series.x, series.y
-end
-
-function setxy!(plt::Plot{QwtBackend}, xy::Tuple{X,Y}, i::Integer) where {X,Y}
- series = plt.o.lines[i]
- series.x, series.y = xy
- plt
-end
-
-
-# -------------------------------
-
-# -------------------------------
-
-# # create the underlying object (each backend will do this differently)
-# function _create_subplot(subplt::Subplot{QwtBackend}, isbefore::Bool)
-# isbefore && return false
-# i = 0
-# rows = Any[]
-# row = Any[]
-# for (i,(r,c)) in enumerate(subplt.layout)
-# push!(row, subplt.plts[i].o)
-# if c == ncols(subplt.layout, r)
-# push!(rows, Qwt.hsplitter(row...))
-# row = Any[]
-# end
-# end
-# # for rowcnt in subplt.layout.rowcounts
-# # push!(rows, Qwt.hsplitter([plt.o for plt in subplt.plts[(1:rowcnt) + i]]...))
-# # i += rowcnt
-# # end
-# subplt.o = Qwt.vsplitter(rows...)
-# # Qwt.resizewidget(subplt.o, getattr(subplt,1)[:size]...)
-# # Qwt.moveToLastScreen(subplt.o) # hack so it goes to my center monitor... sorry
-# true
-# end
-
-function _expand_limits(lims, plt::Plot{QwtBackend}, isx::Bool)
- for series in plt.o.lines
- _expand_limits(lims, isx ? series.x : series.y)
- end
-end
-
-
-function _remove_axis(plt::Plot{QwtBackend}, isx::Bool)
-end
-
-
-# ----------------------------------------------------------------
-
-function Base.show(io::IO, ::MIME"image/png", plt::Plot{QwtBackend})
- Qwt.refresh(plt.o)
- Qwt.savepng(plt.o, "/tmp/dfskjdhfkh.png")
- write(io, readall("/tmp/dfskjdhfkh.png"))
-end
-
-# function Base.show(io::IO, ::MIME"image/png", subplt::Subplot{QwtBackend})
-# for plt in subplt.plts
-# Qwt.refresh(plt.o)
-# end
-# Qwt.savepng(subplt.o, "/tmp/dfskjdhfkh.png")
-# write(io, readall("/tmp/dfskjdhfkh.png"))
-# end
-
-
-function Base.display(::PlotsDisplay, plt::Plot{QwtBackend})
- Qwt.refresh(plt.o)
- Qwt.showwidget(plt.o)
-end
-
-# function Base.display(::PlotsDisplay, subplt::Subplot{QwtBackend})
-# for plt in subplt.plts
-# Qwt.refresh(plt.o)
-# end
-# Qwt.showwidget(subplt.o)
-# end
diff --git a/src/deprecated/backends/winston.jl b/src/deprecated/backends/winston.jl
deleted file mode 100644
index 5f292271..00000000
--- a/src/deprecated/backends/winston.jl
+++ /dev/null
@@ -1,272 +0,0 @@
-
-# https://github.com/nolta/Winston.jl
-
-# credit goes to https://github.com/jverzani for contributing to the first draft of this backend implementation
-
-supported_attrs(::WinstonBackend) = merge_with_base_supported([
- :annotations,
- :linecolor,
- :fillrange,
- :fillcolor,
- :label,
- :legend,
- :seriescolor, :seriesalpha,
- :linestyle,
- :linewidth,
- :markershape,
- :markercolor,
- :markersize,
- :bins,
- :title,
- :window_title,
- :guide, :lims, :scale,
- ])
-supported_types(::WinstonBackend) = [:path, :scatter, :bar]
-supported_styles(::WinstonBackend) = [:auto, :solid, :dash, :dot, :dashdot]
-supported_markers(::WinstonBackend) = [:none, :auto, :rect, :circle, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5]
-supported_scales(::WinstonBackend) = [:identity, :log10]
-is_subplot_supported(::WinstonBackend) = false
-
-
-# --------------------------------------------------------------------------------------
-
-
-function _initialize_backend(::WinstonBackend; kw...)
- @eval begin
- # ENV["WINSTON_OUTPUT"] = "gtk"
- @warn("Winston is no longer supported... many features will likely be broken.")
- import Winston, Gtk
- export Winston, Gtk
- end
-end
-
-# ---------------------------------------------------------------------------
-
-
-## dictionaries for conversion of Plots.jl names to Winston ones.
-const winston_linestyle = KW(:solid=>"solid",
- :dash=>"dash",
- :dot=>"dotted",
- :dashdot=>"dotdashed"
- )
-
-const winston_marker = KW(:none=>".",
- :rect => "square",
- :circle=>"circle",
- :diamond=>"diamond",
- :utriangle=>"triangle",
- :dtriangle=>"down-triangle",
- :cross => "plus",
- :xcross => "cross",
- :star5 => "asterisk"
- )
-
-function _before_update(plt::Plot{WinstonBackend})
- Winston.ghf(plt.o)
-end
-
-# ---------------------------------------------------------------------------
-
-function _create_backend_figure(plt::Plot{WinstonBackend})
- Winston.FramedPlot(
- title = plt.attr[:title],
- xlabel = plt.attr[:xguide],
- ylabel = plt.attr[:yguide]
- )
-end
-
-copy_remove(plotattributes::KW, s::Symbol) = delete!(copy(plotattributes), s)
-
-function addRegressionLineWinston(plotattributes::KW, wplt)
- xs, ys = regressionXY(plotattributes[:x], plotattributes[:y])
- Winston.add(wplt, Winston.Curve(xs, ys, kind="dotted"))
-end
-
-function getWinstonItems(plt::Plot)
- if isa(plt.o, Winston.FramedPlot)
- wplt = plt.o
- window, canvas = nothing, nothing
- else
- window, canvas, wplt = plt.o
- end
- window, canvas, wplt
-end
-
-function _series_added(plt::Plot{WinstonBackend}, series::Series)
- plotattributes = series.plotattributes
- window, canvas, wplt = getWinstonItems(plt)
-
- # until we call it normally, do the hack
- if plotattributes[:seriestype] == :bar
- plotattributes = barHack(;plotattributes...)
- end
-
-
- e = KW()
- e[:color] = getColor(plotattributes[:linecolor])
- e[:linewidth] = plotattributes[:linewidth]
- e[:kind] = winston_linestyle[plotattributes[:linestyle]]
- e[:symbolkind] = winston_marker[plotattributes[:markershape]]
- # markercolor # same choices as `color`, or :match will set the color to be the same as `color`
- e[:symbolsize] = plotattributes[:markersize] / 5
-
- # pos # (Int,Int), move the enclosing window to this position
- # screen # Integer, move enclosing window to this screen number (for multiscreen desktops)
-
-
-
- ## lintype :path, :step, :stepinverted, :sticks, :dots, :none, :histogram2d, :hexbin, :histogram, :bar
- if plotattributes[:seriestype] == :none
- Winston.add(wplt, Winston.Points(plotattributes[:x], plotattributes[:y]; copy_remove(e, :kind)..., color=getColor(plotattributes[:markercolor])))
-
- elseif plotattributes[:seriestype] == :path
- x, y = plotattributes[:x], plotattributes[:y]
- Winston.add(wplt, Winston.Curve(x, y; e...))
-
- fillrange = plotattributes[:fillrange]
- if fillrange != nothing
- if isa(fillrange, AbstractVector)
- y2 = fillrange
- else
- y2 = Float64[fillrange for yi in y]
- end
- Winston.add(wplt, Winston.FillBetween(x, y, x, y2, fillcolor=getColor(plotattributes[:fillcolor])))
- end
-
- elseif plotattributes[:seriestype] == :scatter
- if plotattributes[:markershape] == :none
- plotattributes[:markershape] = :circle
- end
-
- # elseif plotattributes[:seriestype] == :step
- # fn = Winston.XXX
-
- # elseif plotattributes[:seriestype] == :stepinverted
- # fn = Winston.XXX
-
- elseif plotattributes[:seriestype] == :sticks
- Winston.add(wplt, Winston.Stems(plotattributes[:x], plotattributes[:y]; e...))
-
- # elseif plotattributes[:seriestype] == :dots
- # fn = Winston.XXX
-
- # elseif plotattributes[:seriestype] == :histogram2d
- # fn = Winston.XXX
-
- # elseif plotattributes[:seriestype] == :hexbin
- # fn = Winston.XXX
-
- elseif plotattributes[:seriestype] == :histogram
- hst = hist(plotattributes[:y], plotattributes[:bins])
- Winston.add(wplt, Winston.Histogram(hst...; copy_remove(e, :bins)...))
-
- # elseif plotattributes[:seriestype] == :bar
- # # fn = Winston.XXX
-
- else
- error("seriestype $(plotattributes[:seriestype]) not supported by Winston.")
-
- end
-
-
- # markershape
- if plotattributes[:markershape] != :none
- Winston.add(wplt, Winston.Points(plotattributes[:x], plotattributes[:y]; copy_remove(e, :kind)..., color=getColor(plotattributes[:markercolor])))
- end
-
-
- # optionally add a regression line
- plotattributes[:smooth] && plotattributes[:seriestype] != :histogram && addRegressionLineWinston(plotattributes, wplt)
-
- # push!(plt.seriesargs, plotattributes)
- # plt
-end
-
-
-# ----------------------------------------------------------------
-
-const _winstonNames = KW(
- :xlims => :xrange,
- :ylims => :yrange,
- :xscale => :xlog,
- :yscale => :ylog,
- )
-
-function _update_plot_object(plt::Plot{WinstonBackend}, plotattributes::KW)
- window, canvas, wplt = getWinstonItems(plt)
- for k in (:xguide, :yguide, :title, :xlims, :ylims)
- if haskey(plotattributes, k)
- Winston.setattr(wplt, string(get(_winstonNames, k, k)), plotattributes[k])
- end
- end
-
- for k in (:xscale, :yscale)
- if haskey(plotattributes, k)
- islogscale = plotattributes[k] == :log10
- Winston.setattr(wplt, (k == :xscale ? :xlog : :ylog), islogscale)
- end
- end
-
-end
-
-
-
-# ----------------------------------------------------------------
-
-function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::AbstractString)
- Winston.text(x, y, val)
-end
-
-function _add_annotations(plt::Plot{WinstonBackend}, anns::AVec{Tuple{X,Y,V}}) where {X,Y,V}
- for ann in anns
- createWinstonAnnotationObject(plt, ann...)
- end
-end
-
-
-# ----------------------------------------------------------------
-
-# function _create_subplot(subplt::Subplot{WinstonBackend}, isbefore::Bool)
-# # TODO: build the underlying Subplot object. this is where you might layout the panes within a GUI window, for example
-# end
-
-# ----------------------------------------------------------------
-
-function addWinstonLegend(plt::Plot, wplt)
- if plt.attr[:legend] != :none
- Winston.legend(wplt, [sd[:label] for sd in plt.seriesargs])
- end
-end
-
-function Base.show(io::IO, ::MIME"image/png", plt::AbstractPlot{WinstonBackend})
- window, canvas, wplt = getWinstonItems(plt)
- addWinstonLegend(plt, wplt)
- show(io, "image/png", wplt)
-end
-
-
-function Base.display(::PlotsDisplay, plt::Plot{WinstonBackend})
-
- window, canvas, wplt = getWinstonItems(plt)
-
- if window == nothing
- if Winston.output_surface != :gtk
- error("Gtk is the only supported display for Winston in Plots. Set `output_surface = gtk` in src/Winston.ini")
- end
- # initialize window
- w,h = plt.attr[:size]
- canvas = Gtk.GtkCanvasLeaf()
- window = Gtk.GtkWindowLeaf(canvas, plt.attr[:window_title], w, h)
- plt.o = (window, canvas, wplt)
- end
-
- addWinstonLegend(plt, wplt)
-
- Winston.display(canvas, wplt)
- Gtk.showall(window)
-end
-
-
-# function Base.display(::PlotsDisplay, subplt::Subplot{WinstonBackend})
-# # TODO: display/show the Subplot object
-# end
diff --git a/src/deprecated/color_gradients.jl b/src/deprecated/color_gradients.jl
deleted file mode 100644
index 5516ac06..00000000
--- a/src/deprecated/color_gradients.jl
+++ /dev/null
@@ -1,1067 +0,0 @@
-
-# --------------------------------------------------------------------------
-# --------------------------------------------------------------------------
-# The following gradients were taken from https://github.com/BIDS/colormap/blob/master/colormaps.py
-# Here is the licensing note which accompanied this:
-
- # New matplotlib colormaps by Nathaniel J. Smith, Stefan van der Walt,
- # and (in the case of viridis) Eric Firing.
- #
- # This file and the colormaps in it are released under the CC0 license /
- # public domain dedication. We would appreciate credit if you use or
- # redistribute these colormaps, but do not impose any legal restrictions.
- #
- # To the extent possible under law, the persons who associated CC0 with
- # mpl-colormaps have waived all copyright and related or neighboring rights
- # to mpl-colormaps.
- #
- # You should have received a copy of the CC0 legalcode along with this
- # work. If not, see .
-
-function sample_evenly(v::AVec, n::Integer = length(v))
- idx = Int[round(Int, x) for x in range(1, stop=length(v), length=n)]
- v[idx]
-end
-
-# note: to use the full arrays, just take out the second param (n) from the sample_evenly calls
-
-register_gradient_colors(:magma, sample_evenly([
- RGB(0.001462, 0.000466, 0.013866),
- RGB(0.002258, 0.001295, 0.018331),
- RGB(0.003279, 0.002305, 0.023708),
- RGB(0.004512, 0.003490, 0.029965),
- RGB(0.005950, 0.004843, 0.037130),
- RGB(0.007588, 0.006356, 0.044973),
- RGB(0.009426, 0.008022, 0.052844),
- RGB(0.011465, 0.009828, 0.060750),
- RGB(0.013708, 0.011771, 0.068667),
- RGB(0.016156, 0.013840, 0.076603),
- RGB(0.018815, 0.016026, 0.084584),
- RGB(0.021692, 0.018320, 0.092610),
- RGB(0.024792, 0.020715, 0.100676),
- RGB(0.028123, 0.023201, 0.108787),
- RGB(0.031696, 0.025765, 0.116965),
- RGB(0.035520, 0.028397, 0.125209),
- RGB(0.039608, 0.031090, 0.133515),
- RGB(0.043830, 0.033830, 0.141886),
- RGB(0.048062, 0.036607, 0.150327),
- RGB(0.052320, 0.039407, 0.158841),
- RGB(0.056615, 0.042160, 0.167446),
- RGB(0.060949, 0.044794, 0.176129),
- RGB(0.065330, 0.047318, 0.184892),
- RGB(0.069764, 0.049726, 0.193735),
- RGB(0.074257, 0.052017, 0.202660),
- RGB(0.078815, 0.054184, 0.211667),
- RGB(0.083446, 0.056225, 0.220755),
- RGB(0.088155, 0.058133, 0.229922),
- RGB(0.092949, 0.059904, 0.239164),
- RGB(0.097833, 0.061531, 0.248477),
- RGB(0.102815, 0.063010, 0.257854),
- RGB(0.107899, 0.064335, 0.267289),
- RGB(0.113094, 0.065492, 0.276784),
- RGB(0.118405, 0.066479, 0.286321),
- RGB(0.123833, 0.067295, 0.295879),
- RGB(0.129380, 0.067935, 0.305443),
- RGB(0.135053, 0.068391, 0.315000),
- RGB(0.140858, 0.068654, 0.324538),
- RGB(0.146785, 0.068738, 0.334011),
- RGB(0.152839, 0.068637, 0.343404),
- RGB(0.159018, 0.068354, 0.352688),
- RGB(0.165308, 0.067911, 0.361816),
- RGB(0.171713, 0.067305, 0.370771),
- RGB(0.178212, 0.066576, 0.379497),
- RGB(0.184801, 0.065732, 0.387973),
- RGB(0.191460, 0.064818, 0.396152),
- RGB(0.198177, 0.063862, 0.404009),
- RGB(0.204935, 0.062907, 0.411514),
- RGB(0.211718, 0.061992, 0.418647),
- RGB(0.218512, 0.061158, 0.425392),
- RGB(0.225302, 0.060445, 0.431742),
- RGB(0.232077, 0.059889, 0.437695),
- RGB(0.238826, 0.059517, 0.443256),
- RGB(0.245543, 0.059352, 0.448436),
- RGB(0.252220, 0.059415, 0.453248),
- RGB(0.258857, 0.059706, 0.457710),
- RGB(0.265447, 0.060237, 0.461840),
- RGB(0.271994, 0.060994, 0.465660),
- RGB(0.278493, 0.061978, 0.469190),
- RGB(0.284951, 0.063168, 0.472451),
- RGB(0.291366, 0.064553, 0.475462),
- RGB(0.297740, 0.066117, 0.478243),
- RGB(0.304081, 0.067835, 0.480812),
- RGB(0.310382, 0.069702, 0.483186),
- RGB(0.316654, 0.071690, 0.485380),
- RGB(0.322899, 0.073782, 0.487408),
- RGB(0.329114, 0.075972, 0.489287),
- RGB(0.335308, 0.078236, 0.491024),
- RGB(0.341482, 0.080564, 0.492631),
- RGB(0.347636, 0.082946, 0.494121),
- RGB(0.353773, 0.085373, 0.495501),
- RGB(0.359898, 0.087831, 0.496778),
- RGB(0.366012, 0.090314, 0.497960),
- RGB(0.372116, 0.092816, 0.499053),
- RGB(0.378211, 0.095332, 0.500067),
- RGB(0.384299, 0.097855, 0.501002),
- RGB(0.390384, 0.100379, 0.501864),
- RGB(0.396467, 0.102902, 0.502658),
- RGB(0.402548, 0.105420, 0.503386),
- RGB(0.408629, 0.107930, 0.504052),
- RGB(0.414709, 0.110431, 0.504662),
- RGB(0.420791, 0.112920, 0.505215),
- RGB(0.426877, 0.115395, 0.505714),
- RGB(0.432967, 0.117855, 0.506160),
- RGB(0.439062, 0.120298, 0.506555),
- RGB(0.445163, 0.122724, 0.506901),
- RGB(0.451271, 0.125132, 0.507198),
- RGB(0.457386, 0.127522, 0.507448),
- RGB(0.463508, 0.129893, 0.507652),
- RGB(0.469640, 0.132245, 0.507809),
- RGB(0.475780, 0.134577, 0.507921),
- RGB(0.481929, 0.136891, 0.507989),
- RGB(0.488088, 0.139186, 0.508011),
- RGB(0.494258, 0.141462, 0.507988),
- RGB(0.500438, 0.143719, 0.507920),
- RGB(0.506629, 0.145958, 0.507806),
- RGB(0.512831, 0.148179, 0.507648),
- RGB(0.519045, 0.150383, 0.507443),
- RGB(0.525270, 0.152569, 0.507192),
- RGB(0.531507, 0.154739, 0.506895),
- RGB(0.537755, 0.156894, 0.506551),
- RGB(0.544015, 0.159033, 0.506159),
- RGB(0.550287, 0.161158, 0.505719),
- RGB(0.556571, 0.163269, 0.505230),
- RGB(0.562866, 0.165368, 0.504692),
- RGB(0.569172, 0.167454, 0.504105),
- RGB(0.575490, 0.169530, 0.503466),
- RGB(0.581819, 0.171596, 0.502777),
- RGB(0.588158, 0.173652, 0.502035),
- RGB(0.594508, 0.175701, 0.501241),
- RGB(0.600868, 0.177743, 0.500394),
- RGB(0.607238, 0.179779, 0.499492),
- RGB(0.613617, 0.181811, 0.498536),
- RGB(0.620005, 0.183840, 0.497524),
- RGB(0.626401, 0.185867, 0.496456),
- RGB(0.632805, 0.187893, 0.495332),
- RGB(0.639216, 0.189921, 0.494150),
- RGB(0.645633, 0.191952, 0.492910),
- RGB(0.652056, 0.193986, 0.491611),
- RGB(0.658483, 0.196027, 0.490253),
- RGB(0.664915, 0.198075, 0.488836),
- RGB(0.671349, 0.200133, 0.487358),
- RGB(0.677786, 0.202203, 0.485819),
- RGB(0.684224, 0.204286, 0.484219),
- RGB(0.690661, 0.206384, 0.482558),
- RGB(0.697098, 0.208501, 0.480835),
- RGB(0.703532, 0.210638, 0.479049),
- RGB(0.709962, 0.212797, 0.477201),
- RGB(0.716387, 0.214982, 0.475290),
- RGB(0.722805, 0.217194, 0.473316),
- RGB(0.729216, 0.219437, 0.471279),
- RGB(0.735616, 0.221713, 0.469180),
- RGB(0.742004, 0.224025, 0.467018),
- RGB(0.748378, 0.226377, 0.464794),
- RGB(0.754737, 0.228772, 0.462509),
- RGB(0.761077, 0.231214, 0.460162),
- RGB(0.767398, 0.233705, 0.457755),
- RGB(0.773695, 0.236249, 0.455289),
- RGB(0.779968, 0.238851, 0.452765),
- RGB(0.786212, 0.241514, 0.450184),
- RGB(0.792427, 0.244242, 0.447543),
- RGB(0.798608, 0.247040, 0.444848),
- RGB(0.804752, 0.249911, 0.442102),
- RGB(0.810855, 0.252861, 0.439305),
- RGB(0.816914, 0.255895, 0.436461),
- RGB(0.822926, 0.259016, 0.433573),
- RGB(0.828886, 0.262229, 0.430644),
- RGB(0.834791, 0.265540, 0.427671),
- RGB(0.840636, 0.268953, 0.424666),
- RGB(0.846416, 0.272473, 0.421631),
- RGB(0.852126, 0.276106, 0.418573),
- RGB(0.857763, 0.279857, 0.415496),
- RGB(0.863320, 0.283729, 0.412403),
- RGB(0.868793, 0.287728, 0.409303),
- RGB(0.874176, 0.291859, 0.406205),
- RGB(0.879464, 0.296125, 0.403118),
- RGB(0.884651, 0.300530, 0.400047),
- RGB(0.889731, 0.305079, 0.397002),
- RGB(0.894700, 0.309773, 0.393995),
- RGB(0.899552, 0.314616, 0.391037),
- RGB(0.904281, 0.319610, 0.388137),
- RGB(0.908884, 0.324755, 0.385308),
- RGB(0.913354, 0.330052, 0.382563),
- RGB(0.917689, 0.335500, 0.379915),
- RGB(0.921884, 0.341098, 0.377376),
- RGB(0.925937, 0.346844, 0.374959),
- RGB(0.929845, 0.352734, 0.372677),
- RGB(0.933606, 0.358764, 0.370541),
- RGB(0.937221, 0.364929, 0.368567),
- RGB(0.940687, 0.371224, 0.366762),
- RGB(0.944006, 0.377643, 0.365136),
- RGB(0.947180, 0.384178, 0.363701),
- RGB(0.950210, 0.390820, 0.362468),
- RGB(0.953099, 0.397563, 0.361438),
- RGB(0.955849, 0.404400, 0.360619),
- RGB(0.958464, 0.411324, 0.360014),
- RGB(0.960949, 0.418323, 0.359630),
- RGB(0.963310, 0.425390, 0.359469),
- RGB(0.965549, 0.432519, 0.359529),
- RGB(0.967671, 0.439703, 0.359810),
- RGB(0.969680, 0.446936, 0.360311),
- RGB(0.971582, 0.454210, 0.361030),
- RGB(0.973381, 0.461520, 0.361965),
- RGB(0.975082, 0.468861, 0.363111),
- RGB(0.976690, 0.476226, 0.364466),
- RGB(0.978210, 0.483612, 0.366025),
- RGB(0.979645, 0.491014, 0.367783),
- RGB(0.981000, 0.498428, 0.369734),
- RGB(0.982279, 0.505851, 0.371874),
- RGB(0.983485, 0.513280, 0.374198),
- RGB(0.984622, 0.520713, 0.376698),
- RGB(0.985693, 0.528148, 0.379371),
- RGB(0.986700, 0.535582, 0.382210),
- RGB(0.987646, 0.543015, 0.385210),
- RGB(0.988533, 0.550446, 0.388365),
- RGB(0.989363, 0.557873, 0.391671),
- RGB(0.990138, 0.565296, 0.395122),
- RGB(0.990871, 0.572706, 0.398714),
- RGB(0.991558, 0.580107, 0.402441),
- RGB(0.992196, 0.587502, 0.406299),
- RGB(0.992785, 0.594891, 0.410283),
- RGB(0.993326, 0.602275, 0.414390),
- RGB(0.993834, 0.609644, 0.418613),
- RGB(0.994309, 0.616999, 0.422950),
- RGB(0.994738, 0.624350, 0.427397),
- RGB(0.995122, 0.631696, 0.431951),
- RGB(0.995480, 0.639027, 0.436607),
- RGB(0.995810, 0.646344, 0.441361),
- RGB(0.996096, 0.653659, 0.446213),
- RGB(0.996341, 0.660969, 0.451160),
- RGB(0.996580, 0.668256, 0.456192),
- RGB(0.996775, 0.675541, 0.461314),
- RGB(0.996925, 0.682828, 0.466526),
- RGB(0.997077, 0.690088, 0.471811),
- RGB(0.997186, 0.697349, 0.477182),
- RGB(0.997254, 0.704611, 0.482635),
- RGB(0.997325, 0.711848, 0.488154),
- RGB(0.997351, 0.719089, 0.493755),
- RGB(0.997351, 0.726324, 0.499428),
- RGB(0.997341, 0.733545, 0.505167),
- RGB(0.997285, 0.740772, 0.510983),
- RGB(0.997228, 0.747981, 0.516859),
- RGB(0.997138, 0.755190, 0.522806),
- RGB(0.997019, 0.762398, 0.528821),
- RGB(0.996898, 0.769591, 0.534892),
- RGB(0.996727, 0.776795, 0.541039),
- RGB(0.996571, 0.783977, 0.547233),
- RGB(0.996369, 0.791167, 0.553499),
- RGB(0.996162, 0.798348, 0.559820),
- RGB(0.995932, 0.805527, 0.566202),
- RGB(0.995680, 0.812706, 0.572645),
- RGB(0.995424, 0.819875, 0.579140),
- RGB(0.995131, 0.827052, 0.585701),
- RGB(0.994851, 0.834213, 0.592307),
- RGB(0.994524, 0.841387, 0.598983),
- RGB(0.994222, 0.848540, 0.605696),
- RGB(0.993866, 0.855711, 0.612482),
- RGB(0.993545, 0.862859, 0.619299),
- RGB(0.993170, 0.870024, 0.626189),
- RGB(0.992831, 0.877168, 0.633109),
- RGB(0.992440, 0.884330, 0.640099),
- RGB(0.992089, 0.891470, 0.647116),
- RGB(0.991688, 0.898627, 0.654202),
- RGB(0.991332, 0.905763, 0.661309),
- RGB(0.990930, 0.912915, 0.668481),
- RGB(0.990570, 0.920049, 0.675675),
- RGB(0.990175, 0.927196, 0.682926),
- RGB(0.989815, 0.934329, 0.690198),
- RGB(0.989434, 0.941470, 0.697519),
- RGB(0.989077, 0.948604, 0.704863),
- RGB(0.988717, 0.955742, 0.712242),
- RGB(0.988367, 0.962878, 0.719649),
- RGB(0.988033, 0.970012, 0.727077),
- RGB(0.987691, 0.977154, 0.734536),
- RGB(0.987387, 0.984288, 0.742002),
- RGB(0.987053, 0.991438, 0.749504)
-], 30))
-
-register_gradient_colors(:inferno, sample_evenly([
- RGB(0.001462, 0.000466, 0.013866),
- RGB(0.002267, 0.001270, 0.018570),
- RGB(0.003299, 0.002249, 0.024239),
- RGB(0.004547, 0.003392, 0.030909),
- RGB(0.006006, 0.004692, 0.038558),
- RGB(0.007676, 0.006136, 0.046836),
- RGB(0.009561, 0.007713, 0.055143),
- RGB(0.011663, 0.009417, 0.063460),
- RGB(0.013995, 0.011225, 0.071862),
- RGB(0.016561, 0.013136, 0.080282),
- RGB(0.019373, 0.015133, 0.088767),
- RGB(0.022447, 0.017199, 0.097327),
- RGB(0.025793, 0.019331, 0.105930),
- RGB(0.029432, 0.021503, 0.114621),
- RGB(0.033385, 0.023702, 0.123397),
- RGB(0.037668, 0.025921, 0.132232),
- RGB(0.042253, 0.028139, 0.141141),
- RGB(0.046915, 0.030324, 0.150164),
- RGB(0.051644, 0.032474, 0.159254),
- RGB(0.056449, 0.034569, 0.168414),
- RGB(0.061340, 0.036590, 0.177642),
- RGB(0.066331, 0.038504, 0.186962),
- RGB(0.071429, 0.040294, 0.196354),
- RGB(0.076637, 0.041905, 0.205799),
- RGB(0.081962, 0.043328, 0.215289),
- RGB(0.087411, 0.044556, 0.224813),
- RGB(0.092990, 0.045583, 0.234358),
- RGB(0.098702, 0.046402, 0.243904),
- RGB(0.104551, 0.047008, 0.253430),
- RGB(0.110536, 0.047399, 0.262912),
- RGB(0.116656, 0.047574, 0.272321),
- RGB(0.122908, 0.047536, 0.281624),
- RGB(0.129285, 0.047293, 0.290788),
- RGB(0.135778, 0.046856, 0.299776),
- RGB(0.142378, 0.046242, 0.308553),
- RGB(0.149073, 0.045468, 0.317085),
- RGB(0.155850, 0.044559, 0.325338),
- RGB(0.162689, 0.043554, 0.333277),
- RGB(0.169575, 0.042489, 0.340874),
- RGB(0.176493, 0.041402, 0.348111),
- RGB(0.183429, 0.040329, 0.354971),
- RGB(0.190367, 0.039309, 0.361447),
- RGB(0.197297, 0.038400, 0.367535),
- RGB(0.204209, 0.037632, 0.373238),
- RGB(0.211095, 0.037030, 0.378563),
- RGB(0.217949, 0.036615, 0.383522),
- RGB(0.224763, 0.036405, 0.388129),
- RGB(0.231538, 0.036405, 0.392400),
- RGB(0.238273, 0.036621, 0.396353),
- RGB(0.244967, 0.037055, 0.400007),
- RGB(0.251620, 0.037705, 0.403378),
- RGB(0.258234, 0.038571, 0.406485),
- RGB(0.264810, 0.039647, 0.409345),
- RGB(0.271347, 0.040922, 0.411976),
- RGB(0.277850, 0.042353, 0.414392),
- RGB(0.284321, 0.043933, 0.416608),
- RGB(0.290763, 0.045644, 0.418637),
- RGB(0.297178, 0.047470, 0.420491),
- RGB(0.303568, 0.049396, 0.422182),
- RGB(0.309935, 0.051407, 0.423721),
- RGB(0.316282, 0.053490, 0.425116),
- RGB(0.322610, 0.055634, 0.426377),
- RGB(0.328921, 0.057827, 0.427511),
- RGB(0.335217, 0.060060, 0.428524),
- RGB(0.341500, 0.062325, 0.429425),
- RGB(0.347771, 0.064616, 0.430217),
- RGB(0.354032, 0.066925, 0.430906),
- RGB(0.360284, 0.069247, 0.431497),
- RGB(0.366529, 0.071579, 0.431994),
- RGB(0.372768, 0.073915, 0.432400),
- RGB(0.379001, 0.076253, 0.432719),
- RGB(0.385228, 0.078591, 0.432955),
- RGB(0.391453, 0.080927, 0.433109),
- RGB(0.397674, 0.083257, 0.433183),
- RGB(0.403894, 0.085580, 0.433179),
- RGB(0.410113, 0.087896, 0.433098),
- RGB(0.416331, 0.090203, 0.432943),
- RGB(0.422549, 0.092501, 0.432714),
- RGB(0.428768, 0.094790, 0.432412),
- RGB(0.434987, 0.097069, 0.432039),
- RGB(0.441207, 0.099338, 0.431594),
- RGB(0.447428, 0.101597, 0.431080),
- RGB(0.453651, 0.103848, 0.430498),
- RGB(0.459875, 0.106089, 0.429846),
- RGB(0.466100, 0.108322, 0.429125),
- RGB(0.472328, 0.110547, 0.428334),
- RGB(0.478558, 0.112764, 0.427475),
- RGB(0.484789, 0.114974, 0.426548),
- RGB(0.491022, 0.117179, 0.425552),
- RGB(0.497257, 0.119379, 0.424488),
- RGB(0.503493, 0.121575, 0.423356),
- RGB(0.509730, 0.123769, 0.422156),
- RGB(0.515967, 0.125960, 0.420887),
- RGB(0.522206, 0.128150, 0.419549),
- RGB(0.528444, 0.130341, 0.418142),
- RGB(0.534683, 0.132534, 0.416667),
- RGB(0.540920, 0.134729, 0.415123),
- RGB(0.547157, 0.136929, 0.413511),
- RGB(0.553392, 0.139134, 0.411829),
- RGB(0.559624, 0.141346, 0.410078),
- RGB(0.565854, 0.143567, 0.408258),
- RGB(0.572081, 0.145797, 0.406369),
- RGB(0.578304, 0.148039, 0.404411),
- RGB(0.584521, 0.150294, 0.402385),
- RGB(0.590734, 0.152563, 0.400290),
- RGB(0.596940, 0.154848, 0.398125),
- RGB(0.603139, 0.157151, 0.395891),
- RGB(0.609330, 0.159474, 0.393589),
- RGB(0.615513, 0.161817, 0.391219),
- RGB(0.621685, 0.164184, 0.388781),
- RGB(0.627847, 0.166575, 0.386276),
- RGB(0.633998, 0.168992, 0.383704),
- RGB(0.640135, 0.171438, 0.381065),
- RGB(0.646260, 0.173914, 0.378359),
- RGB(0.652369, 0.176421, 0.375586),
- RGB(0.658463, 0.178962, 0.372748),
- RGB(0.664540, 0.181539, 0.369846),
- RGB(0.670599, 0.184153, 0.366879),
- RGB(0.676638, 0.186807, 0.363849),
- RGB(0.682656, 0.189501, 0.360757),
- RGB(0.688653, 0.192239, 0.357603),
- RGB(0.694627, 0.195021, 0.354388),
- RGB(0.700576, 0.197851, 0.351113),
- RGB(0.706500, 0.200728, 0.347777),
- RGB(0.712396, 0.203656, 0.344383),
- RGB(0.718264, 0.206636, 0.340931),
- RGB(0.724103, 0.209670, 0.337424),
- RGB(0.729909, 0.212759, 0.333861),
- RGB(0.735683, 0.215906, 0.330245),
- RGB(0.741423, 0.219112, 0.326576),
- RGB(0.747127, 0.222378, 0.322856),
- RGB(0.752794, 0.225706, 0.319085),
- RGB(0.758422, 0.229097, 0.315266),
- RGB(0.764010, 0.232554, 0.311399),
- RGB(0.769556, 0.236077, 0.307485),
- RGB(0.775059, 0.239667, 0.303526),
- RGB(0.780517, 0.243327, 0.299523),
- RGB(0.785929, 0.247056, 0.295477),
- RGB(0.791293, 0.250856, 0.291390),
- RGB(0.796607, 0.254728, 0.287264),
- RGB(0.801871, 0.258674, 0.283099),
- RGB(0.807082, 0.262692, 0.278898),
- RGB(0.812239, 0.266786, 0.274661),
- RGB(0.817341, 0.270954, 0.270390),
- RGB(0.822386, 0.275197, 0.266085),
- RGB(0.827372, 0.279517, 0.261750),
- RGB(0.832299, 0.283913, 0.257383),
- RGB(0.837165, 0.288385, 0.252988),
- RGB(0.841969, 0.292933, 0.248564),
- RGB(0.846709, 0.297559, 0.244113),
- RGB(0.851384, 0.302260, 0.239636),
- RGB(0.855992, 0.307038, 0.235133),
- RGB(0.860533, 0.311892, 0.230606),
- RGB(0.865006, 0.316822, 0.226055),
- RGB(0.869409, 0.321827, 0.221482),
- RGB(0.873741, 0.326906, 0.216886),
- RGB(0.878001, 0.332060, 0.212268),
- RGB(0.882188, 0.337287, 0.207628),
- RGB(0.886302, 0.342586, 0.202968),
- RGB(0.890341, 0.347957, 0.198286),
- RGB(0.894305, 0.353399, 0.193584),
- RGB(0.898192, 0.358911, 0.188860),
- RGB(0.902003, 0.364492, 0.184116),
- RGB(0.905735, 0.370140, 0.179350),
- RGB(0.909390, 0.375856, 0.174563),
- RGB(0.912966, 0.381636, 0.169755),
- RGB(0.916462, 0.387481, 0.164924),
- RGB(0.919879, 0.393389, 0.160070),
- RGB(0.923215, 0.399359, 0.155193),
- RGB(0.926470, 0.405389, 0.150292),
- RGB(0.929644, 0.411479, 0.145367),
- RGB(0.932737, 0.417627, 0.140417),
- RGB(0.935747, 0.423831, 0.135440),
- RGB(0.938675, 0.430091, 0.130438),
- RGB(0.941521, 0.436405, 0.125409),
- RGB(0.944285, 0.442772, 0.120354),
- RGB(0.946965, 0.449191, 0.115272),
- RGB(0.949562, 0.455660, 0.110164),
- RGB(0.952075, 0.462178, 0.105031),
- RGB(0.954506, 0.468744, 0.099874),
- RGB(0.956852, 0.475356, 0.094695),
- RGB(0.959114, 0.482014, 0.089499),
- RGB(0.961293, 0.488716, 0.084289),
- RGB(0.963387, 0.495462, 0.079073),
- RGB(0.965397, 0.502249, 0.073859),
- RGB(0.967322, 0.509078, 0.068659),
- RGB(0.969163, 0.515946, 0.063488),
- RGB(0.970919, 0.522853, 0.058367),
- RGB(0.972590, 0.529798, 0.053324),
- RGB(0.974176, 0.536780, 0.048392),
- RGB(0.975677, 0.543798, 0.043618),
- RGB(0.977092, 0.550850, 0.039050),
- RGB(0.978422, 0.557937, 0.034931),
- RGB(0.979666, 0.565057, 0.031409),
- RGB(0.980824, 0.572209, 0.028508),
- RGB(0.981895, 0.579392, 0.026250),
- RGB(0.982881, 0.586606, 0.024661),
- RGB(0.983779, 0.593849, 0.023770),
- RGB(0.984591, 0.601122, 0.023606),
- RGB(0.985315, 0.608422, 0.024202),
- RGB(0.985952, 0.615750, 0.025592),
- RGB(0.986502, 0.623105, 0.027814),
- RGB(0.986964, 0.630485, 0.030908),
- RGB(0.987337, 0.637890, 0.034916),
- RGB(0.987622, 0.645320, 0.039886),
- RGB(0.987819, 0.652773, 0.045581),
- RGB(0.987926, 0.660250, 0.051750),
- RGB(0.987945, 0.667748, 0.058329),
- RGB(0.987874, 0.675267, 0.065257),
- RGB(0.987714, 0.682807, 0.072489),
- RGB(0.987464, 0.690366, 0.079990),
- RGB(0.987124, 0.697944, 0.087731),
- RGB(0.986694, 0.705540, 0.095694),
- RGB(0.986175, 0.713153, 0.103863),
- RGB(0.985566, 0.720782, 0.112229),
- RGB(0.984865, 0.728427, 0.120785),
- RGB(0.984075, 0.736087, 0.129527),
- RGB(0.983196, 0.743758, 0.138453),
- RGB(0.982228, 0.751442, 0.147565),
- RGB(0.981173, 0.759135, 0.156863),
- RGB(0.980032, 0.766837, 0.166353),
- RGB(0.978806, 0.774545, 0.176037),
- RGB(0.977497, 0.782258, 0.185923),
- RGB(0.976108, 0.789974, 0.196018),
- RGB(0.974638, 0.797692, 0.206332),
- RGB(0.973088, 0.805409, 0.216877),
- RGB(0.971468, 0.813122, 0.227658),
- RGB(0.969783, 0.820825, 0.238686),
- RGB(0.968041, 0.828515, 0.249972),
- RGB(0.966243, 0.836191, 0.261534),
- RGB(0.964394, 0.843848, 0.273391),
- RGB(0.962517, 0.851476, 0.285546),
- RGB(0.960626, 0.859069, 0.298010),
- RGB(0.958720, 0.866624, 0.310820),
- RGB(0.956834, 0.874129, 0.323974),
- RGB(0.954997, 0.881569, 0.337475),
- RGB(0.953215, 0.888942, 0.351369),
- RGB(0.951546, 0.896226, 0.365627),
- RGB(0.950018, 0.903409, 0.380271),
- RGB(0.948683, 0.910473, 0.395289),
- RGB(0.947594, 0.917399, 0.410665),
- RGB(0.946809, 0.924168, 0.426373),
- RGB(0.946392, 0.930761, 0.442367),
- RGB(0.946403, 0.937159, 0.458592),
- RGB(0.946903, 0.943348, 0.474970),
- RGB(0.947937, 0.949318, 0.491426),
- RGB(0.949545, 0.955063, 0.507860),
- RGB(0.951740, 0.960587, 0.524203),
- RGB(0.954529, 0.965896, 0.540361),
- RGB(0.957896, 0.971003, 0.556275),
- RGB(0.961812, 0.975924, 0.571925),
- RGB(0.966249, 0.980678, 0.587206),
- RGB(0.971162, 0.985282, 0.602154),
- RGB(0.976511, 0.989753, 0.616760),
- RGB(0.982257, 0.994109, 0.631017),
- RGB(0.988362, 0.998364, 0.644924)
-], 30))
-
-register_gradient_colors(:plasma, sample_evenly([
- RGB(0.050383, 0.029803, 0.527975),
- RGB(0.063536, 0.028426, 0.533124),
- RGB(0.075353, 0.027206, 0.538007),
- RGB(0.086222, 0.026125, 0.542658),
- RGB(0.096379, 0.025165, 0.547103),
- RGB(0.105980, 0.024309, 0.551368),
- RGB(0.115124, 0.023556, 0.555468),
- RGB(0.123903, 0.022878, 0.559423),
- RGB(0.132381, 0.022258, 0.563250),
- RGB(0.140603, 0.021687, 0.566959),
- RGB(0.148607, 0.021154, 0.570562),
- RGB(0.156421, 0.020651, 0.574065),
- RGB(0.164070, 0.020171, 0.577478),
- RGB(0.171574, 0.019706, 0.580806),
- RGB(0.178950, 0.019252, 0.584054),
- RGB(0.186213, 0.018803, 0.587228),
- RGB(0.193374, 0.018354, 0.590330),
- RGB(0.200445, 0.017902, 0.593364),
- RGB(0.207435, 0.017442, 0.596333),
- RGB(0.214350, 0.016973, 0.599239),
- RGB(0.221197, 0.016497, 0.602083),
- RGB(0.227983, 0.016007, 0.604867),
- RGB(0.234715, 0.015502, 0.607592),
- RGB(0.241396, 0.014979, 0.610259),
- RGB(0.248032, 0.014439, 0.612868),
- RGB(0.254627, 0.013882, 0.615419),
- RGB(0.261183, 0.013308, 0.617911),
- RGB(0.267703, 0.012716, 0.620346),
- RGB(0.274191, 0.012109, 0.622722),
- RGB(0.280648, 0.011488, 0.625038),
- RGB(0.287076, 0.010855, 0.627295),
- RGB(0.293478, 0.010213, 0.629490),
- RGB(0.299855, 0.009561, 0.631624),
- RGB(0.306210, 0.008902, 0.633694),
- RGB(0.312543, 0.008239, 0.635700),
- RGB(0.318856, 0.007576, 0.637640),
- RGB(0.325150, 0.006915, 0.639512),
- RGB(0.331426, 0.006261, 0.641316),
- RGB(0.337683, 0.005618, 0.643049),
- RGB(0.343925, 0.004991, 0.644710),
- RGB(0.350150, 0.004382, 0.646298),
- RGB(0.356359, 0.003798, 0.647810),
- RGB(0.362553, 0.003243, 0.649245),
- RGB(0.368733, 0.002724, 0.650601),
- RGB(0.374897, 0.002245, 0.651876),
- RGB(0.381047, 0.001814, 0.653068),
- RGB(0.387183, 0.001434, 0.654177),
- RGB(0.393304, 0.001114, 0.655199),
- RGB(0.399411, 0.000859, 0.656133),
- RGB(0.405503, 0.000678, 0.656977),
- RGB(0.411580, 0.000577, 0.657730),
- RGB(0.417642, 0.000564, 0.658390),
- RGB(0.423689, 0.000646, 0.658956),
- RGB(0.429719, 0.000831, 0.659425),
- RGB(0.435734, 0.001127, 0.659797),
- RGB(0.441732, 0.001540, 0.660069),
- RGB(0.447714, 0.002080, 0.660240),
- RGB(0.453677, 0.002755, 0.660310),
- RGB(0.459623, 0.003574, 0.660277),
- RGB(0.465550, 0.004545, 0.660139),
- RGB(0.471457, 0.005678, 0.659897),
- RGB(0.477344, 0.006980, 0.659549),
- RGB(0.483210, 0.008460, 0.659095),
- RGB(0.489055, 0.010127, 0.658534),
- RGB(0.494877, 0.011990, 0.657865),
- RGB(0.500678, 0.014055, 0.657088),
- RGB(0.506454, 0.016333, 0.656202),
- RGB(0.512206, 0.018833, 0.655209),
- RGB(0.517933, 0.021563, 0.654109),
- RGB(0.523633, 0.024532, 0.652901),
- RGB(0.529306, 0.027747, 0.651586),
- RGB(0.534952, 0.031217, 0.650165),
- RGB(0.540570, 0.034950, 0.648640),
- RGB(0.546157, 0.038954, 0.647010),
- RGB(0.551715, 0.043136, 0.645277),
- RGB(0.557243, 0.047331, 0.643443),
- RGB(0.562738, 0.051545, 0.641509),
- RGB(0.568201, 0.055778, 0.639477),
- RGB(0.573632, 0.060028, 0.637349),
- RGB(0.579029, 0.064296, 0.635126),
- RGB(0.584391, 0.068579, 0.632812),
- RGB(0.589719, 0.072878, 0.630408),
- RGB(0.595011, 0.077190, 0.627917),
- RGB(0.600266, 0.081516, 0.625342),
- RGB(0.605485, 0.085854, 0.622686),
- RGB(0.610667, 0.090204, 0.619951),
- RGB(0.615812, 0.094564, 0.617140),
- RGB(0.620919, 0.098934, 0.614257),
- RGB(0.625987, 0.103312, 0.611305),
- RGB(0.631017, 0.107699, 0.608287),
- RGB(0.636008, 0.112092, 0.605205),
- RGB(0.640959, 0.116492, 0.602065),
- RGB(0.645872, 0.120898, 0.598867),
- RGB(0.650746, 0.125309, 0.595617),
- RGB(0.655580, 0.129725, 0.592317),
- RGB(0.660374, 0.134144, 0.588971),
- RGB(0.665129, 0.138566, 0.585582),
- RGB(0.669845, 0.142992, 0.582154),
- RGB(0.674522, 0.147419, 0.578688),
- RGB(0.679160, 0.151848, 0.575189),
- RGB(0.683758, 0.156278, 0.571660),
- RGB(0.688318, 0.160709, 0.568103),
- RGB(0.692840, 0.165141, 0.564522),
- RGB(0.697324, 0.169573, 0.560919),
- RGB(0.701769, 0.174005, 0.557296),
- RGB(0.706178, 0.178437, 0.553657),
- RGB(0.710549, 0.182868, 0.550004),
- RGB(0.714883, 0.187299, 0.546338),
- RGB(0.719181, 0.191729, 0.542663),
- RGB(0.723444, 0.196158, 0.538981),
- RGB(0.727670, 0.200586, 0.535293),
- RGB(0.731862, 0.205013, 0.531601),
- RGB(0.736019, 0.209439, 0.527908),
- RGB(0.740143, 0.213864, 0.524216),
- RGB(0.744232, 0.218288, 0.520524),
- RGB(0.748289, 0.222711, 0.516834),
- RGB(0.752312, 0.227133, 0.513149),
- RGB(0.756304, 0.231555, 0.509468),
- RGB(0.760264, 0.235976, 0.505794),
- RGB(0.764193, 0.240396, 0.502126),
- RGB(0.768090, 0.244817, 0.498465),
- RGB(0.771958, 0.249237, 0.494813),
- RGB(0.775796, 0.253658, 0.491171),
- RGB(0.779604, 0.258078, 0.487539),
- RGB(0.783383, 0.262500, 0.483918),
- RGB(0.787133, 0.266922, 0.480307),
- RGB(0.790855, 0.271345, 0.476706),
- RGB(0.794549, 0.275770, 0.473117),
- RGB(0.798216, 0.280197, 0.469538),
- RGB(0.801855, 0.284626, 0.465971),
- RGB(0.805467, 0.289057, 0.462415),
- RGB(0.809052, 0.293491, 0.458870),
- RGB(0.812612, 0.297928, 0.455338),
- RGB(0.816144, 0.302368, 0.451816),
- RGB(0.819651, 0.306812, 0.448306),
- RGB(0.823132, 0.311261, 0.444806),
- RGB(0.826588, 0.315714, 0.441316),
- RGB(0.830018, 0.320172, 0.437836),
- RGB(0.833422, 0.324635, 0.434366),
- RGB(0.836801, 0.329105, 0.430905),
- RGB(0.840155, 0.333580, 0.427455),
- RGB(0.843484, 0.338062, 0.424013),
- RGB(0.846788, 0.342551, 0.420579),
- RGB(0.850066, 0.347048, 0.417153),
- RGB(0.853319, 0.351553, 0.413734),
- RGB(0.856547, 0.356066, 0.410322),
- RGB(0.859750, 0.360588, 0.406917),
- RGB(0.862927, 0.365119, 0.403519),
- RGB(0.866078, 0.369660, 0.400126),
- RGB(0.869203, 0.374212, 0.396738),
- RGB(0.872303, 0.378774, 0.393355),
- RGB(0.875376, 0.383347, 0.389976),
- RGB(0.878423, 0.387932, 0.386600),
- RGB(0.881443, 0.392529, 0.383229),
- RGB(0.884436, 0.397139, 0.379860),
- RGB(0.887402, 0.401762, 0.376494),
- RGB(0.890340, 0.406398, 0.373130),
- RGB(0.893250, 0.411048, 0.369768),
- RGB(0.896131, 0.415712, 0.366407),
- RGB(0.898984, 0.420392, 0.363047),
- RGB(0.901807, 0.425087, 0.359688),
- RGB(0.904601, 0.429797, 0.356329),
- RGB(0.907365, 0.434524, 0.352970),
- RGB(0.910098, 0.439268, 0.349610),
- RGB(0.912800, 0.444029, 0.346251),
- RGB(0.915471, 0.448807, 0.342890),
- RGB(0.918109, 0.453603, 0.339529),
- RGB(0.920714, 0.458417, 0.336166),
- RGB(0.923287, 0.463251, 0.332801),
- RGB(0.925825, 0.468103, 0.329435),
- RGB(0.928329, 0.472975, 0.326067),
- RGB(0.930798, 0.477867, 0.322697),
- RGB(0.933232, 0.482780, 0.319325),
- RGB(0.935630, 0.487712, 0.315952),
- RGB(0.937990, 0.492667, 0.312575),
- RGB(0.940313, 0.497642, 0.309197),
- RGB(0.942598, 0.502639, 0.305816),
- RGB(0.944844, 0.507658, 0.302433),
- RGB(0.947051, 0.512699, 0.299049),
- RGB(0.949217, 0.517763, 0.295662),
- RGB(0.951344, 0.522850, 0.292275),
- RGB(0.953428, 0.527960, 0.288883),
- RGB(0.955470, 0.533093, 0.285490),
- RGB(0.957469, 0.538250, 0.282096),
- RGB(0.959424, 0.543431, 0.278701),
- RGB(0.961336, 0.548636, 0.275305),
- RGB(0.963203, 0.553865, 0.271909),
- RGB(0.965024, 0.559118, 0.268513),
- RGB(0.966798, 0.564396, 0.265118),
- RGB(0.968526, 0.569700, 0.261721),
- RGB(0.970205, 0.575028, 0.258325),
- RGB(0.971835, 0.580382, 0.254931),
- RGB(0.973416, 0.585761, 0.251540),
- RGB(0.974947, 0.591165, 0.248151),
- RGB(0.976428, 0.596595, 0.244767),
- RGB(0.977856, 0.602051, 0.241387),
- RGB(0.979233, 0.607532, 0.238013),
- RGB(0.980556, 0.613039, 0.234646),
- RGB(0.981826, 0.618572, 0.231287),
- RGB(0.983041, 0.624131, 0.227937),
- RGB(0.984199, 0.629718, 0.224595),
- RGB(0.985301, 0.635330, 0.221265),
- RGB(0.986345, 0.640969, 0.217948),
- RGB(0.987332, 0.646633, 0.214648),
- RGB(0.988260, 0.652325, 0.211364),
- RGB(0.989128, 0.658043, 0.208100),
- RGB(0.989935, 0.663787, 0.204859),
- RGB(0.990681, 0.669558, 0.201642),
- RGB(0.991365, 0.675355, 0.198453),
- RGB(0.991985, 0.681179, 0.195295),
- RGB(0.992541, 0.687030, 0.192170),
- RGB(0.993032, 0.692907, 0.189084),
- RGB(0.993456, 0.698810, 0.186041),
- RGB(0.993814, 0.704741, 0.183043),
- RGB(0.994103, 0.710698, 0.180097),
- RGB(0.994324, 0.716681, 0.177208),
- RGB(0.994474, 0.722691, 0.174381),
- RGB(0.994553, 0.728728, 0.171622),
- RGB(0.994561, 0.734791, 0.168938),
- RGB(0.994495, 0.740880, 0.166335),
- RGB(0.994355, 0.746995, 0.163821),
- RGB(0.994141, 0.753137, 0.161404),
- RGB(0.993851, 0.759304, 0.159092),
- RGB(0.993482, 0.765499, 0.156891),
- RGB(0.993033, 0.771720, 0.154808),
- RGB(0.992505, 0.777967, 0.152855),
- RGB(0.991897, 0.784239, 0.151042),
- RGB(0.991209, 0.790537, 0.149377),
- RGB(0.990439, 0.796859, 0.147870),
- RGB(0.989587, 0.803205, 0.146529),
- RGB(0.988648, 0.809579, 0.145357),
- RGB(0.987621, 0.815978, 0.144363),
- RGB(0.986509, 0.822401, 0.143557),
- RGB(0.985314, 0.828846, 0.142945),
- RGB(0.984031, 0.835315, 0.142528),
- RGB(0.982653, 0.841812, 0.142303),
- RGB(0.981190, 0.848329, 0.142279),
- RGB(0.979644, 0.854866, 0.142453),
- RGB(0.977995, 0.861432, 0.142808),
- RGB(0.976265, 0.868016, 0.143351),
- RGB(0.974443, 0.874622, 0.144061),
- RGB(0.972530, 0.881250, 0.144923),
- RGB(0.970533, 0.887896, 0.145919),
- RGB(0.968443, 0.894564, 0.147014),
- RGB(0.966271, 0.901249, 0.148180),
- RGB(0.964021, 0.907950, 0.149370),
- RGB(0.961681, 0.914672, 0.150520),
- RGB(0.959276, 0.921407, 0.151566),
- RGB(0.956808, 0.928152, 0.152409),
- RGB(0.954287, 0.934908, 0.152921),
- RGB(0.951726, 0.941671, 0.152925),
- RGB(0.949151, 0.948435, 0.152178),
- RGB(0.946602, 0.955190, 0.150328),
- RGB(0.944152, 0.961916, 0.146861),
- RGB(0.941896, 0.968590, 0.140956),
- RGB(0.940015, 0.975158, 0.131326)
-], 30))
-
-register_gradient_colors(:viridis, sample_evenly([
- RGB(0.267004, 0.004874, 0.329415),
- RGB(0.268510, 0.009605, 0.335427),
- RGB(0.269944, 0.014625, 0.341379),
- RGB(0.271305, 0.019942, 0.347269),
- RGB(0.272594, 0.025563, 0.353093),
- RGB(0.273809, 0.031497, 0.358853),
- RGB(0.274952, 0.037752, 0.364543),
- RGB(0.276022, 0.044167, 0.370164),
- RGB(0.277018, 0.050344, 0.375715),
- RGB(0.277941, 0.056324, 0.381191),
- RGB(0.278791, 0.062145, 0.386592),
- RGB(0.279566, 0.067836, 0.391917),
- RGB(0.280267, 0.073417, 0.397163),
- RGB(0.280894, 0.078907, 0.402329),
- RGB(0.281446, 0.084320, 0.407414),
- RGB(0.281924, 0.089666, 0.412415),
- RGB(0.282327, 0.094955, 0.417331),
- RGB(0.282656, 0.100196, 0.422160),
- RGB(0.282910, 0.105393, 0.426902),
- RGB(0.283091, 0.110553, 0.431554),
- RGB(0.283197, 0.115680, 0.436115),
- RGB(0.283229, 0.120777, 0.440584),
- RGB(0.283187, 0.125848, 0.444960),
- RGB(0.283072, 0.130895, 0.449241),
- RGB(0.282884, 0.135920, 0.453427),
- RGB(0.282623, 0.140926, 0.457517),
- RGB(0.282290, 0.145912, 0.461510),
- RGB(0.281887, 0.150881, 0.465405),
- RGB(0.281412, 0.155834, 0.469201),
- RGB(0.280868, 0.160771, 0.472899),
- RGB(0.280255, 0.165693, 0.476498),
- RGB(0.279574, 0.170599, 0.479997),
- RGB(0.278826, 0.175490, 0.483397),
- RGB(0.278012, 0.180367, 0.486697),
- RGB(0.277134, 0.185228, 0.489898),
- RGB(0.276194, 0.190074, 0.493001),
- RGB(0.275191, 0.194905, 0.496005),
- RGB(0.274128, 0.199721, 0.498911),
- RGB(0.273006, 0.204520, 0.501721),
- RGB(0.271828, 0.209303, 0.504434),
- RGB(0.270595, 0.214069, 0.507052),
- RGB(0.269308, 0.218818, 0.509577),
- RGB(0.267968, 0.223549, 0.512008),
- RGB(0.266580, 0.228262, 0.514349),
- RGB(0.265145, 0.232956, 0.516599),
- RGB(0.263663, 0.237631, 0.518762),
- RGB(0.262138, 0.242286, 0.520837),
- RGB(0.260571, 0.246922, 0.522828),
- RGB(0.258965, 0.251537, 0.524736),
- RGB(0.257322, 0.256130, 0.526563),
- RGB(0.255645, 0.260703, 0.528312),
- RGB(0.253935, 0.265254, 0.529983),
- RGB(0.252194, 0.269783, 0.531579),
- RGB(0.250425, 0.274290, 0.533103),
- RGB(0.248629, 0.278775, 0.534556),
- RGB(0.246811, 0.283237, 0.535941),
- RGB(0.244972, 0.287675, 0.537260),
- RGB(0.243113, 0.292092, 0.538516),
- RGB(0.241237, 0.296485, 0.539709),
- RGB(0.239346, 0.300855, 0.540844),
- RGB(0.237441, 0.305202, 0.541921),
- RGB(0.235526, 0.309527, 0.542944),
- RGB(0.233603, 0.313828, 0.543914),
- RGB(0.231674, 0.318106, 0.544834),
- RGB(0.229739, 0.322361, 0.545706),
- RGB(0.227802, 0.326594, 0.546532),
- RGB(0.225863, 0.330805, 0.547314),
- RGB(0.223925, 0.334994, 0.548053),
- RGB(0.221989, 0.339161, 0.548752),
- RGB(0.220057, 0.343307, 0.549413),
- RGB(0.218130, 0.347432, 0.550038),
- RGB(0.216210, 0.351535, 0.550627),
- RGB(0.214298, 0.355619, 0.551184),
- RGB(0.212395, 0.359683, 0.551710),
- RGB(0.210503, 0.363727, 0.552206),
- RGB(0.208623, 0.367752, 0.552675),
- RGB(0.206756, 0.371758, 0.553117),
- RGB(0.204903, 0.375746, 0.553533),
- RGB(0.203063, 0.379716, 0.553925),
- RGB(0.201239, 0.383670, 0.554294),
- RGB(0.199430, 0.387607, 0.554642),
- RGB(0.197636, 0.391528, 0.554969),
- RGB(0.195860, 0.395433, 0.555276),
- RGB(0.194100, 0.399323, 0.555565),
- RGB(0.192357, 0.403199, 0.555836),
- RGB(0.190631, 0.407061, 0.556089),
- RGB(0.188923, 0.410910, 0.556326),
- RGB(0.187231, 0.414746, 0.556547),
- RGB(0.185556, 0.418570, 0.556753),
- RGB(0.183898, 0.422383, 0.556944),
- RGB(0.182256, 0.426184, 0.557120),
- RGB(0.180629, 0.429975, 0.557282),
- RGB(0.179019, 0.433756, 0.557430),
- RGB(0.177423, 0.437527, 0.557565),
- RGB(0.175841, 0.441290, 0.557685),
- RGB(0.174274, 0.445044, 0.557792),
- RGB(0.172719, 0.448791, 0.557885),
- RGB(0.171176, 0.452530, 0.557965),
- RGB(0.169646, 0.456262, 0.558030),
- RGB(0.168126, 0.459988, 0.558082),
- RGB(0.166617, 0.463708, 0.558119),
- RGB(0.165117, 0.467423, 0.558141),
- RGB(0.163625, 0.471133, 0.558148),
- RGB(0.162142, 0.474838, 0.558140),
- RGB(0.160665, 0.478540, 0.558115),
- RGB(0.159194, 0.482237, 0.558073),
- RGB(0.157729, 0.485932, 0.558013),
- RGB(0.156270, 0.489624, 0.557936),
- RGB(0.154815, 0.493313, 0.557840),
- RGB(0.153364, 0.497000, 0.557724),
- RGB(0.151918, 0.500685, 0.557587),
- RGB(0.150476, 0.504369, 0.557430),
- RGB(0.149039, 0.508051, 0.557250),
- RGB(0.147607, 0.511733, 0.557049),
- RGB(0.146180, 0.515413, 0.556823),
- RGB(0.144759, 0.519093, 0.556572),
- RGB(0.143343, 0.522773, 0.556295),
- RGB(0.141935, 0.526453, 0.555991),
- RGB(0.140536, 0.530132, 0.555659),
- RGB(0.139147, 0.533812, 0.555298),
- RGB(0.137770, 0.537492, 0.554906),
- RGB(0.136408, 0.541173, 0.554483),
- RGB(0.135066, 0.544853, 0.554029),
- RGB(0.133743, 0.548535, 0.553541),
- RGB(0.132444, 0.552216, 0.553018),
- RGB(0.131172, 0.555899, 0.552459),
- RGB(0.129933, 0.559582, 0.551864),
- RGB(0.128729, 0.563265, 0.551229),
- RGB(0.127568, 0.566949, 0.550556),
- RGB(0.126453, 0.570633, 0.549841),
- RGB(0.125394, 0.574318, 0.549086),
- RGB(0.124395, 0.578002, 0.548287),
- RGB(0.123463, 0.581687, 0.547445),
- RGB(0.122606, 0.585371, 0.546557),
- RGB(0.121831, 0.589055, 0.545623),
- RGB(0.121148, 0.592739, 0.544641),
- RGB(0.120565, 0.596422, 0.543611),
- RGB(0.120092, 0.600104, 0.542530),
- RGB(0.119738, 0.603785, 0.541400),
- RGB(0.119512, 0.607464, 0.540218),
- RGB(0.119423, 0.611141, 0.538982),
- RGB(0.119483, 0.614817, 0.537692),
- RGB(0.119699, 0.618490, 0.536347),
- RGB(0.120081, 0.622161, 0.534946),
- RGB(0.120638, 0.625828, 0.533488),
- RGB(0.121380, 0.629492, 0.531973),
- RGB(0.122312, 0.633153, 0.530398),
- RGB(0.123444, 0.636809, 0.528763),
- RGB(0.124780, 0.640461, 0.527068),
- RGB(0.126326, 0.644107, 0.525311),
- RGB(0.128087, 0.647749, 0.523491),
- RGB(0.130067, 0.651384, 0.521608),
- RGB(0.132268, 0.655014, 0.519661),
- RGB(0.134692, 0.658636, 0.517649),
- RGB(0.137339, 0.662252, 0.515571),
- RGB(0.140210, 0.665859, 0.513427),
- RGB(0.143303, 0.669459, 0.511215),
- RGB(0.146616, 0.673050, 0.508936),
- RGB(0.150148, 0.676631, 0.506589),
- RGB(0.153894, 0.680203, 0.504172),
- RGB(0.157851, 0.683765, 0.501686),
- RGB(0.162016, 0.687316, 0.499129),
- RGB(0.166383, 0.690856, 0.496502),
- RGB(0.170948, 0.694384, 0.493803),
- RGB(0.175707, 0.697900, 0.491033),
- RGB(0.180653, 0.701402, 0.488189),
- RGB(0.185783, 0.704891, 0.485273),
- RGB(0.191090, 0.708366, 0.482284),
- RGB(0.196571, 0.711827, 0.479221),
- RGB(0.202219, 0.715272, 0.476084),
- RGB(0.208030, 0.718701, 0.472873),
- RGB(0.214000, 0.722114, 0.469588),
- RGB(0.220124, 0.725509, 0.466226),
- RGB(0.226397, 0.728888, 0.462789),
- RGB(0.232815, 0.732247, 0.459277),
- RGB(0.239374, 0.735588, 0.455688),
- RGB(0.246070, 0.738910, 0.452024),
- RGB(0.252899, 0.742211, 0.448284),
- RGB(0.259857, 0.745492, 0.444467),
- RGB(0.266941, 0.748751, 0.440573),
- RGB(0.274149, 0.751988, 0.436601),
- RGB(0.281477, 0.755203, 0.432552),
- RGB(0.288921, 0.758394, 0.428426),
- RGB(0.296479, 0.761561, 0.424223),
- RGB(0.304148, 0.764704, 0.419943),
- RGB(0.311925, 0.767822, 0.415586),
- RGB(0.319809, 0.770914, 0.411152),
- RGB(0.327796, 0.773980, 0.406640),
- RGB(0.335885, 0.777018, 0.402049),
- RGB(0.344074, 0.780029, 0.397381),
- RGB(0.352360, 0.783011, 0.392636),
- RGB(0.360741, 0.785964, 0.387814),
- RGB(0.369214, 0.788888, 0.382914),
- RGB(0.377779, 0.791781, 0.377939),
- RGB(0.386433, 0.794644, 0.372886),
- RGB(0.395174, 0.797475, 0.367757),
- RGB(0.404001, 0.800275, 0.362552),
- RGB(0.412913, 0.803041, 0.357269),
- RGB(0.421908, 0.805774, 0.351910),
- RGB(0.430983, 0.808473, 0.346476),
- RGB(0.440137, 0.811138, 0.340967),
- RGB(0.449368, 0.813768, 0.335384),
- RGB(0.458674, 0.816363, 0.329727),
- RGB(0.468053, 0.818921, 0.323998),
- RGB(0.477504, 0.821444, 0.318195),
- RGB(0.487026, 0.823929, 0.312321),
- RGB(0.496615, 0.826376, 0.306377),
- RGB(0.506271, 0.828786, 0.300362),
- RGB(0.515992, 0.831158, 0.294279),
- RGB(0.525776, 0.833491, 0.288127),
- RGB(0.535621, 0.835785, 0.281908),
- RGB(0.545524, 0.838039, 0.275626),
- RGB(0.555484, 0.840254, 0.269281),
- RGB(0.565498, 0.842430, 0.262877),
- RGB(0.575563, 0.844566, 0.256415),
- RGB(0.585678, 0.846661, 0.249897),
- RGB(0.595839, 0.848717, 0.243329),
- RGB(0.606045, 0.850733, 0.236712),
- RGB(0.616293, 0.852709, 0.230052),
- RGB(0.626579, 0.854645, 0.223353),
- RGB(0.636902, 0.856542, 0.216620),
- RGB(0.647257, 0.858400, 0.209861),
- RGB(0.657642, 0.860219, 0.203082),
- RGB(0.668054, 0.861999, 0.196293),
- RGB(0.678489, 0.863742, 0.189503),
- RGB(0.688944, 0.865448, 0.182725),
- RGB(0.699415, 0.867117, 0.175971),
- RGB(0.709898, 0.868751, 0.169257),
- RGB(0.720391, 0.870350, 0.162603),
- RGB(0.730889, 0.871916, 0.156029),
- RGB(0.741388, 0.873449, 0.149561),
- RGB(0.751884, 0.874951, 0.143228),
- RGB(0.762373, 0.876424, 0.137064),
- RGB(0.772852, 0.877868, 0.131109),
- RGB(0.783315, 0.879285, 0.125405),
- RGB(0.793760, 0.880678, 0.120005),
- RGB(0.804182, 0.882046, 0.114965),
- RGB(0.814576, 0.883393, 0.110347),
- RGB(0.824940, 0.884720, 0.106217),
- RGB(0.835270, 0.886029, 0.102646),
- RGB(0.845561, 0.887322, 0.099702),
- RGB(0.855810, 0.888601, 0.097452),
- RGB(0.866013, 0.889868, 0.095953),
- RGB(0.876168, 0.891125, 0.095250),
- RGB(0.886271, 0.892374, 0.095374),
- RGB(0.896320, 0.893616, 0.096335),
- RGB(0.906311, 0.894855, 0.098125),
- RGB(0.916242, 0.896091, 0.100717),
- RGB(0.926106, 0.897330, 0.104071),
- RGB(0.935904, 0.898570, 0.108131),
- RGB(0.945636, 0.899815, 0.112838),
- RGB(0.955300, 0.901065, 0.118128),
- RGB(0.964894, 0.902323, 0.123941),
- RGB(0.974417, 0.903590, 0.130215),
- RGB(0.983868, 0.904867, 0.136897),
- RGB(0.993248, 0.906157, 0.143936)
-], 30))
-
-
-# end of matplotlib colormaps
-# ----------------------------------------------------------------------
-# ----------------------------------------------------------------------
diff --git a/src/deprecated/colors.jl b/src/deprecated/colors.jl
deleted file mode 100644
index 5e01bdc1..00000000
--- a/src/deprecated/colors.jl
+++ /dev/null
@@ -1,415 +0,0 @@
-
-abstract type ColorScheme end
-
-Base.getindex(scheme::ColorScheme, i::Integer) = getColor(scheme, i)
-
-export
- cgrad
-
-cgrad() = default_gradient()
-
-function cgrad(arg, values = nothing; alpha = nothing, scale = :identity)
- colors = ColorGradient(arg, alpha=alpha).colors
- values = if values != nothing
- values
- elseif scale in (:log, :log10)
- log10(range(1, stop=10, length=30))
- elseif scale == :log2
- log2(range(1, stop=2, length=30))
- elseif scale == :ln
- log(range(1, stop=pi, length=30))
- elseif scale in (:exp, :exp10)
- (exp10(range(0, stop=1, length=30)) - 1) / 9
- else
- range(0, stop=1, length=length(colors))
- end
- ColorGradient(colors, values)
-end
-
-# --------------------------------------------------------------
-
-getColor(scheme::ColorScheme) = getColor(scheme, 1)
-getColorVector(scheme::ColorScheme) = [getColor(scheme)]
-
-colorscheme(scheme::ColorScheme) = scheme
-colorscheme(s::AbstractString; kw...) = colorscheme(Symbol(s); kw...)
-colorscheme(s::Symbol; kw...) = haskey(_gradients, s) ? ColorGradient(s; kw...) : ColorWrapper(convertColor(s); kw...)
-colorscheme(s::Symbol, vals::AVec{T}; kw...) where {T<:Real} = ColorGradient(s, vals; kw...)
-colorscheme(cs::AVec, vs::AVec; kw...) = ColorGradient(cs, vs; kw...)
-colorscheme(cs::AVec{T}; kw...) where {T<:Colorant} = ColorGradient(cs; kw...)
-colorscheme(f::Function; kw...) = ColorFunction(f; kw...)
-colorscheme(v::AVec; kw...) = ColorVector(v; kw...)
-colorscheme(m::AMat; kw...) = size(m,1) == 1 ? map(c->colorscheme(c; kw...), m) : [colorscheme(m[:,i]; kw...) for i in 1:size(m,2)]'
-colorscheme(c::Colorant; kw...) = ColorWrapper(c; kw...)
-
-
-# --------------------------------------------------------------
-
-
-convertColor(c::AbstractString) = parse(Colorant, c)
-convertColor(c::Symbol) = parse(Colorant, string(c))
-convertColor(c::Colorant) = c
-convertColor(cvec::AbstractVector) = map(convertColor, cvec)
-convertColor(c::ColorScheme) = c
-convertColor(v::Nothing) = RGBA(0,0,0,0)
-convertColor(b::Bool) = b ? RGBA(0,0,0,1) : RGBA(0,0,0,0)
-
-function convertColor(c, α::Real)
- c = convertColor(c)
- RGBA(RGB(getColor(c)), α)
-end
-convertColor(cs::AVec, α::Real) = map(c -> convertColor(c, α), cs)
-convertColor(c, α::Nothing) = convertColor(c)
-
-# backup... try to convert
-getColor(c) = convertColor(c)
-
-# --------------------------------------------------------------
-
-function darken(c, v=0.1)
- rgba = convert(RGBA, c)
- r = max(0, min(rgba.r - v, 1))
- g = max(0, min(rgba.g - v, 1))
- b = max(0, min(rgba.b - v, 1))
- RGBA(r,g,b,rgba.alpha)
-end
-function lighten(c, v=0.3)
- darken(c, -v)
-end
-
-# --------------------------------------------------------------
-
-const _rainbowColors = [colorant"purple", colorant"blue", colorant"green", colorant"orange", colorant"red"]
-const _testColors = [colorant"darkblue", colorant"blueviolet", colorant"darkcyan",colorant"green",
- darken(colorant"yellow",0.3), colorant"orange", darken(colorant"red",0.2)]
-
-const _gradients = KW(
- :blues => [colorant"lightblue", colorant"darkblue"],
- :reds => [colorant"lightpink", colorant"darkred"],
- :greens => [colorant"lightgreen", colorant"darkgreen"],
- :redsblues => [colorant"darkred", RGB(0.8,0.85,0.8), colorant"darkblue"],
- :bluesreds => [colorant"darkblue", RGB(0.8,0.85,0.8), colorant"darkred"],
- :heat => [colorant"lightyellow", colorant"orange", colorant"darkred"],
- :grays => [RGB(.95,.95,.95),RGB(.05,.05,.05)],
- :rainbow => _rainbowColors,
- :lightrainbow => map(lighten, _rainbowColors),
- :darkrainbow => map(darken, _rainbowColors),
- :darktest => _testColors,
- :lighttest => map(c -> lighten(c, 0.3), _testColors),
- )
-
-function register_gradient_colors(name::Symbol, colors::AVec{C}) where C<:Colorant
- _gradients[name] = colors
-end
-
-include("color_gradients.jl")
-
-default_gradient() = ColorGradient(:inferno)
-
-# --------------------------------------------------------------
-
-"Continuous gradient between values. Wraps a list of bounding colors and the values they represent."
-struct ColorGradient <: ColorScheme
- colors::Vector
- values::Vector
-
- function ColorGradient(cs::AVec, vals::AVec{S} = range(0, stop=1, length=length(cs)); alpha = nothing) where S<:Real
- if length(cs) == length(vals)
- return new(convertColor(cs,alpha), collect(vals))
- end
-
- # # otherwise interpolate evenly between the minval and maxval
- # minval, maxval = minimum(vals), maximum(vals)
- # vs = Float64[interpolate(minval, maxval, w) for w in range(0, stop = 1, length = length(cs))]
- # new(convertColor(cs,alpha), vs)
-
- # interpolate the colors for each value
- vals = merge(range(0, stop=1, length=length(cs)), vals)
- grad = ColorGradient(cs)
- cs = [getColorZ(grad, z) for z in range(0, stop=1, length=length(vals))]
- new(convertColor(cs, alpha), vals)
- end
-end
-
-
-
-Base.getindex(cs::ColorGradient, i::Integer) = getColor(cs, i)
-Base.getindex(cs::ColorGradient, z::Number) = getColorZ(cs, z)
-
-
-# create a gradient from a symbol (blues, reds, etc) and vector of boundary values
-function ColorGradient(s::Symbol, vals::AVec{T} = 0:0; kw...) where T<:Real
- haskey(_gradients, s) || error("Invalid gradient symbol. Choose from: ", sort(collect(keys(_gradients))))
- cs = _gradients[s]
- if vals == 0:0
- vals = range(0, stop=1, length=length(cs))
- end
- ColorGradient(cs, vals; kw...)
-end
-
-# function ColorGradient{T<:Real}(cs::AVec, vals::AVec{T} = range(0, stop = 1, length = length(cs)); kw...)
-# ColorGradient(map(convertColor, cs), vals; kw...)
-# end
-
-function ColorGradient(grad::ColorGradient; alpha = nothing)
- ColorGradient(convertColor(grad.colors, alpha), grad.values)
-end
-
-# anything else just gets the default gradient
-function ColorGradient(cw; alpha=nothing)
- ColorGradient(default_gradient(), alpha=alpha)
-end
-
-getColor(gradient::ColorGradient, idx::Int) = gradient.colors[mod1(idx, length(gradient.colors))]
-
-function getColorZ(gradient::ColorGradient, z::Real)
- cs = gradient.colors
- vs = gradient.values
- n = length(cs)
- @assert n > 0 && n == length(vs)
-
- # can we just return the first color?
- if z <= vs[1] || n == 1
- return cs[1]
- end
-
- # find the bounding colors and interpolate
- for i in 2:n
- if z <= vs[i]
- return interpolate_rgb(cs[i-1], cs[i], (z - vs[i-1]) / (vs[i] - vs[i-1]))
- end
- end
-
- # if we get here, return the last color
- cs[end]
-end
-
-getColorVector(gradient::ColorGradient) = gradient.colors
-
-# for 0.3
-Colors.RGBA(c::Colorant) = RGBA(red(c), green(c), blue(c), alpha(c))
-Colors.RGB(c::Colorant) = RGB(red(c), green(c), blue(c))
-
-function interpolate_rgb(c1::Colorant, c2::Colorant, w::Real)
- rgb1 = RGBA(c1)
- rgb2 = RGBA(c2)
- r = interpolate(rgb1.r, rgb2.r, w)
- g = interpolate(rgb1.g, rgb2.g, w)
- b = interpolate(rgb1.b, rgb2.b, w)
- a = interpolate(rgb1.alpha, rgb2.alpha, w)
- RGBA(r, g, b, a)
-end
-
-
-function interpolate(v1::Real, v2::Real, w::Real)
- (1-w) * v1 + w * v2
-end
-
-# --------------------------------------------------------------
-
-"Wraps a function, taking an index and returning a Colorant"
-struct ColorFunction <: ColorScheme
- f::Function
-end
-
-getColor(scheme::ColorFunction, idx::Int) = scheme.f(idx)
-
-# --------------------------------------------------------------
-
-"Wraps a function, taking an z-value and returning a Colorant"
-struct ColorZFunction <: ColorScheme
- f::Function
-end
-
-getColorZ(scheme::ColorZFunction, z::Real) = scheme.f(z)
-
-# --------------------------------------------------------------
-
-"Wraps a vector of colors... may be vector of Symbol/String/Colorant"
-struct ColorVector <: ColorScheme
- v::Vector{Colorant}
- ColorVector(v::AVec; alpha = nothing) = new(convertColor(v,alpha))
-end
-
-getColor(scheme::ColorVector, idx::Int) = convertColor(scheme.v[mod1(idx, length(scheme.v))])
-getColorVector(scheme::ColorVector) = scheme.v
-
-
-# --------------------------------------------------------------
-
-"Wraps a single color"
-struct ColorWrapper <: ColorScheme
- c::RGBA
- ColorWrapper(c::Colorant; alpha = nothing) = new(convertColor(c, alpha))
-end
-
-ColorWrapper(s::Symbol; alpha = nothing) = ColorWrapper(convertColor(parse(Colorant, s), alpha))
-
-getColor(scheme::ColorWrapper, idx::Int) = scheme.c
-getColorZ(scheme::ColorWrapper, z::Real) = scheme.c
-convertColor(c::ColorWrapper, α::Nothing) = c.c
-
-# --------------------------------------------------------------
-
-
-isbackgrounddark(bgcolor::Color) = Lab(bgcolor).l < 0.5
-
-# move closer to lighter/darker depending on background value
-function adjustAway(val, bgval, vmin=0., vmax=100.)
- if bgval < 0.5 * (vmax+vmin)
- tmp = max(val, bgval)
- return 0.5 * (tmp + max(tmp, vmax))
- else
- tmp = min(val, bgval)
- return 0.5 * (tmp + min(tmp, vmin))
- end
-end
-
-# borrowed from http://stackoverflow.com/a/1855903:
-lightnessLevel(c::Colorant) = 0.299 * red(c) + 0.587 * green(c) + 0.114 * blue(c)
-
-isdark(c::Colorant) = lightnessLevel(c) < 0.5
-islight(c::Colorant) = !isdark(c)
-
-function convertHexToRGB(h::Unsigned)
- mask = 0x0000FF
- RGB([(x & mask) / 0xFF for x in (h >> 16, h >> 8, h)]...)
-end
-
-# note: I found this list of hex values in a comment by Tatarize here: http://stackoverflow.com/a/12224359
-const _masterColorList = [
- 0xFFFFFF, 0x000000, 0x0000FF, 0x00FF00, 0xFF0000, 0x01FFFE, 0xFFA6FE, 0xFFDB66, 0x006401, 0x010067,
- 0x95003A, 0x007DB5, 0xFF00F6, 0xFFEEE8, 0x774D00, 0x90FB92, 0x0076FF, 0xD5FF00, 0xFF937E, 0x6A826C,
- 0xFF029D, 0xFE8900, 0x7A4782, 0x7E2DD2, 0x85A900, 0xFF0056, 0xA42400, 0x00AE7E, 0x683D3B, 0xBDC6FF,
- 0x263400, 0xBDD393, 0x00B917, 0x9E008E, 0x001544, 0xC28C9F, 0xFF74A3, 0x01D0FF, 0x004754, 0xE56FFE,
- 0x788231, 0x0E4CA1, 0x91D0CB, 0xBE9970, 0x968AE8, 0xBB8800, 0x43002C, 0xDEFF74, 0x00FFC6, 0xFFE502,
- 0x620E00, 0x008F9C, 0x98FF52, 0x7544B1, 0xB500FF, 0x00FF78, 0xFF6E41, 0x005F39, 0x6B6882, 0x5FAD4E,
- 0xA75740, 0xA5FFD2, 0xFFB167, 0x009BFF, 0xE85EBE
- ]
-const _allColors = map(convertHexToRGB, _masterColorList)
-const _darkColors = filter(isdark, _allColors)
-const _lightColors = filter(islight, _allColors)
-const _sortedColorsForDarkBackground = vcat(_lightColors, reverse(_darkColors[2:end]))
-const _sortedColorsForLightBackground = vcat(_darkColors, reverse(_lightColors[2:end]))
-
-const _defaultNumColors = 17
-
-# --------------------------------------------------------------
-
-# Methods to automatically generate gradients for color selection based on
-# background color and a short list of seed colors
-
-# here are some magic constants that could be changed if you really want
-const _lightness_darkbg = [80.0]
-const _lightness_lightbg = [60.0]
-const _lch_c_const = [60]
-
-function adjust_lch(color, l, c)
- lch = convert(LCHab, color)
- convert(RGB, LCHab(l, c, lch.h))
-end
-
-function lightness_from_background(bgcolor)
- bglight = convert(LCHab, bgcolor).l
- bglight < 50.0 ? _lightness_darkbg[1] : _lightness_lightbg[1]
-end
-
-function gradient_from_list(cs)
- zvalues = Plots.get_zvalues(length(cs))
- indices = sortperm(zvalues)
- sorted_colors = map(RGBA, cs[indices])
- sorted_zvalues = zvalues[indices]
- ColorGradient(sorted_colors, sorted_zvalues)
-end
-
-function generate_colorgradient(bgcolor = colorant"white";
- color_bases = color_bases=[colorant"steelblue",colorant"orangered"],
- lightness = lightness_from_background(bgcolor),
- chroma = _lch_c_const[1],
- n = _defaultNumColors)
- seed_colors = vcat(bgcolor, map(c -> adjust_lch(c, lightness, chroma), color_bases))
- colors = distinguishable_colors(n,
- seed_colors,
- lchoices=Float64[lightness],
- cchoices=Float64[chroma],
- hchoices=range(0, stop=340, length=20)
- )[2:end]
- gradient_from_list(colors)
-end
-
-function get_color_palette(palette, bgcolor::Union{Colorant,ColorWrapper}, numcolors::Integer)
- grad = if palette == :auto
- generate_colorgradient(bgcolor)
- else
- ColorGradient(palette)
- end
- zrng = get_zvalues(numcolors)
- RGBA[getColorZ(grad, z) for z in zrng]
-end
-
-function get_color_palette(palette::Vector{C},
-bgcolor::Union{Colorant,ColorWrapper}, numcolors::Integer) where C<:Colorant
- palette
-end
-
-# ----------------------------------------------------------------------------------
-
-
-function getpctrange(n::Int)
- n > 0 || error()
- n == 1 && return zeros(1)
- zs = [0.0, 1.0]
- for i in 3:n
- sorted = sort(zs)
- diffs = diff(sorted)
- widestj = 0
- widest = 0.0
- for (j,d) in enumerate(diffs)
- if d > widest
- widest = d
- widestj = j
- end
- end
- push!(zs, sorted[widestj] + 0.5 * diffs[widestj])
- end
- zs
-end
-
-function get_zvalues(n::Int)
- offsets = getpctrange(ceil(Int,n/4)+1)/4
- offsets = vcat(offsets[1], offsets[3:end])
- zvalues = Float64[]
- for offset in offsets
- append!(zvalues, offset + [0.0, 0.5, 0.25, 0.75])
- end
- vcat(zvalues[1], 1.0, zvalues[2:n-1])
-end
-
-# ----------------------------------------------------------------------------------
-
-
-make255(x) = round(Int, 255 * x)
-
-function webcolor(c::Color)
- @sprintf("rgb(%d, %d, %d)", [make255(f(c)) for f in [red,green,blue]]...)
-end
-function webcolor(c::TransparentColor)
- @sprintf("rgba(%d, %d, %d, %1.3f)", [make255(f(c)) for f in [red,green,blue]]..., alpha(c))
-end
-webcolor(cs::ColorScheme) = webcolor(getColor(cs))
-webcolor(c) = webcolor(convertColor(c))
-webcolor(c, α) = webcolor(convertColor(getColor(c), α))
-
-# ----------------------------------------------------------------------------------
-
-
-# converts a symbol or string into a colorant (Colors.RGB), and assigns a color automatically
-function getSeriesRGBColor(c, sp::Subplot, n::Int)
-
- if c == :auto
- c = autopick(sp[:color_palette], n)
- end
-
- # c should now be a subtype of ColorScheme
- colorscheme(c)
-end
diff --git a/src/deprecated/contours.jl b/src/deprecated/contours.jl
deleted file mode 100644
index f9ab0954..00000000
--- a/src/deprecated/contours.jl
+++ /dev/null
@@ -1,63 +0,0 @@
-
-
-# TODO:
-"""
-- load Contours.jl similar to DataFrames
-- method to build grid from x/y/z vectors
-- method to wrap contours creation
-- method to plot contours as custom shapes (TODO: create Stroke and Fill types and add markerstroke/markerfill args)
-
-"""
-
-
-
-# # ----------------------------------------------------------
-# # ----------------------------------------------------------
-
-
-# immutable Vertex
-# x::Float64
-# y::Float64
-# z::Float64
-# end
-
-# immutable Edge
-# v::Vertex
-# u::Vertex
-# end
-
-# # ----------------------------------------------------------
-
-# # one rectangle's z-values and the center vertex
-# # z is ordered: topleft, topright, bottomright, bottomleft
-# immutable GridRect
-# z::Vector{Float64}
-# center::Vertex
-# data::Vector{Vertex}
-# end
-
-
-
-# type Grid
-# xs::Vector{Float64}
-# ys::Vector{Float64}
-# rects::Matrix{GridRect}
-# end
-
-# function splitDataEvenly(v::AbstractVector{Float64}, n::Int)
-# vs = sort(v)
-
-# end
-
-# # the goal here is to create the vertical and horizontal partitions
-# # which define the grid, so that the data is somewhat evenly split
-# function bucketData(x, y, z)
-
-# end
-
-
-# function buildGrid(x, y, z)
-# # create
-# end
-
-
diff --git a/src/deprecated/series_args.jl b/src/deprecated/series_args.jl
deleted file mode 100644
index 4dafda80..00000000
--- a/src/deprecated/series_args.jl
+++ /dev/null
@@ -1,99 +0,0 @@
-
-# create a new "build_series_args" which converts all inputs into xs = Any[xitems], ys = Any[yitems].
-# Special handling for: no args, xmin/xmax, parametric, dataframes
-# Then once inputs have been converted, build the series args, map functions, etc.
-# This should cut down on boilerplate code and allow more focused dispatch on type
-# note: returns meta information... mainly for use with automatic labeling from DataFrames for now
-
-const FuncOrFuncs = Union{Function, AVec{Function}}
-
-all3D(plotattributes::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image), get(plotattributes, :seriestype, :none))
-
-# missing
-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
-
-# string vector
-convertToAnyVector(v::AVec{T}, plotattributes::KW) where {T<:AbstractString} = Any[v], nothing
-
-function convertToAnyVector(v::AMat, plotattributes::KW)
- if all3D(plotattributes)
- Any[Surface(v)]
- else
- Any[v[:,i] for i in 1:size(v,2)]
- end, nothing
-end
-
-# function
-convertToAnyVector(f::Function, plotattributes::KW) = Any[f], nothing
-
-# surface
-convertToAnyVector(s::Surface, plotattributes::KW) = Any[s], nothing
-
-# # vector of OHLC
-# convertToAnyVector(v::AVec{OHLC}, plotattributes::KW) = Any[v], nothing
-
-# dates
-convertToAnyVector(dts::AVec{D}, plotattributes::KW) where {D<:Union{Date,DateTime}} = Any[dts], nothing
-
-# list of things (maybe other vectors, functions, or something else)
-function convertToAnyVector(v::AVec, plotattributes::KW)
- if all(x -> typeof(x) <: Number, v)
- # all real numbers wrap the whole vector as one item
- Any[convert(Vector{Float64}, v)], nothing
- else
- # something else... treat each element as an item
- vcat(Any[convertToAnyVector(vi, plotattributes)[1] for vi in v]...), nothing
- # Any[vi for vi in v], nothing
- end
-end
-
-convertToAnyVector(t::Tuple, plotattributes::KW) = Any[t], nothing
-
-
-function convertToAnyVector(args...)
- error("In convertToAnyVector, could not handle the argument types: $(map(typeof, args[1:end-1]))")
-end
-
-# --------------------------------------------------------------------
-
-# 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) = 1:size(z,1)
-compute_x(x::Nothing, y, z) = 1:size(y,1)
-compute_x(x::Function, y, z) = map(x, y)
-compute_x(x, y, z) = copy(x)
-
-# compute_y(x::Void, y::Function, z) = error()
-compute_y(x::Nothing, y::Nothing, z) = 1:size(z,2)
-compute_y(x, y::Function, z) = map(y, x)
-compute_y(x, y, z) = copy(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)
-
-nobigs(v::AVec{BigFloat}) = map(Float64, v)
-nobigs(v::AVec{BigInt}) = map(Int64, v)
-nobigs(v) = v
-
-@noinline function compute_xyz(x, y, z)
- x = compute_x(x,y,z)
- y = compute_y(x,y,z)
- z = compute_z(x,y,z)
- nobigs(x), nobigs(y), nobigs(z)
-end
-
-# not allowed
-compute_xyz(x::Nothing, y::FuncOrFuncs, z) = error("If you want to plot the function `$y`, you need to define the x values!")
-compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs) = error("If you want to plot the function `$z`, you need to define x and y values!")
-compute_xyz(x::Nothing, y::Nothing, z::Nothing) = error("x/y/z are all nothing!")
-
-# --------------------------------------------------------------------
diff --git a/src/utils.jl b/src/utils.jl
index c52ba186..f80244b1 100644
--- a/src/utils.jl
+++ b/src/utils.jl
@@ -737,7 +737,7 @@ function with(f::Function, args...; kw...)
end
# # TODO: generalize this strategy to allow args as much as possible
- # # as in: with(:gadfly, :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??
# k = :seriestype
diff --git a/test/runtests.jl b/test/runtests.jl
index f98f877c..1587d1bb 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -87,16 +87,6 @@ end
# # @static Sys.islinux() && image_comparison_facts(:plotly, only=[1,3,4,7,8,9,10,11,12,14,15,20,22,23,27], tol=img_tol)
# end
-
-# @testset "Immerse" begin
-# @test immerse() == Plots.ImmerseBackend()
-# @test backend() == Plots.ImmerseBackend()
-#
-# # as long as we can plot anything without error, it should be the same as Gadfly
-# image_comparison_facts(:immerse, only=[1], tol=img_tol)
-# end
-
-
# @testset "PlotlyJS" begin
# @test plotlyjs() == Plots.PlotlyJSBackend()
# @test backend() == Plots.PlotlyJSBackend()
@@ -106,19 +96,6 @@ end
# end
-# @testset "Gadfly" begin
-# @test gadfly() == Plots.GadflyBackend()
-# @test backend() == Plots.GadflyBackend()
-#
-# @test typeof(plot(1:10)) == Plots.Plot{Plots.GadflyBackend}
-# @test plot(Int[1,2,3], rand(3)) == not(nothing)
-# @test plot(sort(rand(10)), rand(Int, 10, 3)) == not(nothing)
-# @test plot!(rand(10,3), rand(10,3)) == not(nothing)
-#
-# image_comparison_facts(:gadfly, skip=[4,6,23,24,27], tol=img_tol)
-# end
-
-
@testset "Axes" begin