在 Matlab 中使用 OpenGL 获取深度缓冲区 [英] Using OpenGL in Matlab to get depth buffer

问题描述

我之前问过一个类似的问题，但没有找到直接的答案.

Ive asked a similar question before and didnt manage to find a direct answer.

谁能提供在Matlab中提取对象渲染到图形的深度缓冲区的示例代码?

Could someone provide sample code for extracting the depth buffer of the rendering of an object into a figure in Matlab?

所以假设我加载了一个 obj 文件，甚至只是一个简单的冲浪调用，渲染它，现在想要进入它的深度缓冲区，然后什么代码会使用 Matlab 和 OpenGL 为我做这件事.IE.我如何设置它然后访问实际数据?

So lets say I load an obj file or even just a simple surf call, render it and now want to get to its depth buffer then what code will do that for me using both Matlab and OpenGL. I.e. how do I set this up and then access the actual data?

我基本上希望能够使用 Matlabs 强大的绘图功能，然后能够访问底层图形上下文以获取深度缓冲区.

I essentially want to be able to use Matlabs powerful plotting functions and then be able to access the underlying graphics context for getting the depth buffer out.

注意:赏金指定 JOGL 但这不是必须的.任何可以在Matlab中运行后为我提供深度缓冲区的代码就足够了)

NOTE: The bounty specifies JOGL but that is not a must. Any code which acts as above and can provide me with the depth buffer after running it in Matlab is sufficient)

推荐答案

今天，我和同事一起去喝酒，喝了五杯啤酒和一些龙舌兰酒后，我发现了这个问题，心想:请客！"所以我挣扎了一段时间，但后来我找到了一个使用 MEX 的简单解决方案.我的理论是，如果脚本在同一线程中运行，则由最后一个窗口创建的 OpenGL 上下文可以保持活动状态，因此可以从C"访问.

Today, I went drinking with my colleagues, and after five beers and some tequillas I found this question and thought, "have at ya!" So I was struggling for a while but then I found a simple solution using MEX. I theorized that the OpenGL context, created by the last window, could be left active and therefore could be accessible from "C", if the script ran in the same thread.

我创建了一个简单的C"程序，它调用一个名为testofmyfilter"的 matlab 函数，它绘制滤波器的频率响应(这是我手头唯一的脚本).这是使用 OpenGL 渲染的.然后程序使用 glGetViewport() 和 glReadPixels() 来访问 OpenGL 缓冲区.然后它创建一个矩阵，用深度值填充它，并将它传递给第二个函数，称为trytodisplaydepthmap".它只是使用 imshow 函数显示深度图.请注意，MEX 函数也允许返回值，因此后处理可能不必是另一个函数，但我无法理解它是如何完成的.不过应该是微不足道的.我今天第一次与 MEX 合作.

I created a simple "C" program which calls one matlab function, called "testofmyfilter" which plots frequency response of a filter (that was the only script I had at hand). This is rendered using OpenGL. Then the program uses glGetViewport() and glReadPixels() to get to the OpenGL buffers. Then it creates a matrix, fills it with the depth values, and passes it to the second function, called "trytodisplaydepthmap". It just displays the depthmap using the imshow function. Note that the MEX function is allowed to return values as well, so maybe the postprocessing would not have to be another function, but I'm in no state to be able to understand how it's done. Should be trivial, though. I'm working with MEX for the first time today.

事不宜迟，有我使用的源代码:

Without further delay, there are source codes I used:

testofmyfilter.m

testofmyfilter.m

imp = zeros(10000,1);
imp(5000) = 1;
% impulse

[bwb,bwa] = butter(3, 0.1, 'high');
b = filter(bwb, bwa, imp);
% filter impulse by the filter

fs = 44100; % sampling frequency (all frequencies are relative to fs)
frequency_response=fft(b); % calculate response (complex numbers)
amplitude_response=20*log10(abs(frequency_response)); % calculate module of the response, convert to dB
frequency_axis=(0:length(b)-1)*fs/length(b); % generate frequency values for each response value
min_f=2;
max_f=fix(length(b)/2)+1; % min, max frequency

figure(1);
lighting gouraud
set(gcf,'Renderer','OpenGL')

semilogx(frequency_axis(min_f:max_f),amplitude_response(min_f:max_f),'r-') % plot with logarithmic axis using red line
axis([frequency_axis(min_f) frequency_axis(max_f) -90 10])  % set axis limits

xlabel('frequency [Hz]');
ylabel('amplitude [dB]'); % legend

grid on % draw grid

test.c

//You can include any C libraries that you normally use
#include "windows.h"
#include "stdio.h"
#include "math.h"
#include "mex.h"   //--This one is required

