精华内容
下载资源
问答
  • 运动模糊

    2019-09-17 16:21:05
    运动模糊效果是指物体移动时,会拖带一个尾巴。通过颜色混合,可以实现这种效果。实现原理就是每隔一小段位移以某种alpha值重复绘制物体, 通过与前面画的物体进行颜色混合来实现模糊的效果。 混合因子选择如下: ...

    运动模糊效果是指物体移动时,会拖带一个尾巴。通过颜色混合,可以实现这种效果。实现原理就是每隔一小段位移以某种alpha值重复绘制物体, 通过与前面画的物体进行颜色混合来实现模糊的效果。

    混合因子选择如下:

    S因子:GL_SRC_ALPHA

    D因子:GL_ONE

     

    实例代码如下:

     

    public class MyRenderer implements Renderer {
    
    	private Square square1 = null;
    
    	private static final float M_PI = 3.14159265358979323846f;
    	private static final float blur_detail = 24;
    
    	private float x = -2.0f;
    
    	public MyRenderer(Context ctx) {
    		square1 = new Square(ctx, false);
    
    	}
    
    	@Override
    	public void onDrawFrame(GL10 gl) {
    
    		gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
    		// Replace the current matrix with the identity matrix
    		gl.glMatrixMode(GL10.GL_MODELVIEW);
    		gl.glLoadIdentity();
    
    		if (x > 2.0f)
    			x = -2.0f;
    		x += 0.05f;
    
    		gl.glPushMatrix();
    
    		float ball_alpha = 1 / blur_detail;
    
    		gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE);
    		gl.glTranslatef(x, 0, 0);
    
    		for (int i = 0; i < blur_detail; ++i) {
    			gl.glTranslatef(0.5f / blur_detail, 0, -0.5f / blur_detail);
    
    			/* comment the following line for quick but boring linear blur */
    			ball_alpha = (float) (Math.sin((M_PI / blur_detail) * i) / blur_detail);
    
    			gl.glColor4f(1, 1, 1, ball_alpha);
    			square1.draw(gl);
    
    		}
    
    		gl.glPopMatrix();
    
    	}
    
    	@Override
    	public void onSurfaceChanged(GL10 gl, int width, int height) {
    		float ratio = (float) width / height;
    		gl.glMatrixMode(GL10.GL_PROJECTION);
    		gl.glLoadIdentity();
    		GLU.gluPerspective(gl, 45, ratio, 0.01f, 100);
    		GLU.gluLookAt(gl, 0, 0, -5, 0, 0, 0, 0, 1, 0);
    		gl.glMatrixMode(GL10.GL_MODELVIEW);
    		gl.glLoadIdentity();
    	}
    
    	@Override
    	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
    		// TODO Auto-generated method stub
    		gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    		// Enable Smooth Shading, default not really needed.
    		gl.glShadeModel(GL10.GL_SMOOTH);
    		gl.glEnable(GL10.GL_BLEND);
    		gl.glBlendFunc(GL10.GL_ONE, GL10.GL_ONE_MINUS_SRC_ALPHA);
    
    	}
    
    }


     

    转载于:https://my.oschina.net/fuyajun1983cn/blog/263967

    展开全文
  • 运动模糊图像恢复算法的研究 学生: 学号: 指导老师: 2007年5月26日 一. 研究背景 二. 本文的主要工作 三. 运动模糊图像的形成 四. 运动模糊图像的复原算法 五. 实验结果和对比分析 六. 总结与展望 简介 一. 研究背景...
  • 视觉追踪运动模糊

    2021-03-03 03:30:51
    视觉追踪运动模糊
  • OpenGL运动模糊

    2021-03-20 15:40:40
    OpenGL运动模糊OpenGL运动模糊简介源代码剖析主要源代码 OpenGL运动模糊简介 模糊(运动模糊)是用于快速3D游戏的一种非常流行的技术,其思想是向运动的对象添加模糊。这增强了玩家的真实感。可以用几种方法进行模糊...

    OpenGL运动模糊简介

    模糊(运动模糊)是用于快速3D游戏的一种非常流行的技术,其思想是向运动的对象添加模糊。这增强了玩家的真实感。可以用几种方法进行模糊处理。可能是基于相机运动的模糊相机,也可能是基于对象的模糊相机。在本教程中,我们将介绍一种实现。

    模糊背后的想法是,我们可以为2帧之间的每个渲染像素计算运动矢量。从当前颜色缓冲区中沿该向量取平均值,我们得到代表相应对象运动的像素。就这样。让我们深入研究细节。下面是所需步骤的简要说明,之后我们将继续进行代码本身。

    该方法分为2个阶段-渲染阶段和模糊阶段。
    在渲染过程中,我们渲染到2个缓冲区-常规颜色缓冲区和运动矢量缓冲区。彩色缓冲区存储原始图像,就好像没有模糊一样。运动向量是每个像素的向量,实际上是在当前帧和先前帧之间在屏幕上移动它。
    通过将前一帧的WVP矩阵应用于VS来计算运动矢量。我们使用当前的WVP和上一个WVP将每个顶点的位置从本地空间转换为将两个结果都传递给FS的时间。我们将在FS的裁剪器空间中获取插值位置,然后将它们除以相应的W坐标,将其转换为NDC,这样就完成了它们在屏幕上的投影,现在我们可以从当前位置减去前一个位置并获得运动矢量。矢量将被写入纹理。
    模糊渲染是通过渲染矩形以填充屏幕来实现的。我们为FS中的每个像素获取一个运动矢量,然后沿着该矢量从颜色缓冲区中获取颜色(从当前像素开始)。
    我们计算每个样本的总和,为当前像素分配最大的权重,为最远的像素分配最小的权重(这是本课中的实现,但还有其他事情)。
    这是沿运动矢量的样本结果的平均值,并产生模糊效果。显然,帧之间位置不变的像素看起来与以前相同,这就是我们想要的。

    源代码剖析

    virtual void RenderSceneCB()
    {
        CalcFPS();
     
        m_pGameCamera->OnRender();
     
            RenderPass();
     
            MotionBlurPass();
     
        RenderFPS();
     
        glutSwapBuffers();
    }
    

    这是主要的渲染功能,非常简单。我们为场景中的所有对象提供了渲染通道,并为模糊提供了后处理通道。

    void RenderPass()
    {
            m_intermediateBuffer.BindForWriting();
     
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     
        m_pSkinningTech->Enable();
     
        vector<matrix4f> Transforms;
     
        float RunningTime = (float)((double)GetCurrentTimeMillis() - (double)m_startTime) / 1000.0f;
     
        m_mesh.BoneTransform(RunningTime, Transforms);
     
        for (uint i = 0 ; i < Transforms.size() ; i++) {
            m_pSkinningTech->SetBoneTransform(i, Transforms[i]);
                m_pSkinningTech->SetPrevBoneTransform(i, m_prevTransforms[i]);
        }
     
        m_pSkinningTech->SetEyeWorldPos(m_pGameCamera->GetPos());
     
        m_pipeline.SetCamera(m_pGameCamera->GetPos(),
        m_pGameCamera->GetTarget(), m_pGameCamera->GetUp());
        m_pipeline.SetPerspectiveProj(m_persProjInfo);
        m_pipeline.Scale(0.1f, 0.1f, 0.1f);
     
        Vector3f Pos(m_position);
        m_pipeline.WorldPos(Pos);
        m_pipeline.Rotate(270.0f, 180.0f, 0.0f);
        m_pSkinningTech->SetWVP(m_pipeline.GetWVPTrans());
        m_pSkinningTech->SetWorldMatrix(m_pipeline.GetWorldTrans());
     
        m_mesh.Render();
     
            m_prevTransforms = Transforms;
    }
    

    这是我们的渲染过程。它与“骨骼动画”教程中的几乎相同。中间缓冲区是一个简单的类,可将颜色,深度和运动矢量缓冲区存储在单个帧缓冲区中。我们已经在有关延迟渲染的教程(#35-#37)中看到了这一点,因此我们不再赘述。有关详细信息,请参见源代码。这个想法是在FBO中呈现的,而不是直接呈现在屏幕上。在模糊传递中,我们将从中间缓冲区读取。

    除此之外,我们可以看到。我们在’Tutorial41’类中添加了一个类属性,用于存储前一帧的骨骼转换向量。我们将其提供给具有当前骨骼转换的蒙皮方法。我们将看到它如何在GLSL代码中使用。

    void MotionBlurPass()
    {
        m_intermediateBuffer.BindForReading();
     
        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
     
        m_pMotionBlurTech->Enable();
     
        m_quad.Render();
    }
    

    在模糊过程中,我们绑定一个中间读取缓冲区(即渲染将在屏幕上进行),然后将矩形渲染为全屏。屏幕的每个像素将被处理1次,此时将计算模糊效果。

    struct VSInput
    {
        vec3  Position;
        vec2  TexCoord;
        vec3  Normal;
        ivec4 BoneIDs;
        vec4  Weights;
    };
     
    interface VSOutput
    {
        vec2 TexCoord;
        vec3 Normal;
        vec3 WorldPos;
     
            vec4 ClipSpacePos;
            vec4 PrevClipSpacePos;
    };
     
    const int MAX_BONES = 100;
     
    uniform mat4 gWVP;
    uniform mat4 gWorld;
    uniform mat4 gBones[MAX_BONES];
        uniform mat4 gPrevBones[MAX_BONES];
     
    shader VSmain(in VSInput VSin:0, out VSOutput VSout)
    {
        mat4 BoneTransform = gBones[VSin.BoneIDs[0]] * VSin.Weights[0];
        BoneTransform     += gBones[VSin.BoneIDs[1]] * VSin.Weights[1];
        BoneTransform     += gBones[VSin.BoneIDs[2]] * VSin.Weights[2];
        BoneTransform     += gBones[VSin.BoneIDs[3]] * VSin.Weights[3];
     
        vec4 PosL      = BoneTransform * vec4(VSin.Position, 1.0);
        vec4 ClipSpacePos = gWVP * PosL;
        gl_Position    = ClipSpacePos;
        VSout.TexCoord = VSin.TexCoord;
        vec4 NormalL   = BoneTransform * vec4(VSin.Normal, 0.0);
        VSout.Normal   = (gWorld * NormalL).xyz;
        VSout.WorldPos = (gWorld * PosL).xyz;
     
        mat4 PrevBoneTransform = gPrevBones[VSin.BoneIDs[0]] * VSin.Weights[0];
        PrevBoneTransform     += gPrevBones[VSin.BoneIDs[1]] * VSin.Weights[1];
        PrevBoneTransform     += gPrevBones[VSin.BoneIDs[2]] * VSin.Weights[2];
        PrevBoneTransform     += gPrevBones[VSin.BoneIDs[3]] * VSin.Weights[3];
     
        VSout.ClipSpacePos = ClipSpacePos;
        vec4 PrevPosL      = PrevBoneTransform * vec4(VSin.Position, 1.0);
        VSout.PrevClipSpacePos = gWVP * PrevPosL;
    }
    

    上面,我们看到了蒙皮算法中VS的变化。我们在前一帧中添加了具有骨变换的统一数组,它将用于查找前一帧中Clipper空间中当前顶点的位置。该位置以及当前顶点在当前帧中的裁剪器空间中的位置将被传输到FS。

    struct FSOutput
    {
        vec3 Color;
        vec2 MotionVector;
    };
     
    shader FSmain(in VSOutput FSin, out FSOutput FSOut)
    {
        VSOutput1 In;
        In.TexCoord = FSin.TexCoord;
        In.Normal = normalize(FSin.Normal);
        In.WorldPos = FSin.WorldPos;
     
        vec4 TotalLight = CalcDirectionalLight(In);
     
        for (int i = 0 ; i < gNumPointLights ; i++) {
            TotalLight += CalcPointLight(gPointLights[i], In);
        }
     
        for (int i = 0 ; i < gNumSpotLights ; i++) {
            TotalLight += CalcSpotLight(gSpotLights[i], In);
        }
     
        vec4 Color = texture(gColorMap, In.TexCoord) * TotalLight;
        FSOut.Color = Color.xyz;
        vec3 NDCPos = (FSin.ClipSpacePos / FSin.ClipSpacePos.w).xyz;
        vec3 PrevNDCPos = (FSin.PrevClipSpacePos / FSin.PrevClipSpacePos.w).xyz;
        FSOut.MotionVector = (NDCPos - PrevNDCPos).xy;
    }
    

    蒙皮技术的FS已更新,现在将2个矢量输出到2个单独的缓冲区(颜色和运动矢量缓冲区)中。颜色是照常计算的。为了计算运动矢量,我们通过透视划分投影当前帧和前一帧的裁剪器空间中的位置,并从另一个中减去一个。

    请注意,位置向量只是2D向量。这是由于他仅在屏幕上“生活”的事实。使用类型GL_RG创建匹配的模糊缓冲区以进行匹配。

    struct VSInput
    {
        vec3  Position;
        vec2  TexCoord;
    };
     
    interface VSOutput
    {
        vec2 TexCoord;
    };
     
     
    shader VSmain(in VSInput VSin:0, out VSOutput VSout)
    {
        gl_Position    = vec4(VSin.Position, 1.0);
        VSout.TexCoord = VSin.TexCoord;
    }
    

    这是VS模糊技术。我们只需传递全屏矩形每个顶点的文本的位置和坐标即可。

    uniform sampler2D gColorTexture;
    uniform sampler2D gMotionTexture;
     
    shader FSmain(in VSOutput FSin, out vec4 FragColor)
    {
          vec2 MotionVector = (texture(gMotionTexture, FSin.TexCoord).xy) / 2.0f;
     
          vec4 Color = vec4(0.0);
     
          vec2 TexCoord = FSin.TexCoord;
     
          Color += texture(gColorTexture, TexCoord) * 0.4;
          TexCoord -= MotionVector;
          Color += texture(gColorTexture, TexCoord) * 0.3;
          TexCoord -= MotionVector;
          Color += texture(gColorTexture, TexCoord) * 0.2;
          TexCoord -= MotionVector;
          Color += texture(gColorTexture, TexCoord) * 0.1;
     
          FragColor = Color;
    }
    

    那就是模糊的乐趣所在。我们从当前像素获取运动矢量,并使用它从颜色缓冲区中获取4个纹理像素。当前像素的颜色取自原始位置,并获得最高权重(0.4)。接下来,我们沿着与运动矢量方向相反的纹理坐标移动,并选择3个以上的纹理像素。接下来,我们通过减少和减少移除时的重量来组合它们。

    您可能已经注意到,我将原始运动矢量除以2。您可能需要进行一些微调,包括调整权重以获得最佳效果。玩得开心。

    可能结果的示例:
    在这里插入图片描述

    主要源代码

    #include <math.h>
    #include <GL/glew.h>
    #include <GL/freeglut.h>
    #include <string>
    #ifndef WIN32
    #include <sys/time.h>
    #include <unistd.h>
    #endif
    #include <sys/types.h>
    
    #include "ogldev_engine_common.h"
    #include "ogldev_app.h"
    #include "ogldev_util.h"
    #include "ogldev_pipeline.h"
    #include "ogldev_camera.h"
    #include "skinning_technique.h"
    #include "motion_blur_technique.h"
    #include "ogldev_glut_backend.h"
    #include "ogldev_skinned_mesh.h"
    #include "intermediate_buffer.h"
    
    using namespace std;
    
    #define WINDOW_WIDTH  1280  
    #define WINDOW_HEIGHT 1024
    
    class Tutorial41 : public ICallbacks, public OgldevApp
    {
    public:
    
        Tutorial41() 
        {
            m_pGameCamera = NULL;
            m_pSkinningTech = NULL;
            m_pMotionBlurTech = NULL;
            m_directionalLight.Color = Vector3f(1.0f, 1.0f, 1.0f);
            m_directionalLight.AmbientIntensity = 0.66f;
            m_directionalLight.DiffuseIntensity = 1.0f;
            m_directionalLight.Direction = Vector3f(1.0f, 0.0, 0.0);
    
            m_persProjInfo.FOV = 60.0f;
            m_persProjInfo.Height = WINDOW_HEIGHT;
            m_persProjInfo.Width = WINDOW_WIDTH;
            m_persProjInfo.zNear = 1.0f;
            m_persProjInfo.zFar = 100.0f;  
            
            m_position = Vector3f(0.0f, 0.0f, 6.0f);      
        }
    
        ~Tutorial41()
        {
            SAFE_DELETE(m_pSkinningTech);
            SAFE_DELETE(m_pMotionBlurTech);
            SAFE_DELETE(m_pGameCamera);
        }    
    
        bool Init()
        {
            Vector3f Pos(0.0f, 3.0f, -1.0f);
            Vector3f Target(0.0f, 0.0f, 1.0f);
            Vector3f Up(0.0, 1.0f, 0.0f);
    
            m_pGameCamera = new Camera(WINDOW_WIDTH, WINDOW_HEIGHT, Pos, Target, Up);
            
            if (!m_intermediateBuffer.Init(WINDOW_WIDTH, WINDOW_HEIGHT)) {
                printf("Error initializing the intermediate buffer\n");
                return false;
            }
          
            m_pSkinningTech = new SkinningTechnique();
    
            if (!m_pSkinningTech->Init()) {
                printf("Error initializing the skinning technique\n");
                return false;
            }
    
            m_pSkinningTech->Enable();
    
            m_pSkinningTech->SetColorTextureUnit(COLOR_TEXTURE_UNIT_INDEX);
            m_pSkinningTech->SetDirectionalLight(m_directionalLight);
            m_pSkinningTech->SetMatSpecularIntensity(0.0f);
            m_pSkinningTech->SetMatSpecularPower(0);
    
            m_pMotionBlurTech = new MotionBlurTechnique();
    
            if (!m_pMotionBlurTech->Init()) {
                printf("Error initializing the motion blur technique\n");
                return false;
            }
            
            m_pMotionBlurTech->Enable();
            m_pMotionBlurTech->SetColorTextureUnit(COLOR_TEXTURE_UNIT_INDEX);
            m_pMotionBlurTech->SetMotionTextureUnit(MOTION_TEXTURE_UNIT_INDEX);
    
            if (!m_mesh.LoadMesh("../Content/boblampclean.md5mesh")) {
                printf("Mesh load failed\n");
                return false;            
            }
            
            m_mesh.BoneTransform(0.0f, m_prevTransforms);
    
            if (!m_quad.LoadMesh("../Content/quad_r.obj")) {
                printf("Quad mesh load failed\n");
                return false;            
            }
            
    #ifdef FREETYPE
            if (!m_fontRenderer.InitFontRenderer()) {
                return false;
            }
    #endif        	      
            return true;
        }
    
        void Run()
        {
            GLUTBackendRun(this);
        }
        
    
        virtual void RenderSceneCB()
        {   
            CalcFPS();
                  
            m_pGameCamera->OnRender();
    
            RenderPass();
            
            MotionBlurPass();
                                  
            RenderFPS();       
            
            glutSwapBuffers();
        }
        
        void RenderPass()
        {
            m_intermediateBuffer.BindForWriting();
    
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
            m_pSkinningTech->Enable();
            
            vector<Matrix4f> Transforms;
                   
            float RunningTime = GetRunningTime();
    
            m_mesh.BoneTransform(RunningTime, Transforms);
            
            for (uint i = 0 ; i < Transforms.size() ; i++) {
                m_pSkinningTech->SetBoneTransform(i, Transforms[i]);
                m_pSkinningTech->SetPrevBoneTransform(i, m_prevTransforms[i]);
            }                
                   
            m_pSkinningTech->SetEyeWorldPos(m_pGameCamera->GetPos());
            
            m_pipeline.SetCamera(m_pGameCamera->GetPos(), m_pGameCamera->GetTarget(), m_pGameCamera->GetUp());
            m_pipeline.SetPerspectiveProj(m_persProjInfo);           
            m_pipeline.Scale(0.1f, 0.1f, 0.1f);                
                 
            Vector3f Pos(m_position);
            m_pipeline.WorldPos(Pos);        
            m_pipeline.Rotate(270.0f, 180.0f, 0.0f);       
            m_pSkinningTech->SetWVP(m_pipeline.GetWVPTrans());
            m_pSkinningTech->SetWorldMatrix(m_pipeline.GetWorldTrans());            
           
            m_mesh.Render();        
            
            m_prevTransforms = Transforms;
        }
        
        
        void MotionBlurPass()
        {
            m_intermediateBuffer.BindForReading();
    
            glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    
            m_pMotionBlurTech->Enable();
           
            m_quad.Render();
        }
    
    
        virtual void KeyboardCB(OGLDEV_KEY OgldevKey)
        {
            switch (OgldevKey) {
            case OGLDEV_KEY_ESCAPE:
            case OGLDEV_KEY_q:
                    GLUTBackendLeaveMainLoop();
                    break;
            default:
                    m_pGameCamera->OnKeyboard(OgldevKey);
            }
        }
    
    
        virtual void PassiveMouseCB(int x, int y)
        {
            m_pGameCamera->OnMouse(x, y);
        }
        
        
    private:
            
        SkinningTechnique* m_pSkinningTech;
        MotionBlurTechnique* m_pMotionBlurTech;
        Camera* m_pGameCamera;
        DirectionalLight m_directionalLight;
        SkinnedMesh m_mesh;
        SkinnedMesh m_quad;
        Vector3f m_position;            
        PersProjInfo m_persProjInfo;
        IntermediateBuffer m_intermediateBuffer;
        Pipeline m_pipeline;
        vector<Matrix4f> m_prevTransforms;
    };
    
    
    int main(int argc, char** argv)
    {
        Magick::InitializeMagick(*argv);
        GLUTBackendInit(argc, argv, true, false);
    
        if (!GLUTBackendCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, false, "Tutorial 41")) {
            return 1;
        }
        
        SRANDOM;
        
        Tutorial41* pApp = new Tutorial41();
    
        if (!pApp->Init()) {
            return 1;
        }
        
        pApp->Run();
    
        delete pApp;
     
        return 0;
    }
    
    展开全文
  • 基于辐照度的运动模糊图像去模糊
  • 摘 要 : 运动模糊图片的频谱中存在平行的零点直线 。这里提出了一种算法 , 识别零点直线含 有的运动模糊方向和模糊度信息 : 首先对模糊图像进行分块 , 然后将分成的小块相加 , 利用拉氏算 子对最后的相加结果进行无...
  • 原标题:OpenCV+Python实现图像运动模糊和高斯模糊运动模糊:由于相机和物体之间的相对运动造成的模糊,又称为动态模糊OpenCV+Python实现运动模糊,主要用到的函数是cv2.filter2D:# coding: utf-8importnumpy ...

    原标题:OpenCV+Python实现图像运动模糊和高斯模糊

    运动模糊:由于相机和物体之间的相对运动造成的模糊,又称为动态模糊

    OpenCV+Python实现运动模糊,主要用到的函数是cv2.filter2D:

    # coding: utf-8

    importnumpy asnp

    importcv2

    defmotion_blur(image, degree= 12, angle= 45):

    image = np.array(image)

    # 这里生成任意角度的运动模糊kernel的矩阵, degree越大,模糊程度越高

    M = cv2.getRotationMatrix2D((degree / 2, degree / 2), angle, 1)

    motion_blur_kernel = np.diag(np.ones(degree))

    motion_blur_kernel = cv2.warpAffine(motion_blur_kernel, M, (degree, degree))

    motion_blur_kernel = motion_blur_kernel / degree

    blurred = cv2.filter2D(image, - 1, motion_blur_kernel)

    # convert to uint8

    cv2.normalize(blurred, blurred, 0, 255, cv2.NORM_MINMAX)

    blurred = np.array(blurred, dtype=np.uint8)

    returnblurred

    img = cv2.imread( 'linuxidc.com.jpg')

    img_ = motion_blur(img)

    cv2.imshow( 'Source image',img)

    cv2.imshow( 'blur image',img_)

    cv2.waitKey

    原图与运动模糊效果如下:

    高斯模糊:图像与二维高斯分布的概率密度函数做卷积,模糊图像细节

    OpenCV+Python实现高斯模糊,主要用到的函数是cv2.GaussianBlur:

    # coding: utf-8

    importnumpy asnp

    importcv2

    img = cv2.imread( 'linuxidc.com.jpg')

    img_ = cv2.GaussianBlur(img, ksize=( 9, 9), sigmaX= 0, sigmaY= 0)

    cv2.imshow( 'Source image',img)

    cv2.imshow( 'blur image',img_)

    cv2.waitKey

    高斯模糊效果如下:

    责任编辑:

    展开全文
  • 一种运动模糊图像的模糊参数估计方法
  • Unity Shader实现运动模糊(一) : 摄像机运动产生模糊-附件资源
  • 一种运动模糊图像的鲁棒运动估计策略
  • Unity3d 径向模糊-运动模糊2 shader
  • 运动模糊图像经典复原算法
  • 识别运动模糊的虹膜图像
  • 运动模糊:由于相机和物体之间的相对运动造成的模糊,又称为动态模糊 Opencv+Python实现运动模糊,主要用到的函数是cv2.filter2D(): # coding: utf-8 import numpy as np import cv2 def motion_blur(image, ...
  • 单幅运动模糊图像去模糊研究 单幅运动模糊图像去模糊研究
  • 运动模糊及复原

    2017-06-08 22:04:53
    运动模糊的相关知识,及图像复原方法的总结
  • Java 运动模糊

    2019-09-25 13:06:04
    Java 运动模糊代码 想用Java 写个运动模糊的效果,无奈本人水平有限,国内也没找到资源,于是Google到了一个文档,特地分享出来! 本代码源自 http://www.jhlabs.com/ip/blurring.html Java运动模糊算法: import ...

    Java 运动模糊代码

    想用Java 写个运动模糊的效果,无奈本人水平有限,国内也没找到资源,于是Google到了一个文档,特地分享出来!

    本代码源自 http://www.jhlabs.com/ip/blurring.html

    Java运动模糊算法:

    import java.awt.*;
    import java.awt.geom.*;
    import java.awt.image.*;
    
    public class MotionBlurOp extends AbstractBufferedImageOp {
        private float centreX = 0.5f, centreY = 0.5f;
        private float distance=20.0f;                //这里设置运动距离
        private float angle;
        private float rotation;
        private float zoom;
    
        public MotionBlurOp() {
        }
    
        public MotionBlurOp( float distance, float angle, float rotation, float zoom ) {
            this.distance = distance;
            this.angle = angle;
            this.rotation = rotation;
            this.zoom = zoom;
        }
    
        public void setAngle( float angle ) {
            this.angle = angle;
        }
    
        public float getAngle() {
            return angle;
        }
    
        public void setDistance( float distance ) {
            this.distance = distance;
        }
    
        public float getDistance() {
            return distance;
        }
    
        public void setRotation( float rotation ) {
            this.rotation = rotation;
        }
    
        public float getRotation() {
            return rotation;
        }
    
        public void setZoom( float zoom ) {
            this.zoom = zoom;
        }
    
        public float getZoom() {
            return zoom;
        }
    
        public void setCentreX( float centreX ) {
            this.centreX = centreX;
        }
    
        public float getCentreX() {
            return centreX;
        }
    
        public void setCentreY( float centreY ) {
            this.centreY = centreY;
        }
    
        public float getCentreY() {
            return centreY;
        }
    
        public void setCentre( Point2D centre ) {
            this.centreX = (float)centre.getX();
            this.centreY = (float)centre.getY();
        }
    
        public Point2D getCentre() {
            return new Point2D.Float( centreX, centreY );
        }
    
        private int log2( int n ) {
            int m = 1;
            int log2n = 0;
    
            while (m < n) {
                m *= 2;
                log2n++;
            }
            return log2n;
        }
    
        public BufferedImage filter( BufferedImage src, BufferedImage dst ) {
            if ( dst == null )
                dst = createCompatibleDestImage( src, null );
            BufferedImage tsrc = src;
            float cx = (float)src.getWidth() * centreX;
            float cy = (float)src.getHeight() * centreY;
            float imageRadius = (float)Math.sqrt( cx*cx + cy*cy );
            float translateX = (float)(distance * Math.cos( angle ));
            float translateY = (float)(distance * -Math.sin( angle ));
            float scale = zoom;
            float rotate = rotation;
            float maxDistance = distance + Math.abs(rotation*imageRadius) + zoom*imageRadius;
            int steps = log2((int)maxDistance);
    
            translateX /= maxDistance;
            translateY /= maxDistance;
            scale /= maxDistance;
            rotate /= maxDistance;
    
            if ( steps == 0 ) {
                Graphics2D g = dst.createGraphics();
                g.drawRenderedImage( src, null );
                g.dispose();
                return dst;
            }
    
            BufferedImage tmp = createCompatibleDestImage( src, null );
            for ( int i = 0; i < steps; i++ ) {
                Graphics2D g = tmp.createGraphics();
                g.drawImage( tsrc, null, null );
                g.setRenderingHint( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
                g.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR );
                g.setComposite( AlphaComposite.getInstance( AlphaComposite.SRC_OVER, 0.5f ) );
    
                g.translate( cx+translateX, cy+translateY );
                g.scale( 1.0001+scale, 1.0001+scale );  // The .0001 works round a bug on Windows where drawImage throws an ArrayIndexOutofBoundException
                if ( rotation != 0 )
                    g.rotate( rotate );
                g.translate( -cx, -cy );
    
                g.drawImage( dst, null, null );
                g.dispose();
                BufferedImage ti = dst;
                dst = tmp;
                tmp = ti;
                tsrc = dst;
    
                translateX *= 2;
                translateY *= 2;
                scale *= 2;
                rotate *= 2;
            }
            return dst;
        }
    
        public String toString() {
            return "Blur/Motion Blur...";
        }
    }

    测试代码:

    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.io.IOException;
    
    /**
     * Created by zdmein on 2018/1/10.
     */
    public class MotionBlurOpTest {
        public static void main(String [] args) throws IOException {
            BufferedImage sourceImage = ImageIO.read(new File("flower.jpg"));
            MotionBlurOp filter=new MotionBlurOp();
            BufferedImage destImage=filter.filter(sourceImage,null);
            ImageIO.write(destImage, "PNG", new File("MotionBlurOpflower.jpg"));
    
        }
    }
    

    原图
    Motion

    转载于:https://www.cnblogs.com/daminzhou/p/8257551.html

    展开全文
  • 运动模糊综述

    千次阅读 2019-03-27 15:41:12
    运动模糊是相机,物体,背景间相对运动造成的效果,可以借助移动镜头追踪移动的物体来避免 影响因素 影响模糊的参数主要是:1,角度,0~360度,不同角度会造成不同模糊类型,2,长度,长度为移动多少间隔的像素 ...
  • 运动模糊是指快速运动的物体造成明显的模糊拖动痕迹;以简单的直线运动为例,运动模糊应该具有两个参数,分别是半径长度和角度;比如在Sketch中如下:但是 CSS、Canvas、SVG 的滤镜均不支持运动模糊。那是不是意味着...
  • 基于模糊路径下反卷积的运动模糊图像快速恢复方法
  • 运动模糊matlab编程

    2013-06-15 22:01:55
    运动模糊matlab编程 如何采用matlab编程得到运动模糊恢复的图像
  • 多帧超分辨率处理运动模糊
  • 单幅图像运动模糊

    2014-12-30 11:53:02
    单幅图像运动模糊,支持曝光时间,运动长度设置。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,846
精华内容 738
关键字:

运动模糊