mantao/Plots.jl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

color fixes; pyplot shape iteration; KernelDensity in travis and warning; attribute accessors

Browse Source
This commit is contained in:
Thomas Breloff 2016-07-07 21:46:34 -04:00
parent 4d99b37def
commit e53ab85745
10 changed files with 279 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Plots.jl
View File

@ -5,12 +5,12 @@ module Plots
using Compat
using Reexport
@reexport using Colors
# @reexport using Colors
# using Requires
using FixedSizeArrays
@reexport using RecipesBase
using Base.Meta
using PlotUtils
@reexport using PlotUtils
export
AbstractPlot,

35
src/args.jl
View File

@ -499,7 +499,7 @@ function handleColors!(d::KW, arg, csym::Symbol)
d[csym] = :auto
else
# c = colorscheme(arg)
c = plot_color(arg, nothing)
c = plot_color(arg)
d[csym] = c
end
return true
@ -520,13 +520,13 @@ function processLineArg(d::KW, arg)
elseif typeof(arg) <: Stroke
arg.width == nothing || (d[:linewidth] = arg.width)
arg.color == nothing || (d[:linecolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
arg.color == nothing || (d[:linecolor] = arg.color == :auto ? :auto : plot_color(arg.color))
arg.alpha == nothing || (d[:linealpha] = arg.alpha)
arg.style == nothing || (d[:linestyle] = arg.style)
elseif typeof(arg) <: Brush
arg.size == nothing || (d[:fillrange] = arg.size)
arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : plot_color(arg.color))
arg.alpha == nothing || (d[:fillalpha] = arg.alpha)
elseif typeof(arg) <: Arrow || arg in (:arrow, :arrows)
@ -559,13 +559,13 @@ function processMarkerArg(d::KW, arg)
elseif typeof(arg) <: Stroke
arg.width == nothing || (d[:markerstrokewidth] = arg.width)
arg.color == nothing || (d[:markerstrokecolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
arg.color == nothing || (d[:markerstrokecolor] = arg.color == :auto ? :auto : plot_color(arg.color))
arg.alpha == nothing || (d[:markerstrokealpha] = arg.alpha)
arg.style == nothing || (d[:markerstrokestyle] = arg.style)
elseif typeof(arg) <: Brush
arg.size == nothing || (d[:markersize] = arg.size)
arg.color == nothing || (d[:markercolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
arg.color == nothing || (d[:markercolor] = arg.color == :auto ? :auto : plot_color(arg.color))
arg.alpha == nothing || (d[:markeralpha] = arg.alpha)
# linealpha
@ -587,7 +587,7 @@ end
function processFillArg(d::KW, arg)
if typeof(arg) <: Brush
arg.size == nothing || (d[:fillrange] = arg.size)
arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : colorscheme(arg.color))
arg.color == nothing || (d[:fillcolor] = arg.color == :auto ? :auto : plot_color(arg.color))
arg.alpha == nothing || (d[:fillalpha] = arg.alpha)
# fillrange function
@ -850,7 +850,7 @@ end
# d[k] = if v == :match
# match_color
# elseif v == nothing
# colorscheme(RGBA(0,0,0,0))
# plot_color(RGBA(0,0,0,0))
# else
# v
# end
@ -859,7 +859,9 @@ end
function color_or_nothing!(d::KW, k::Symbol)
v = d[k]
d[k] = if v == nothing || v == false
colorscheme(RGBA(0,0,0,0))
plot_color(RGBA(0,0,0,0))
elseif v != :match
plot_color(v)
else
v
end
@ -935,6 +937,17 @@ function Base.getindex(series::Series, k::Symbol)
series.d[k]
end
Base.setindex!(plt::Plot, v, k::Symbol) = (plt.attr[k] = v)
Base.setindex!(sp::Subplot, v, k::Symbol) = (sp.attr[k] = v)
Base.setindex!(axis::Axis, v, k::Symbol) = (axis.d[k] = v)
Base.setindex!(series::Series, v, k::Symbol) = (series.d[k] = v)
Base.get(plt::Plot, k::Symbol, v) = get(plt.attr, k, v)
Base.get(sp::Subplot, k::Symbol, v) = get(sp.attr, k, v)
Base.get(axis::Axis, k::Symbol, v) = get(axis.d, k, v)
Base.get(series::Series, k::Symbol, v) = get(series.d, k, v)
# -----------------------------------------------------------------------------
# update attr from an input dictionary
@ -1048,7 +1061,7 @@ end
# -----------------------------------------------------------------------------
function has_black_border_for_default(st::Symbol)
like_histogram(st) || st in (:hexbin, :bar)
like_histogram(st) || st in (:hexbin, :bar, :shape)
end
@ -1100,7 +1113,7 @@ function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
for s in (:line, :marker, :fill)
csym, asym = Symbol(s,:color), Symbol(s,:alpha)
d[csym] = if d[csym] == :match
if has_black_border_for_default(d[:seriestype]) && csym == :line
if has_black_border_for_default(d[:seriestype]) && s == :line
plot_color(:black, d[asym])
else
d[:seriescolor]
@ -1112,7 +1125,7 @@ function _add_defaults!(d::KW, plt::Plot, sp::Subplot, commandIndex::Int)
# update markerstrokecolor
d[:markerstrokecolor] = if d[:markerstrokecolor] == :match
sp[:foreground_color_subplot]
plot_color(sp[:foreground_color_subplot], d[:markerstrokealpha])
else
getSeriesRGBColor(d[:markerstrokecolor], d[:markerstrokealpha], sp, plotIndex)
end

140
src/backends/gr.jl
View File

@ -112,10 +112,10 @@ function gr_getcolorind(c)
convert(Int, GR.inqcolorfromrgb(red(c), green(c), blue(c)))
end
gr_set_linecolor(c) = GR.setlinecolorind(gr_getcolorind(c))
gr_set_fillcolor(c) = GR.setfillcolorind(gr_getcolorind(c))
gr_set_markercolor(c) = GR.setmarkercolorind(gr_getcolorind(c))
gr_set_textcolor(c) = GR.settextcolorind(gr_getcolorind(c))
gr_set_linecolor(c) = GR.setlinecolorind(gr_getcolorind(cycle(c,1)))
gr_set_fillcolor(c) = GR.setfillcolorind(gr_getcolorind(cycle(c,1)))
gr_set_markercolor(c) = GR.setmarkercolorind(gr_getcolorind(cycle(c,1)))
gr_set_textcolor(c) = GR.settextcolorind(gr_getcolorind(cycle(c,1)))
# --------------------------------------------------------------------------------------
@ -271,8 +271,8 @@ end
# draw the markers, one at a time
function gr_draw_markers(d::KW, x, y, msize, mz)
shape = d[:markershape]
function gr_draw_markers(series::Series, x, y, msize, mz)
shape = series[:markershape]
if shape != :none
for i=1:length(x)
msi = cycle(msize, i)
@ -280,18 +280,19 @@ function gr_draw_markers(d::KW, x, y, msize, mz)
cfuncind = isa(shape, Shape) ? GR.setfillcolorind : GR.setmarkercolorind
# draw a filled in shape, slightly bigger, to estimate a stroke
if d[:markerstrokewidth] > 0
cfunc(cycle(d[:markerstrokecolor], i)) #, d[:markerstrokealpha])
gr_draw_marker(x[i], y[i], msi + d[:markerstrokewidth], shape)
if series[:markerstrokewidth] > 0
cfunc(cycle(series[:markerstrokecolor], i)) #, series[:markerstrokealpha])
gr_draw_marker(x[i], y[i], msi + series[:markerstrokewidth], shape)
end
# draw the shape
if mz == nothing
cfunc(cycle(d[:markercolor], i)) #, d[:markeralpha])
cfunc(cycle(series[:markercolor], i)) #, series[:markeralpha])
else
# pick a color from the pre-loaded gradient
ci = round(Int, 1000 + cycle(mz, i) * 255)
cfuncind(ci)
GR.settransparency(_gr_gradient_alpha[ci-999])
end
gr_draw_marker(x[i], y[i], msi, shape)
end
@ -300,12 +301,11 @@ end
function gr_draw_markers(series::Series, x, y)
isempty(x) && return
d = series.d
mz = normalize_zvals(d[:marker_z])
mz = normalize_zvals(series[:marker_z])
GR.setfillintstyle(GR.INTSTYLE_SOLID)
gr_draw_markers(d, x, y, d[:markersize], mz)
gr_draw_markers(series, x, y, series[:markersize], mz)
if mz != nothing
gr_colorbar(d[:subplot])
gr_colorbar(series[:subplot])
end
end
@ -403,13 +403,14 @@ gr_view_ydiff() = viewport_plotarea[4] - viewport_plotarea[3]
# --------------------------------------------------------------------------------------
const _gr_gradient_alpha = ones(256)
function gr_set_gradient(c) #, a)
function gr_set_gradient(c)
grad = isa(c, ColorGradient) ? c : cgrad()
# grad = ColorGradient(grad, alpha=a)
for (i,z) in enumerate(linspace(0, 1, 256))
c = grad[z]
GR.setcolorrep(999+i, red(c), green(c), blue(c), alpha(c))
GR.setcolorrep(999+i, red(c), green(c), blue(c))
_gr_gradient_alpha[i] = alpha(c)
end
grad
end
@ -474,8 +475,8 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
draw_axes = true
# axes_2d = true
for series in series_list(sp)
st = series.d[:seriestype]
if st in (:contour, :surface, :heatmap) || series.d[:marker_z] != nothing
st = series[:seriestype]
if st in (:contour, :surface, :heatmap) || series[:marker_z] != nothing
cmap = true
end
if st == :pie
@ -613,14 +614,13 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
GR.setcolormap(1000 + GR.COLORMAP_COOLWARM)
for (idx, series) in enumerate(series_list(sp))
d = series.d
st = d[:seriestype]
st = series[:seriestype]
# update the current stored gradient
if st in (:contour, :surface, :wireframe, :heatmap)
gr_set_gradient(d[:fillcolor]) #, d[:fillalpha])
elseif d[:marker_z] != nothing
d[:markercolor] = gr_set_gradient(d[:markercolor], d[:markeralpha])
gr_set_gradient(series[:fillcolor]) #, series[:fillalpha])
elseif series[:marker_z] != nothing
series[:markercolor] = gr_set_gradient(series[:markercolor])
end
GR.savestate()
@ -635,12 +635,12 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
end
end
x, y, z = d[:x], d[:y], d[:z]
frng = d[:fillrange]
x, y, z = series[:x], series[:y], series[:z]
frng = series[:fillrange]
# recompute data
if st in (:contour, :surface, :wireframe)
z = vec(transpose_z(d, z.surf, false))
z = vec(transpose_z(series, z.surf, false))
elseif ispolar(sp)
if frng != nothing
_, frng = convert_to_polar(x, frng, (rmin, rmax))
@ -653,7 +653,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
# do area fill
if frng != nothing
gr_set_fillcolor(d[:fillcolor]) #, d[:fillalpha])
gr_set_fillcolor(series[:fillcolor]) #, series[:fillalpha])
GR.setfillintstyle(GR.INTSTYLE_SOLID)
frng = isa(frng, Number) ? Float64[frng] : frng
nx, ny, nf = length(x), length(y), length(frng)
@ -669,24 +669,24 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
# draw the line(s)
if st == :path
gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor]) #, d[:linealpha])
gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
gr_polyline(x, y)
end
end
if d[:markershape] != :none
if series[:markershape] != :none
gr_draw_markers(series, x, y)
end
elseif st == :contour
zmin, zmax = gr_lims(zaxis, false)
if typeof(d[:levels]) <: Array
h = d[:levels]
if typeof(series[:levels]) <: Array
h = series[:levels]
else
h = linspace(zmin, zmax, d[:levels])
h = linspace(zmin, zmax, series[:levels])
end
GR.setspace(zmin, zmax, 0, 90)
if d[:fillrange] != nothing
if series[:fillrange] != nothing
GR.surface(x, y, z, GR.OPTION_CELL_ARRAY)
else
GR.contour(x, y, h, z, 1000)
@ -713,7 +713,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
cmap && gr_colorbar(sp)
elseif st == :heatmap
z = vec(transpose_z(d, z.surf, false))
z = vec(transpose_z(series, z.surf, false))
zmin, zmax = gr_lims(zaxis, true)
GR.setspace(zmin, zmax, 0, 90)
GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
@ -723,13 +723,13 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
# draw path
if st == :path3d
if length(x) > 1
gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor]) #, d[:linealpha])
gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
GR.polyline3d(x, y, z)
end
end
# draw markers
if st == :scatter3d || d[:markershape] != :none
if st == :scatter3d || series[:markershape] != :none
x2, y2 = unzip(map(GR.wc3towc, x, y, z))
gr_draw_markers(series, x2, y2)
end
@ -750,7 +750,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
ymin, ymax = ycenter - r, ycenter + r
end
labels = pie_labels(sp, series)
slices = d[:y]
slices = series[:y]
numslices = length(slices)
total = sum(slices)
a1 = 0
@ -783,17 +783,27 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
GR.selntran(1)
elseif st == :shape
# draw the interior
gr_set_fill(d[:fillcolor]) #, d[:fillalpha])
gr_polyline(d[:x], d[:y], GR.fillarea)
for (i,rng) in enumerate(iter_segments(series[:x], series[:y]))
if length(rng) > 1
# connect to the beginning
rng = vcat(rng, rng[1])
# draw the shapes
gr_set_line(d[:linewidth], :solid, d[:linecolor]) #, d[:linealpha])
gr_polyline(d[:x], d[:y])
# get the segments
x, y = series[:x][rng], series[:y][rng]
# draw the interior
gr_set_fill(cycle(series[:fillcolor], i))
GR.fillarea(x, y)
# draw the shapes
gr_set_line(series[:linewidth], :solid, cycle(series[:linecolor], i))
GR.polyline(x, y)
end
end
elseif st == :image
img = d[:z].surf
img = series[:z].surf
w, h = size(img)
if eltype(img) <: Colors.AbstractGray
grey = round(UInt8, float(img) * 255)
@ -823,11 +833,11 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
for series in series_list(sp)
should_add_to_legend(series) || continue
n += 1
if typeof(series.d[:label]) <: Array
if typeof(series[:label]) <: Array
i += 1
lab = series.d[:label][i]
lab = series[:label][i]
else
lab = series.d[:label]
lab = series[:label]
end
tbx, tby = gr_inqtext(0, 0, lab)
w = max(w, tbx[3] - tbx[1])
@ -845,13 +855,12 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
i = 0
for series in series_list(sp)
should_add_to_legend(series) || continue
d = series.d
st = d[:seriestype]
gr_set_line(d[:linewidth], d[:linestyle], d[:linecolor]) #, d[:linealpha])
st = series[:seriestype]
gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
if st == :path
GR.polyline([xpos - 0.07, xpos - 0.01], [ypos, ypos])
elseif st == :shape
gr_set_fill(d[:fillcolor]) #, d[:fillalpha])
gr_set_fill(series[:fillcolor]) #, series[:fillalpha])
l, r = xpos-0.07, xpos-0.01
b, t = ypos-0.4dy, ypos+0.4dy
x = [l, r, r, l, l]
@ -860,28 +869,15 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
gr_polyline(x, y)
end
gr_draw_markers(d, xpos-[0.06,0.02], [ypos,ypos], 10, nothing)
# shape = d[:markershape]
# if shape != :none #st == :scatter || d[:markershape] != :none
# msize = 10
# for xoff in [0.06,0.02]
# gr_set_markercolor(d[:markerstrokecolor]) #, d[:markerstrokealpha])
# gr_draw_marker(xpos-xoff, ypos, msize*1.1, shape)
# gr_set_markercolor(d[:markercolor], d[:markeralpha])
# gr_draw_marker(xpos-xoff, ypos, msize, shape)
# end
# # gr_setmarkershape(d)
# # if st == :path
# # gr_polymarker(d, [xpos - 0.06, xpos - 0.02], [ypos, ypos])
# # else
# # gr_polymarker(d, [xpos - 0.06, xpos - 0.04, xpos - 0.02], [ypos, ypos, ypos])
# # end
# end
if typeof(d[:label]) <: Array
if series[:markershape] != :none
gr_draw_markers(series, xpos-[0.06,0.02], [ypos,ypos], 10, nothing)
end
if typeof(series[:label]) <: Array
i += 1
lab = d[:label][i]
lab = series[:label][i]
else
lab = d[:label]
lab = series[:label]
end
GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
gr_set_textcolor(sp[:foreground_color_legend])