extern WINAPI void glGetIntegerv(int n_enum, int *p_value);

extern WINAPI void glReadPixels(int     x, 
    int     y, 
    int     width, 
    int     height, 
    int     format, 
    int     type, 
    void *      data);

#define GL_VIEWPORT                       0x0BA2
#define GL_DEPTH_COMPONENT                0x1902
#define GL_FLOAT                          0x1406

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
    int viewport[4], i, x, y;
    int colLen;
    float *data;
    double *matrix;
    mxArray *arg[1];

    mexCallMATLAB(0, NULL, 0, NULL, "testofmyfilter");
    // call an .m file which creates OpenGL window and draws a plot inside

    glGetIntegerv(GL_VIEWPORT, viewport);
    printf("GL_VIEWPORT = [%d, %d, %d, %d]
", viewport[0], viewport[1], viewport[2], viewport[3]);
    // print viewport dimensions, should be [0, 0, m, n]
    // where m and n are size of the GL window

    data = (float*)malloc(viewport[2] * viewport[3] * sizeof(float));
    glReadPixels(0, 0, viewport[2], viewport[3], GL_DEPTH_COMPONENT, GL_FLOAT, data);
    // alloc data and read the depth buffer

    /*for(i = 0; i < 10; ++ i)
        printf("%f
", data[i]);*/
    // debug

    arg[0] = mxCreateNumericMatrix(viewport[3], viewport[2], mxDOUBLE_CLASS, mxREAL);
    matrix = mxGetPr(arg[0]);
    colLen = mxGetM(arg[0]);
    printf("0x%08x 0x%08x 0x%08x %d
", data, arg[0], matrix, colLen); // debug
    for(x = 0; x < viewport[2]; ++ x) {
        for(y = 0; y < viewport[3]; ++ y)
            matrix[x * colLen + y] = data[x + (viewport[3] - 1 - y) * viewport[2]];
    }
    // create matrix, copy data (this is stupid, but matlab switches
    // rows/cols, also convert float to double - but OpenGL could have done that)

    free(data);
    // don't need this anymore

    mexCallMATLAB(0, NULL, 1, arg, "trytodisplaydepthmap");
    // pass the array to a function (returnig something from here
    // is beyond my understanding of mex, but should be doable)

    mxDestroyArray(arg[0]);
    // cleanup

    return;
}

trytodisplaydepthmap.m:

trytodisplaydepthmap.m:

function [] = trytodisplaydepthmap(depthMap)

figure(2);
imshow(depthMap, []);
% see what's inside

将所有这些保存到同一目录中，使用(在 Matlab 控制台中输入)编译 test.c:

Save all of these to the same directory, compile test.c with (type that to Matlab console):

mex test.c Q:MATLABR2008asyslcclibopengl32.lib

其中Q:MATLABR2008asyslcclibopengl32.lib"是opengl32.lib"文件的路径.

Where "Q:MATLABR2008asyslcclibopengl32.lib" is path to "opengl32.lib" file.

最后只需在 matlab 控制台中键入test"即可执行所有操作.它应该打开一个带有滤波器频率响应的窗口，以及另一个带有深度缓冲区的窗口.请注意，前缓冲区和后缓冲区在C"代码读取深度缓冲区时交换，因此可能需要运行脚本两次才能获得任何结果(因此现在包含结果的前缓冲区再次与后缓冲区交换，并且可以读出深度).这可以由C"自动完成，或者您可以尝试包含 getframe(gcf);在脚本的末尾(它也从 OpenGL 读回，因此它会为您交换缓冲区或其他内容).

And finally execute it all by merely typing "test" in matlab console. It should bring up a window with filter frequency response, and another window with the depth buffer. Note the front and back buffers are swapped at the moment "C" code reads the depth buffer, so it might be required to run the script twice to get any results (so the front buffer which now contains the results swaps with back buffer again, and the depth can be read out). This could be done automatically by "C", or you can try including getframe(gcf); at the end of your script (that reads back from OpenGL as well so it swaps the buffers for you, or something).

这在 Matlab 7.6.0.324 (R2008a) 中对我有用.脚本运行并吐出以下内容:

This works for me in Matlab 7.6.0.324 (R2008a). The script runs and spits out the following:

>>test
GL_VIEWPORT = [0, 0, 560, 419]
0x11150020 0x0bd39620 0x12b20030 419

当然它会显示图像.请注意，深度缓冲范围取决于 Matlab，并且可能非常高，因此对生成的图像进行任何理解可能并不简单.

And of course it displays the images. Note the depth buffer range depends on Matlab, and can be quite high, so making any sense of the generated images may not be straightforward.

这篇关于在 Matlab 中使用 OpenGL 获取深度缓冲区的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！