Opengl 如何模糊图像的边缘

我想模糊图像的边缘，我采用的方法是将图像渲染到帧缓冲区，然后对其应用高斯模糊

然后我尝试将实际图像覆盖在模糊图像的顶部，但这种方法似乎不起作用

因为这不会在边缘周围产生模糊效果，但模糊图像会移开

请建议我实现这一点的方法，或者如果你能告诉我如何在片段着色器中实现这一点

代码

// Generate frame buffers
         glGenFramebuffers(2, pingpongFBO);
    glGenTextures(2, pingpongBuffer);
    for (unsigned int i = 0; i < 2; i++)
    {
        glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[i]);
        glBindTexture(GL_TEXTURE_2D, pingpongBuffer[i]);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, SCR_WIDTH, SCR_HEIGHT, 0, GL_RGBA,
            GL_FLOAT, NULL);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,pingpongBuffer[i],0);
    }


// blur the image
        bool horizontal = true, first_iteration = true;
        float blurValue = 6;
        GLint drawFrameBuffer;
        int amount = blurValue;
        shaderBlur.use();
        shaderBlur.setInt("image", 0);
        glDisable(GL_DEPTH_TEST);
        glActiveTexture(GL_TEXTURE0);
        glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[horizontal]);
        glClearColor(1.0, 1.0, 1.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT);
        glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[!horizontal]);
        glClearColor(1.0, 1.0, 1.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT);
        for (unsigned int i = 0; i < amount; i++)
        {
            shaderBlur.setInt("horizontal", horizontal);
            glBindFramebuffer(GL_FRAMEBUFFER, pingpongFBO[horizontal]);
            if (first_iteration)
            {
                glBindTexture(GL_TEXTURE_2D, image.textureID);
                glGenerateMipmap(GL_TEXTURE_2D);
            }
            else
            {
                glBindTexture(GL_TEXTURE_2D, pingpongBuffer[!horizontal]);
                glGenerateMipmap(GL_TEXTURE_2D);
            }
            renderQuadInner();
            horizontal = !horizontal;
            if (first_iteration)
                first_iteration = false;
        }   


   // Map the image
        shader.use();
        shader.setInt("u_tex", 0);
        glBindFramebuffer(GL_FRAMEBUFFER, 0); // the default frame buffer
        glClearColor(0.0, 0.0, 0.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT);               
        glBindTexture(GL_TEXTURE_2D, pingpongBuffer[horizontal]);  // the blurred image
        renderQuad(); 
        glBindTexture(GL_TEXTURE_2D, image.textureID);  // the actual image
        renderQuad();

//生成帧缓冲区
glGenFramebuffers（2个，pingpongFBO）；
玻璃纤维织物（2件，乒乓球垫）；
for（无符号整数i=0；i<2；i++）
{
glBindFramebuffer（GL_FRAMEBUFFER，pingpongFBO[i]）；
glBindTexture（GL_TEXTURE_2D，乒乓球垫[i]）；
GLTEXAGE2D（GL_纹理_2D，0，GL_RGBA16F，SCR_宽度，SCR_高度，0，GL_RGBA，
总账浮点数，空）；
glTexParameteri（GL_纹理2D、GL_纹理最小过滤器、GL_线性）；
glTexParameteri（GL_纹理2D、GL_纹理MAG_过滤器、GL_线性）；
glTexParameteri（GL_纹理_2D、GL_纹理_包裹、GL_夹紧_至_边缘）；
glTexParameteri（GL_纹理_2D、GL_纹理_包裹、GL_夹紧_至_边缘）；
glFramebufferTexture2D（GL_帧缓冲区、GL_颜色附件0、GL_纹理2D、乒乓球缓冲[i]，0）；
}
//模糊图像
布尔水平=真，第一次迭代=真；
浮点数=6；
闪烁帧缓冲区；
整数金额=模糊值；
shaderBlur.use（）；
shaderBlur.setInt（“图像”，0）；
glDisable（GLU深度测试）；
玻璃纹理（GL_纹理0）；
glBindFramebuffer（GL_FRAMEBUFFER，pingpongFBO[horizontal]）；
glClearColor（1.0,1.0,1.0,0.0）；
glClear（GLU颜色缓冲位）；
glBindFramebuffer（GL_FRAMEBUFFER，pingpongFBO[！horizontal]）；
glClearColor（1.0,1.0,1.0,0.0）；
glClear（GLU颜色缓冲位）；
for（无符号整数i=0；i

