1GLCONVOLUTIONFILTER2(3G) OpenGL Manual GLCONVOLUTIONFILTER2(3G)
2
6 glConvolutionFilter2D - define a two-dimensional convolution filter
7
9 void glConvolutionFilter2D(GLenum target, GLenum internalformat,
10 GLsizei width, GLsizei height,
11 GLenum format, GLenum type,
12 const GLvoid * data);
13
15 target
16 Must be GL_CONVOLUTION_2D.
17 internalformat
19 The internal format of the convolution filter kernel. The allowable
20 values are GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16,
21 GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12,
22 GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4,
23 GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4,
24 GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY,
25 GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16,
26 GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12,
27 GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8,
28 GL_RGB10_A2, GL_RGBA12, or GL_RGBA16.
29 width
31 The width of the pixel array referenced by data.
32 height
34 The height of the pixel array referenced by data.
35 format
37 The format of the pixel data in data. The allowable values are
38 GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA,
39 GL_BGRA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA.
40 type
42 The type of the pixel data in data. Symbolic constants
43 GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT,
44 GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2,
45 GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5,
46 GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4,
47 GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1,
48 GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8,
49 GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2, and
50 GL_UNSIGNED_INT_2_10_10_10_REV are accepted.
51 data
53 Pointer to a two-dimensional array of pixel data that is processed
54 to build the convolution filter kernel.
55
57 glConvolutionFilter2D builds a two-dimensional convolution filter
58 kernel from an array of pixels.
59 The pixel array specified by width, height, format, type, and data is
61 extracted from memory and processed just as if glDrawPixels() were
62 called, but processing stops after the final expansion to RGBA is
63 completed.
64 If a non-zero named buffer object is bound to the
66 GL_PIXEL_UNPACK_BUFFER target (see glBindBuffer()) while a convolution
67 filter is specified, data is treated as a byte offset into the buffer
68 object's data store.
69 The R, G, B, and A components of each pixel are next scaled by the four
71 2D GL_CONVOLUTION_FILTER_SCALE parameters and biased by the four 2D
72 GL_CONVOLUTION_FILTER_BIAS parameters. (The scale and bias parameters
73 are set by glConvolutionParameter() using the GL_CONVOLUTION_2D target
74 and the names GL_CONVOLUTION_FILTER_SCALE and
75 GL_CONVOLUTION_FILTER_BIAS. The parameters themselves are vectors of
76 four values that are applied to red, green, blue, and alpha, in that
77 order.) The R, G, B, and A values are not clamped to [0,1] at any time
78 during this process.
79 Each pixel is then converted to the internal format specified by
81 internalformat. This conversion simply maps the component values of the
82 pixel (R, G, B, and A) to the values included in the internal format
83 (red, green, blue, alpha, luminance, and intensity). The mapping is as
84 follows:
85 ┌─────────────────────────────────┬─────────────────────────────┬───────────────────────────────┬──────────────────────────────┬───────────────────────────────┬───────────────────────────────────┬───────────────────────────────────┐
87 │ │ │ │ │ │ │ │
88 │ Internal │ Red │ Green │ Blue │ Alpha │ Luminance │ Intensity │
89 │Format │ │ │ │ │ │ │
90 │ │ │ │ │ │ │ │
91 ├─────────────────────────────────┼─────────────────────────────┼───────────────────────────────┼──────────────────────────────┼───────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┤
92 │GL_ALPHA │ │ │ │ A │ │ │
93 ├─────────────────────────────────┼─────────────────────────────┼───────────────────────────────┼──────────────────────────────┼───────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┤
94 │GL_LUMINANCE │ │ │ │ │ R │ │
95 ├─────────────────────────────────┼─────────────────────────────┼───────────────────────────────┼──────────────────────────────┼───────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┤
96 │GL_LUMINANCE_ALPHA │ │ │ │ A │ R │ │
97 ├─────────────────────────────────┼─────────────────────────────┼───────────────────────────────┼──────────────────────────────┼───────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┤
98 │GL_INTENSITY │ │ │ │ │ │ R │
99 ├─────────────────────────────────┼─────────────────────────────┼───────────────────────────────┼──────────────────────────────┼───────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┤
100 │GL_RGB │ R │ G │ B │ │ │ │
101 ├─────────────────────────────────┼─────────────────────────────┼───────────────────────────────┼──────────────────────────────┼───────────────────────────────┼───────────────────────────────────┼───────────────────────────────────┤
102 │GL_RGBA │ R │ G │ B │ A │ │ │
103 └─────────────────────────────────┴─────────────────────────────┴───────────────────────────────┴──────────────────────────────┴───────────────────────────────┴───────────────────────────────────┴───────────────────────────────────┘
104 The red, green, blue, alpha, luminance, and/or intensity components of
106 the resulting pixels are stored in floating-point rather than integer
107 format. They form a two-dimensional filter kernel image indexed with
108 coordinates i and j such that i starts at zero and increases from left
109 to right, and j starts at zero and increases from bottom to top. Kernel
110 location i,j is derived from the Nth pixel, where N is i+j*width.
111 Note that after a convolution is performed, the resulting color
113 components are also scaled by their corresponding
114 GL_POST_CONVOLUTION_c_SCALE parameters and biased by their
115 corresponding GL_POST_CONVOLUTION_c_BIAS parameters (where c takes on
116 the values RED, GREEN, BLUE, and ALPHA). These parameters are set by
117 glPixelTransfer().
118
120 glConvolutionFilter2D is present only if ARB_imaging is returned when
121 glGetString() is called with an argument of GL_EXTENSIONS.
122
124 GL_INVALID_ENUM is generated if target is not GL_CONVOLUTION_2D.
125 GL_INVALID_ENUM is generated if internalformat is not one of the
127 allowable values.
128 GL_INVALID_ENUM is generated if format is not one of the allowable
130 values.
131 GL_INVALID_ENUM is generated if type is not one of the allowable
133 values.
134 GL_INVALID_VALUE is generated if width is less than zero or greater
136 than the maximum supported value. This value may be queried with
137 glGetConvolutionParameter() using target GL_CONVOLUTION_2D and name
138 GL_MAX_CONVOLUTION_WIDTH.
139 GL_INVALID_VALUE is generated if height is less than zero or greater
141 than the maximum supported value. This value may be queried with
142 glGetConvolutionParameter() using target GL_CONVOLUTION_2D and name
143 GL_MAX_CONVOLUTION_HEIGHT.
144 GL_INVALID_OPERATION is generated if height is one of
146 GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV,
147 GL_UNSIGNED_SHORT_5_6_5, or GL_UNSIGNED_SHORT_5_6_5_REV and format is
148 not GL_RGB.
149 GL_INVALID_OPERATION is generated if height is one of
151 GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV,
152 GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV,
153 GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV,
154 GL_UNSIGNED_INT_10_10_10_2, or GL_UNSIGNED_INT_2_10_10_10_REV and
155 format is neither GL_RGBA nor GL_BGRA.
156 GL_INVALID_OPERATION is generated if a non-zero buffer object name is
158 bound to the GL_PIXEL_UNPACK_BUFFER target and the buffer object's data
159 store is currently mapped.
160 GL_INVALID_OPERATION is generated if a non-zero buffer object name is
162 bound to the GL_PIXEL_UNPACK_BUFFER target and the data would be
163 unpacked from the buffer object such that the memory reads required
164 would exceed the data store size.
165 GL_INVALID_OPERATION is generated if a non-zero buffer object name is
167 bound to the GL_PIXEL_UNPACK_BUFFER target and data is not evenly
168 divisible into the number of bytes needed to store in memory a datum
169 indicated by type.
170 GL_INVALID_OPERATION is generated if glConvolutionFilter2D is executed
172 between the execution of glBegin() and the corresponding execution of
173 glEnd().
174
176 glGetConvolutionParameter(), glGetConvolutionFilter()
177
179 glConvolutionFilter1D(), glSeparableFilter2D(),
180 glConvolutionParameter(), glPixelTransfer()
181
183 Copyright © 1991-2006 Silicon Graphics, Inc. This document is licensed
184 under the SGI Free Software B License. For details, see
185 http://oss.sgi.com/projects/FreeB/.
186
188 opengl.org
189opengl.org 07/13/2018 GLCONVOLUTIONFILTER2(3G)