440
src/backends/pyplot.jl
View File

@ -104,7 +104,7 @@ py_color(cs::AVec) = map(py_color, cs)
py_color(grad::ColorGradient) = py_color(grad.colors)
function py_colormap(grad::ColorGradient)
pyvals = [(z, py_color(c[z])) for z in c.values]
pyvals = [(z, py_color(grad[z])) for z in grad.values]
pycolors.LinearSegmentedColormap[:from_list]("tmp", pyvals)
end
py_colormap(c) = py_colormap(cgrad())
@ -143,27 +143,27 @@ const _path_MOVETO = UInt8(1)
const _path_LINETO = UInt8(2)
const _path_CLOSEPOLY = UInt8(79)
# see http://matplotlib.org/users/path_tutorial.html
# and http://matplotlib.org/api/path_api.html#matplotlib.path.Path
function py_path(x, y)
n = length(x)
mat = zeros(n+1, 2)
codes = zeros(UInt8, n+1)
lastnan = true
for i=1:n
mat[i,1] = x[i]
mat[i,2] = y[i]
nan = !ok(x[i], y[i])
codes[i] = if nan && i>1
_path_CLOSEPOLY
else
lastnan ? _path_MOVETO : _path_LINETO
end
lastnan = nan
end
codes[n+1] = _path_CLOSEPOLY
pypath.pymember("Path")(mat, codes)
end
# # see http://matplotlib.org/users/path_tutorial.html
# # and http://matplotlib.org/api/path_api.html#matplotlib.path.Path
# function py_path(x, y)
# n = length(x)
# mat = zeros(n+1, 2)
# codes = zeros(UInt8, n+1)
# lastnan = true
# for i=1:n
# mat[i,1] = x[i]
# mat[i,2] = y[i]
# nan = !ok(x[i], y[i])
# codes[i] = if nan && i>1
# _path_CLOSEPOLY
# else
# lastnan ? _path_MOVETO : _path_LINETO
# end
# lastnan = nan
# end
# codes[n+1] = _path_CLOSEPOLY
# pypath.pymember("Path")(mat, codes)
# end
# get the marker shape
function py_marker(marker::Symbol)
@ -220,29 +220,17 @@ function add_pyfixedformatter(cbar, vals::AVec)
cbar[:update_ticks]()
end
# # TODO: smoothing should be moved into the SliceIt method, should not touch backends
# function handleSmooth(plt::Plot{PyPlotBackend}, ax, d::KW, smooth::Bool)
# if smooth
# xs, ys = regressionXY(d[:x], d[:y])
# ax[:plot](xs, ys,
# # linestyle = py_linestyle(:path, :dashdot),
# color = py_color(d[:linecolor]),
# linewidth = 2
# )
# end
# end
# handleSmooth(plt::Plot{PyPlotBackend}, ax, d::KW, smooth::Real) = handleSmooth(plt, ax, d, true)
# ---------------------------------------------------------------------------
function fix_xy_lengths!(plt::Plot{PyPlotBackend}, d::KW)
x, y = d[:x], d[:y]
function fix_xy_lengths!(plt::Plot{PyPlotBackend}, series::Series)
x, y = series[:x], series[:y]
nx, ny = length(x), length(y)
if !isa(get(d, :z, nothing), Surface) && nx != ny
if !isa(get(series.d, :z, nothing), Surface) && nx != ny
if nx < ny
d[:x] = Float64[x[mod1(i,nx)] for i=1:ny]
series[:x] = Float64[x[mod1(i,nx)] for i=1:ny]
else
d[:y] = Float64[y[mod1(i,ny)] for i=1:nx]
series[:y] = Float64[y[mod1(i,ny)] for i=1:nx]
end
end
end
@ -258,14 +246,14 @@ function py_color_fix(c, x)
end
end
py_linecolor(d::KW) = py_color(d[:linecolor]) #, d[:linealpha])
py_markercolor(d::KW) = py_color(d[:markercolor]) #, d[:markeralpha])
py_markerstrokecolor(d::KW) = py_color(d[:markerstrokecolor]) #, d[:markerstrokealpha])
py_fillcolor(d::KW) = py_color(d[:fillcolor]) #, d[:fillalpha])
py_linecolor(series::Series) = py_color(series[:linecolor])
py_markercolor(series::Series) = py_color(series[:markercolor])
py_markerstrokecolor(series::Series) = py_color(series[:markerstrokecolor])
py_fillcolor(series::Series) = py_color(series[:fillcolor])
py_linecolormap(d::KW) = py_colormap(d[:linecolor]) #, d[:linealpha])
py_markercolormap(d::KW) = py_colormap(d[:markercolor]) #, d[:markeralpha])
py_fillcolormap(d::KW) = py_colormap(d[:fillcolor]) #, d[:fillalpha])
py_linecolormap(series::Series) = py_colormap(series[:linecolor])
py_markercolormap(series::Series) = py_colormap(series[:markercolor])
py_fillcolormap(series::Series) = py_colormap(series[:fillcolor])
# ---------------------------------------------------------------------------
@ -392,9 +380,9 @@ end
# function _series_added(plt::Plot{PyPlotBackend}, series::Series)
function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
d = series.d
st = d[:seriestype]
sp = d[:subplot]
# d = series.d
st = series[:seriestype]
sp = series[:subplot]
ax = sp.o
if !(st in supported_types(plt.backend))
@ -402,10 +390,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
end
# PyPlot doesn't handle mismatched x/y
fix_xy_lengths!(plt, d)
fix_xy_lengths!(plt, series)
# ax = getAxis(plt, series)
x, y, z = d[:x], d[:y], d[:z]
x, y, z = series[:x], series[:y], series[:z]
xyargs = (st in _3dTypes ? (x,y,z) : (x,y))
# handle zcolor and get c/cmap
@ -418,7 +406,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
# pass in an integer value as an arg, but a levels list as a keyword arg
levels = d[:levels]
levels = series[:levels]
levelargs = if isscalar(levels)
(levels)
elseif isvector(levels)
@ -432,14 +420,14 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
# line plot
if st in (:path, :path3d, :steppre, :steppost)
if d[:linewidth] > 0
if d[:line_z] == nothing
if series[:linewidth] > 0
if series[:line_z] == nothing
handle = ax[:plot](xyargs...;
label = d[:label],
zorder = d[:series_plotindex],
color = py_linecolor(d),
linewidth = py_dpi_scale(plt, d[:linewidth]),
linestyle = py_linestyle(st, d[:linestyle]),
label = series[:label],
zorder = series[:series_plotindex],
color = py_linecolor(series),
linewidth = py_dpi_scale(plt, series[:linewidth]),
linestyle = py_linestyle(st, series[:linestyle]),
solid_capstyle = "round",
drawstyle = py_stepstyle(st)
)[1]
@ -450,18 +438,18 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
n = length(x) - 1
segments = Array(Any,n)
kw = KW(
:label => d[:label],
:label => series[:label],
:zorder => plt.n,
:cmap => py_linecolormap(d),
:linewidth => py_dpi_scale(plt, d[:linewidth]),
:linestyle => py_linestyle(st, d[:linestyle])
:cmap => py_linecolormap(series),
:linewidth => py_dpi_scale(plt, series[:linewidth]),
:linestyle => py_linestyle(st, series[:linestyle])
)
handle = if is3d(st)
for i=1:n
segments[i] = [(cycle(x,i), cycle(y,i), cycle(z,i)), (cycle(x,i+1), cycle(y,i+1), cycle(z,i+1))]
end
lc = pyart3d.Line3DCollection(segments; kw...)
lc[:set_array](d[:line_z])
lc[:set_array](series[:line_z])
ax[:add_collection3d](lc, zs=z) #, zdir='y')
lc
else
@ -469,7 +457,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
segments[i] = [(cycle(x,i), cycle(y,i)), (cycle(x,i+1), cycle(y,i+1))]
end
lc = pycollections.LineCollection(segments; kw...)
lc[:set_array](d[:line_z])
lc[:set_array](series[:line_z])
ax[:add_collection](lc)
lc
end
@ -477,7 +465,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
needs_colorbar = true
end
a = d[:arrow]
a = series[:arrow]
if a != nothing && !is3d(st) # TODO: handle 3d later
if typeof(a) != Arrow
warn("Unexpected type for arrow: $(typeof(a))")
@ -486,10 +474,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
:arrowstyle => "simple,head_length=$(a.headlength),head_width=$(a.headwidth)",
:shrinkA => 0,
:shrinkB => 0,
:edgecolor => py_linecolor(d),
:facecolor => py_linecolor(d),
:linewidth => py_dpi_scale(plt, d[:linewidth]),
:linestyle => py_linestyle(st, d[:linestyle]),
:edgecolor => py_linecolor(series),
:facecolor => py_linecolor(series),
:linewidth => py_dpi_scale(plt, series[:linewidth]),
:linestyle => py_linestyle(st, series[:linestyle]),
)
add_arrows(x, y) do xyprev, xy
ax[:annotate]("",
@ -504,53 +492,16 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
end
end
# if st == :bar
# bw = d[:bar_width]
# if bw == nothing
# bw = mean(diff(isvertical(d) ? x : y))
# end
# extrakw[isvertical(d) ? :width : :height] = bw
# fr = get(d, :fillrange, nothing)
# if fr != nothing
# extrakw[:bottom] = fr
# d[:fillrange] = nothing
# end
# handle = ax[isvertical(d) ? :bar : :barh](x, y;
# label = d[:label],
# zorder = d[:series_plotindex],
# color = py_fillcolor(d),
# edgecolor = py_linecolor(d),
# linewidth = d[:linewidth],
# align = d[:bar_edges] ? "edge" : "center",
# extrakw...
# )[1]
# push!(handles, handle)
# end
# if st == :sticks
# extrakw[isvertical(d) ? :width : :height] = 0.0
# handle = ax[isvertical(d) ? :bar : :barh](x, y;
# label = d[:label],
# zorder = d[:series_plotindex],
# color = py_linecolor(d),
# edgecolor = py_linecolor(d),
# linewidth = d[:linewidth],
# align = "center",
# extrakw...
# )[1]
# push!(handles, handle)
# end
# add markers?
if d[:markershape] != :none && st in (:path, :scatter, :path3d,
if series[:markershape] != :none && st in (:path, :scatter, :path3d,
:scatter3d, :steppre, :steppost,
:bar)
extrakw = KW()
if d[:marker_z] == nothing
extrakw[:c] = py_color_fix(py_markercolor(d), x)
if series[:marker_z] == nothing
extrakw[:c] = py_color_fix(py_markercolor(series), x)
else
extrakw[:c] = convert(Vector{Float64}, d[:marker_z])
extrakw[:cmap] = py_markercolormap(d)
extrakw[:c] = convert(Vector{Float64}, series[:marker_z])
extrakw[:cmap] = py_markercolormap(series)
clims = sp[:clims]
if is_2tuple(clims)
isfinite(clims[1]) && (extrakw[:vmin] = clims[1])
@ -558,72 +509,23 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
end
needs_colorbar = true
end
xyargs = if st == :bar && !isvertical(d)
xyargs = if st == :bar && !isvertical(series)
(y, x)
else
xyargs
end
handle = ax[:scatter](xyargs...;
label = d[:label],
zorder = d[:series_plotindex] + 0.5,
marker = py_marker(d[:markershape]),
s = py_dpi_scale(plt, d[:markersize] .^ 2),
edgecolors = py_markerstrokecolor(d),
linewidths = py_dpi_scale(plt, d[:markerstrokewidth]),
label = series[:label],
zorder = series[:series_plotindex] + 0.5,
marker = py_marker(series[:markershape]),
s = py_dpi_scale(plt, series[:markersize] .^ 2),
edgecolors = py_markerstrokecolor(series),
linewidths = py_dpi_scale(plt, series[:markerstrokewidth]),
extrakw...
)
push!(handles, handle)
end
# if st == :histogram
# handle = ax[:hist](y;
# label = d[:label],
# zorder = d[:series_plotindex],
# color = py_fillcolor(d),
# edgecolor = py_linecolor(d),
# linewidth = d[:linewidth],
# bins = d[:bins],
# normed = d[:normalize],
# weights = d[:weights],
# orientation = (isvertical(d) ? "vertical" : "horizontal"),
# histtype = (d[:bar_position] == :stack ? "barstacked" : "bar")
# )[3]
# push!(handles, handle)
# # expand the extrema... handle is a list of Rectangle objects
# for rect in handle
# xmin, ymin, xmax, ymax = rect[:get_bbox]()[:extents]
# expand_extrema!(sp, xmin, xmax, ymin, ymax)
# # expand_extrema!(sp[:xaxis], (xmin, xmax))
# # expand_extrema!(sp[:yaxis], (ymin, ymax))
# end
# end
# if st == :histogram2d
# clims = sp[:clims]
# if is_2tuple(clims)
# isfinite(clims[1]) && (extrakw[:vmin] = clims[1])
# isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
# end
# handle = ax[:hist2d](x, y;
# label = d[:label],
# zorder = d[:series_plotindex],
# bins = d[:bins],
# normed = d[:normalize],
# weights = d[:weights],
# cmap = py_fillcolormap(d), # applies to the pcolorfast object
# extrakw...
# )[4]
# push!(handles, handle)
# needs_colorbar = true
# # expand the extrema... handle is a AxesImage object
# expand_extrema!(sp, handle[:get_extent]()...)
# # xmin, xmax, ymin, ymax = handle[:get_extent]()
# # expand_extrema!(sp[:xaxis], (xmin, xmax))
# # expand_extrema!(sp[:yaxis], (ymin, ymax))
# end
if st == :hexbin
clims = sp[:clims]
if is_2tuple(clims)
@ -631,33 +533,20 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
end
handle = ax[:hexbin](x, y;
label = d[:label],
zorder = d[:series_plotindex],
gridsize = d[:bins],
linewidths = py_dpi_scale(plt, d[:linewidth]),
edgecolors = py_linecolor(d),
cmap = py_fillcolormap(d), # applies to the pcolorfast object
label = series[:label],
zorder = series[:series_plotindex],
gridsize = series[:bins],
linewidths = py_dpi_scale(plt, series[:linewidth]),
edgecolors = py_linecolor(series),
cmap = py_fillcolormap(series), # applies to the pcolorfast object
extrakw...
)
push!(handles, handle)
needs_colorbar = true
end
# if st in (:hline,:vline)
# for yi in d[:y]
# func = ax[st == :hline ? :axhline : :axvline]
# handle = func(yi;
# linewidth=d[:linewidth],
# color=py_linecolor(d),
# linestyle=py_linestyle(st, d[:linestyle])
# )
# push!(handles, handle)
# end
# end
if st in (:contour, :contour3d)
# z = z.surf'
z = transpose_z(d, z.surf)
z = transpose_z(series, z.surf)
needs_colorbar = true
clims = sp[:clims]
@ -672,21 +561,21 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
# contour lines
handle = ax[:contour](x, y, z, levelargs...;
label = d[:label],
zorder = d[:series_plotindex],
linewidths = py_dpi_scale(plt, d[:linewidth]),
linestyles = py_linestyle(st, d[:linestyle]),
cmap = py_linecolormap(d),
label = series[:label],
zorder = series[:series_plotindex],
linewidths = py_dpi_scale(plt, series[:linewidth]),
linestyles = py_linestyle(st, series[:linestyle]),
cmap = py_linecolormap(series),
extrakw...
)
push!(handles, handle)
# contour fills
if d[:fillrange] != nothing
if series[:fillrange] != nothing
handle = ax[:contourf](x, y, z, levelargs...;
label = d[:label],
zorder = d[:series_plotindex] + 0.5,
cmap = py_fillcolormap(d),
label = series[:label],
zorder = series[:series_plotindex] + 0.5,
cmap = py_fillcolormap(series),
extrakw...
)
push!(handles, handle)
@ -698,13 +587,13 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
x, y, z = map(Array, (x,y,z))
if !ismatrix(x) || !ismatrix(y)
x = repmat(x', length(y), 1)
y = repmat(y, 1, length(d[:x]))
y = repmat(y, 1, length(series[:x]))
end
# z = z'
z = transpose_z(d, z)
z = transpose_z(series, z)
if st == :surface
if d[:marker_z] != nothing
extrakw[:facecolors] = py_shading(d[:fillcolor], d[:marker_z], d[:fillalpha])
if series[:marker_z] != nothing
extrakw[:facecolors] = py_shading(series[:fillcolor], series[:marker_z], series[:fillalpha])
extrakw[:shade] = false
clims = sp[:clims]
if is_2tuple(clims)
@ -712,28 +601,28 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
end
else
extrakw[:cmap] = py_fillcolormap(d)
extrakw[:cmap] = py_fillcolormap(series)
needs_colorbar = true
end
end
handle = ax[st == :surface ? :plot_surface : :plot_wireframe](x, y, z;
label = d[:label],
zorder = d[:series_plotindex],
label = series[:label],
zorder = series[:series_plotindex],
rstride = 1,
cstride = 1,
linewidth = py_dpi_scale(plt, d[:linewidth]),
edgecolor = py_linecolor(d),
linewidth = py_dpi_scale(plt, series[:linewidth]),
edgecolor = py_linecolor(series),
extrakw...
)
push!(handles, handle)
# contours on the axis planes
if d[:contours]
if series[:contours]
for (zdir,mat) in (("x",x), ("y",y), ("z",z))
offset = (zdir == "y" ? maximum : minimum)(mat)
handle = ax[:contourf](x, y, z, levelargs...;
zdir = zdir,
cmap = py_fillcolormap(d),
cmap = py_fillcolormap(series),
offset = (zdir == "y" ? maximum : minimum)(mat) # where to draw the contour plane
)
push!(handles, handle)
@ -754,11 +643,11 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
end
handle = ax[:plot_trisurf](x, y, z;
label = d[:label],
zorder = d[:series_plotindex],
cmap = py_fillcolormap(d),
linewidth = py_dpi_scale(plt, d[:linewidth]),
edgecolor = py_linecolor(d),
label = series[:label],
zorder = series[:series_plotindex],
cmap = py_fillcolormap(series),
linewidth = py_dpi_scale(plt, series[:linewidth]),
edgecolor = py_linecolor(series),
extrakw...
)
push!(handles, handle)
@ -770,7 +659,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
if st == :image
# @show typeof(z)
img = Array(transpose_z(d, z.surf))
img = Array(transpose_z(series, z.surf))
z = if eltype(img) <: Colors.AbstractGray
float(img)
elseif eltype(img) <: Colorant
@ -779,7 +668,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
z # hopefully it's in a data format that will "just work" with imshow
end
handle = ax[:imshow](z;
zorder = d[:series_plotindex],
zorder = series[:series_plotindex],
cmap = py_colormap([:black, :white]),
vmin = 0.0,
vmax = 1.0
@ -789,11 +678,11 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
# expand extrema... handle is AxesImage object
xmin, xmax, ymax, ymin = handle[:get_extent]()
expand_extrema!(sp, xmin, xmax, ymin, ymax)
# sp[:yaxis].d[:flip] = true
# sp[:yaxis].series[:flip] = true
end
if st == :heatmap
x, y, z = heatmap_edges(x), heatmap_edges(y), transpose_z(d, z.surf)
x, y, z = heatmap_edges(x), heatmap_edges(y), transpose_z(series, z.surf)
# if !(eltype(z) <: Number)
# z, discrete_colorbar_values = indices_and_unique_values(z)
# end
@ -809,10 +698,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
end
handle = ax[:pcolormesh](x, y, z;
label = d[:label],
zorder = d[:series_plotindex],
cmap = py_fillcolormap(d),
edgecolors = (d[:linewidth] > 0 ? py_linecolor(d) : "face"),
label = series[:label],
zorder = series[:series_plotindex],
cmap = py_fillcolormap(series),
edgecolors = (series[:linewidth] > 0 ? py_linecolor(series) : "face"),
extrakw...
)
push!(handles, handle)
@ -830,16 +719,32 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
end
if st == :shape
path = py_path(x, y)
patches = pypatches.pymember("PathPatch")(path;
label = d[:label],
zorder = d[:series_plotindex],
edgecolor = py_linecolor(d),
facecolor = py_fillcolor(d),
linewidth = py_dpi_scale(plt, d[:linewidth]),
fill = true
)
handle = ax[:add_patch](patches)
handle = []
for (i,rng) in enumerate(iter_segments(x, y))
if length(rng) > 1
path = pypath.pymember("Path")(hcat(x[rng], y[rng]))
patches = pypatches.pymember("PathPatch")(
path;
label = series[:label],
zorder = series[:series_plotindex],
edgecolor = py_color(cycle(series[:linecolor], i)),
facecolor = py_color(cycle(series[:fillcolor], i)),
linewidth = py_dpi_scale(plt, series[:linewidth]),
fill = true
)
push!(handle, ax[:add_patch](patches))
end
end
# path = py_path(x, y)
# patches = pypatches.pymember("PathPatch")(path;
# label = series[:label],
# zorder = series[:series_plotindex],
# edgecolor = py_linecolor(series),
# facecolor = py_fillcolor(series),
# linewidth = py_dpi_scale(plt, series[:linewidth]),
# fill = true
# )
# handle = ax[:add_patch](patches)
push!(handles, handle)
end
@ -858,10 +763,10 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
expand_extrema!(sp, -lim, lim, -lim, lim)
end
d[:serieshandle] = handles
series[:serieshandle] = handles
# # smoothing
# handleSmooth(plt, ax, d, d[:smooth])
# handleSmooth(plt, ax, series, series[:smooth])
# add the colorbar legend
if needs_colorbar && sp[:colorbar] != :none
@ -886,55 +791,29 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
end
# handle area filling
fillrange = d[:fillrange]
fillrange = series[:fillrange]
if fillrange != nothing && st != :contour
f, dim1, dim2 = if isvertical(d)
f, dim1, dim2 = if isvertical(series)
:fill_between, x, y
else
:fill_betweenx, y, x
end
n = length(dim1)
args = if typeof(fillrange) <: Union{Real, AVec}
dim1, fillrange, dim2
else
dim1, fillrange...
dim1, expand_data(fillrange, n), dim2
elseif is_2tuple(fillrange)
dim1, expand_data(fillrange[1], n), expand_data(fillrange[2], n)
end
handle = ax[f](args...;
zorder = d[:series_plotindex],
facecolor = py_fillcolor(d),
zorder = series[:series_plotindex],
facecolor = py_fillcolor(series),
linewidths = 0
)
push!(handles, handle)
end
end
# --------------------------------------------------------------------------
# function update_limits!(sp::Subplot{PyPlotBackend}, series::Series, letters)
# for letter in letters
# py_set_lims(sp.o, sp[Symbol(letter, :axis)])
# end
# end
# function _series_updated(plt::Plot{PyPlotBackend}, series::Series)
# d = series.d
# for handle in get(d, :serieshandle, [])
# if is3d(series)
# handle[:set_data](d[:x], d[:y])
# handle[:set_3d_properties](d[:z])
# else
# try
# handle[:set_data](d[:x], d[:y])
# catch
# handle[:set_offsets](hcat(d[:x], d[:y]))
# end
# end
# end
# update_limits!(d[:subplot], series, is3d(series) ? (:x,:y,:z) : (:x,:y))
# end
# --------------------------------------------------------------------------
function py_set_lims(ax, axis::Axis)
@ -1029,7 +908,6 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
w, h = plt[:size]
fig = plt.o
fig[:clear]()
# fig[:set_size_inches](px2inch(w), px2inch(h), forward = true)
dpi = plt[:dpi]
fig[:set_size_inches](w/dpi, h/dpi, forward = true)
fig[:set_facecolor](py_color(plt[:background_color_outside]))
@ -1175,21 +1053,6 @@ end
# -----------------------------------------------------------------
# function _remove_axis(plt::Plot{PyPlotBackend}, isx::Bool)
# if isx
# plot!(plt, xticks=zeros(0), xlabel="")
# else
# plot!(plt, yticks=zeros(0), ylabel="")
# end
# end
#
# function _expand_limits(lims, plt::Plot{PyPlotBackend}, isx::Bool)
# pltlims = plt.o.ax[isx ? :get_xbound : :get_ybound]()
# _expand_limits(lims, pltlims)
# end
# -----------------------------------------------------------------
const _pyplot_legend_pos = KW(
:right => "right",
:left => "center left",
@ -1210,12 +1073,15 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
for series in series_list(sp)
if should_add_to_legend(series)
# add a line/marker and a label
push!(handles, if series.d[:seriestype] == :histogram
PyPlot.plt[:Line2D]((0,1),(0,0), color=py_fillcolor(series.d), linewidth=py_dpi_scale(plt, 4))
push!(handles, if series[:seriestype] == :shape
PyPlot.plt[:Line2D]((0,1),(0,0),
color = py_color(cycle(series[:fillcolor],1)),
linewidth = py_dpi_scale(plt, 4)
)
else
series.d[:serieshandle][1]
series[:serieshandle][1]
end)
push!(labels, series.d[:label])
push!(labels, series[:label])
end
end

14
src/components.jl
View File

@ -14,13 +14,13 @@ compute_angle(v::P2) = (angle = atan2(v[2], v[1]); angle < 0 ? 2π - angle : ang
immutable Shape
x::Vector{Float64}
y::Vector{Float64}
function Shape(x::AVec, y::AVec)
if x[1] != x[end] || y[1] != y[end]
new(vcat(x, x[1]), vcat(y, y[1]))
else
new(x, y)
end
end
# function Shape(x::AVec, y::AVec)
# # if x[1] != x[end] || y[1] != y[end]
# # new(vcat(x, x[1]), vcat(y, y[1]))
# # else
# new(x, y)
# end
# end
end
Shape(verts::AVec) = Shape(unzip(verts)...)

8
src/recipes.jl
View File

@ -653,6 +653,8 @@ end
# ---------------------------------------------------------------------------
# Violin Plot
const _violin_warned = [false]
# if the user has KernelDensity installed, use this for violin plots.
# otherwise, just use a histogram
if is_installed("KernelDensity")
@ -668,7 +670,11 @@ if is_installed("KernelDensity")
end
else
@eval function violin_coords(y; trim::Bool=false)
edges, widths = hist(y, 30)
if !_violin_warned[1]
warn("Install the KernelDensity package for best results.")
_violin_warned[1] = true
end
edges, widths = my_hist(y, 10)
centers = 0.5 * (edges[1:end-1] + edges[2:end])
ymin, ymax = extrema(y)
vcat(0.0, widths, 0.0), vcat(ymin, centers, ymax)

6
src/series.jl
View File

@ -257,17 +257,17 @@ end
# # plotting arbitrary shapes/polygons
@recipe function f(shape::Shape)
seriestype := :shape
seriestype --> :shape
shape_coords(shape)
end
@recipe function f(shapes::AVec{Shape})
seriestype := :shape
seriestype --> :shape
shape_coords(shapes)
end
@recipe function f(shapes::AMat{Shape})
seriestype := :shape
seriestype --> :shape
for j in 1:size(shapes,2)
@series shape_coords(vec(shapes[:,j]))
end

19
src/utils.jl
View File

@ -166,7 +166,6 @@ end
type SegmentsIterator
args::Tuple
# nextidx::Int
n::Int
end
function iter_segments(args...)
@ -176,13 +175,13 @@ function iter_segments(args...)
end
# helpers to figure out if there are NaN values in a list of array types
anynan(i::Int, args...) = any(a -> !isfinite(cycle(a,i)), args)
anynan(istart::Int, iend::Int, args...) = any(i -> anynan(i, args...), istart:iend)
allnan(istart::Int, iend::Int, args...) = all(i -> anynan(i, args...), istart:iend)
anynan(i::Int, args::Tuple) = any(a -> !isfinite(cycle(a,i)), args)
anynan(istart::Int, iend::Int, args::Tuple) = any(i -> anynan(i, args), istart:iend)
allnan(istart::Int, iend::Int, args::Tuple) = all(i -> anynan(i, args), istart:iend)
function Base.start(itr::SegmentsIterator)
nextidx = 1
if anynan(1, itr.args...)
if anynan(1, itr.args)
_, nextidx = next(itr, 1)
end
nextidx
@ -193,7 +192,7 @@ function Base.next(itr::SegmentsIterator, nextidx::Int)
# find the next NaN, and iend is the one before
while i <= itr.n + 1
if i > itr.n || anynan(i, itr.args...)
if i > itr.n || anynan(i, itr.args)
# done... array end or found NaN
iend = i-1
break
@ -203,7 +202,7 @@ function Base.next(itr::SegmentsIterator, nextidx::Int)
# find the next non-NaN, and set nextidx
while i <= itr.n
if !anynan(i, itr.args...)
if !anynan(i, itr.args)
break
end
i += 1
@ -229,6 +228,8 @@ Base.cycle(v::AVec, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
Base.cycle(v::AMat, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
Base.cycle(v, idx::AVec{Int}) = v
Base.cycle(grad::ColorGradient, idx) = cycle(grad.colors, idx)
makevec(v::AVec) = v
makevec{T}(v::T) = T[v]
@ -264,6 +265,7 @@ function _expand_limits(lims, x)
nothing
end
expand_data(v, n::Integer) = [cycle(v, i) for i=1:n]
# if the type exists in a list, replace the first occurence. otherwise add it to the end
function addOrReplace(v::AbstractVector, t::DataType, args...; kw...)
@ -368,6 +370,7 @@ is_2tuple(v) = typeof(v) <: Tuple && length(v) == 2
isvertical(d::KW) = get(d, :orientation, :vertical) in (:vertical, :v, :vert)
isvertical(series::Series) = isvertical(series.d)
# ticksType{T<:Real,S<:Real}(ticks::@compat(Tuple{T,S})) = :limits
@ -427,7 +430,7 @@ end
# this is a helper function to determine whether we need to transpose a surface matrix.
# it depends on whether the backend matches rows to x (transpose_on_match == true) or vice versa
# for example: PyPlot sends rows to y, so transpose_on_match should be true
function transpose_z(d::KW, z, transpose_on_match::Bool = true)
function transpose_z(d, z, transpose_on_match::Bool = true)
if d[:match_dimensions] == transpose_on_match
z'
else

4
test/runtests.jl
View File

@ -23,14 +23,14 @@ facts("PyPlot") do
@fact pyplot() --> Plots.PyPlotBackend()
@fact backend() --> Plots.PyPlotBackend()
image_comparison_facts(:pyplot, skip=[30], eps=img_eps)
image_comparison_facts(:pyplot, skip=[], eps=img_eps)
end
facts("GR") do
@fact gr() --> Plots.GRBackend()
@fact backend() --> Plots.GRBackend()
@linux_only image_comparison_facts(:gr, skip=[30], eps=img_eps)
@linux_only image_comparison_facts(:gr, skip=[], eps=img_eps)
end
facts("Plotly") do

2
test/travis_commands.jl
View File

@ -11,6 +11,8 @@ Pkg.build("GR")
# Pkg.clone("https://github.com/tbreloff/ExamplePlots.jl.git");
Pkg.clone("https://github.com/JuliaPlots/PlotReferenceImages.jl.git")
Pkg.clone("https://github.com/JuliaStats/KernelDensity.jl.git")
# Pkg.clone("https://github.com/JunoLab/Blink.jl.git")
# Pkg.build("Blink")
# import Blink