GL4Dummies  0.1.7
Fonctions | Variables
Référence du fichier gl4dfCanny.c

filtre Canny à partir d'une texture ou l'écran vers une texture ou l'écran. Plus de détails...

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "gl4du.h"
#include "gl4df.h"
#include "gl4dfCommon.h"
Graphe des dépendances par inclusion de gl4dfCanny.c:

Aller au code source de ce fichier.

Fonctions

static void queueInit (int n)
 
static void queuePut (int i)
 
static int queueGet (void)
 
static int queueEmpty (void)
 
static void init (void)
 
static void quit (void)
 
 MKFWINIT3 (canny, void, GLuint, GLuint, GLboolean)
 
void gl4dfCanny (GLuint in, GLuint out, GLboolean flipV)
 Filtre 2D Canny (détection des contours) Plus de détails...
 
void gl4dfCannySetResultMode (GL4DFenum mode)
 Fonction liée au filtre Canny. Méthode de calcul du résultat final du Canny. Plus de détails...
 
void gl4dfCannySetMixMode (GL4DFenum mode)
 Fonction liée au filtre Canny. Méthode de combinaison du résultat final du Canny avec l'image d'origine. Plus de détails...
 
void gl4dfCannySetMixFactor (GLfloat factor)
 Fonction liée au filtre Canny. Modification du facteur de mix utilisé par le mode GL4DF_CANNY_MIX_ADD. Plus de détails...
 
void gl4dfCannySetThresholds (GLfloat lowTh, GLfloat highTh)
 Fonction liée au filtre Canny. Modification des seuils : bas (lowTh) et haut (highTh). Plus de détails...
 
static void cannyfinit (GLuint in, GLuint out, GLboolean flipV)
 
static void ccl (GLuint tex)
 
static void cannyffunc (GLuint in, GLuint out, GLboolean flipV)
 

Variables

static GLfloat _mixFactor = 0.5f
 
static GLfloat _lowTh = 0.37f
 
static GLfloat _highTh = 0.75f
 
static GLuint _cannyPId [3] = {0}
 
static GLuint _mixMode = 0
 
static GLuint _tempTexId [5] = {0}
 
static GLboolean _isLuminance = GL_FALSE
 
static GLboolean _isInvert = GL_FALSE
 
static int * _fifo = NULL
 
static int _head = -1
 
static int _queue = -1
 
static int _size = 0
 

Description détaillée

filtre Canny à partir d'une texture ou l'écran vers une texture ou l'écran.

Auteur
Farès BELHADJ amsi@.nosp@m.ai.u.nosp@m.niv-p.nosp@m.aris.nosp@m.8.fr
Date
March 08, 2019

Définition dans le fichier gl4dfCanny.c.

Documentation des fonctions

◆ cannyffunc()

