Discussion :

[black_hole]

Bonjour.
Je viens de finir un petit programme sur OpenCV pour un lien entre cuda et opengl.
J ai donc mon buffet de 32 bits contenant le valeurs rgba de mon pixel.
Le problème est que des que je mets la valeur de mes pixels à 0 ( la valeur 32 bits à 0) mon image est noire mais des que je mets une valeur rouge vert ou bleu à 1, elle se sature à la valeur max.

Comment puis je savoir de ou viens mon problème?

[LittleWhite]

Bonjour,

Lorsque vous dites, elle se sature à la valeur max, ça veut dire : #FFFFFFFF ? Ou alors, vous dites que la valeur 1 passe direct en FF ?
Peut être une mauvaise interprétation des données avec OpenGL ? Dans tous les cas, il faut regarder l'état du tampon dans toute votre chaîne de transformation.

[black_hole]

Voici mon programme, c'est en fait le programme de base simpleCuda2GL:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
#include "Displayer.h"
 
 
static const char *glsl_drawtex_vertshader_src =
        "void main(void)\n"
        "{\n"
        "	gl_Position = gl_Vertex;\n"
        "	gl_TexCoord[0].xy = gl_MultiTexCoord0.xy;\n"
        "}\n";
 
static const char *glsl_drawtex_fragshader_src =
        "#version 130\n"
        "uniform usampler2D texImage;\n"
        "void main()\n"
        "{\n"
        "   vec4 c = texture(texImage, gl_TexCoord[0].xy);\n"
        "	gl_FragColor = c / 255.0;\n"
        "}\n";
 
 
//static const char *glsl_draw_fragshader_src =
//        "#version 130\n"
//        "out uvec4 FragColor;\n"
//        "void main()\n"
//        "{"
//        "  FragColor = uvec4(gl_Color.xyz * 255.0, 255.0);\n"
//        "}\n";
 
 
__global__ void DisplayerKernel(u_int8_t *u8x3_Data, unsigned int *g_odata, int w,int h)
{
 
    int x = blockIdx.x*blockDim.x;
    int y = blockIdx.y*blockDim.y;
    int xglobal = x+threadIdx.x;
    int yglobal = y+threadIdx.y;
 
 
    if(xglobal>=w/2 || yglobal >=h)
        return;
    int iptr        =  xglobal+ yglobal*w;
//    int iptr_rgb    =  xglobal*3+ yglobal*w*3;
//    u_int8_t u8_R   = u8x3_Data[iptr_rgb];
//    u_int8_t u8_G   = u8x3_Data[iptr_rgb+1];
//    u_int8_t u8_B   = u8x3_Data[iptr_rgb+2];
//    u_int8_t u8_A   = 0xFF;
 
    unsigned int val;
    val = ((float)threadIdx.x);
    g_odata[iptr]   = val<<16;// &*/ /*xglobal+yglobal*w/25.0*/;//(int(xglobal)<<24) |int(xglobal/w)<<16) | (int((float)yglobal/(float)h)<<8) | int(u8_R);
 
}
 
 
Displayer::Displayer(int iheight, int iwidth):
    // Blending_GPU(iwidth,iheight)
    iwidth_(iwidth),
    iheight_(iheight)
{
    //Init the GL context
    init();
}
 
 
Displayer::~Displayer()
{
    // free device memory
    std::cout << "Destroy Displayer " << std::endl;
}
 
 
 
