C++ 亮度滤波器opengl中的彩色噪声

我的最终目标是检测照片中的激光线。为此，首先我将RGB颜色空间转换为HSV（以检查亮度）。然后，我将仅选择具有特定H、S和V值的像素（具有特定颜色的最亮像素（在我的示例中为红色））

满足这些值的像素我为RGB的所有3个通道设置它们的亮度，如果它们不满足，我将它们设置为黑色

我的问题来了：

正如我提到的，我会有一个黑色像素或灰色（亮度）像素。我不明白这些紫色或绿色像素是怎么进入我的图片的。它们就像噪音一样，不断变化！ 起初，我认为我有这些颜色是因为值大于1。但我认为OpenGL将值限制为0-1（我自己也尝试过，但没有成功）

有人知道是什么导致了这种效果吗？ 任何帮助或想法都将不胜感激

这是我的片段着色器：

precision highp float;

varying vec2 textureCoordinate;

uniform sampler2D inputImageTexture;


const highp vec3 W = vec3(0.299, 0.587, 0.114);


void main()
{
 lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);

 float luminance = dot(textureColor.rgb, W);

 float r = textureColor.r;
 float g = textureColor.g;
 float b = textureColor.b;
 float h;
 float s;
 float v;

 float min = 0.0;
 float max = 0.0;
 float delta = 0.0;

 if(r >= g) {
     if(r >= b) {
         max = r;
     }
     else {
         max = b;
     }
 }
 else {
     if(g >= b) {
         max = g;
     }
     else {
         max = b;
     }
 }

 // max = MAX( r, g, b );
 if(r < g) {
     if(r < b) {
         min = r;
     }
     else {
         min = b;
     }
 }
 else {
     if(g < b) {
         min = g;
     }
     else {
         min = b;
     }
 }


 v = max;                // v
 delta = max - min;

 if (delta == 0.0) {
     h = 0.0;
     s = 0.0;
     return;
 }
 else if( max != 0.0 )
     s = delta / max;        // s
 else {
     // r = g = b = 0        // s = 0, v is undefined
     s = 0.0;
     h = -1.0;
     return;
 }
 if( r == max ){
     h = ( g - b ) / delta;         // between yellow & magenta

     h = mod(h, 6.0);
 }
 else if( g == max )
     h = 2.0 + ( b - r ) / delta;    // between cyan & yellow
 else
     h = 4.0 + ( r - g ) / delta;    // between magenta & cyan


 h = h * 60.0;                // degrees

 if( h < 0.0 )
     h = h + 360.0;
 //HSV transformation ends here
 if(v >0.8){
     if(s > 0.7){
         if( h >320.0  && h < 360.0){

             if(luminance  > 1.0)
                 gl_FragColor = vec4(vec3(1.0), textureColor.a);
             else
                 gl_FragColor = vec4(vec3(luminance ), textureColor.a);
         }

     }
 }else{
     gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
 }
}

高精度浮点；
可变矢量2纹理坐标；
均匀的二维纹理；
常量高p vec3 W=vec3（0.299,0.587,0.114）；
void main（）
{
lowp vec4 textureColor=texture2D（输入图像纹理，纹理坐标）；
浮动亮度=点（textureColor.rgb，W）；
浮动r=纹理颜色.r；
float g=textureColor.g；
浮动b=纹理颜色.b；
浮动h；
浮子；
浮动v；
浮动最小值=0.0；
浮动最大值=0.0；
浮动增量=0.0；
如果（r>=g）{
如果（r>=b）{
max=r；
}
否则{
max=b；
}
}
否则{
如果（g>=b）{
最大值=g；
}
否则{
max=b；
}
}
//max=max（r，g，b）；
if（r0.8）{
如果（s>0.7）{
如果（h>320.0&&h<360.0）{
如果（亮度>1.0）
gl_FragColor=vec4（vec3（1.0），textureColor.a）；
其他的
gl_FragColor=vec4（vec3（亮度），纹理颜色.a）；
}
}
}否则{
gl_FragColor=vec4（0.0,0.0,0.0,1.0）；
}
}

---

我必须提到的是，大白点是阳光，它是如此明亮，它通过我的HSV条件在最后。这不是我现在的问题，但是这些紫色的噪声像像素一样存在，或者图片周围的绿色噪声是我的问题

紫色和绿色像素可能是未初始化的内存

gl_FragColor不能保证在着色器开始时初始化，因此在第70行和第78行的返回语句之前初始化它应该可以解决这个问题

如果没有，并且使用了未初始化的帧缓冲区，则可能是因为另一个原因（可能性较小）：

• 这可能是因为混合。尝试禁用它或确保gl_FragColor.a为1
• 这可能是因为模具缓冲区正在将其公开。尝试禁用模具测试或确保所有像素都通过模具测试

或者，如果它是由模具测试的混合引起的，则可以使用类似glClear（）的东西初始化帧缓冲区

