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

changes for markers etc

Browse Source
This commit is contained in:
SimonDanisch 2016-11-17 17:29:22 +01:00
parent e2a4a1e2ea
commit 34a64db91d
1 changed files with 127 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
src/backends/glvisualize.jl
View File

@ -1,4 +1,4 @@
#=
``#=
TODO
* move all gl_ methods to GLPlot
* integrate GLPlot UI
@ -156,46 +156,34 @@ end
function create_window(plt::Plot{GLVisualizeBackend}, visible)
name = Symbol("Plots.jl")
screen = if isempty(GLVisualize.get_screens())
# make sure we have any screen open
if isempty(GLVisualize.get_screens())
# create a fresh, new screen
parent = GLVisualize.glscreen(
screen = GLVisualize.glscreen(
"Plot",
resolution = plt[:size],
visible = visible
)
@async GLWindow.waiting_renderloop(parent)
screen = GLWindow.Screen(parent,
name = name,
area = map(identity, parent.area)
@async GLWindow.waiting_renderloop(screen)
end
# now lets get ourselves a permanent Plotting screen
plot_screens = get_plot_screen(GLVisualize.get_screens(), name)
screen = if isempty(plot_screens) # no screen with `name`
parent = GLVisualize.current_screen()
screen = GLWindow.Screen(
parent, area = map(GLWindow.zeroposition, parent.area),
name = name
)
for (k, s) in screen.inputs # copy signals, so we can clean them up better
screen.inputs[k] = map(identity, s)
end
screen
elseif length(plot_screens) == 1
plot_screens[1]
else
plot_screens = get_plot_screen(GLVisualize.get_screens(), name)
if isempty(plot_screens)
parent = GLVisualize.current_screen()
empty!(parent)
inputs = Dict{Symbol, Any}()
for (k, s) in parent.inputs # copy signals, so we can clean them up better
inputs[k] = map(identity, s)
end
screen = GLWindow.Screen(parent,
name = name,
area = map(identity, parent.area)
)
for (k, s) in screen.inputs # copy signals, so we can clean them up better
screen.inputs[k] = map(identity, s)
end
screen
elseif length(plot_screens) == 1
plot_screens[1]
else
# okay this is silly! Lets see if we can. There is an ID we could use
# will not be fine for more than 255 screens though -.-.
error("multiple Plot screens. Please don't use any screen with the name Plots.jl")
end
# okay this is silly! Lets see if we can. There is an ID we could use
# will not be fine for more than 255 screens though -.-.
error("multiple Plot screens. Please don't use any screen with the name Plots.jl")
end
# Since we own this window, we can do deep cleansing
empty_screen!(screen)
@ -226,6 +214,7 @@ const _gl_marker_map = KW(
:hline => '━',
:+ => '+',
:x => 'x',
:circle => '●'
)
function gl_marker(shape)
@ -241,6 +230,12 @@ function gl_marker(shape::Shape)
GeometryTypes.GLNormalMesh(points)
end
# create a marker/shape type
function gl_marker(shape::Vector{Symbol})
String(map(shape) do sym
get(_gl_marker_map, sym, '●')
end)
end
function gl_marker(shape::Symbol)
if shape == :rect
GeometryTypes.HyperRectangle(Vec2f0(0), Vec2f0(1))
@ -265,6 +260,12 @@ function extract_limits(sp, d, kw_args)
nothing
end
to_vec{T <: FixedVector}(::Type{T}, vec::T) = vec
to_vec{T <: FixedVector{2}}(::Type{T}, vec::FixedVector{3}) = T(vec[1], vec[2])
to_vec{T <: FixedVector{3}}(::Type{T}, vec::FixedVector{2}) = T(vec[1], vec[2], 0)
to_vec{T <: FixedVector}(::Type{T}, vecs::Vector) = map(x-> to_vec(T, x), vecs)
function extract_marker(d, kw_args)
dim = Plots.is3d(d) ? 3 : 2
scaling = dim == 3 ? 0.003 : 2
@ -278,13 +279,11 @@ function extract_marker(d, kw_args)
dim = isa(kw_args[:primitive], GLVisualize.Sprites) ? 2 : 3
if haskey(d, :markersize)
msize = d[:markersize]
if isa(msize, AbstractArray)
kw_args[:scale] = map(x->GeometryTypes.Vec{dim, Float32}(x*scaling), msize)
else
kw_args[:scale] = GeometryTypes.Vec{dim, Float32}(msize*scaling)
end
kw_args[:scale] = to_vec(GeometryTypes.Vec{dim, Float32}, msize .* scaling)
end
if haskey(d, :offset)
kw_args[:offset] = d[:offset]
end
# get the color
key = :markercolor
haskey(d, key) || return
@ -315,6 +314,7 @@ end
function _extract_surface(d::AbstractArray)
d
end
# TODO when to transpose??
function extract_surface(d)
map(_extract_surface, (d[:x], d[:y], d[:z]))
@ -327,7 +327,7 @@ function extract_points(d)
array = (d[:x], d[:y], d[:z])[1:dim]
topoints(Point{dim, Float32}, array)
end
function make_gradient{C<:Colorant}(grad::Vector{C})
function make_gradient{C <: Colorant}(grad::Vector{C})
grad
end
function make_gradient(grad::ColorGradient)
@ -373,9 +373,10 @@ end
function extract_stroke(d, kw_args)
extract_c(d, kw_args, :line)
if haskey(d, :linewidth)
kw_args[:thickness] = d[:linewidth]*3
kw_args[:thickness] = d[:linewidth] * 3
end
end
function extract_color(d, sym)
d[Symbol("$(sym)color")]
end
@ -413,6 +414,7 @@ end
dist(a, b) = abs(a-b)
mindist(x, a, b) = min(dist(a, x), dist(b, x))
function gappy(x, ps)
n = length(ps)
x <= first(ps) && return first(ps) - x
@ -426,7 +428,7 @@ function gappy(x, ps)
return last(ps) - x
end
function ticks(points, resolution)
Float16[gappy(x, points) for x=linspace(first(points),last(points), resolution)]
Float16[gappy(x, points) for x = linspace(first(points),last(points), resolution)]
end
@ -461,9 +463,11 @@ function extract_linestyle(d, kw_args)
extract_c(d, kw_args, :line)
nothing
end
function hover(to_hover::Vector, to_display, window)
hover(to_hover[], to_display, window)
end
function get_cam(x)
if isa(x, GLAbstraction.Context)
return get_cam(x.children)
@ -474,6 +478,7 @@ function get_cam(x)
end
end
function hover(to_hover, to_display, window)
if isa(to_hover, GLAbstraction.Context)
return hover(to_hover.children, to_display, window)
@ -523,7 +528,7 @@ function hover(to_hover, to_display, window)
end
function extract_extrema(d, kw_args)
xmin,xmax = extrema(d[:x]); ymin,ymax = extrema(d[:y])
xmin, xmax = extrema(d[:x]); ymin, ymax = extrema(d[:y])
kw_args[:primitive] = GeometryTypes.SimpleRectangle{Float32}(xmin, ymin, xmax-xmin, ymax-ymin)
nothing
end
@ -554,6 +559,7 @@ function extract_colornorm(d, kw_args)
kw_args[:intensity] = map(Float32, collect(z))
end
end
function extract_gradient(d, kw_args, sym)
key = Symbol("$(sym)color")
haskey(d, key) || return
@ -563,6 +569,7 @@ function extract_gradient(d, kw_args, sym)
kw_args[:color_map] = c
return
end
function extract_c(d, kw_args, sym)
key = Symbol("$(sym)color")
haskey(d, key) || return
@ -624,20 +631,24 @@ function align_offset(startpos, lastpos, atlas, rscale, font, align)
error("Align $align not known")
end
end
function align_offset(startpos, lastpos, atlas, rscale, font, align::Vec)
xscale, yscale = GLVisualize.glyph_scale!('X', rscale)
xmove = (lastpos-startpos)[1] + xscale
return -Vec2f0(xmove, yscale) .* align
end
function alignment2num(x::Symbol)
(x in (:hcenter, :vcenter)) && return 0.5
(x in (:left, :bottom)) && return 0.0
(x in (:right, :top)) && return 1.0
0.0 # 0 default, or better to error?
end
function alignment2num(font::Plots.Font)
Vec2f0(map(alignment2num, (font.halign, font.valign)))
end
pointsize(font) = font.pointsize * 2
function draw_ticks(
@ -683,16 +694,18 @@ function draw_ticks(
end
text, positions, offsets
end
function text(position, text, kw_args)
text_align = alignment2num(text.font)
startpos = Vec2f0(position)
atlas = GLVisualize.get_texture_atlas()
font = GLVisualize.defaultfont()
rscale = kw_args[:relative_scale]
m = Reactive.value(kw_args[:model])
position = GLVisualize.calc_position(text.str, startpos, rscale, font, atlas)
offset = GLVisualize.calc_offset(text.str, rscale, font, atlas)
alignoff = align_offset(startpos, last(position), atlas, rscale, font, text_align)
map!(position) do pos
pos .+ alignoff
end
@ -969,6 +982,39 @@ end
# ----------------------------------------------------------------
function scale_for_annotations!(series::Series, scaletype::Symbol = :pixels)
anns = series[:series_annotations]
if anns != nothing && !isnull(anns.baseshape)
# we use baseshape to overwrite the markershape attribute
# with a list of custom shapes for each
msw, msh = anns.scalefactor
offsets = Array(Vec2f0, length(anns.strs))
series[:markersize] = map(1:length(anns.strs)) do i
str = cycle(anns.strs, i)
# get the width and height of the string (in mm)
sw, sh = text_size(str, anns.font.pointsize)
# how much to scale the base shape?
# note: it's a rough assumption that the shape fills the unit box [-1,-1,1,1],
# so we scale the length-2 shape by 1/2 the total length
xscale = 0.5to_pixels(sw) * 1.8
yscale = 0.5to_pixels(sh) * 1.8
# we save the size of the larger direction to the markersize list,
# and then re-scale a copy of baseshape to match the w/h ratio
s = Vec2f0(xscale, yscale)
offsets[i] = -s
s
end
series[:offset] = offsets
end
return
end
function _display(plt::Plot{GLVisualizeBackend}, visible = true)
screen = create_window(plt, visible)
sw, sh = plt[:size]
@ -1002,14 +1048,7 @@ function _display(plt::Plot{GLVisualizeBackend}, visible = true)
screen.area, sub_area,
Signal(rel_plotarea), Signal(sp)
)
for ann in sp[:annotations]
x, y, plot_text = ann
txt_args = Dict{Symbol, Any}(:model => eye(GeometryTypes.Mat4f0))
x, y, _1, _1 = Reactive.value(model_m) * Vec{4,Float32}(x, y, 0, 1)
extract_font(plot_text.font, txt_args)
t = text(Point2f0(x, y), plot_text, txt_args)
GLVisualize._view(t, sp_screen, camera=:perspective)
end
# loop over the series and add them to the subplot
if !_3d
axis = gl_draw_axes_2d(sp, model_m, Reactive.value(sub_area))
@ -1035,7 +1074,7 @@ function _display(plt::Plot{GLVisualizeBackend}, visible = true)
if !_3d # 3D is treated differently, since we need boundingboxes for camera
kw_args[:boundingbox] = nothing # don't calculate bb, we dont need it
end
scale_for_annotations!(series)
if st in (:surface, :wireframe)
x, y, z = extract_surface(d)
extract_gradient(d, kw_args, :fill)
@ -1064,7 +1103,7 @@ function _display(plt::Plot{GLVisualizeBackend}, visible = true)
if d[:fillrange] != nothing
kw = copy(kw_args)
fr = d[:fillrange]
ps = if all(x->x>=0, diff(d[:x])) # if is monotonic
ps = if all(x-> x >= 0, diff(d[:x])) # if is monotonic
vcat(points, Point2f0[(points[i][1], cycle(fr, i)) for i=length(points):-1:1])
else
points
@ -1116,6 +1155,7 @@ function _display(plt::Plot{GLVisualizeBackend}, visible = true)
else
error("failed to display plot type $st")
end
isa(vis, Array) && isempty(vis) && continue # nothing to see here
GLVisualize._view(vis, sp_screen, camera=:perspective)
@ -1126,6 +1166,16 @@ function _display(plt::Plot{GLVisualizeBackend}, visible = true)
del_signal = Main.GLPlot.register_plot!(vis, sp_screen, create_gizmo=false)
append!(_glplot_deletes, del_signal)
end
anns = series[:series_annotations]
for (x, y, str) in EachAnn(anns, d[:x], d[:y])
txt_args = Dict{Symbol, Any}(:model => eye(GLAbstraction.Mat4f0))
x, y = Reactive.value(model_m) * Vec{4, Float32}(x, y, 0, 1)
extract_font(anns.font, txt_args)
pt = isa(str, String) ? PlotText(str, anns.font) : str
t = text(Point2f0(x, y), pt, txt_args)
GLVisualize._view(t, sp_screen, camera = :perspective)
end
end
generate_legend(sp, sp_screen, model_m)
if _3d
@ -1208,14 +1258,7 @@ function gl_shape(d, kw_args)
result
end
tovec2(x::FixedSizeArrays.Vec{2, Float32}) = x
tovec2(x::AbstractVector) = map(tovec2, x)
tovec2(x::FixedSizeArrays.Vec) = Vec2f0(x[1], x[2])
tovec3(x) = x
tovec3(x::FixedSizeArrays.Vec{3}) = Vec3f0(x)
tovec3(x::AbstractVector) = map(tovec3, x)
tovec3(x::FixedSizeArrays.Vec{2}) = Vec3f0(x[1], x[2], 1)
function gl_scatter(points, kw_args)
prim = get(kw_args, :primitive, GeometryTypes.Circle)
@ -1225,21 +1268,31 @@ function gl_scatter(points, kw_args)
kw_args[:scale] = GLAbstraction.const_lift(kw_args[:model], kw_args[:scale], p) do m, sc, p
s = Vec3f0(m[1,1], m[2,2], m[3,3])
ps = Vec3f0(p[1,1], p[2,2], p[3,3])
r = sc./(s.*ps)
r = sc ./ (s .* ps)
r
end
end
else # 2D prim
kw_args[:scale] = tovec2(kw_args[:scale])
kw_args[:scale] = to_vec(Vec2f0, kw_args[:scale])
end
if haskey(kw_args, :stroke_width)
s = Reactive.value(kw_args[:scale])
sw = kw_args[:stroke_width]
if sw*5 > cycle(Reactive.value(s), 1)[1] # restrict marker stroke to 1/10th of scale (and handle arrays of scales)
kw_args[:stroke_width] = s[1]/5f0
kw_args[:stroke_width] = s[1] / 5f0
end
end
kw_args[:scale_primitive] = false
if isa(prim, String)
kw_args[:position] = points
if !isa(kw_args[:scale], Vector) # if not vector, we can assume it's relative scale
kw_args[:relative_scale] = kw_args[:scale]
delete!(kw_args, :scale)
end
return visualize(prim, Style(:default), kw_args)
end
visualize((prim, points), Style(:default), kw_args)
end
@ -1259,6 +1312,9 @@ function gl_poly(points, kw_args)
result
end
function gl_surface(x,y,z, kw_args)
if isa(x, Range) && isa(y, Range)
main = z
@ -1267,8 +1323,8 @@ function gl_surface(x,y,z, kw_args)
if isa(x, AbstractMatrix) && isa(y, AbstractMatrix)
main = map(s->map(Float32, s), (x, y, z))
elseif isa(x, AbstractVector) || isa(y, AbstractVector)
x = Float32[x[i] for i=1:size(z,1), j=1:size(z,2)]
y = Float32[y[j] for i=1:size(z,1), j=1:size(z,2)]
x = Float32[x[i] for i = 1:size(z,1), j = 1:size(z,2)]
y = Float32[y[j] for i = 1:size(z,1), j = 1:size(z,2)]
main = (x, y, map(Float32, z))
else
error("surface: combination of types not supported: $(typeof(x)) $(typeof(y)) $(typeof(z))")
@ -1278,8 +1334,10 @@ function gl_surface(x,y,z, kw_args)
faces = Cuint[]
idx = (i,j) -> sub2ind(size(z), i, j) - 1
for i=1:size(z,1), j=1:size(z,2)
i < size(z,1) && push!(faces, idx(i, j), idx(i+1, j))
j < size(z,2) && push!(faces, idx(i, j), idx(i, j+1))
end
color = get(kw_args, :stroke_color, RGBA{Float32}(0,0,0,1))
kw_args[:color] = color
@ -1295,15 +1353,18 @@ function gl_surface(x,y,z, kw_args)
end
function gl_contour(x,y,z, kw_args)
function gl_contour(x, y, z, kw_args)
if kw_args[:fillrange] != nothing
delete!(kw_args, :intensity)
I = GLVisualize.Intensity{1, Float32}
main = I[z[j,i] for i=1:size(z, 2), j=1:size(z, 1)]
return visualize(main, Style(:default), kw_args)
else
h = kw_args[:levels]
levels = Contour.contours(x, y, z, h)
T = eltype(z)
levels = Contour.contours(map(T, x), map(T, y), z, h)
result = Point2f0[]
zmin, zmax = get(kw_args, :limits, Vec2f0(extrema(z)))
cmap = get(kw_args, :color_map, get(kw_args, :color, RGBA{Float32}(0,0,0,1)))
@ -1313,7 +1374,7 @@ function gl_contour(x,y,z, kw_args)
append!(result, elem.vertices)
push!(result, Point2f0(NaN32))
col = GLVisualize.color_lookup(cmap, c.level, zmin, zmax)
append!(colors, fill(col, length(elem.vertices)+1))
append!(colors, fill(col, length(elem.vertices) + 1))
end
end
kw_args[:color] = colors