288 lines
9.9 KiB
Julia
288 lines
9.9 KiB
Julia
# https://github.com/sisl/PGFPlots.jl
|
||
|
||
function _initialize_backend(::PGFPlotsBackend; kw...)
|
||
@eval begin
|
||
import PGFPlots
|
||
export PGFPlots
|
||
# TODO: other initialization that needs to be eval-ed
|
||
end
|
||
# TODO: other initialization
|
||
end
|
||
|
||
_pgfplots_get_color(c) = "{rgb,1:red,$(float(c.r));green,$(float(c.g));blue,$(float(c.b))}"
|
||
|
||
function _pgfplots_get_linestyle!(kwargs, plt)
|
||
linestyle = plt[:linestyle]
|
||
if linestyle == :dash
|
||
kwargs[:style] *= "dashed,"
|
||
elseif linestyle == :dot
|
||
kwargs[:style] *= "dotted,"
|
||
elseif linestyle == :dashdot
|
||
kwargs[:style] *= "dashdotted,"
|
||
elseif linestyle == :dashdotdot
|
||
kwargs[:style] *= "dashdotdotted,"
|
||
end
|
||
|
||
kwargs[:style] *= (haskey(plt, :linewidth) && plt[:linewidth] != :auto) ? "line width = $(plt[:linewidth]) pt," : "line width = 1 pt,"
|
||
end
|
||
|
||
|
||
function _pgfplots_get_marker!(kwargs, plt)
|
||
# Control marker shape
|
||
mark = plt[:markershape]
|
||
if mark in (:none,:n, :no)
|
||
kwargs[:style] *= "mark = none,"
|
||
elseif mark in (:auto, :a)
|
||
kwargs[:style] *= "mark = *,"
|
||
elseif mark in (:cross, :+, :plus)
|
||
kwargs[:style] *= "mark = +,"
|
||
elseif mark in (:xcross ,:X, :x)
|
||
kwargs[:style] *= "mark = x,"
|
||
elseif mark in (:utriangle, :^, :uptri, :uptriangle, :ut, :utri,
|
||
:dtriangle, :V, :downtri, :downtriangle, :dt ,:dtri, :v)
|
||
kwargs[:style] *= "mark = triangle*,"
|
||
elseif mark in (:ellipse, :c, :circle)
|
||
kwargs[:style] *= "mark = o*,"
|
||
elseif mark in (:rect ,:r, :sq, :square)
|
||
kwargs[:style] *= "mark = square*,"
|
||
elseif mark in (:star5 ,:s, :star, :star1)
|
||
kwargs[:style] *= "mark = star,"
|
||
elseif mark in (:star6,)
|
||
kwargs[:style] *= "mark = asterisk,"
|
||
elseif mark in (:diamond, :d)
|
||
kwargs[:style] *= "mark = diamond*,"
|
||
elseif mark in (:pentagon ,:p, :pent)
|
||
kwargs[:style] *= "mark = pentagon*,"
|
||
end
|
||
|
||
# Control marker size
|
||
kwargs[:style] *= "mark size = $(plt[:markersize]/2),"
|
||
|
||
# Control marker colors and alphas
|
||
marker_fill = plt[:markercolor].c
|
||
α = plt[:markeralpha] == nothing ? 1.0 : plt[:markeralpha]
|
||
marker_stroke = plt[:markerstrokecolor].c
|
||
kwargs[:style] *= "mark options = {color="*_pgfplots_get_color(marker_stroke)*","
|
||
kwargs[:style] *= mark in (:dtriangle, :V, :downtri, :downtriangle, :dt ,:dtri, :v) ? "rotate=180," : ""
|
||
kwargs[:style] *= "fill="*_pgfplots_get_color(marker_fill)*","
|
||
kwargs[:style] *= "fill opacity = $α,"
|
||
markerstrokestyle = plt[:markerstrokestyle]
|
||
if markerstrokestyle == :solid
|
||
kwargs[:style] *= "solid,"
|
||
elseif markerstrokestyle == :dash
|
||
kwargs[:style] *= "dashed,"
|
||
elseif markerstrokestyle == :dot
|
||
kwargs[:style] *= "dotted,"
|
||
elseif markerstrokestyle == :dashdot
|
||
kwargs[:style] *= "dashdotted,"
|
||
elseif markerstrokestyle == :dashdotdot
|
||
kwargs[:style] *= "dashdotdotted,"
|
||
end
|
||
kwargs[:style] *= "},"
|
||
end
|
||
|
||
function _pgfplots_get_series_color!(kwargs, plt)
|
||
color = plt[:seriescolor].c
|
||
α = plt[:seriesalpha] == nothing ? 1.0 : plt[:seriesalpha]
|
||
kwargs[:style] *= "color="*_pgfplots_get_color(color)*","
|
||
kwargs[:style] *= "draw opacity = $α,"
|
||
end
|
||
|
||
function _pgfplots_get_plot_kwargs(plt)
|
||
kwargs = KW()
|
||
kwargs[:style] = ""
|
||
_pgfplots_get_linestyle!(kwargs, plt)
|
||
_pgfplots_get_marker!(kwargs, plt)
|
||
_pgfplots_get_series_color!(kwargs, plt)
|
||
kwargs
|
||
end
|
||
|
||
function _pgfplots_axis(plt_series)
|
||
line_type = plt_series[:linetype]
|
||
plt_kwargs = _pgfplots_get_plot_kwargs(plt_series)
|
||
if line_type == :path
|
||
PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
|
||
elseif line_type == :path3d
|
||
PGFPlots.Linear3(plt_series[:x], plt_series[:y], plt_series[:z]; plt_kwargs...)
|
||
elseif line_type == :scatter
|
||
PGFPlots.Scatter(plt_series[:x], plt_series[:y]; plt_kwargs...)
|
||
elseif line_type == :steppre
|
||
plt_kwargs[:style] *= "const plot mark right,"
|
||
PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
|
||
elseif line_type == :stepmid
|
||
plt_kwargs[:style] *= "const plot mark mid,"
|
||
PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
|
||
elseif line_type == :steppost
|
||
plt_kwargs[:style] *= "const plot,"
|
||
PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
|
||
elseif line_type == :hist
|
||
#TODO patch this in PGFPlots.jl instead; the problem is that PGFPlots will
|
||
# save _all_ data points in the figure which can be quite heavy
|
||
plt_hist = hist(plt_series[:y])
|
||
plt_kwargs[:style] *= "ybar interval, mark = none"
|
||
PGFPlots.Linear(plt_hist[1][1:end-1]+plt_hist[1].step/2, plt_hist[2]; plt_kwargs...)
|
||
elseif line_type == :hist2d
|
||
PGFPlots.Histogram2(plt_series[:x], plt_series[:y])
|
||
elseif line_type == :bar
|
||
plt_kwargs[:style] *= "ybar, mark = none"
|
||
PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
|
||
elseif line_type == :sticks || line_type == :ysticks
|
||
plt_kwargs[:style] *= "ycomb"
|
||
PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
|
||
elseif line_type == :xsticks
|
||
plt_kwargs[:style] *= "xcomb"
|
||
PGFPlots.Linear(plt_series[:x], plt_series[:y]; plt_kwargs...)
|
||
elseif line_type == :contour
|
||
PGFPlots.Contour(plt_series[:z].surf, plt_series[:x], plt_series[:y])
|
||
end
|
||
end
|
||
|
||
# ---------------------------------------------------------------------------
|
||
|
||
function _create_plot(pkg::PGFPlotsBackend, d::KW)
|
||
# TODO: create the window/canvas/context that is the plot within the backend (call it `o`)
|
||
# TODO: initialize the plot... title, xlabel, bgcolor, etc
|
||
Plot(nothing, pkg, 0, d, KW[])
|
||
end
|
||
|
||
|
||
function _add_series(::PGFPlotsBackend, plt::Plot, d::KW)
|
||
# TODO: add one series to the underlying package
|
||
push!(plt.seriesargs, d)
|
||
plt
|
||
end
|
||
|
||
function _add_annotations{X,Y,V}(plt::Plot{PGFPlotsBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
|
||
# set or add to the annotation_list
|
||
if haskey(plt.plotargs, :annotation_list)
|
||
append!(plt.plotargs[:annotation_list], anns)
|
||
else
|
||
plt.plotargs[:annotation_list] = anns
|
||
end
|
||
end
|
||
|
||
# ----------------------------------------------------------------
|
||
|
||
function _before_update_plot(plt::Plot{PGFPlotsBackend})
|
||
end
|
||
|
||
# TODO: override this to update plot items (title, xlabel, etc) after creation
|
||
function _update_plot(plt::Plot{PGFPlotsBackend}, d::KW)
|
||
end
|
||
|
||
function _update_plot_pos_size(plt::AbstractPlot{PGFPlotsBackend}, d::KW)
|
||
end
|
||
|
||
# ----------------------------------------------------------------
|
||
|
||
# accessors for x/y data
|
||
|
||
# function getxy(plt::Plot{PGFPlotsBackend}, i::Int)
|
||
# d = plt.seriesargs[i]
|
||
# d[:x], d[:y]
|
||
# end
|
||
#
|
||
# function setxy!{X,Y}(plt::Plot{PGFPlotsBackend}, xy::Tuple{X,Y}, i::Integer)
|
||
# d = plt.seriesargs[i]
|
||
# d[:x], d[:y] = xy
|
||
# plt
|
||
# end
|
||
|
||
# ----------------------------------------------------------------
|
||
|
||
function _create_subplot(subplt::Subplot{PGFPlotsBackend}, isbefore::Bool)
|
||
# TODO: build the underlying Subplot object. this is where you might layout the panes within a GUI window, for example
|
||
true
|
||
end
|
||
|
||
function _expand_limits(lims, plt::Plot{PGFPlotsBackend}, isx::Bool)
|
||
# TODO: call expand limits for each plot data
|
||
end
|
||
|
||
function _remove_axis(plt::Plot{PGFPlotsBackend}, isx::Bool)
|
||
# TODO: if plot is inner subplot, might need to remove ticks or axis labels
|
||
end
|
||
|
||
# ----------------------------------------------------------------
|
||
|
||
function _pgfplots_get_axis_kwargs(d)
|
||
axisargs = KW()
|
||
axisargs[:style] = "{"
|
||
for arg in (:xlabel, :ylabel, :zlabel, :title)
|
||
axisargs[arg] = d[arg]
|
||
end
|
||
axisargs[:style] *= d[:xflip] == true ? "x dir=reverse," : ""
|
||
axisargs[:style] *= d[:yflip] == true ? "y dir=reverse," : ""
|
||
if d[:xscale] in (:log, :log2, :ln, :log10)
|
||
axisargs[:xmode] = "log"
|
||
if d[:xscale] == :log2
|
||
axisargs[:style] *= "log basis x=2,"
|
||
elseif d[:xscale] in (:log, :log10)
|
||
axisargs[:style] *= "log basis x=10,"
|
||
end
|
||
end
|
||
if d[:yscale] in (:log, :log2, :ln, :log10)
|
||
axisargs[:ymode] = "log"
|
||
if d[:yscale] == :log2
|
||
axisargs[:style] *= "log basis y=2,"
|
||
elseif d[:yscale] in (:log, :log10)
|
||
axisargs[:style] *= "log basis x=10,"
|
||
end
|
||
end
|
||
if d[:zscale] in (:log, :log2, :ln, :log10)
|
||
axisargs[:zmode] = "log"
|
||
if d[:zscale] == :log2
|
||
axisargs[:style] *= "log basis z=2,"
|
||
elseif d[:zscale] in (:log, :log10)
|
||
axisargs[:style] *= "log basis x=10,"
|
||
end
|
||
end
|
||
axisargs[:style] *= "},"
|
||
|
||
# Control background color
|
||
bg_color = d[:background_color].c
|
||
axisargs[:style] *= "axis background/.style={fill={rgb,1:red,$(float(bg_color.r));green,$(float(bg_color.g));blue,$(float(bg_color.b))},}"
|
||
|
||
# Control x/y-limits
|
||
if d[:xlims] !== :auto
|
||
axisargs[:xmin] = d[:xlims][1]
|
||
axisargs[:xmax] = d[:xlims][2]
|
||
end
|
||
if d[:ylims] !== :auto
|
||
axisargs[:ymin] = d[:ylims][1]
|
||
axisargs[:ymax] = d[:ylims][2]
|
||
end
|
||
if d[:grid] == true
|
||
axisargs[:style] = "grid = major"
|
||
elseif d[:grid] == false
|
||
|
||
end
|
||
axisargs
|
||
end
|
||
|
||
# ----------------------------------------------------------------
|
||
|
||
################# This is the important method to implement!!! #################
|
||
function _make_pgf_plot(plt::Plot{PGFPlotsBackend})
|
||
os = [_pgfplots_axis(plt_series) for plt_series in plt.seriesargs]
|
||
axisargs =_pgfplots_get_axis_kwargs(plt.plotargs)
|
||
plt.o = PGFPlots.Axis([os...]; axisargs...)
|
||
end
|
||
|
||
function Base.writemime(io::IO, mime::MIME"image/svg+xml", plt::AbstractPlot{PGFPlotsBackend})
|
||
plt.o = _make_pgf_plot(plt)
|
||
writemime(io, mime, plt.o)
|
||
end
|
||
|
||
# function Base.writemime(io::IO, ::MIME"text/html", plt::AbstractPlot{PGFPlotsBackend})
|
||
# end
|
||
|
||
function Base.display(::PlotsDisplay, plt::AbstractPlot{PGFPlotsBackend})
|
||
plt.o = _make_pgf_plot(plt)
|
||
display(plt.o)
|
||
end
|
||
|
||
# function Base.display(::PlotsDisplay, plt::Subplot{PGFPlotsBackend})
|
||
# # TODO: display/show the subplot
|
||
# end
|