模糊着色器

#version 330 core
out vec4 FragColor;
in vec2 TexCoords;
uniform sampler2D image;
uniform bool horizontal;
float offset[3] = float[]( 0.0, 1.3846153846, 3.2307692308 );
uniform float weight[3] = float[] (0.2270270270, 0.316216162, 0.0702702703);

void main()
{             
    vec2 tex_offset = 3.0 / textureSize(image, 0); // gets size of single texel
    vec4 result = texture(image, TexCoords).rgba * weight[0];
    vec2 uv = TexCoords.xy;
     if(horizontal)
     {
         for(int i = 1; i < 3; ++i)
         {
            result += texture(image, TexCoords + vec2(tex_offset.x * i, 0.0)).rgba * weight[i];
            result += texture(image, TexCoords - vec2(tex_offset.x * i, 0.0)).rgba * weight[i];
         
         }
     }
     else
     {
         for(int i = 1; i < 3; ++i)
         {
             result += texture(image, TexCoords + vec2(0.0, tex_offset.y * i)).rgba * weight[i];
             result += texture(image, TexCoords - vec2(0.0, tex_offset.y * i)).rgba * weight[i];  
         }
     }
     FragColor = vec4(result);
}

#版本330核心
out vec4 FragColor；
在vec2-TexCoords中；
二维图像的均匀采样；
均匀布尔水平；
浮动偏移量[3]=浮动[]（0.0,1.3846153846,3.2307692308）；
均匀浮子重量[3]=浮子[]（0.22702700,0.316216162,0.0702702703）；
void main（）
{             
vec2 tex_offset=3.0/textureSize（图像，0）；//获取单个texel的大小
vec4结果=纹理（图像，TexCoords）.rgba*权重[0]；
vec2 uv=TexCoords.xy；
如果（水平）
{
对于（int i=1；i<3；++i）
{
结果+=纹理（图像，TexCoords+vec2（tex_offset.x*i，0.0））.rgba*权重[i]；
结果+=纹理（图像，TexCoords-vec2（tex_offset.x*i，0.0））.rgba*权重[i]；
}
}
其他的
{
对于（int i=1；i<3；++i）
{
结果+=纹理（图像，TexCoords+vec2（0.0，tex_offset.y*i））.rgba*权重[i]；
结果+=纹理（图像，TexCoords-vec2（0.0，tex_offset.y*i））.rgba*权重[i]；
}
}
FragColor=vec4（结果）；
}

您所采取的方法非常正确，但是，您的实现可能存在一些问题。请共享一个最小的可复制代码，以便我们可以看到问题所在。@codetiger我已更新了代码。请检查此示例，如果偏移量正确，它可以正常工作@Summit，您能为我做一个测试吗？修改模糊着色器，使其仅输出纹理图像，而不进行任何奇特的效果和渲染。显示结果，或者至少让我们知道图像是否仍在移动。i、 e just do

FragColor=纹理（图像，TexCoords）

然后，您发送到gpu的顶点数据在两个渲染之间似乎存在差异。您所采取的方法非常正确，但是，您的实现可能存在一些问题。请共享一个最小的可复制代码，以便我们可以看到问题所在。@codetiger我已更新了代码。请检查此示例，如果偏移量正确，它可以正常工作@Summit，您能为我做一个测试吗？修改模糊着色器，使其仅输出纹理图像，而不进行任何奇特的效果和渲染。显示结果，或者至少让我们知道图像是否仍在移动。i、 e just do

FragColor=纹理（图像，TexCoords）然后，在两个渲染之间发送到gpu的顶点数据似乎有差异。