static void cannyffunc ( GLuint  in,
GLuint  out,
GLboolean  flipV 
)
static
145  {
146  GLuint rout = out, fbo;
147  GLint vp[4], w, h, cfbo, ctex, cpId;
148  GLboolean dt = glIsEnabled(GL_DEPTH_TEST), bl = glIsEnabled(GL_BLEND);
149 #ifndef __GLES4D__
150  GLint polygonMode[2];
151  glGetIntegerv(GL_POLYGON_MODE, polygonMode);
152 #endif
153  glGetIntegerv(GL_VIEWPORT, vp);
154  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &cfbo);
155  glGetIntegerv(GL_TEXTURE_BINDING_2D, &ctex);
156  glGetIntegerv(GL_CURRENT_PROGRAM, &cpId);
157  if(in == 0) { /* Pas d'entrée, donc l'entrée est le dernier draw */
158  fcommMatchTex(in = _tempTexId[0], 0);
159  gl4dfConvFrame2Tex(&_tempTexId[0]);
160  } else if(in == out) {
161  fcommMatchTex(in = _tempTexId[0], out);
162  gl4dfConvTex2Tex(out, _tempTexId[0], GL_FALSE);
163  }
164  if(out == 0) { /* Pas de sortie, donc sortie aux dimensions du viewport */
165  w = vp[2];
166  h = vp[3];
167  fcommMatchTex(rout = _tempTexId[1], out);
168  } else {
169  glBindTexture(GL_TEXTURE_2D, out);
170  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
171  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
172  }
173  fcommMatchTex(_tempTexId[2], rout);
174  fcommMatchTex(_tempTexId[3], rout);
175  fcommMatchTex(_tempTexId[4], rout);
176 #ifndef __GLES4D__
177  glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
178 #endif
179  if(dt) glDisable(GL_DEPTH_TEST);
180  if(bl) glDisable(GL_BLEND);
181  glViewport(0, 0, w, h);
182  glGenFramebuffers(1, &fbo);
183  glBindFramebuffer(GL_FRAMEBUFFER, fbo); {
184  GLfloat step[] = {1.0f / (GLfloat)w, 1.0f / (GLfloat)h};
185  GLenum buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 };
186  glDrawBuffers(2, buffers);
187  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, _tempTexId[2], 0);
188  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, _tempTexId[3], 0);
189  glUseProgram(_cannyPId[0]);
190  glUniform1i(glGetUniformLocation(_cannyPId[0], "inv"), 0);
191  glUniform1i(glGetUniformLocation(_cannyPId[0], "myTexture"), 0);
192  glUniform2fv(glGetUniformLocation(_cannyPId[0], "step"), 1, step);
193  glActiveTexture(GL_TEXTURE0);
194  glBindTexture(GL_TEXTURE_2D, in);
195  gl4dgDraw(fcommGetPlane());
196  glBindTexture(GL_TEXTURE_2D, 0);
197  glDrawBuffers(1, buffers);
198 
199  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, _tempTexId[4], 0);
200  glUseProgram(_cannyPId[1]);
201  glUniform1i(glGetUniformLocation(_cannyPId[1], "len"), 0);
202  glUniform1i(glGetUniformLocation(_cannyPId[1], "dir"), 0);
203  glUniform1i(glGetUniformLocation(_cannyPId[1], "inv"), 0);
204  /* glUniform1i(glGetUniformLocation(_cannyPId[1], "inv"), flipV); */
205  glUniform2fv(glGetUniformLocation(_cannyPId[1], "step"), 1, step);
206  glUniform1f(glGetUniformLocation(_cannyPId[1], "lowTh"), _lowTh);
207  glUniform1f(glGetUniformLocation(_cannyPId[1], "highTh"), _highTh);
208  glActiveTexture(GL_TEXTURE0);
209  glBindTexture(GL_TEXTURE_2D, _tempTexId[2]);
210  glActiveTexture(GL_TEXTURE1);
211  glBindTexture(GL_TEXTURE_2D, _tempTexId[3]);
212  gl4dgDraw(fcommGetPlane());
213  glActiveTexture(GL_TEXTURE1);
214  glBindTexture(GL_TEXTURE_2D, 0);
215  glActiveTexture(GL_TEXTURE0);
216  glBindTexture(GL_TEXTURE_2D, 0);
217 
218  ccl(_tempTexId[4]);
219 
220  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rout, 0);
221  glUseProgram(_cannyPId[2]);
222  glUniform1i(glGetUniformLocation(_cannyPId[2], "len"), 0);
223  glUniform1i(glGetUniformLocation(_cannyPId[2], "orig"), 1);
224  glUniform1i(glGetUniformLocation(_cannyPId[2], "inv"), flipV);
225  glUniform1i(glGetUniformLocation(_cannyPId[2], "invResult"), _isInvert ? 1 : 0);
226  glUniform1i(glGetUniformLocation(_cannyPId[2], "luminance"), _isLuminance ? 1 : 0);
227  glUniform1i(glGetUniformLocation(_cannyPId[2], "mixMode"), _mixMode);
228  glUniform1f(glGetUniformLocation(_cannyPId[2], "mixFactor"), _mixFactor);
229  glActiveTexture(GL_TEXTURE0);
230  glBindTexture(GL_TEXTURE_2D, _tempTexId[4]);
231  glActiveTexture(GL_TEXTURE1);
232  glBindTexture(GL_TEXTURE_2D, in);
233  gl4dgDraw(fcommGetPlane());
234  glActiveTexture(GL_TEXTURE1);
235  glBindTexture(GL_TEXTURE_2D, 0);
236  glActiveTexture(GL_TEXTURE0);
237  glBindTexture(GL_TEXTURE_2D, 0);
238  }
239 
240  if(!out) { /* Copier à l'écran en cas de out nul */
241  glUseProgram(0);
242  glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
243  glBlitFramebuffer(0, 0, w, h, vp[0], vp[1], vp[0] + vp[2], vp[1] + vp[3], GL_COLOR_BUFFER_BIT, GL_LINEAR);
244  }
245  glViewport(vp[0], vp[1], vp[2], vp[3]);
246  glBindFramebuffer(GL_FRAMEBUFFER, (GLuint)cfbo);
247  glUseProgram(cpId);
248 #ifndef __GLES4D__
249  glPolygonMode(GL_FRONT_AND_BACK, polygonMode[0]);
250 #endif
251  if(bl) glEnable(GL_BLEND);
252  if(dt) glEnable(GL_DEPTH_TEST);
253  glDeleteFramebuffers(1, &fbo);
254 }

