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

working on image type; working on ijulia display_dict

Browse Source
This commit is contained in:
Thomas Breloff 2016-05-05 00:13:45 -04:00
parent e30affdfc2
commit ec87489dd4
9 changed files with 109 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/Plots.jl
View File

@ -276,16 +276,11 @@ yaxis!(plt::Plot, args...; kw...) = plot!(pl
const CURRENT_BACKEND = CurrentBackend(:none)
function __init__()
# override IJulia inline display
if isijulia()
@eval import IJulia
IJulia.display_dict(plt::AbstractPlot) = Dict{ASCIIString, ByteString}("text/html" => sprint(writemime, "text/html", plt))
end
setup_dataframes()
setup_atom()
setup_ijulia()
setup_dataframes()
setup_atom()
end
# ---------------------------------------------------------

12
src/args.jl
View File

@ -11,7 +11,7 @@ const _3dTypes = [:path3d, :scatter3d, :surface, :wireframe, :contour3d]
const _allTypes = vcat([
:none, :line, :path, :steppre, :steppost, :sticks, :scatter,
:heatmap, :hexbin, :hist, :hist2d, :hist3d, :density, :bar, :hline, :vline, :ohlc,
:contour, :contour3d, :pie, :shape, :box, :violin, :quiver
:contour, :pie, :shape, :box, :violin, :quiver, :image
], _3dTypes)
@compat const _typeAliases = KW(
:n => :none,
@ -41,11 +41,14 @@ const _allTypes = vcat([
:boxplot => :box,
:velocity => :quiver,
:gradient => :quiver,
:img => :image,
:imshow => :image,
:imagesc => :image,
)
like_histogram(linetype::Symbol) = linetype in (:hist, :density)
like_line(linetype::Symbol) = linetype in (:line, :path, :steppre, :steppost)
like_surface(linetype::Symbol) = linetype in (:contour, :contour3d, :heatmap, :surface, :wireframe)
like_surface(linetype::Symbol) = linetype in (:contour, :contour3d, :heatmap, :surface, :wireframe, :image)
const _allStyles = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
@ -148,6 +151,7 @@ _seriesDefaults[:quiver] = nothing
_seriesDefaults[:normalize] = false # do we want a normalized histogram?
_seriesDefaults[:weights] = nothing # optional weights for histograms (1D and 2D)
_seriesDefaults[:contours] = false # add contours to 3d surface and wireframe plots
_seriesDefaults[:match_dimensions] = false # do rows match x (true) or y (false) for heatmap/image/spy? see issue 196
const _plotDefaults = KW()
@ -571,10 +575,6 @@ function preprocessArgs!(d::KW)
for arg in wraptuple(pop!(d, :line, ()))
processLineArg(d, arg)
end
# delete!(d, :line)
# if get(d, :linewidth, :auto) == :auto
# d[:linewidth] = (get(d, :linetype, :path) in (:surface,:heatmap) ? 0 : 1)
# end
# handle marker args... default to ellipse if shape not set
anymarker = false

2
src/backends.jl
View File

@ -148,6 +148,7 @@ supportedMarkers(::AbstractBackend) = [:none]
supportedScales(::AbstractBackend) = [:identity]
subplotSupported(::AbstractBackend) = false
stringsSupported(::AbstractBackend) = false
nativeImagesSupported(::AbstractBackend) = false
supportedAxes() = supportedAxes(backend())
supportedTypes() = supportedTypes(backend())
@ -156,5 +157,6 @@ supportedMarkers() = supportedMarkers(backend())
supportedScales() = supportedScales(backend())
subplotSupported() = subplotSupported(backend())
stringsSupported() = stringsSupported(backend())
nativeImagesSupported() = nativeImagesSupported(backend())
# ---------------------------------------------------------

6
src/backends/gr.jl
View File

@ -535,7 +535,7 @@ function gr_display(plt::Plot{GRBackend}, clear=true, update=true,
GR.setcharheight(charheight)
GR.colormap()
elseif lt == :contour
x, y, z = p[:x], p[:y], p[:z].surf
x, y, z = p[:x], p[:y], transpose_z(p, p[:z].surf, false)
zmin, zmax = minimum(z), maximum(z)
if typeof(p[:levels]) <: Array
h = p[:levels]
@ -556,7 +556,7 @@ function gr_display(plt::Plot{GRBackend}, clear=true, update=true,
GR.setcharheight(charheight)
GR.axes(0, ztick, xmax, zmin, 0, 1, 0.005)
elseif lt in [:surface, :wireframe]
x, y, z = p[:x], p[:y], p[:z].surf
x, y, z = p[:x], p[:y], transpose_z(p, p[:z].surf, false)
zmin, zmax = GR.adjustrange(minimum(z), maximum(z))
GR.setspace(zmin, zmax, 40, 70)
xtick = GR.tick(xmin, xmax) / 2
@ -588,7 +588,7 @@ function gr_display(plt::Plot{GRBackend}, clear=true, update=true,
GR.colormap()
end
elseif lt == :heatmap
x, y, z = p[:x], p[:y], p[:z].surf
x, y, z = p[:x], p[:y], transpose_z(p, p[:z].surf, false)
zmin, zmax = GR.adjustrange(minimum(z), maximum(z))
GR.setspace(zmin, zmax, 0, 90)
GR.setcolormap(GR.COLORMAP_COOLWARM)

8
src/backends/pyplot.jl
View File

@ -531,7 +531,8 @@ function _add_series(pkg::PyPlotBackend, plt::Plot, d::KW)
end
if lt in (:contour, :contour3d)
z = z.surf'
# z = z.surf'
z = transpose_z(d, z.surf)
needs_colorbar = true
@ -568,8 +569,9 @@ function _add_series(pkg::PyPlotBackend, plt::Plot, d::KW)
if !ismatrix(x) || !ismatrix(y)
x = repmat(x', length(y), 1)
y = repmat(y, 1, length(d[:x]))
z = z'
end
# z = z'
z = transpose_z(d, z)
if lt == :surface
if d[:marker_z] != nothing
extrakw[:facecolors] = getPyPlotCustomShading(d[:fillcolor], d[:marker_z], d[:fillalpha])
@ -626,7 +628,7 @@ function _add_series(pkg::PyPlotBackend, plt::Plot, d::KW)
end
if lt == :heatmap
x, y, z = heatmap_edges(x), heatmap_edges(y), z.surf'
x, y, z = heatmap_edges(x), heatmap_edges(y), transpose_z(d, z.surf)
if !(eltype(z) <: Number)
z, discrete_colorbar_values = indices_and_unique_values(z)
end

35
src/output.jl
View File

@ -99,12 +99,6 @@ end
savefig(fn::@compat(AbstractString)) = savefig(current(), fn)
# savepng(args...; kw...) = savepng(current(), args...; kw...)
# savepng(plt::AbstractPlot, fn::@compat(AbstractString); kw...) = (io = open(fn, "w"); writemime(io, MIME("image/png"), plt); close(io))
# ---------------------------------------------------------
gui(plt::AbstractPlot = current()) = display(PlotsDisplay(), plt)
@ -115,9 +109,36 @@ Base.display(::Base.REPL.REPLDisplay, ::MIME"text/plain", plt::AbstractPlot) = g
# a backup for html... passes to svg
function Base.writemime(io::IO, ::MIME"text/html", plt::AbstractPlot)
writemime(io, MIME("image/svg+xml"), plt)
writemime(io, MIME("image/svg+xml"), plt)
end
# ---------------------------------------------------------
# IJulia
# ---------------------------------------------------------
const _ijulia_output = ASCIIString["text/html"]
function setup_ijulia()
# override IJulia inline display
if isijulia()
@eval begin
import IJulia
export set_ijulia_output
function set_ijulia_output(mimestr::ASCIIString)
info("Setting IJulia output format to $mimestr")
global _ijulia_output
_ijulia_output[1] = mimestr
end
function IJulia.display_dict(plt::AbstractPlot)
global _ijulia_output
Dict{ASCIIString, ByteString}(_ijulia_output[1] => sprint(writemime, _ijulia_output[1], plt))
end
end
# IJulia.display_dict(plt::AbstractPlot) = Dict{ASCIIString, ByteString}("text/html" => sprint(writemime, "text/html", plt))
set_ijulia_output("text/html")
end
end
# ---------------------------------------------------------
# Atom PlotPane

2
src/plot.jl
View File

@ -165,7 +165,7 @@ function _add_series(plt::Plot, d::KW, ::Void, args...;
# get the list of dictionaries, one per series
dumpdict(d, "before process_inputs")
process_inputs(plt, d, args...)
dumpdict(d, "after process_inputs")
dumpdict(d, "after process_inputs", true)
if idxfilter != nothing
# add the group name as the label if there isn't one passed in

28
src/series_args.jl
View File

@ -192,8 +192,6 @@ function build_series_args(plt::AbstractPlot, kw::KW) #, idxfilter)
append!(ret, apply_series_recipe(copy(d), Val{:quiver}))
end
# now that we've processed a given series... optionally split into
# multiple dicts through a recipe (for example, a box plot is split into component
# parts... polygons, lines, and scatters)
@ -248,6 +246,32 @@ function process_inputs{T<:Number}(plt::AbstractPlot, d::KW, mat::AMat{T})
end
end
# images - grays
function process_inputs{T<:Gray}(plt::AbstractPlot, d::KW, mat::AMat{T})
d[:linetype] = :image
d[:yflip] = true
n,m = size(mat)
d[:x], d[:y], d[:z] = 1:n, 1:m, mat
# handle images... when not supported natively, do a hack to use heatmap machinery
if !nativeImagesSupported()
d[:linetype] = :heatmap
d[:z] = convert(Matrix{Float64}, mat)
d[:fillcolor] = ColorGradient([:black, :white])
end
end
# images - colors
function process_inputs{T<:Colorant}(plt::AbstractPlot, d::KW, mat::AMat{T})
d[:linetype] = :image
d[:yflip] = true
n,m = size(mat)
d[:x], d[:y], d[:z] = 1:n, 1:m, mat
# handle images... when not supported natively, do a hack to use heatmap machinery
if !nativeImagesSupported()
imageHack(d)
end
end
# plotting arbitrary shapes/polygons
function process_inputs(plt::AbstractPlot, d::KW, shape::Shape)

34
src/utils.jl
View File

@ -114,6 +114,27 @@ function regressionXY(x, y)
regx, regy
end
function replace_image_with_heatmap{T<:Colorant}(z::Array{T})
@show T, size(z)
n, m = size(z)
# idx = 0
colors = ColorGradient(vec(z))
newz = reshape(linspace(0, 1, n*m), n, m)
newz, colors
# newz = zeros(n, m)
# for i=1:n, j=1:m
# push!(colors, T(z[i,j]...))
# newz[i,j] = idx / (n*m-1)
# idx += 1
# end
# newz, ColorGradient(colors)
end
function imageHack(d::KW)
:heatmap in supportedTypes() || error("Neither :image or :heatmap are supported!")
d[:linetype] = :heatmap
d[:z], d[:fillcolor] = replace_image_with_heatmap(d[:z])
end
# ---------------------------------------------------------------
# ------------------------------------------------------------------------------------
@ -259,6 +280,19 @@ function indices_and_unique_values(z::AbstractArray)
newz, vals
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)
if d[:match_dimensions] == transpose_on_match
z'
else
z
end
end
# ---------------------------------------------------------------
wraptuple(x::@compat(Tuple)) = x