void Displayer::display(u_int8_t* u8x3_rgbImage_Device)
{
 
    // run the Cuda kernel
    unsigned int *out_data;
 
    checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_dest_resource, 0));
    size_t num_bytes;
    checkCudaErrors(cudaGraphicsResourceGetMappedPointer((void **)&out_data, &num_bytes,
                                                         cuda_pbo_dest_resource));
 
    std::cout << "num_bytes " << num_bytes << std::endl;
 
    dim3 blocks(ceil((float)iwidth_ / ( BLOCK_SIZE_X)), ceil((float)iheight_ / BLOCK_SIZE_Y));
    dim3 threads(BLOCK_SIZE_X, BLOCK_SIZE_Y);
 
    DisplayerKernel<<<blocks,threads>>>(u8x3_rgbImage_Device,out_data,iwidth_,iheight_);
    checkCudaErrors(cudaGetLastError());
 
    checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_dest_resource, 0));
    glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo_dest);
 
    glBindTexture(GL_TEXTURE_2D, tex_cudaResult);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
                    iwidth_, iheight_,
                    GL_RGBA, GL_UNSIGNED_BYTE, NULL);
    glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
    glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
 
 
 
 
    ///////////////////////////////////////////////////
    /// Display texture
    glBindTexture(GL_TEXTURE_2D, tex_cudaResult);
    glEnable(GL_TEXTURE_2D);
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_LIGHTING);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
 
    glViewport(0, 0, iwidth_, iheight_);
 
    glUseProgram(shDrawTex);
    GLint id = glGetUniformLocation(shDrawTex, "texImage");
    glUniform1i(id, 0); // texture unit 0 to "texImage"
 
 
    glBegin(GL_QUADS);
    glTexCoord2f(0.0, 0.0);
    glVertex3f(-1.0, -1.0, 0.5);
    glTexCoord2f(1.0, 0.0);
    glVertex3f(1.0, -1.0, 0.5);
    glTexCoord2f(1.0, 1.0);
    glVertex3f(1.0, 1.0, 0.5);
    glTexCoord2f(0.0, 1.0);
    glVertex3f(-1.0, 1.0, 0.5);
    glEnd();
 
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
 
    glDisable(GL_TEXTURE_2D);
 
    glUseProgram(0);
 
 
    cudaDeviceSynchronize();
 
    // flip backbuffer
    glutSwapBuffers();
}
 
 
 
void Displayer::init()
{
 
    setenv ("DISPLAY", ":0", 0);
 
    /////////////////////////
    // Create GL context
    char *myargv[1];
    int myargc=1;
    myargv [0]= "BGEDisplayer";
    glutInit(&myargc, myargv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_ALPHA | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize(iwidth_, iheight_);
    iGLUTWindowHandle = glutCreateWindow("CUDA OpenGL post-processing");
 
    // initialize necessary OpenGL extensions
    glewInit();
 
    glClearColor(0.5, 0.5, 0.5, 1.0);
 
    glDisable(GL_DEPTH_TEST);
 
    // viewport
    glViewport(0, 0, iwidth_, iheight_);
 
    // projection
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0, (GLfloat)iwidth_ / (GLfloat) iheight_, 0.1f, 10.0f);
 
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
    glEnable(GL_LIGHT0);
    float red[] = { 1.0f, 0.1f, 0.1f, 1.0f };
    float white[] = { 1.0f, 1.0f, 1.0f, 1.0f };
    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, red);
    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0f);
 
    ////////////////////////
    ////createPBO
    // set up vertex data parameter
    int num_texels = iwidth_ * iheight_;
    int num_values = num_texels * 4;
    int size_tex_data = sizeof(GLubyte) * num_values;
    void *data = malloc(size_tex_data);
 
    // create buffer object
    glGenBuffers(1, &pbo_dest);
    glBindBuffer(GL_ARRAY_BUFFER, pbo_dest);
    glBufferData(GL_ARRAY_BUFFER, size_tex_data, data, GL_DYNAMIC_DRAW);
    free(data);
 
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    // register this buffer object with CUDA
    checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_pbo_dest_resource, pbo_dest , cudaGraphicsMapFlagsNone));
 
 
    /////////////////////////////
    //// createTextureDst
    // create a texture
    glGenTextures(1, &tex_cudaResult);
    glBindTexture(GL_TEXTURE_2D, tex_cudaResult);
 
    // set basic parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, iwidth_, iheight_, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
 
    // load shader programs
//    shDraw = compileGLSLprogram(NULL, glsl_draw_fragshader_src);
    shDrawTex = compileGLSLprogram(glsl_drawtex_vertshader_src, glsl_drawtex_fragshader_src);
 
 
 
    ////////////////////////////
    /// initCUDABuffers
    // set up vertex data parameter
    int inum_texels = iwidth_ * iheight_;
    int inum_values = inum_texels * 4;
    int isize_tex_data = sizeof(GLubyte) * inum_values;
    checkCudaErrors(cudaMalloc((void **)&cuda_dest_resource, isize_tex_data));
 
 
 
}
 
 
 