Références _cannyPId, _highTh, _isInvert, _isLuminance, _lowTh, _mixFactor, _mixMode, _tempTexId, ccl(), fcommGetPlane(), fcommMatchTex(), gl4dfConvFrame2Tex(), gl4dfConvTex2Tex(), gl4dgDraw(), et in().

Référencé par cannyfinit().

◆ cannyfinit()

static void cannyfinit ( GLuint  in,
GLuint  out,
GLboolean  flipV 
)
static
87  {
88  init();
89  cannyfptr = cannyffunc;
90  cannyfptr(in, out, flipV);
91 }

Références cannyffunc(), in(), et init().

Référencé par quit().

◆ ccl()

static void ccl ( GLuint  tex)
inlinestatic
93  {
94  /* CCL (Connected-Component Labeling) en CPU */
95  GLubyte *_pixmap = NULL, *_marks = NULL;
96  GLint w, h, wh, cc, i, lTh = _lowTh * 255, hTh = _highTh * 255;
97  glBindTexture(GL_TEXTURE_2D, tex);
98  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &w);
99  glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &h);
100  queueInit(w * h);
101  _pixmap = malloc(4 * w * h * sizeof *_pixmap);
102  assert(_pixmap);
103  _marks = calloc(4 * w * h, sizeof *_marks);
104  assert(_marks);
105  glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, _pixmap);
106  for(cc = 0, wh = 4 * w * h; cc < 4; ++cc) {
107  /* GLint d[] = {4, 4 - (w << 2), -(w << 2), -4 - (w << 2), -4, -4 + (w << 2), (w << 2), 4 + (w << 2)}, */
108  /* d2[][2] = {{1, 0}, {1, -1}, {0, -1}, {-1, -1}, {-1, 0}, {-1, 1}, {0, 1}, {1, 1}}; */
109  GLint d[] = {4, -(w << 2), -4, (w << 2)},
110  d2[][2] = {{1, 0}, {0, -1}, {-1, 0}, {0, 1}};
111  for(i = cc; i < wh; i += 4) {
112  if(!_marks[i] && _pixmap[i] >= hTh) {
113  _marks[i] = 2;
114  queuePut(i);
115  }
116  while(!queueEmpty()) {
117  GLint j, q = queueGet(), x, y;
118  x = (q >> 2); y = x / w; x = x % w;
119  for(j = 0; j < (GLint)(sizeof d / sizeof *d); ++j) {
120  GLint nx = x + d2[j][0], ny = y + d2[j][1], nq = q + d[j];
121  if(nx >= 0 && ny >= 0 && nx < w && ny < h &&
122  !_marks[nq]) {
123  if(_pixmap[nq] >= lTh) {
124  _marks[nq] = 2;
125  queuePut(nq);
126  } else
127  _marks[nq] = 1;
128  }
129  }
130  }
131  }
132  for(i = cc; i < wh; i += 4) {
133  if(_marks[i] < 2)
134  _pixmap[i] = 0;
135  else
136  _pixmap[i] = 255;//_pixmap[i] == 255 ? _pixmap[i] : 100;
137  }
138  }
139  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, _pixmap);
140  free(_pixmap);
141  free(_marks);
142 }