当片段“返回”而不设置片段颜色时，如下所示：

 else {
     // r = g = b = 0        // s = 0, v is undefined
     s = 0.0;
     h = -1.0;
     return; //<<<<==== NO gl_FragColor set

else{
//r=g=b=0//s=0，v未定义
s=0.0；
h=-1.0；
return；//因此我的错误是我返回了一些地方，但没有设置gl_FragColor。在我的情况下，任何地方的流程失败或不符合我必须设置的条件：

gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);

更正后的代码应如下所示：

precision highp float;

varying vec2 textureCoordinate;

uniform sampler2D inputImageTexture;

const highp vec3 W = vec3(0.299, 0.587, 0.114);

void main()
{
 lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);
 float luminance = dot(textureColor.rgb, W);

 //RF: test
 float r = textureColor.r;
 float g = textureColor.g;
 float b = textureColor.b;
 float h;
 float s;
 float v;

 float min = 0.0;
 float max = 0.0;
 float delta = 0.0;

 // min = MIN( r, g, b );
 if(r >= g) {
     if(r >= b) {
         max = r;
     }
     else {
         max = b;
     }
 }
 else {
     if(g >= b) {
         max = g;
     }
     else {
         max = b;
     }
 }

 if(r < g) {
     if(r < b) {
         min = r;
     }
     else {
         min = b;
     }
 }
 else {
     if(g < b) {
         min = g;
     }
     else {
         min = b;
     }
 }


 v = max;                // v
 delta = max - min;

 if (delta == 0.0) {
     h = 0.0;
     s = 0.0;
     gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
     return;
 }
 else if( max != 0.0 )
     s = delta / max;        // s
 else {
     s = 0.0;
     h = -1.0;
     gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
     return;
 }
 if( r == max ){
     h = ( g - b ) / delta;         // between yellow & magenta

     h = mod(h, 6.0);
 }
 else if( g == max )
     h = 2.0 + ( b - r ) / delta;    // between cyan & yellow
 else
     h = 4.0 + ( r - g ) / delta;    // between magenta & cyan
 h = h * 60.0;                // degrees
 if( h < 0.0 )
     h = h + 360.0;
 //---------------------------------------------------

 if(v >0.8){
     if(s > 0.2){
         if( h >320.0  && h < 360.0){
             gl_FragColor = vec4(vec3(luminance ), textureColor.a);
             return;
         }
     }
 }
 gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
}

高精度浮点；
可变矢量2纹理坐标；
均匀的二维纹理；
常量高p vec3 W=vec3（0.299,0.587,0.114）；
void main（）
{
lowp vec4 textureColor=texture2D（输入图像纹理，纹理坐标）；
浮动亮度=点（textureColor.rgb，W）；
//射频：测试
浮动r=纹理颜色.r；
float g=textureColor.g；
浮动b=纹理颜色.b；
浮动h；
浮子；
浮动v；
浮动最小值=0.0；
浮动最大值=0.0；
浮动增量=0.0；
//min=min（r，g，b）；
如果（r>=g）{
如果（r>=b）{
max=r；
}
否则{
max=b；
}
}
否则{
如果（g>=b）{
最大值=g；
}
否则{
max=b；
}
}
if（r0.8）{
如果（s>0.2）{
如果（h>320.0&&h<360.0）{
gl_FragColor=vec4（vec3（亮度），纹理颜色.a）；
返回；
precision highp float;

varying vec2 textureCoordinate;

uniform sampler2D inputImageTexture;

const highp vec3 W = vec3(0.299, 0.587, 0.114);

void main()
{
 lowp vec4 textureColor = texture2D(inputImageTexture, textureCoordinate);
 float luminance = dot(textureColor.rgb, W);

 //RF: test
 float r = textureColor.r;
 float g = textureColor.g;
 float b = textureColor.b;
 float h;
 float s;
 float v;

 float min = 0.0;
 float max = 0.0;
 float delta = 0.0;

 // min = MIN( r, g, b );
 if(r >= g) {
     if(r >= b) {
         max = r;
     }
     else {
         max = b;
     }
 }
 else {
     if(g >= b) {
         max = g;
     }
     else {
         max = b;
     }
 }

 if(r < g) {
     if(r < b) {
         min = r;
     }
     else {
         min = b;
     }
 }
 else {
     if(g < b) {
         min = g;
     }
     else {
         min = b;
     }
 }


 v = max;                // v
 delta = max - min;

 if (delta == 0.0) {
     h = 0.0;
     s = 0.0;
     gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
     return;
 }
 else if( max != 0.0 )
     s = delta / max;        // s
 else {
     s = 0.0;
     h = -1.0;
     gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
     return;
 }
 if( r == max ){
     h = ( g - b ) / delta;         // between yellow & magenta

     h = mod(h, 6.0);
 }
 else if( g == max )
     h = 2.0 + ( b - r ) / delta;    // between cyan & yellow
 else
     h = 4.0 + ( r - g ) / delta;    // between magenta & cyan
 h = h * 60.0;                // degrees
 if( h < 0.0 )
     h = h + 360.0;
 //---------------------------------------------------

 if(v >0.8){
     if(s > 0.2){
         if( h >320.0  && h < 360.0){
             gl_FragColor = vec4(vec3(luminance ), textureColor.a);
             return;
         }
     }
 }
 gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
}