Error plotting a *large* matrix

[giordano]

While trying to reproduce this issue, I gave Makie.jl a try, however it fails to plot, with heatmap, a matrix with size 24900 x 26620 (but also 170000 x 17000):

julia> using AbstractPlotting, GLMakie, Makie

julia> heatmap(rand(Float32, 24900, 26620))
Error showing value of type Scene:
ERROR: glTexImage 2D: width too large. Width: 24900
[...]

Images this large are relatively common in astronomy and currently I don't see any tool in Julia able to visualise them.

[asinghvi17]

#291 (comment) may have a solution to this (probably have to replace 3d with 2d but otherwise...)

[giordano]

I'm talking about a 2D image, not a 3D one, thus I guess that glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE) is unrelated. BTW:

julia> glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE)
-1

[asinghvi17]

That's weird, the heatmap command 'works' on my machine (although its output is suspect). Are you plotting on a headless system or something? glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE) should return a number >= 64...

On my machine:

using Makie
heatmap(rand(Float32, 24900, 26620))

yields

[asinghvi17]

Also, what I meant to show when linking to that was

vol = rand(506, 720, 1440)
ranges = (1:256, 1:256, 1:256)
scene = volume(ranges..., vol[ranges...])
for i in 1:3
    global ranges
    ranges = ntuple(3) do j
        s = j == i ? last(ranges[j]) : 1
        e = j == i ? size(vol, j) : last(ranges[j])
        s:e
    end
    volume!(ranges..., vol[ranges...])
end

scene

for which you could do the same in 2 dimensions with heatmaps.

[giordano]

Are you plotting on a headless system or something?

Not sure what you mean by "headless system", it's a MacBook running Arch Linux.

[asinghvi17]

Hmm...does Makie work otherwise?

(What I meant by a headless system is one with no display, like an SSH-only server or something).

If your Macbook Air is old enough, it may not support OpenGL, meaning Makie might not work there..

[giordano]

julia> using Makie, GLMakie, ModernGL

julia> heatmap(rand(Float32, 10_000, 10_000))

[asinghvi17]

Perhaps this approach might work?

using Makie
heatmap(rand(Float32, 10_000, 10_000))
heatmap!(10000:20000, 10000:20000, rand(Float32, 10000, 10000))
heatmap!(10000:20000, 0:10000, rand(Float32, 10000, 10000))
heatmap!(00000:10000, 10000:20000, rand(Float32, 10000, 10000))

which yields

[asinghvi17]

Essentially, assemble the whole plot from slices of data, thereby making the texture non continuous and circumventing the OpenGL error. Doing it in one command fails on mine too (although silently). Perhaps this is something we should add to the docs!

[SimonDanisch]

yeah this is too big for the gpu and needs tiling!

[asinghvi17]

Is there a value that can be accessed which gives the max 2d texture size (similar to glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE))?

[giordano]

yeah this is too big for the gpu and needs tiling!

I guess it uses a different way to plot figures, but matplotlib has no problem to deal with matrices this large and is also relatively fast.

These large matrices are not rare in astronomy and it would be great if it were possible to handle them more easily.

[asinghvi17]

I suspect that could be written into a recipe (something like bigheatmap)?

[asinghvi17]

Since heatmap is a primitive, would we have to build this into every backend?

[asinghvi17]

We could recursively break up too-large heatmaps. Not sure if that's doable, though - might need some massaging on the AbstractPlotting end

[SimonDanisch]

I think something like that should be handled by another package creating a recipe to view very large arrays

[tecosaur]

I just ran into this issue when trying to run heatmap on a large matrix of mine (30k x 30k). Is the current suggestion that somebody creates a GLMakieLargeHeatmapTilingWorkaround.jl package that just contains the equivalent of:

for xslice in Iterators.partition(axes(mat, 1), 10000)
    for yslice in Iterators.partition(axes(mat, 2), 10000)
        heatmap!(ax, xslice, yslice, mat[xslice, yslice])
    end
end

[asinghvi17]

Yes, I would go with that for now.