Références _highTh, _lowTh, queueEmpty(), queueGet(), queueInit(), et queuePut().

Référencé par cannyffunc().

◆ gl4dfCanny()

void gl4dfCanny ( GLuint  in,
GLuint  out,
GLboolean  flipV 
)

Filtre 2D Canny (détection des contours)

Paramètres
inidentifiant de texture source. Si 0, le framebuffer écran est pris à la place.
outidentifiant de texture destination. Si 0, la sortie s'effectuera à l'écran.
flipVindique s'il est nécessaire d'effectuer un mirroir vertical du résultat.
32  {
33  cannyfptr(in, out, flipV);
34 }

Références in().

◆ gl4dfCannySetMixFactor()

void gl4dfCannySetMixFactor ( GLfloat  factor)

Fonction liée au filtre Canny. Modification du facteur de mix utilisé par le mode GL4DF_CANNY_MIX_ADD.

Paramètres
factorfacteur de mélange compris entre 0 et 1
Voir également
gl4dfCannySetMixMode
77  {
78  _mixFactor = factor;
79 }

Références _mixFactor.

◆ gl4dfCannySetMixMode()

void gl4dfCannySetMixMode ( GL4DFenum  mode)

Fonction liée au filtre Canny. Méthode de combinaison du résultat final du Canny avec l'image d'origine.

Paramètres
modeindique les différents modes possibles. Plusieurs choix sont disponibles:
  • GL4DF_CANNY_MIX_NONE : le Canny est seul ;
  • GL4DF_CANNY_MIX_ADD : le Canny est pondéré et additionné à l'image d'origine (utilise la fonction GLSL mix). Le facteur de pondération est fixé par gl4dfCannySetMixFactor;
  • GL4DF_CANNY_MIX_MULT : le Canny est multiplié par l'image d'origine.
60  {
61  switch(mode) {
62  case GL4DF_CANNY_MIX_NONE:
63  _mixMode = 0;
64  break;
65  case GL4DF_CANNY_MIX_ADD:
66  _mixMode = 1;
67  break;
68  case GL4DF_CANNY_MIX_MULT:
69  _mixMode = 2;
70  break;
71  default:
72  fprintf(stderr, "%s: this value (%d) has no effect\n", __func__, mode);
73  break;
74  }
75 }

Références _mixMode, GL4DF_CANNY_MIX_ADD, GL4DF_CANNY_MIX_MULT, et GL4DF_CANNY_MIX_NONE.

◆ gl4dfCannySetResultMode()

void gl4dfCannySetResultMode ( GL4DFenum  mode)

Fonction liée au filtre Canny. Méthode de calcul du résultat final du Canny.

Paramètres
modeindique les différents modes possibles. Plusieurs choix sont disponibles:
  • GL4DF_CANNY_RESULT_RGB : le résultat du Canny est laissé inchangé (chaque composante contien son Canny) ;
  • GL4DF_CANNY_RESULT_INV_RGB : idem que la précédente avec une inversion (1.0 - s) ;
  • GL4DF_CANNY_RESULT_LUMINANCE : le résultat est transformé en Luminance sur les 3 composantes ;
  • GL4DF_CANNY_RESULT_INV_LUMINANCE : mode par défault, le résultat est l'inverse de la Luminance sur les 3 composantes.