GLuint Displayer::compileGLSLprogram(const char *vertex_shader_src, const char *fragment_shader_src)
{
    GLuint v, f, p = 0;
 
    p = glCreateProgram();
 
    if (vertex_shader_src)
    {
        v = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(v, 1, &vertex_shader_src, NULL);
        glCompileShader(v);
 
        // check if shader compiled
        GLint compiled = 0;
        glGetShaderiv(v, GL_COMPILE_STATUS, &compiled);
 
        if (!compiled)
        {
            //#ifdef NV_REPORT_COMPILE_ERRORS
            char temp[256] = "";
            glGetShaderInfoLog(v, 256, NULL, temp);
            printf("Vtx Compile failed:\n%s\n", temp);
            //#endif
            glDeleteShader(v);
            return 0;
        }
        else
        {
            glAttachShader(p,v);
        }
    }
 
    if (fragment_shader_src)
    {
        f = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(f, 1, &fragment_shader_src, NULL);
        glCompileShader(f);
 
        // check if shader compiled
        GLint compiled = 0;
        glGetShaderiv(f, GL_COMPILE_STATUS, &compiled);
 
        if (!compiled)
        {
            //#ifdef NV_REPORT_COMPILE_ERRORS
            char temp[256] = "";
            glGetShaderInfoLog(f, 256, NULL, temp);
            printf("frag Compile failed:\n%s\n", temp);
            //#endif
            glDeleteShader(f);
            return 0;
        }
        else
        {
            glAttachShader(p,f);
        }
    }
 
    glLinkProgram(p);
 
    int infologLength = 0;
    int charsWritten  = 0;
 
    glGetProgramiv(p, GL_INFO_LOG_LENGTH, (GLint *)&infologLength);
 
    if (infologLength > 0)
    {
        char *infoLog = (char *)malloc(infologLength);
        glGetProgramInfoLog(p, infologLength, (GLsizei *)&charsWritten, infoLog);
        printf("Shader compilation error: %s\n", infoLog);
        free(infoLog);
    }
 
    return p;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#ifndef DISPLAYER_H
#define DISPLAYER_H
 
#include "../cuda/Global_var.h"
 
#include <cuda.h>
#include <cuda_runtime.h>
#include <stdio.h>
#include <iostream>
 
 
#include <GL/glew.h>
#include <GL/freeglut.h>
 
// CUDA includes
#include <cuda_runtime.h>
#include <cuda_gl_interop.h>
 
class Displayer//:public Blending_GPU
{
    int iwidth_;
    int iheight_;
    int iGLUTWindowHandle;          // handle to the GLUT window
 
    unsigned int *cuda_dest_resource;
    GLuint pbo_dest;
    cudaGraphicsResource *cuda_pbo_dest_resource;
    GLuint tex_cudaResult;  // where we will copy the CUDA result
 
 
    GLuint shDraw;
    GLuint shDrawTex;
public:
    /////////////////////////////
    /// \brief Blending::Blending
    /// \param rows
    /// \param cols
    ///
    Displayer(int iheight, int iwidth);
 
 
    ///////////////////////////////////
    /// \brief Blending::~Blending
    ///
    ~Displayer();
 
 
    /////////////
    /// \brief compileGLSLprogram
    /// \param vertex_shader_src
    /// \param fragment_shader_src
    /// \return
    ///
    GLuint compileGLSLprogram(const char *vertex_shader_src, const char *fragment_shader_src);
 
 
    ///////////////////////////////////
    /// \brief Displayer::run
    /// \param
    ///
    void display(u_int8_t *u8x3_rgbImage_Device);
 
    /////////////////
    /// \brief init
    ///
    void init();
 
};
 
 
#endif

[dragonjoker59]

Salut!

Dans une texture non HDR, dans le shader, la couleur max (en flottants) est 1.0.
Il nous faudrait plus d'informations sur "elle se sature à la valeur max."