df33ed40d6
- slightly reduced the nominal marker size - use character height as line spacing criterion when plotting legends - use GR surface function for filled contours - avoid calling GR setwindow/adjust* functions with Inf arguments - corrected bounding box for legend
1389 lines
49 KiB
Julia
1389 lines
49 KiB
Julia
|
|
# https://github.com/jheinen/GR.jl
|
|
|
|
# significant contributions by @jheinen
|
|
|
|
supportedArgs(::GRBackend) = [
|
|
:annotations,
|
|
:background_color, :foreground_color, :color_palette,
|
|
:background_color_legend, :background_color_inside, :background_color_outside,
|
|
:foreground_color_legend, :foreground_color_grid, :foreground_color_axis,
|
|
:foreground_color_text, :foreground_color_border,
|
|
: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,
|
|
# :axis, :yrightlabel,
|
|
:z, :zguide, :zlims, :zticks, :zscale, :zflip,
|
|
:z,
|
|
:tickfont, :guidefont, :legendfont,
|
|
:grid, :legend, :colorbar,
|
|
:marker_z, :levels,
|
|
:xerror, :yerror,
|
|
:ribbon, :quiver,
|
|
:orientation,
|
|
:overwrite_figure,
|
|
:polar,
|
|
:aspect_ratio,
|
|
:normalize, :weights
|
|
]
|
|
supportedAxes(::GRBackend) = _allAxes
|
|
supportedTypes(::GRBackend) = [
|
|
:path, #:steppre, :steppost,
|
|
:scatter,
|
|
#:histogram2d, :hexbin,
|
|
# :sticks,
|
|
# :hline, :vline,
|
|
:heatmap, :pie, :image,
|
|
:contour, :path3d, :scatter3d, :surface, :wireframe,
|
|
:shape
|
|
]
|
|
supportedStyles(::GRBackend) = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
|
|
supportedMarkers(::GRBackend) = vcat(_allMarkers, Shape)
|
|
supportedScales(::GRBackend) = [:identity, :log10]
|
|
subplotSupported(::GRBackend) = true
|
|
# nativeImagesSupported(::GRBackend) = true
|
|
|
|
|
|
|
|
function _initialize_backend(::GRBackend; kw...)
|
|
@eval begin
|
|
import GR
|
|
export GR
|
|
end
|
|
end
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
|
|
const gr_linetype = KW(
|
|
:auto => 1,
|
|
:solid => 1,
|
|
:dash => 2,
|
|
:dot => 3,
|
|
:dashdot => 4,
|
|
:dashdotdot => -1
|
|
)
|
|
|
|
const gr_markertype = KW(
|
|
:auto => 1,
|
|
:none => -1,
|
|
:ellipse => -1,
|
|
:rect => -7,
|
|
:diamond => -13,
|
|
:utriangle => -3,
|
|
:dtriangle => -5,
|
|
:pentagon => -21,
|
|
:hexagon => -22,
|
|
:heptagon => -23,
|
|
:octagon => -24,
|
|
:cross => 2,
|
|
:xcross => 5,
|
|
:star4 => -25,
|
|
:star5 => -26,
|
|
:star6 => -27,
|
|
:star7 => -28,
|
|
:star8 => -29,
|
|
:vline => -30,
|
|
:hline => -31
|
|
)
|
|
|
|
const gr_halign = KW(
|
|
:left => 1,
|
|
:hcenter => 2,
|
|
:right => 3
|
|
)
|
|
|
|
const gr_valign = KW(
|
|
:top => 1,
|
|
:vcenter => 3,
|
|
:bottom => 5
|
|
)
|
|
|
|
const gr_font_family = Dict(
|
|
"times" => 1,
|
|
"helvetica" => 5,
|
|
"courier" => 9,
|
|
"bookman" => 14,
|
|
"newcenturyschlbk" => 18,
|
|
"avantgarde" => 22,
|
|
"palatino" => 26
|
|
)
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
|
|
function gr_getcolorind(v)
|
|
c = getColor(v)
|
|
return convert(Int, GR.inqcolorfromrgb(c.r, c.g, c.b))
|
|
end
|
|
|
|
function gr_getaxisind(d)
|
|
axis = :left
|
|
if axis in [:none, :left]
|
|
return 1
|
|
else
|
|
return 2
|
|
end
|
|
end
|
|
|
|
function gr_setmarkershape(d)
|
|
if d[:markershape] != :none
|
|
shape = d[:markershape]
|
|
if isa(shape, Shape)
|
|
d[:vertices] = vertices(shape)
|
|
else
|
|
GR.setmarkertype(gr_markertype[shape])
|
|
d[:vertices] = :none
|
|
end
|
|
end
|
|
end
|
|
|
|
function gr_polymarker(d, x, y)
|
|
if d[:vertices] != :none
|
|
vertices= d[:vertices]
|
|
dx = Float64[el[1] for el in vertices] * 0.03
|
|
dy = Float64[el[2] for el in vertices] * 0.03
|
|
GR.selntran(0)
|
|
GR.setfillcolorind(gr_getcolorind(d[:markercolor]))
|
|
GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
for i = 1:length(x)
|
|
xn, yn = GR.wctondc(x[i], y[i])
|
|
GR.fillarea(xn + dx, yn + dy)
|
|
end
|
|
GR.selntran(1)
|
|
else
|
|
GR.polymarker(x, y)
|
|
end
|
|
end
|
|
|
|
# draw line segments, splitting x/y into contiguous/finite segments
|
|
# note: this can be used for shapes by passing func `GR.fillarea`
|
|
function gr_polyline(x, y, func = GR.polyline)
|
|
iend = 0
|
|
n = length(x)
|
|
while iend < n-1
|
|
# set istart to the first index that is finite
|
|
istart = -1
|
|
for j = iend+1:n
|
|
if isfinite(x[j]) && isfinite(y[j])
|
|
istart = j
|
|
break
|
|
end
|
|
end
|
|
|
|
if istart > 0
|
|
# iend is the last finite index
|
|
iend = -1
|
|
for j = istart+1:n
|
|
if isfinite(x[j]) && isfinite(y[j])
|
|
iend = j
|
|
else
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
# if we found a start and end, draw the line segment, otherwise we're done
|
|
if istart > 0 && iend > 0
|
|
func(x[istart:iend], y[istart:iend])
|
|
else
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
# # TODO: simplify
|
|
# function gr_polyline(x, y)
|
|
# if NaN in x || NaN in y
|
|
# i = 1
|
|
# j = 1
|
|
# n = length(x)
|
|
# while i < n
|
|
# while j < n && x[j] != NaN && y[j] != NaN
|
|
# j += 1
|
|
# end
|
|
# if i < j
|
|
# GR.polyline(x[i:j], y[i:j])
|
|
# end
|
|
# i = j + 1
|
|
# end
|
|
# else
|
|
# GR.polyline(x, y)
|
|
# end
|
|
# end
|
|
|
|
function gr_polaraxes(rmin, rmax)
|
|
GR.savestate()
|
|
GR.setlinetype(GR.LINETYPE_SOLID)
|
|
GR.setlinecolorind(88)
|
|
tick = 0.5 * GR.tick(rmin, rmax)
|
|
n = round(Int, (rmax - rmin) / tick + 0.5)
|
|
for i in 0:n
|
|
r = float(i) / n
|
|
if i % 2 == 0
|
|
GR.setlinecolorind(88)
|
|
if i > 0
|
|
GR.drawarc(-r, r, -r, r, 0, 359)
|
|
end
|
|
GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
|
|
x, y = GR.wctondc(0.05, r)
|
|
GR.text(x, y, string(signif(rmin + i * tick, 12)))
|
|
else
|
|
GR.setlinecolorind(90)
|
|
GR.drawarc(-r, r, -r, r, 0, 359)
|
|
end
|
|
end
|
|
for alpha in 0:45:315
|
|
a = alpha + 90
|
|
sinf = sin(a * pi / 180)
|
|
cosf = cos(a * pi / 180)
|
|
GR.polyline([sinf, 0], [cosf, 0])
|
|
GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_HALF)
|
|
x, y = GR.wctondc(1.1 * sinf, 1.1 * cosf)
|
|
GR.textext(x, y, string(alpha, "^o"))
|
|
end
|
|
GR.restorestate()
|
|
end
|
|
|
|
# function gr_getzlims(d, zmin, zmax, adjust)
|
|
# if d[:zlims] != :auto
|
|
# zlims = d[:zlims]
|
|
# if zlims[1] != NaN
|
|
# zmin = zlims[1]
|
|
# end
|
|
# if zlims[2] != NaN
|
|
# zmax = zlims[2]
|
|
# end
|
|
# adjust = false
|
|
# end
|
|
# if adjust
|
|
# zmin, zmax = GR.adjustrange(zmin, zmax)
|
|
# end
|
|
# zmin, zmax
|
|
# end
|
|
|
|
|
|
# using the axis extrema and limit overrides, return the min/max value for this axis
|
|
gr_x_axislims(sp::Subplot) = axis_limits(sp[:xaxis])
|
|
gr_y_axislims(sp::Subplot) = axis_limits(sp[:yaxis])
|
|
gr_z_axislims(sp::Subplot) = axis_limits(sp[:zaxis])
|
|
gr_xy_axislims(sp::Subplot) = gr_x_axislims(sp)..., gr_y_axislims(sp)...
|
|
|
|
function gr_lims(axis::Axis, adjust::Bool, expand = nothing)
|
|
if expand != nothing
|
|
expand_extrema!(axis, expand)
|
|
end
|
|
lims = axis_limits(axis)
|
|
if adjust
|
|
GR.adjustrange(lims...)
|
|
else
|
|
lims
|
|
end
|
|
end
|
|
|
|
|
|
function gr_fill_viewport(vp::AVec{Float64}, c)
|
|
GR.savestate()
|
|
GR.selntran(0)
|
|
GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
GR.setfillcolorind(gr_getcolorind(c))
|
|
GR.fillrect(vp...)
|
|
GR.selntran(1)
|
|
GR.restorestate()
|
|
end
|
|
|
|
function gr_fillrect(series::Series, l, r, b, t)
|
|
GR.setfillcolorind(gr_getcolorind(series.d[:fillcolor]))
|
|
GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
# GR.fillrect(i-0.4, i+0.4, max(0, ymin), y[i])
|
|
GR.fillrect(l, r, b, t)
|
|
GR.setfillcolorind(gr_getcolorind(series.d[:linecolor]))
|
|
GR.setfillintstyle(GR.INTSTYLE_HOLLOW)
|
|
# GR.fillrect(i-0.4, i+0.4, max(0, ymin), y[i])
|
|
GR.fillrect(l, r, b, t)
|
|
end
|
|
|
|
normalize_zvals(zv::Void) = zv
|
|
function normalize_zvals(zv::AVec)
|
|
vmin, vmax = extrema(zv)
|
|
if vmin == vmax
|
|
zeros(length(zv))
|
|
else
|
|
(zv - vmin) ./ (vmax - vmin)
|
|
end
|
|
end
|
|
|
|
function gr_draw_markers(series::Series, x = series.d[:x], y = series.d[:y])
|
|
d = series.d
|
|
msize = 0.4 * d[:markersize]
|
|
mz = normalize_zvals(d[:marker_z])
|
|
GR.setmarkercolorind(gr_getcolorind(d[:markercolor]))
|
|
gr_setmarkershape(d)
|
|
if typeof(msize) <: Number && mz == nothing
|
|
GR.setmarkersize(msize)
|
|
if length(x) > 0
|
|
gr_polymarker(d, x, y)
|
|
end
|
|
else
|
|
c = d[:markercolor]
|
|
# GR.setcolormap(-GR.COLORMAP_GLOWING)
|
|
for i = 1:length(x)
|
|
if isa(c, ColorGradient) && mz != nothing
|
|
ci = round(Int, 1000 + mz[i] * 255)
|
|
GR.setmarkercolorind(ci)
|
|
end
|
|
GR.setmarkersize(isa(msize, Number) ? msize : msize[mod1(i, length(msize))])
|
|
gr_polymarker(d, [x[i]], [y[i]])
|
|
end
|
|
end
|
|
|
|
if mz != nothing && d[:subplot][:colorbar] != :none
|
|
GR.setviewport(viewport_plotarea[2] + 0.02, viewport_plotarea[2] + 0.05, viewport_plotarea[3], viewport_plotarea[4])
|
|
GR.colormap()
|
|
GR.setviewport(viewport_plotarea[1], viewport_plotarea[2], viewport_plotarea[3], viewport_plotarea[4])
|
|
end
|
|
end
|
|
|
|
# function gr_barplot(series::Series, x, y)
|
|
# # x, y = d[:x], d[:y]
|
|
# n = length(y)
|
|
# if length(x) == n + 1
|
|
# # x is edges
|
|
# for i=1:n
|
|
# gr_fillrect(series, x[i], x[i+1], 0, y[i])
|
|
# end
|
|
# elseif length(x) == n
|
|
# # x is centers
|
|
# leftwidth = length(x) > 1 ? abs(0.5 * (x[2] - x[1])) : 0.5
|
|
# for i=1:n
|
|
# rightwidth = (i == n ? leftwidth : abs(0.5 * (x[i+1] - x[i])))
|
|
# gr_fillrect(series, x[i] - leftwidth, x[i] + rightwidth, 0, y[i])
|
|
# end
|
|
# else
|
|
# error("gr_barplot: x must be same length as y (centers), or one more than y (edges).\n\t\tlength(x)=$(length(x)), length(y)=$(length(y))")
|
|
# end
|
|
# end
|
|
|
|
function gr_set_line(w, style, c)
|
|
GR.setlinetype(gr_linetype[style])
|
|
GR.setlinewidth(w)
|
|
GR.setlinecolorind(gr_getcolorind(c))
|
|
end
|
|
|
|
|
|
|
|
function gr_set_fill(c)
|
|
GR.setfillcolorind(gr_getcolorind(c))
|
|
GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
end
|
|
|
|
# this stores the conversion from a font pointsize to "percentage of window height" which is what GR uses
|
|
const _gr_point_mult = zeros(1)
|
|
|
|
# set the font attributes... assumes _gr_point_mult has been populated already
|
|
function gr_set_font(f::Font)
|
|
family = lowercase(f.family)
|
|
GR.setcharheight(_gr_point_mult[1] * f.pointsize)
|
|
GR.setcharup(sin(f.rotation), cos(f.rotation))
|
|
if haskey(gr_font_family, family)
|
|
GR.settextfontprec(100 + gr_font_family[family], GR.TEXT_PRECISION_STRING)
|
|
end
|
|
GR.settextcolorind(gr_getcolorind(f.color))
|
|
GR.settextalign(gr_halign[f.halign], gr_valign[f.valign])
|
|
end
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
|
|
# # convert a bounding box from absolute coords to percentages...
|
|
# # returns an array of percentages of figure size: [left, bottom, width, height]
|
|
# function bbox_to_pcts(bb::BoundingBox, figw, figh, flipy = true)
|
|
# mms = Float64[f(bb).value for f in (left,bottom,width,height)]
|
|
# if flipy
|
|
# mms[2] = figh.value - mms[2] # flip y when origin in bottom-left
|
|
# end
|
|
# mms ./ Float64[figw.value, figh.value, figw.value, figh.value]
|
|
# end
|
|
|
|
const viewport_plotarea = zeros(4)
|
|
|
|
function gr_viewport_from_bbox(bb::BoundingBox, w, h, viewport_canvas)
|
|
viewport = zeros(4)
|
|
viewport[1] = viewport_canvas[2] * (left(bb) / w)
|
|
viewport[2] = viewport_canvas[2] * (right(bb) / w)
|
|
viewport[3] = viewport_canvas[4] * (1.0 - bottom(bb) / h)
|
|
viewport[4] = viewport_canvas[4] * (1.0 - top(bb) / h)
|
|
viewport
|
|
end
|
|
|
|
function gr_set_gradient(c)
|
|
grad = isa(c, ColorGradient) ? c : default_gradient()
|
|
for (i,z) in enumerate(linspace(0, 1, 256))
|
|
c = getColorZ(grad, z)
|
|
GR.setcolorrep(999+i, red(c), green(c), blue(c))
|
|
end
|
|
end
|
|
|
|
# this is our new display func... set up the viewport_canvas, compute bounding boxes, and display each subplot
|
|
function gr_display(plt::Plot)
|
|
GR.clearws()
|
|
|
|
# collect some monitor/display sizes in meters and pixels
|
|
display_width_meters, display_height_meters, display_width_px, display_height_px = GR.inqdspsize()
|
|
display_width_ratio = display_width_meters / display_width_px
|
|
display_height_ratio = display_height_meters / display_height_px
|
|
|
|
# compute the viewport_canvas, normalized to the larger dimension
|
|
viewport_canvas = Float64[0,1,0,1]
|
|
w, h = plt[:size]
|
|
if w > h
|
|
ratio = float(h) / w
|
|
msize = display_width_ratio * w
|
|
GR.setwsviewport(0, msize, 0, msize * ratio)
|
|
GR.setwswindow(0, 1, 0, ratio)
|
|
viewport_canvas[3] *= ratio
|
|
viewport_canvas[4] *= ratio
|
|
else
|
|
ratio = float(w) / h
|
|
msize = display_height_ratio * h
|
|
GR.setwsviewport(0, msize * ratio, 0, msize)
|
|
GR.setwswindow(0, ratio, 0, 1)
|
|
viewport_canvas[1] *= ratio
|
|
viewport_canvas[2] *= ratio
|
|
end
|
|
|
|
# fill in the viewport_canvas background
|
|
gr_fill_viewport(viewport_canvas, plt[:background_color_outside])
|
|
# @show "PLOT SETUP" plt.layout.bbox ratio viewport_canvas
|
|
|
|
# update point mult
|
|
px_per_pt = px / pt
|
|
_gr_point_mult[1] = px_per_pt / h
|
|
|
|
# subplots:
|
|
for sp in plt.subplots
|
|
gr_display(sp, w*px, h*px, viewport_canvas)
|
|
end
|
|
|
|
GR.updatews()
|
|
end
|
|
|
|
|
|
function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
|
|
# the viewports for this subplot
|
|
viewport_subplot = gr_viewport_from_bbox(bbox(sp), w, h, viewport_canvas)
|
|
viewport_plotarea[:] = gr_viewport_from_bbox(plotarea(sp), w, h, viewport_canvas)
|
|
# @show "SUBPLOT",sp[:subplot_index] bbox(sp) plotarea(sp) viewport_subplot viewport_plotarea
|
|
|
|
# fill in the plot area background
|
|
bg = getColor(sp[:background_color_inside])
|
|
gr_fill_viewport(viewport_plotarea, bg)
|
|
# # # # c = getColor(d[:background_color_inside])
|
|
dark_bg = 0.21 * bg.r + 0.72 * bg.g + 0.07 * bg.b < 0.9
|
|
|
|
# # multiplier to convert a font's pointsize to GR's percentage of window height
|
|
# winheight_px = sp.plt[:size][2]
|
|
# px_per_pt = px / pt
|
|
# pointsize_mult = px_per_pt / winheight_px
|
|
# @show winheight_px px_per_pt pointsize_mult
|
|
|
|
# end
|
|
#
|
|
# function gr_old_display(plt::Plot{GRBackend}, subplot=[0, 1, 0, 1])
|
|
# # clear=true, update=true,
|
|
# # subplot=[0, 1, 0, 1])
|
|
# # d = plt.attr
|
|
#
|
|
# # clear && GR.clearws()
|
|
#
|
|
# # tbreloff notes:
|
|
# # - `GR.selntran(0)` changes the commands to be relative to the viewport_canvas, 1 means go back to the viewport you set
|
|
#
|
|
# # display_width_meters, display_height_meters, display_width_px, display_height_px = GR.inqdspsize()
|
|
# # w, h = plt.attr[:size]
|
|
# # display_width_ratio = display_width_meters / display_width_px
|
|
# # display_height_ratio = display_height_meters / display_height_px
|
|
# #
|
|
# # viewport_plotarea = zeros(4)
|
|
# # viewport_canvas = float(subplot)
|
|
# # if w > h
|
|
# # ratio = float(h) / w
|
|
# # msize = display_width_ratio * w
|
|
# # GR.setwsviewport(0, msize, 0, msize * ratio)
|
|
# # GR.setwswindow(0, 1, 0, ratio)
|
|
# # viewport_canvas[3] *= ratio
|
|
# # viewport_canvas[4] *= ratio
|
|
# # else
|
|
# # ratio = float(w) / h
|
|
# # msize = display_height_meters * h / display_height_px
|
|
# # GR.setwsviewport(0, msize * ratio, 0, msize)
|
|
# # GR.setwswindow(0, ratio, 0, 1)
|
|
# # viewport_canvas[1] *= ratio
|
|
# # viewport_canvas[2] *= ratio
|
|
# # end
|
|
# #
|
|
# # # note: these seem to be the "minpadding" computations!
|
|
# # # I think the midpadding is in percentages, and is: (l,r,b,t) = (0.125, 0.05, 0.125, 0.05)
|
|
# # viewport_plotarea[1] = viewport_canvas[1] + 0.125 * (viewport_canvas[2] - viewport_canvas[1])
|
|
# # viewport_plotarea[2] = viewport_canvas[1] + 0.95 * (viewport_canvas[2] - viewport_canvas[1])
|
|
# # viewport_plotarea[3] = viewport_canvas[3] + 0.125 * (viewport_canvas[4] - viewport_canvas[3])
|
|
# # if w > h
|
|
# # viewport_plotarea[3] += (1 - (subplot[4] - subplot[3])^2) * 0.02
|
|
# # end
|
|
# # viewport_plotarea[4] = viewport_canvas[3] + 0.95 * (viewport_canvas[4] - viewport_canvas[3])
|
|
# # @show viewport_plotarea viewport_canvas
|
|
# #
|
|
# # # bg = gr_getcolorind(plt.attr[:background_color]) # TODO: background for all subplots?
|
|
# # # fg = gr_getcolorind(plt.attr[:foreground_color])
|
|
# #
|
|
# # # GR.savestate()
|
|
# # # GR.selntran(0)
|
|
# # # GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
# # # GR.setfillcolorind(gr_getcolorind(plt.attr[:background_color_outside]))
|
|
# # # GR.fillrect(viewport_canvas[1], viewport_canvas[2], viewport_canvas[3], viewport_canvas[4])
|
|
# # gr_fill_viewport(viewport_canvas, plt.attr[:background_color_outside])
|
|
# #
|
|
# # # # c = getColor(d[:background_color_inside])
|
|
# # # # dark_bg = 0.21 * c.r + 0.72 * c.g + 0.07 * c.b < 0.9
|
|
# # # GR.setfillcolorind(gr_getcolorind(d[:background_color_inside]))
|
|
# # # GR.fillrect(viewport_plotarea[1], viewport_plotarea[2], viewport_plotarea[3], viewport_plotarea[4])
|
|
# # # GR.selntran(1)
|
|
# # # GR.restorestate()
|
|
# # gr_fill_viewport(viewport_plotarea, sp.attr[:background_color_inside])
|
|
|
|
num_axes = 1
|
|
grid_flag = sp[:grid]
|
|
|
|
# reduced from before... set some flags based on the series in this subplot
|
|
# TODO: can these be generic flags?
|
|
outside_ticks = false
|
|
cmap = false
|
|
axes_2d = true
|
|
for series in series_list(sp)
|
|
st = ispolar(sp) ? :polar : series.d[:seriestype]
|
|
if st in (:histogram2d, :hexbin, :contour, :surface, :heatmap) || series.d[:marker_z] != nothing
|
|
cmap = true
|
|
end
|
|
if st in (:pie, :polar, :surface, :wireframe, :path3d, :scatter3d)
|
|
axes_2d = false
|
|
end
|
|
if st == :heatmap
|
|
outside_ticks = true
|
|
end
|
|
end
|
|
|
|
|
|
|
|
# # section: compute axis extrema
|
|
# for axis = 1:2
|
|
# xmin = ymin = typemax(Float64)
|
|
# xmax = ymax = typemin(Float64)
|
|
# for d in plt.seriesargs
|
|
# st = d[:seriestype]
|
|
# if get(d, :polar, false)
|
|
# st = :polar
|
|
# end
|
|
# if axis == gr_getaxisind(d)
|
|
# if axis == 2
|
|
# num_axes = 2
|
|
# end
|
|
# if st == :bar
|
|
# x, y = 1:length(d[:y]), d[:y]
|
|
# elseif st in [:histogram, :density]
|
|
# x, y = Base.hist(d[:y], d[:bins])
|
|
# elseif st in [:histogram2d, :hexbin]
|
|
# E = zeros(length(d[:x]),2)
|
|
# E[:,1] = d[:x]
|
|
# E[:,2] = d[:y]
|
|
# if isa(d[:bins], Tuple)
|
|
# xbins, ybins = d[:bins]
|
|
# else
|
|
# xbins = ybins = d[:bins]
|
|
# end
|
|
# cmap = true
|
|
# x, y, H = Base.hist2d(E, xbins, ybins)
|
|
# elseif st in [:pie, :polar]
|
|
# axes_2d = false
|
|
# xmin, xmax, ymin, ymax = 0, 1, 0, 1
|
|
# x, y = d[:x], d[:y]
|
|
# else
|
|
# if st in [:contour, :surface, :heatmap]
|
|
# cmap = true
|
|
# end
|
|
# if st in [:surface, :wireframe, :path3d, :scatter3d]
|
|
# axes_2d = false
|
|
# end
|
|
# if st == :heatmap
|
|
# outside_ticks = true
|
|
# end
|
|
# x, y = d[:x], d[:y]
|
|
# end
|
|
# if !(st in [:pie, :polar])
|
|
# xmin = min(minimum(x), xmin)
|
|
# xmax = max(maximum(x), xmax)
|
|
# ymin = min(minimum(y), ymin)
|
|
# ymax = max(maximum(y), ymax)
|
|
# if d[:xerror] != nothing || d[:yerror] != nothing
|
|
# dx = xmax - xmin
|
|
# xmin -= 0.02 * dx
|
|
# xmax += 0.02 * dx
|
|
# dy = ymax - ymin
|
|
# ymin -= 0.02 * dy
|
|
# ymax += 0.02 * dy
|
|
# end
|
|
# end
|
|
# end
|
|
# end
|
|
# if d[:xlims] != :auto
|
|
# xmin, xmax = d[:xlims]
|
|
# end
|
|
# if d[:ylims] != :auto
|
|
# ymin, ymax = d[:ylims]
|
|
# end
|
|
# if xmax <= xmin
|
|
# xmax = xmin + 1
|
|
# end
|
|
# if ymax <= ymin
|
|
# ymax = ymin + 1
|
|
# end
|
|
# extrema[axis,:] = [xmin, xmax, ymin, ymax]
|
|
# end
|
|
|
|
|
|
|
|
# compute extrema
|
|
lims = gr_xy_axislims(sp)
|
|
extrema = Float64[lims[c] for r=1:2,c=1:4]
|
|
|
|
# TODO: this should be accounted for in `_update_min_padding!`
|
|
if num_axes == 2 || !axes_2d
|
|
# note: add extra midpadding on the right for a second (right) axis
|
|
viewport_plotarea[2] -= 0.0525
|
|
end
|
|
if cmap
|
|
# note: add extra midpadding on the right for the colorbar
|
|
viewport_plotarea[2] -= 0.1
|
|
end
|
|
|
|
# set our plot area view
|
|
GR.setviewport(viewport_plotarea[1], viewport_plotarea[2], viewport_plotarea[3], viewport_plotarea[4])
|
|
|
|
# these are the Axis objects, which hold scale, lims, etc
|
|
xaxis = sp[:xaxis]
|
|
yaxis = sp[:yaxis]
|
|
zaxis = sp[:zaxis]
|
|
|
|
scale = 0
|
|
xaxis[:scale] == :log10 && (scale |= GR.OPTION_X_LOG)
|
|
yaxis[:scale] == :log10 && (scale |= GR.OPTION_Y_LOG)
|
|
xaxis[:flip] && (scale |= GR.OPTION_FLIP_X)
|
|
yaxis[:flip] && (scale |= GR.OPTION_FLIP_Y)
|
|
# d[:xscale] == :log10 && (scale |= GR.OPTION_X_LOG)
|
|
# d[:yscale] == :log10 && (scale |= GR.OPTION_Y_LOG)
|
|
# get(d, :xflip, false) && (scale |= GR.OPTION_FLIP_X)
|
|
# get(d, :yflip, false) && (scale |= GR.OPTION_FLIP_Y)
|
|
|
|
window_diag = sqrt((viewport_plotarea[2] - viewport_plotarea[1])^2 + (viewport_plotarea[4] - viewport_plotarea[3])^2)
|
|
|
|
for axis_idx = 1:num_axes
|
|
xmin, xmax, ymin, ymax = extrema[axis_idx,:]
|
|
|
|
if xmax > xmin && ymax > ymin
|
|
# NOTE: for log axes, the major_x and major_y - if non-zero (omit labels) - control the minor grid lines (1 = draw 9 minor grid lines, 2 = no minor grid lines)
|
|
# NOTE: for log axes, the x_tick and y_tick - if non-zero (omit axes) - only affect the output appearance (1 = nomal, 2 = scientiic notation)
|
|
if scale & GR.OPTION_X_LOG == 0
|
|
# xmin, xmax = GR.adjustlimits(xmin, xmax)
|
|
majorx = 1 #5
|
|
xtick = GR.tick(xmin, xmax) / majorx
|
|
else
|
|
# log axis
|
|
# xtick = majorx = 1
|
|
xtick = 2 # scientific notation
|
|
majorx = 2 # no minor grid lines
|
|
end
|
|
if scale & GR.OPTION_Y_LOG == 0
|
|
# ymin, ymax = GR.adjustlimits(ymin, ymax)
|
|
majory = 1 #5
|
|
ytick = GR.tick(ymin, ymax) / majory
|
|
else
|
|
# log axis
|
|
# ytick = majory = 1
|
|
ytick = 2 # scientific notation
|
|
majory = 2 # no minor grid lines
|
|
end
|
|
xorg = (scale & GR.OPTION_FLIP_X == 0) ? (xmin,xmax) : (xmax,xmin)
|
|
yorg = (scale & GR.OPTION_FLIP_Y == 0) ? (ymin,ymax) : (ymax,ymin)
|
|
# if scale & GR.OPTION_FLIP_X == 0
|
|
# xorg = (xmin, xmax)
|
|
# else
|
|
# xorg = (xmax, xmin)
|
|
# end
|
|
# if scale & GR.OPTION_FLIP_Y == 0
|
|
# yorg = (ymin, ymax)
|
|
# else
|
|
# yorg = (ymax, ymin)
|
|
# end
|
|
|
|
extrema[axis_idx,:] = [xmin, xmax, ymin, ymax]
|
|
GR.setwindow(xmin, xmax, ymin, ymax)
|
|
GR.setscale(scale)
|
|
end
|
|
|
|
# window_diag = sqrt((viewport_plotarea[2] - viewport_plotarea[1])^2 + (viewport_plotarea[4] - viewport_plotarea[3])^2)
|
|
# charheight = max(0.018 * window_diag, 0.01)
|
|
# GR.setcharheight(charheight)
|
|
GR.settextcolorind(gr_getcolorind(xaxis[:foreground_color_text]))
|
|
|
|
if axes_2d
|
|
# draw the grid lines
|
|
GR.setlinewidth(1)
|
|
# GR.setlinetype(GR.LINETYPE_DOTTED)
|
|
if grid_flag
|
|
GR.setlinecolorind(gr_getcolorind(sp[:foreground_color_grid]))
|
|
GR.grid(xtick, ytick, 0, 0, majorx, majory)
|
|
# @show dark_bg, xtick, ytick, majorx, majory
|
|
# if dark_bg
|
|
# GR.grid(xtick * majorx, ytick * majory, 0, 0, 1, 1)
|
|
# else
|
|
# GR.grid(xtick, ytick, 0, 0, majorx, majory)
|
|
# end
|
|
end
|
|
|
|
ticksize = 0.0075 * window_diag
|
|
if outside_ticks
|
|
ticksize = -ticksize
|
|
end
|
|
# TODO: this should be done for each axis separately
|
|
GR.setlinecolorind(gr_getcolorind(xaxis[:foreground_color_axis]))
|
|
if num_axes == 1
|
|
GR.axes(xtick, ytick, xorg[1], yorg[1], majorx, majory, ticksize)
|
|
GR.axes(xtick, ytick, xorg[2], yorg[2], -majorx, -majory, -ticksize)
|
|
elseif axis_idx == 1
|
|
GR.axes(xtick, ytick, xorg[1], yorg[1], majorx, majory, ticksize)
|
|
else
|
|
GR.axes(xtick, ytick, xorg[2], yorg[2], -majorx, majory, -ticksize)
|
|
end
|
|
end
|
|
end
|
|
|
|
# GR.setcharheight(pointsize_mult * sp[:titlefont].pointsize)
|
|
if sp[:title] != ""
|
|
GR.savestate()
|
|
gr_set_font(sp[:titlefont])
|
|
GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
|
|
GR.settextcolorind(gr_getcolorind(sp[:foreground_color_title]))
|
|
GR.text(0.5 * (viewport_plotarea[1] + viewport_plotarea[2]), viewport_subplot[4], sp[:title])
|
|
GR.restorestate()
|
|
end
|
|
|
|
# GR.setcharheight(pointsize_mult * xaxis[:guidefont].pointsize)
|
|
if xaxis[:guide] != ""
|
|
GR.savestate()
|
|
gr_set_font(xaxis[:guidefont])
|
|
GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
|
|
GR.settextcolorind(gr_getcolorind(xaxis[:foreground_color_guide]))
|
|
GR.text(0.5 * (viewport_plotarea[1] + viewport_plotarea[2]), viewport_subplot[3], xaxis[:guide])
|
|
GR.restorestate()
|
|
end
|
|
|
|
# GR.setcharheight(pointsize_mult * yaxis[:guidefont].pointsize)
|
|
if yaxis[:guide] != ""
|
|
GR.savestate()
|
|
gr_set_font(yaxis[:guidefont])
|
|
GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
|
|
GR.setcharup(-1, 0)
|
|
GR.settextcolorind(gr_getcolorind(yaxis[:foreground_color_guide]))
|
|
GR.text(viewport_subplot[1], 0.5 * (viewport_plotarea[3] + viewport_plotarea[4]), yaxis[:guide])
|
|
GR.restorestate()
|
|
end
|
|
# if get(d, :yrightlabel, "") != ""
|
|
# GR.savestate()
|
|
# GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
|
|
# GR.setcharup(1, 0)
|
|
# GR.settextcolorind(fg)
|
|
# GR.text(viewport_subplot[2], 0.5 * (viewport_plotarea[3] + viewport_plotarea[4]), d[:yrightlabel])
|
|
# GR.restorestate()
|
|
# end
|
|
|
|
gr_set_font(xaxis[:tickfont])
|
|
GR.setcolormap(1000 + GR.COLORMAP_COOLWARM)
|
|
|
|
# legend = falses(length(plt.seriesargs))
|
|
|
|
# for (idx, d) in enumerate(plt.seriesargs)
|
|
for (idx, series) in enumerate(series_list(sp))
|
|
d = series.d
|
|
# idx = d[:series_plotindex]
|
|
st = d[:seriestype]
|
|
if st in (:histogram2d, :hexbin, :contour, :surface, :wireframe, :heatmap)
|
|
# grad = isa(d[:fillcolor], ColorGradient) ? d[:fillcolor] : default_gradient()
|
|
# cs = [getColorZ(grad, z) for z in linspace(0, 1, 256)]
|
|
# for (i, c) in enumerate(cs)
|
|
# GR.setcolorrep(999+i, red(c), green(c), blue(c))
|
|
# end
|
|
gr_set_gradient(d[:fillcolor])
|
|
elseif d[:marker_z] != nothing
|
|
gr_set_gradient(d[:markercolor])
|
|
end
|
|
# if get(d, :polar, false)
|
|
# st = :polar
|
|
# end
|
|
GR.savestate()
|
|
xmin, xmax, ymin, ymax = extrema[gr_getaxisind(d),:]
|
|
if xmax > xmin && ymax > ymin
|
|
GR.setwindow(xmin, xmax, ymin, ymax)
|
|
end
|
|
if st in [:path, :polar]
|
|
GR.setlinetype(gr_linetype[d[:linestyle]])
|
|
GR.setlinewidth(d[:linewidth])
|
|
GR.setlinecolorind(gr_getcolorind(d[:linecolor]))
|
|
end
|
|
|
|
if ispolar(sp)
|
|
xmin, xmax, ymin, ymax = viewport_plotarea
|
|
ymax -= 0.05 * (xmax - xmin)
|
|
xcenter = 0.5 * (xmin + xmax)
|
|
ycenter = 0.5 * (ymin + ymax)
|
|
r = 0.5 * min(xmax - xmin, ymax - ymin)
|
|
GR.setviewport(xcenter -r, xcenter + r, ycenter - r, ycenter + r)
|
|
GR.setwindow(-1, 1, -1, 1)
|
|
rmin, rmax = GR.adjustrange(minimum(r), maximum(r))
|
|
gr_polaraxes(rmin, rmax)
|
|
phi, r = d[:x], d[:y]
|
|
r = 0.5 * (r - rmin) / (rmax - rmin)
|
|
n = length(r)
|
|
x = zeros(n)
|
|
y = zeros(n)
|
|
for i in 1:n
|
|
x[i] = r[i] * cos(phi[i])
|
|
y[i] = r[i] * sin(phi[i])
|
|
end
|
|
gr_polyline(x, y)
|
|
|
|
if d[:markershape] != :none
|
|
gr_draw_markers(series, x, y)
|
|
end
|
|
|
|
elseif st == :path
|
|
x, y = d[:x], d[:y]
|
|
if length(x) > 1
|
|
frng = d[:fillrange]
|
|
if frng != nothing
|
|
GR.setfillcolorind(gr_getcolorind(d[:fillcolor]))
|
|
GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
# @show map(length,(d[:x], d[:fillrange], d[:y]))
|
|
# @show size([d[:x][1]; d[:x]; d[:x][length(d[:x])]], [d[:fillrange]; d[:y]; d[:fillrange]])
|
|
# GR.fillarea([d[:x][1]; d[:x]; d[:x][length(d[:x])]], [d[:fillrange]; d[:y]; d[:fillrange]])
|
|
frng = isa(frng, Number) ? Float64[frng] : frng
|
|
nx, ny, nf = length(x), length(y), length(frng)
|
|
n = max(nx, ny)
|
|
fx, fy = zeros(2n), zeros(2n)
|
|
for i=1:n
|
|
fx[i] = fx[end-i+1] = x[mod1(i,nx)]
|
|
fy[i] = y[mod1(i,ny)]
|
|
fy[end-i+1] = frng[mod1(i,nf)]
|
|
end
|
|
GR.fillarea(fx, fy)
|
|
end
|
|
gr_polyline(x, y)
|
|
end
|
|
# legend[idx] = true
|
|
|
|
if d[:markershape] != :none && axes_2d
|
|
gr_draw_markers(series)
|
|
end
|
|
|
|
|
|
# # TODO: use recipe
|
|
# elseif st == :line
|
|
# if length(d[:x]) > 1
|
|
# gr_polyline(d[:x], d[:y])
|
|
# end
|
|
# # legend[idx] = true
|
|
|
|
# # TODO: use recipe
|
|
# elseif st in [:steppre, :steppost]
|
|
# n = length(d[:x])
|
|
# x = zeros(2*n + 1)
|
|
# y = zeros(2*n + 1)
|
|
# x[1], y[1] = d[:x][1], d[:y][1]
|
|
# j = 2
|
|
# for i = 2:n
|
|
# if st == :steppre
|
|
# x[j], x[j+1] = d[:x][i-1], d[:x][i]
|
|
# y[j], y[j+1] = d[:y][i], d[:y][i]
|
|
# else
|
|
# x[j], x[j+1] = d[:x][i], d[:x][i]
|
|
# y[j], y[j+1] = d[:y][i-1], d[:y][i]
|
|
# end
|
|
# j += 2
|
|
# end
|
|
# if n > 1
|
|
# gr_polyline(x, y)
|
|
# end
|
|
# # legend[idx] = true
|
|
|
|
# # TODO: use recipe
|
|
# elseif st == :sticks
|
|
# x, y = d[:x], d[:y]
|
|
# for i = 1:length(y)
|
|
# gr_polyline([x[i], x[i]], [ymin, y[i]])
|
|
# end
|
|
# # legend[idx] = true
|
|
|
|
elseif st == :scatter
|
|
if d[:markershape] != :none && axes_2d
|
|
gr_draw_markers(series)
|
|
end
|
|
# @show "HERE" d[:markershape]
|
|
# GR.setmarkercolorind(gr_getcolorind(d[:markercolor]))
|
|
# gr_setmarkershape(d)
|
|
# if typeof(d[:markersize]) <: Number
|
|
# GR.setmarkersize(d[:markersize] / 4.0)
|
|
# if length(d[:x]) > 0
|
|
# gr_polymarker(d, d[:x], d[:y])
|
|
# end
|
|
# else
|
|
# c = d[:markercolor]
|
|
# GR.setcolormap(-GR.COLORMAP_GLOWING)
|
|
# for i = 1:length(d[:x])
|
|
# if isa(c, ColorGradient) && d[:marker_z] != nothing
|
|
# ci = round(Int, 1000 + d[:marker_z][i] * 255)
|
|
# GR.setmarkercolorind(ci)
|
|
# end
|
|
# GR.setmarkersize(d[:markersize][i] / 4.0)
|
|
# gr_polymarker(d, [d[:x][i]], [d[:y][i]])
|
|
# end
|
|
# end
|
|
# legend[idx] = true
|
|
|
|
# # TODO: use recipe
|
|
# elseif st == :bar
|
|
# gr_barplot(series, d[:x], d[:y])
|
|
# # for i = 1:length(y)
|
|
# # gr_fillrect(series, i-0.4, i+0.4, max(0, ymin), y[i])
|
|
# # # GR.setfillcolorind(gr_getcolorind(d[:fillcolor]))
|
|
# # # GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
# # # GR.fillrect(i-0.4, i+0.4, max(0, ymin), y[i])
|
|
# # # GR.setfillcolorind(fg)
|
|
# # # GR.setfillintstyle(GR.INTSTYLE_HOLLOW)
|
|
# # # GR.fillrect(i-0.4, i+0.4, max(0, ymin), y[i])
|
|
# # end
|
|
|
|
# # TODO: use recipe
|
|
# elseif st in [:histogram, :density]
|
|
# edges, counts = Base.hist(d[:y], d[:bins])
|
|
# gr_barplot(series, edges, counts)
|
|
# # x, y = float(collect(h[1])), float(h[2])
|
|
# # for i = 2:length(y)
|
|
# # GR.setfillcolorind(gr_getcolorind(d[:fillcolor]))
|
|
# # GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
# # GR.fillrect(x[i-1], x[i], ymin, y[i])
|
|
# # GR.setfillcolorind(fg)
|
|
# # GR.setfillintstyle(GR.INTSTYLE_HOLLOW)
|
|
# # GR.fillrect(x[i-1], x[i], ymin, y[i])
|
|
# # end
|
|
|
|
# # TODO: use recipe
|
|
# elseif st in [:hline, :vline]
|
|
# for xy in d[:y]
|
|
# if st == :hline
|
|
# gr_polyline([xmin, xmax], [xy, xy])
|
|
# else
|
|
# gr_polyline([xy, xy], [ymin, ymax])
|
|
# end
|
|
# end
|
|
|
|
# # TODO: use recipe
|
|
# elseif st in [:histogram2d, :hexbin]
|
|
# E = zeros(length(d[:x]),2)
|
|
# E[:,1] = d[:x]
|
|
# E[:,2] = d[:y]
|
|
# if isa(d[:bins], Tuple)
|
|
# xbins, ybins = d[:bins]
|
|
# else
|
|
# xbins = ybins = d[:bins]
|
|
# end
|
|
# x, y, H = Base.hist2d(E, xbins, ybins)
|
|
# maxh = maximum(H)
|
|
# n, m = size(H)
|
|
# counts = Int32[round(Int32, 1000 + 255 * H[n-i+1,j] / maxh) for i=1:n,j=1:m]
|
|
# GR.cellarray(xmin, xmax, ymin, ymax, n, m, counts)
|
|
|
|
# # NOTE: set viewport to the colorbar area, get character height, draw it, then reset viewport
|
|
# GR.setviewport(viewport_plotarea[2] + 0.02, viewport_plotarea[2] + 0.05, viewport_plotarea[3], viewport_plotarea[4])
|
|
# # zmin, zmax = gr_getzlims(d, 0, maximum(counts), false)
|
|
# zmin, zmax = gr_lims(zaxis, false, (0, maximum(counts)))
|
|
# GR.setspace(zmin, zmax, 0, 90)
|
|
# window_diag = sqrt((viewport_plotarea[2] - viewport_plotarea[1])^2 + (viewport_plotarea[4] - viewport_plotarea[3])^2)
|
|
# charheight = max(0.016 * window_diag, 0.01)
|
|
# GR.setcharheight(charheight)
|
|
# GR.colormap()
|
|
# GR.setviewport(viewport_plotarea[1], viewport_plotarea[2], viewport_plotarea[3], viewport_plotarea[4])
|
|
|
|
elseif st == :contour
|
|
x, y, z = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
|
|
# zmin, zmax = gr_getzlims(d, minimum(z), maximum(z), false)
|
|
zmin, zmax = gr_lims(zaxis, false)
|
|
if typeof(d[:levels]) <: Array
|
|
h = d[:levels]
|
|
else
|
|
h = linspace(zmin, zmax, d[:levels])
|
|
end
|
|
GR.setspace(zmin, zmax, 0, 90)
|
|
if d[:fillrange] != nothing
|
|
GR.surface(x, y, z, GR.OPTION_CELL_ARRAY)
|
|
else
|
|
GR.contour(x, y, h, reshape(z, length(x) * length(y)), 1000)
|
|
end
|
|
GR.setviewport(viewport_plotarea[2] + 0.02, viewport_plotarea[2] + 0.05, viewport_plotarea[3], viewport_plotarea[4])
|
|
l = round(Int32, 1000 + (h - minimum(h)) / (maximum(h) - minimum(h)) * 255)
|
|
GR.setwindow(xmin, xmax, zmin, zmax)
|
|
GR.cellarray(xmin, xmax, zmax, zmin, 1, length(l), l)
|
|
ztick = 0.5 * GR.tick(zmin, zmax)
|
|
# window_diag = sqrt((viewport_plotarea[2] - viewport_plotarea[1])^2 + (viewport_plotarea[4] - viewport_plotarea[3])^2)
|
|
# charheight = max(0.016 * window_diag, 0.01)
|
|
# GR.setcharheight(charheight)
|
|
GR.axes(0, ztick, xmax, zmin, 0, 1, 0.005)
|
|
GR.setviewport(viewport_plotarea[1], viewport_plotarea[2], viewport_plotarea[3], viewport_plotarea[4])
|
|
|
|
elseif st in [:surface, :wireframe]
|
|
x, y, z = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
|
|
# zmin, zmax = gr_getzlims(d, minimum(z), maximum(z), true)
|
|
zmin, zmax = gr_lims(zaxis, true)
|
|
GR.setspace(zmin, zmax, 40, 70)
|
|
xtick = GR.tick(xmin, xmax) / 2
|
|
ytick = GR.tick(ymin, ymax) / 2
|
|
ztick = GR.tick(zmin, zmax) / 2
|
|
# window_diag = sqrt((viewport_plotarea[2] - viewport_plotarea[1])^2 + (viewport_plotarea[4] - viewport_plotarea[3])^2)
|
|
# charheight = max(0.018 * window_diag, 0.01)
|
|
ticksize = 0.01 * (viewport_plotarea[2] - viewport_plotarea[1])
|
|
GR.setlinewidth(1)
|
|
if grid_flag
|
|
GR.grid3d(xtick, 0, ztick, xmin, ymin, zmin, 2, 0, 2)
|
|
GR.grid3d(0, ytick, 0, xmax, ymin, zmin, 0, 2, 0)
|
|
end
|
|
z = reshape(z, length(x) * length(y))
|
|
if st == :surface
|
|
GR.gr3.surface(x, y, z, GR.OPTION_COLORED_MESH)
|
|
else
|
|
GR.setfillcolorind(0)
|
|
GR.surface(x, y, z, GR.OPTION_FILLED_MESH)
|
|
end
|
|
GR.setlinewidth(1)
|
|
# GR.setcharheight(charheight)
|
|
GR.axes3d(xtick, 0, ztick, xmin, ymin, zmin, 2, 0, 2, -ticksize)
|
|
GR.axes3d(0, ytick, 0, xmax, ymin, zmin, 0, 2, 0, ticksize)
|
|
if cmap
|
|
GR.setviewport(viewport_plotarea[2] + 0.07, viewport_plotarea[2] + 0.1, viewport_plotarea[3], viewport_plotarea[4])
|
|
GR.colormap()
|
|
end
|
|
|
|
elseif st == :heatmap
|
|
x, y, z = d[:x], d[:y], transpose_z(d, d[:z].surf, false)
|
|
# zmin, zmax = gr_getzlims(d, minimum(z), maximum(z), true)
|
|
zmin, zmax = gr_lims(zaxis, true)
|
|
GR.setspace(zmin, zmax, 0, 90)
|
|
z = reshape(z, length(x) * length(y))
|
|
GR.surface(x, y, z, GR.OPTION_COLORED_MESH)
|
|
if cmap
|
|
GR.setviewport(viewport_plotarea[2] + 0.02, viewport_plotarea[2] + 0.05, viewport_plotarea[3], viewport_plotarea[4])
|
|
GR.colormap()
|
|
GR.setviewport(viewport_plotarea[1], viewport_plotarea[2], viewport_plotarea[3], viewport_plotarea[4])
|
|
end
|
|
|
|
elseif st in (:path3d, :scatter3d)
|
|
x, y, z = d[:x], d[:y], d[:z]
|
|
|
|
# first set up the 3D axes
|
|
zmin, zmax = gr_lims(zaxis, true)
|
|
GR.setspace(zmin, zmax, 40, 70)
|
|
xtick = GR.tick(xmin, xmax) / 2
|
|
ytick = GR.tick(ymin, ymax) / 2
|
|
ztick = GR.tick(zmin, zmax) / 2
|
|
# window_diag = sqrt((viewport_plotarea[2] - viewport_plotarea[1])^2 + (viewport_plotarea[4] - viewport_plotarea[3])^2)
|
|
# charheight = max(0.018 * window_diag, 0.01)
|
|
ticksize = 0.01 * (viewport_plotarea[2] - viewport_plotarea[1])
|
|
GR.setlinewidth(1)
|
|
if grid_flag
|
|
GR.grid3d(xtick, 0, ztick, xmin, ymin, zmin, 2, 0, 2)
|
|
GR.grid3d(0, ytick, 0, xmax, ymin, zmin, 0, 2, 0)
|
|
end
|
|
GR.axes3d(xtick, 0, ztick, xmin, ymin, zmin, 2, 0, 2, -ticksize)
|
|
GR.axes3d(0, ytick, 0, xmax, ymin, zmin, 0, 2, 0, ticksize)
|
|
|
|
# draw path
|
|
if st == :path3d
|
|
if length(x) > 0
|
|
GR.setlinewidth(d[:linewidth])
|
|
GR.polyline3d(x, y, z)
|
|
end
|
|
end
|
|
|
|
# draw markers
|
|
if st == :scatter3d || d[:markershape] != :none
|
|
x2, y2 = unzip(map(GR.wc3towc, x, y, z))
|
|
gr_draw_markers(series, x2, y2)
|
|
# GR.setmarkercolorind(gr_getcolorind(d[:markercolor]))
|
|
# gr_setmarkershape(d)
|
|
# for i = 1:length(z)
|
|
# xi, yi = GR.wc3towc(x[i], y[i], z[i])
|
|
# gr_polymarker(d, [xi], [yi])
|
|
# end
|
|
end
|
|
# GR.setlinewidth(1)
|
|
# # GR.setcharheight(charheight)
|
|
|
|
elseif st == :pie
|
|
GR.selntran(0)
|
|
GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
xmin, xmax, ymin, ymax = viewport_plotarea
|
|
ymax -= 0.05 * (xmax - xmin)
|
|
xcenter = 0.5 * (xmin + xmax)
|
|
ycenter = 0.5 * (ymin + ymax)
|
|
if xmax - xmin > ymax - ymin
|
|
r = 0.5 * (ymax - ymin)
|
|
xmin, xmax = xcenter - r, xcenter + r
|
|
else
|
|
r = 0.5 * (xmax - xmin)
|
|
ymin, ymax = ycenter - r, ycenter + r
|
|
end
|
|
# labels, slices = d[:x], d[:y]
|
|
labels = pie_labels(sp, series)
|
|
slices = d[:y]
|
|
numslices = length(slices)
|
|
total = sum(slices)
|
|
a1 = 0
|
|
x = zeros(3)
|
|
y = zeros(3)
|
|
for i in 1:numslices
|
|
a2 = round(Int, a1 + (slices[i] / total) * 360.0)
|
|
GR.setfillcolorind(980 + (i-1) % 20)
|
|
GR.fillarc(xmin, xmax, ymin, ymax, a1, a2)
|
|
alpha = 0.5 * (a1 + a2)
|
|
cosf = r * cos(alpha * pi / 180)
|
|
sinf = r * sin(alpha * pi / 180)
|
|
x[1] = xcenter + cosf
|
|
y[1] = ycenter + sinf
|
|
x[2] = x[1] + 0.1 * cosf
|
|
y[2] = y[1] + 0.1 * sinf
|
|
y[3] = y[2]
|
|
if 90 <= alpha < 270
|
|
x[3] = x[2] - 0.05
|
|
GR.settextalign(GR.TEXT_HALIGN_RIGHT, GR.TEXT_VALIGN_HALF)
|
|
GR.text(x[3] - 0.01, y[3], string(labels[i]))
|
|
else
|
|
x[3] = x[2] + 0.05
|
|
GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
|
|
GR.text(x[3] + 0.01, y[3], string(labels[i]))
|
|
end
|
|
gr_polyline(x, y)
|
|
a1 = a2
|
|
end
|
|
GR.selntran(1)
|
|
|
|
elseif st == :shape
|
|
# TODO: use GR.fillarea(x, y) similar to pie (extract shape drawing and re-use in pie!)
|
|
# TODO: while we're at it, make a pie series recipe??
|
|
gr_set_line(d[:markerstrokewidth], :solid, d[:markerstrokecolor])
|
|
gr_set_fill(d[:markercolor])
|
|
|
|
# draw the shapes
|
|
gr_polyline(d[:x], d[:y])
|
|
gr_polyline(d[:x], d[:y], GR.fillarea)
|
|
|
|
|
|
|
|
elseif st == :image
|
|
img = d[:z].surf
|
|
w, h = size(img)
|
|
if eltype(img) <: Colors.AbstractGray
|
|
grey = round(UInt8, float(img) * 255)
|
|
rgba = map(c -> UInt32( 0xff000000 + Int(c)<<16 + Int(c)<<8 + Int(c) ), grey)
|
|
else
|
|
rgba = map(c -> UInt32( round(Int, alpha(c) * 255) << 24 +
|
|
round(Int, blue(c) * 255) << 16 +
|
|
round(Int, green(c) * 255) << 8 +
|
|
round(Int, red(c) * 255) ), img)
|
|
end
|
|
GR.drawimage(xmin, xmax, ymax, ymin, w, h, rgba)
|
|
end
|
|
|
|
GR.restorestate()
|
|
end
|
|
|
|
if sp[:legend] != :none #&& any(legend) == true
|
|
GR.savestate()
|
|
GR.selntran(0)
|
|
GR.setscale(0)
|
|
gr_set_font(sp[:legendfont])
|
|
w = 0
|
|
i = 0
|
|
n = 0
|
|
# for (idx, d) in enumerate(plt.seriesargs)
|
|
for series in series_list(sp)
|
|
should_add_to_legend(series) || continue
|
|
# if !legend[idx] || d[:label] == ""
|
|
# continue
|
|
# end
|
|
n += 1
|
|
if typeof(series.d[:label]) <: Array
|
|
i += 1
|
|
lab = series.d[:label][i]
|
|
else
|
|
lab = series.d[:label]
|
|
end
|
|
tbx, tby = GR.inqtext(0, 0, lab)
|
|
w = max(w, tbx[3] - tbx[1])
|
|
end
|
|
if w > 0
|
|
xpos = viewport_plotarea[2] - 0.05 - w
|
|
ypos = viewport_plotarea[4] - 0.06
|
|
# dy = 0.03 * sqrt((viewport_plotarea[2] - viewport_plotarea[1])^2 + (viewport_plotarea[4] - viewport_plotarea[3])^2)
|
|
dy = _gr_point_mult[1] * sp[:legendfont].pointsize * 1.75
|
|
GR.setfillintstyle(GR.INTSTYLE_SOLID)
|
|
GR.setfillcolorind(gr_getcolorind(sp[:background_color_legend]))
|
|
GR.fillrect(xpos - 0.08, xpos + w + 0.02, ypos + dy, ypos - dy * n)
|
|
GR.setlinetype(1)
|
|
GR.setlinewidth(1)
|
|
GR.drawrect(xpos - 0.08, xpos + w + 0.02, ypos + dy, ypos - dy * n)
|
|
i = 0
|
|
# for (idx, d) in enumerate(plt.seriesargs)
|
|
for series in series_list(sp)
|
|
should_add_to_legend(series) || continue
|
|
# if !legend[idx] || d[:label] == ""
|
|
# continue
|
|
# end
|
|
d = series.d
|
|
st = d[:seriestype]
|
|
GR.setlinewidth(d[:linewidth])
|
|
if st == :path
|
|
GR.setlinecolorind(gr_getcolorind(d[:linecolor]))
|
|
GR.setlinetype(gr_linetype[d[:linestyle]])
|
|
GR.polyline([xpos - 0.07, xpos - 0.01], [ypos, ypos])
|
|
end
|
|
if st == :scatter || d[:markershape] != :none
|
|
GR.setmarkercolorind(gr_getcolorind(d[:markercolor]))
|
|
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
|
|
i += 1
|
|
lab = d[:label][i]
|
|
else
|
|
lab = d[:label]
|
|
end
|
|
GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
|
|
GR.settextcolorind(gr_getcolorind(sp[:foreground_color_legend]))
|
|
GR.text(xpos, ypos, lab)
|
|
ypos -= dy
|
|
end
|
|
end
|
|
GR.selntran(1)
|
|
GR.restorestate()
|
|
end
|
|
|
|
GR.savestate()
|
|
for ann in sp[:annotations]
|
|
x, y, val = ann
|
|
x, y = GR.wctondc(x, y)
|
|
# alpha = val.font.rotation
|
|
# family = lowercase(val.font.family)
|
|
# GR.setcharheight(0.7 * val.font.pointsize / sp.plt[:size][2])
|
|
# GR.setcharup(sin(val.font.rotation), cos(val.font.rotation))
|
|
# if haskey(gr_font_family, family)
|
|
# GR.settextfontprec(100 + gr_font_family[family], GR.TEXT_PRECISION_STRING)
|
|
# end
|
|
# GR.settextcolorind(gr_getcolorind(val.font.color))
|
|
# GR.settextalign(gr_halign[val.font.halign], gr_valign[val.font.valign])
|
|
gr_set_font(val.font)
|
|
GR.text(x, y, val.str)
|
|
end
|
|
GR.restorestate()
|
|
end
|
|
|
|
|
|
# ----------------------------------------------------------------
|
|
|
|
# # Set the (left, top, right, bottom) minimum padding around the plot area
|
|
# # to fit ticks, tick labels, guides, colorbars, etc.
|
|
# function _update_min_padding!(sp::Subplot{GRBackend})
|
|
# sp.minpad = (10mm, 5mm, 3mm, 8mm)
|
|
# end
|
|
|
|
# # clear, display, and update the plot... using in all output modes
|
|
# function gr_finalize(plt::Plot{GRBackend})
|
|
# GR.clearws()
|
|
# gr_display(plt)
|
|
# GR.updatews()
|
|
# end
|
|
|
|
# # setup and tear down gks before and after displaying... used in IO output
|
|
# function gr_finalize_mime(plt::Plot{GRBackend}, wstype)
|
|
# GR.emergencyclosegks()
|
|
# ENV["GKS_WSTYPE"] = wstype
|
|
# gr_display(plt)
|
|
# GR.emergencyclosegks()
|
|
# end
|
|
|
|
# ----------------------------------------------------------------
|
|
|
|
const _gr_mimeformats = Dict(
|
|
"application/pdf" => "pdf",
|
|
"image/png" => "png",
|
|
"application/postscript" => "ps",
|
|
"image/svg+xml" => "svg",
|
|
)
|
|
|
|
|
|
for (mime, fmt) in _gr_mimeformats
|
|
# @eval function Base.writemime(io::IO, ::MIME{Symbol($mime)}, plt::Plot{PyPlotBackend})
|
|
@eval function _writemime(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
|
|
GR.emergencyclosegks()
|
|
ENV["GKS_WSTYPE"] = $fmt
|
|
gr_display(plt)
|
|
GR.emergencyclosegks()
|
|
write(io, readall("gks." * $fmt))
|
|
end
|
|
end
|
|
|
|
# function Base.writemime(io::IO, m::MIME"image/png", plt::Plot{GRBackend})
|
|
# gr_display(plt, "png")
|
|
# write(io, readall("gks.png"))
|
|
# end
|
|
#
|
|
# function Base.writemime(io::IO, m::MIME"image/svg+xml", plt::Plot{GRBackend})
|
|
# gr_display(plt, "svg")
|
|
# write(io, readall("gks.svg"))
|
|
# end
|
|
#
|
|
# # function Base.writemime(io::IO, m::MIME"text/html", plt::Plot{GRBackend})
|
|
# # writemime(io, MIME("image/svg+xml"), plt)
|
|
# # end
|
|
#
|
|
# function Base.writemime(io::IO, m::MIME"application/pdf", plt::Plot{GRBackend})
|
|
# gr_display(plt, "pdf")
|
|
# write(io, readall("gks.pdf"))
|
|
# end
|
|
#
|
|
# function Base.writemime(io::IO, m::MIME"application/postscript", plt::Plot{GRBackend})
|
|
# gr_display(plt, "ps")
|
|
# write(io, readall("gks.ps"))
|
|
# end
|
|
|
|
function _display(plt::Plot{GRBackend})
|
|
gr_display(plt)
|
|
end
|