36  {
37  switch(mode) {
38  case GL4DF_CANNY_RESULT_RGB:
39  _isLuminance = GL_FALSE;
40  _isInvert = GL_FALSE;
41  break;
42  case GL4DF_CANNY_RESULT_INV_RGB:
43  _isLuminance = GL_FALSE;
44  _isInvert = GL_TRUE;
45  break;
46  case GL4DF_CANNY_RESULT_LUMINANCE:
47  _isLuminance = GL_TRUE;
48  _isInvert = GL_FALSE;
49  break;
50  case GL4DF_CANNY_RESULT_INV_LUMINANCE:
51  _isLuminance = GL_TRUE;
52  _isInvert = GL_TRUE;
53  break;
54  default:
55  fprintf(stderr, "%s: this value (%d) has no effect\n", __func__, mode);
56  break;
57  }
58 }

Références _isInvert, _isLuminance, GL4DF_CANNY_RESULT_INV_LUMINANCE, GL4DF_CANNY_RESULT_INV_RGB, GL4DF_CANNY_RESULT_LUMINANCE, et GL4DF_CANNY_RESULT_RGB.

◆ gl4dfCannySetThresholds()

void gl4dfCannySetThresholds ( GLfloat  lowTh,
GLfloat  highTh 
)

Fonction liée au filtre Canny. Modification des seuils : bas (lowTh) et haut (highTh).

Paramètres
lowThseuil bas du filtre Canny
highThseuil haut du filtre Canny
81  {
82  _lowTh = lowTh / 4.0f; /* ??? */
83  _highTh = highTh / 4.0f; /* ??? */
84 }

Références _highTh, et _lowTh.

◆ init()

static void init ( void  )
static
256  {
257  GLint ctex;
258  GLuint i;
259  glGetIntegerv(GL_TEXTURE_BINDING_2D, &ctex);
260  if(!_tempTexId[0])
261  glGenTextures((sizeof _tempTexId / sizeof *_tempTexId), _tempTexId);
262  for(i = 0; i < (sizeof _tempTexId / sizeof *_tempTexId); ++i) {
263  glBindTexture(GL_TEXTURE_2D, _tempTexId[i]);
264  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
265  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
266  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
267  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
268  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
269  }
270  glBindTexture(GL_TEXTURE_2D, ctex);
271  if(!_cannyPId[0]) {
272  const char * imfs0 =
273  "<imfs>gl4df_canny0.fs</imfs>\n"
274 #ifdef __GLES4D__
275  "#version 300 es\n"
276 #else
277  "#version 330\n"
278 #endif
279  "uniform sampler2D myTexture;\n \
280  uniform vec2 step;\n \
281  in vec2 vsoTexCoord;\n \
282  layout (location = 0) out vec4 fragLen;\n \
283  layout (location = 1) out vec4 fragDir;\n \
284  const int ossize = 9;\n \
285  const float _2pi = 6.283;\n \
286  const vec2 G[ossize] = vec2[]( vec2(-1.0, -1.0), vec2(0.0, -2.0), vec2(1.0, -1.0),\n \
287  vec2(-2.0, 0.0), vec2(0.0, 0.0), vec2(2.0, 0.0),\n \
288  vec2(-1.0, 1.0), vec2(0.0, 2.0), vec2(1.0, 1.0) );\n \
289  vec2 offset[ossize] = vec2[](vec2(-step.x , -step.y), vec2( 0.0, -step.y), vec2( step.x , -step.y),\n \
290  vec2(-step.x, 0.0), vec2( 0.0, 0.0), vec2( step.x, 0.0),\n \
291  vec2(-step.x, step.y), vec2( 0.0, step.y), vec2( step.x , step.y) );\n \
292  void canny(in sampler2D s, in vec2 c, out vec4 len, out vec4 dir) {\n \
293  vec2 r = vec2(0.0, 0.0), g = vec2(0.0, 0.0), b = vec2(0.0, 0.0), a = vec2(0.0, 0.0);\n \
294  for(int i = 0; i < ossize; i++) {\n \
295  // ATTENTION ICI JE NE PRENDS QUE LE ROUGE - A MODIFIER\n \
296  vec4 t = texture(s, c + offset[i]);\n \
297  r += t.r * G[i];\n \
298  g += t.g * G[i];\n \
299  b += t.b * G[i];\n \
300  a += t.a * G[i];\n \
301  }\n \
302  len = vec4(length(r), length(g), length(b), length(a));\n \
303  dir = atan(vec4(r.y, g.y, b.y, a.y), vec4(r.x, g.x, b.x, a.x)) / _2pi;\n\
304  if(dir.x < 0.0) dir.x++;\n \
305  if(dir.y < 0.0) dir.y++;\n \
306  if(dir.z < 0.0) dir.z++;\n \
307  if(dir.w < 0.0) dir.w++;\n \
308  }\n \
309  void main(void) {\n \
310  vec4 len, dir;\n \
311  canny(myTexture, vsoTexCoord, len, dir);\n \
312  fragLen = len;\n \
313  fragDir = dir;\n \
314  }";
315  const char * imfs1 =
316  "<imfs>gl4df_canny1.fs</imfs>\n"
317 #ifdef __GLES4D__
318  "#version 300 es\n"
319 #else
320  "#version 330\n"
321 #endif
322  "uniform sampler2D len, dir;\n \
323  uniform vec2 step;\n \
324  uniform float lowTh, highTh;\n \
325  in vec2 vsoTexCoord;\n \
326  out vec4 fragColor;\n \
327  const float pi = 3.1415, _2pi = 6.283, pi_2 = 1.57075;\n \
328  void main(void) {\n \
329  vec4 l = texture(len, vsoTexCoord);\n \
330  vec4 d = texture(dir, vsoTexCoord) * _2pi;// + vec4(pi_2);\n \
331  for(int i = 0; i < 4; ++i) {\n \
332  if(l[i] >= lowTh) {\n \
333  vec4 dnc = texture(len, vsoTexCoord + 1.4142 * step * vec2(cos(d[i]), sin(d[i])));\n \
334  vec4 odnc = texture(len, vsoTexCoord + 1.4142 * step * vec2(cos(d[i] + pi), sin(d[i] + pi)));\n \
335  if(l[i] <= dnc[i] || l[i] <= odnc[i] /*|| (l[i] == dnc[i] && l[i] == odnc[i])*/) {\n \
336  l[i] = 0.0;\n \
337  }\n \
338  } else\n \
339  l[i] = 0.0;\n \
340  }\n \
341  fragColor = l;\n \
342  }";
343  const char * imfs2 =
344  "<imfs>gl4df_canny2.fs</imfs>\n"
345 #ifdef __GLES4D__
346  "#version 300 es\n"
347 #else
348  "#version 330\n"
349 #endif
350  "uniform sampler2D len, orig;\n \
351  uniform int invResult, luminance, mixMode;\n \
352  uniform float mixFactor;\n \
353  in vec2 vsoTexCoord;\n \
354  out vec4 fragColor;\n \
355  void main(void) {\n \
356  vec4 l = texture(len, vsoTexCoord);\n \
357  vec4 c = texture(orig, vsoTexCoord);\n \
358  if(invResult != 0)\n \
359  l = vec4(1) - l;\n \
360  if(luminance != 0)\n \
361  l = vec4(vec3(dot(vec3(0.299, 0.587, 0.114), l.rgb)), l.a);\n \
362  if(mixMode == 0)\n \
363  fragColor = l;\n \
364  else if(mixMode == 1)\n \
365  fragColor = mix(c, l, mixFactor);\n \
366  else\n \
367  fragColor = c * l;\n \
368  }";
369  _cannyPId[0] = gl4duCreateProgram(gl4dfBasicVS, imfs0, NULL);
370  _cannyPId[1] = gl4duCreateProgram(gl4dfBasicVS, imfs1, NULL);
371  _cannyPId[2] = gl4duCreateProgram(gl4dfBasicVS, imfs2, NULL);
372  gl4duAtExit(quit);
373  }
374 }

Références _cannyPId, _tempTexId, gl4dfBasicVS, gl4duAtExit(), gl4duCreateProgram(), et quit().

Référencé par cannyfinit().

◆ MKFWINIT3()

MKFWINIT3 ( canny  ,
void  ,
GLuint  ,
GLuint  ,
GLboolean   
)

◆ queueEmpty()

static int queueEmpty ( void  )
inlinestatic
412  {
413  return _head == _queue;
414 }

Références _head, et _queue.

Référencé par ccl().

◆ queueGet()

static int queueGet ( void  )
inlinestatic
409  {
410  return _fifo[++_head];
411 }

Références _fifo, et _head.

Référencé par ccl().

◆ queueInit()

static void queueInit ( int  n)
static
388  {
389  int * nfifo = NULL;
390  _head = _queue = -1;
391  if(n == 0) {
392  if(_fifo) free(_fifo);
393  _fifo = NULL; _size = 0;
394  return;
395  }
396  if(_size != n) {
397  _size = n;
398  nfifo = realloc(_fifo, n * sizeof *_fifo);
399  if(nfifo == NULL) {
400  queueInit(0);
401  assert(0);
402  }
403  _fifo = nfifo;
404  }
405 }

Références _fifo, _head, _queue, et _size.

Référencé par ccl(), et quit().

◆ queuePut()

static void queuePut ( int  i)
inlinestatic
406  {
407  _fifo[++_queue] = i;
408 }

Références _fifo, et _queue.

Référencé par ccl().

◆ quit()

static void quit ( void  )
static
376  {
377  if(_tempTexId[0]) {
378  glDeleteTextures((sizeof _tempTexId / sizeof *_tempTexId), _tempTexId);
379  _tempTexId[0] = 0;
380  queueInit(0);
381  }
382  _cannyPId[0] = 0;
383  cannyfptr = cannyfinit;
384 }

Références _cannyPId, _tempTexId, cannyfinit(), et queueInit().

Référencé par init().

Documentation des variables

◆ _cannyPId

GLuint _cannyPId[3] = {0}
static

Référencé par cannyffunc(), init(), et quit().

◆ _fifo

int* _fifo = NULL
static

Référencé par queueGet(), queueInit(), et queuePut().

◆ _head

int _head = -1
static

Référencé par queueEmpty(), queueGet(), et queueInit().

◆ _highTh

GLfloat _highTh = 0.75f
static

Référencé par cannyffunc(), ccl(), et gl4dfCannySetThresholds().

◆ _isInvert

GLboolean _isInvert = GL_FALSE
static

Référencé par cannyffunc(), et gl4dfCannySetResultMode().

◆ _isLuminance

GLboolean _isLuminance = GL_FALSE
static

Référencé par cannyffunc(), et gl4dfCannySetResultMode().

◆ _lowTh

GLfloat _lowTh = 0.37f
static

Référencé par cannyffunc(), ccl(), et gl4dfCannySetThresholds().

◆ _mixFactor

GLfloat _mixFactor = 0.5f
static

Référencé par cannyffunc(), et gl4dfCannySetMixFactor().

◆ _mixMode

GLuint _mixMode = 0
static

Référencé par cannyffunc(), et gl4dfCannySetMixMode().

◆ _queue

int _queue = -1
static

Référencé par queueEmpty(), queueInit(), et queuePut().

◆ _size

int _size = 0
static

Référencé par queueInit().

◆ _tempTexId

GLuint _tempTexId[5] = {0}
static

Référencé par cannyffunc(), init(), et quit().

cannyfinit
static void cannyfinit(GLuint in, GLuint out, GLboolean flipV)
Definition: gl4dfCanny.c:87
GL4DF_CANNY_RESULT_INV_LUMINANCE
@ GL4DF_CANNY_RESULT_INV_LUMINANCE
Definition: gl4df.h:43
gl4dfBasicVS
static const char * gl4dfBasicVS
Definition: gl4dfCommon.h:22
cannyffunc
static void cannyffunc(GLuint in, GLuint out, GLboolean flipV)
Definition: gl4dfCanny.c:145
GL4DF_CANNY_RESULT_LUMINANCE
@ GL4DF_CANNY_RESULT_LUMINANCE
Definition: gl4df.h:42
GL4DF_CANNY_MIX_NONE
@ GL4DF_CANNY_MIX_NONE
Definition: gl4df.h:44
_isLuminance
static GLboolean _isLuminance
Definition: gl4dfCanny.c:20
in
static int in(void *func, void **funcList, int n)
regarde si le pointeur func est un élément du tableau funcList
Definition: gl4dhAnimeManager.c:143
GL4DF_CANNY_MIX_ADD
@ GL4DF_CANNY_MIX_ADD
Definition: gl4df.h:45
_mixMode
static GLuint _mixMode
Definition: gl4dfCanny.c:19
gl4dfConvTex2Tex
GL4DAPI void GL4DAPIENTRY gl4dfConvTex2Tex(GLuint in, GLuint out, GLboolean flipV)
Copie la texture identifiée par in dans out. Le mode d'interpolation (par défaut GL_NEAREST) est à re...
Definition: gl4dfConversion.c:72
_cannyPId
static GLuint _cannyPId[3]
Definition: gl4dfCanny.c:19
GL4DF_CANNY_RESULT_RGB
@ GL4DF_CANNY_RESULT_RGB
Definition: gl4df.h:40
gl4dgDraw
void gl4dgDraw(GLuint id)
Dessine un objet-géométrie dont l'identifiant (référence) est passé en argument.
Definition: gl4dg.c:451
_mixFactor
static GLfloat _mixFactor
Definition: gl4dfCanny.c:18
ccl
static void ccl(GLuint tex)
Definition: gl4dfCanny.c:93
queuePut
static void queuePut(int i)
Definition: gl4dfCanny.c:406
_lowTh
static GLfloat _lowTh
Definition: gl4dfCanny.c:18
gl4duAtExit
void gl4duAtExit(void(*func)(void))
ajoute func dans la liste des fonctions à appeler lors du gl4duClean avec l'argument GL4DU_AT_EXIT ou...
Definition: gl4du.c:616
GL4DF_CANNY_RESULT_INV_RGB
@ GL4DF_CANNY_RESULT_INV_RGB
Definition: gl4df.h:41
_size
static int _size
Definition: gl4dfCanny.c:387
fcommMatchTex
void fcommMatchTex(GLuint goal, GLuint orig)
Definition: gl4dfCommon.c:45
_tempTexId
static GLuint _tempTexId[5]
Definition: gl4dfCanny.c:19
gl4dfConvFrame2Tex
GL4DAPI void GL4DAPIENTRY gl4dfConvFrame2Tex(GLuint *out)
Envoie le framebuffer actif (ou l'écran) vers une texture.
Definition: gl4dfConversion.c:21
_highTh
static GLfloat _highTh
Definition: gl4dfCanny.c:18
quit
static void quit(void)
Definition: gl4dfCanny.c:376
_isInvert
static GLboolean _isInvert
Definition: gl4dfCanny.c:20
init
static void init(void)
Definition: gl4dfCanny.c:256
GL4DF_CANNY_MIX_MULT
@ GL4DF_CANNY_MIX_MULT
Definition: gl4df.h:46
queueEmpty
static int queueEmpty(void)
Definition: gl4dfCanny.c:412
_queue
static int _queue
Definition: gl4dfCanny.c:387
queueInit
static void queueInit(int n)
Definition: gl4dfCanny.c:388
gl4duCreateProgram
GLuint gl4duCreateProgram(const char *firstone,...)
créé un program à partir d'une liste (variable) de nom de fichiers shaders et renvoie l'identifiant o...
Definition: gl4du.c:368
_head
static int _head
Definition: gl4dfCanny.c:387
fcommGetPlane
GLuint fcommGetPlane(void)
Definition: gl4dfCommon.c:65
queueGet
static int queueGet(void)
Definition: gl4dfCanny.c:409
_fifo
static int * _fifo
Definition: gl4dfCanny.c:387