精华内容
下载资源
问答
  • 图像锐化算法

    热门讨论 2013-10-01 13:08:18
    图像锐化算法算法比较厉害,能处理的更清晰,是我见过的最好的锐化算法。免费下载!
  • MATLAB 实现数字图像锐化处理 摘要讨论了数字图像增强技术中空域图像锐化四种算法及其用MATLAB实现同时给出了利用四种算法进行图像锐化后对照图像 比较实验结果可知运用算法锐化处理后图像比原来图像清晰 ...
  • 在经典拉普拉斯图像锐化中,所有像素都被一一处理,这导致大量计算。 在CPU上进行传统拉普拉斯锐化处理非常耗时,特别是对于那些大图片。 在本文中,我们提出了基于Compute Unified Device Architecture(CUDA...
  • 之前一段我们提到的算法都是和平滑有关, 经过平滑算法之后, 图像锐度降低, 降低到一定程度, 就变成了模糊。 今天我们反其道行之, 我们看看锐化是怎么做的。 这里的锐化, 还是的从平滑谈开去。我们先来观察原来...

    http://blog.csdn.net/ebowtang/article/details/38961399

    之前一段我们提到的算法都是和平滑有关, 经过平滑算法之后, 图像锐度降低, 降低到一定程度, 就变成了模糊。 今天我们反其道行之, 我们看看锐化是怎么做的。 这里的锐化, 还是的从平滑谈开去。我们先来观察原来的图像和平滑图像的区别:

    原图 raw:

     raw

    模糊图 blur:

     blur

    _________________________________________________________

    源图像减去模糊图像等于 锐化后的边缘mask效果:

     mask        

    这个时候, 我们发现,减法做完的这个图赫然勾勒出了原图的边缘!! 这样给我们一个启示就是, 如果我们把这个mask加到原图上那岂不就是锐化了? (不明白? 锐化的意思就是边缘的色差比较大, 产生的图片貌似清晰的效果) 说干就干, 马上我们来做个新的算式:

    老图 raw:

      raw

    加上mask

      mask

    _______________________________________________________

    等于锐化图  sharpen

      sharp

    怎么样, 是不是有了锐化的效果了??所以我们实际上的锐化效果就是从这么简单的想法衍生出来的。 所以锐化的公式可以简单的表述为 sharp = raw + ( raw-blur ); 再来看看我们原来的高斯模版的话就是这样:

    formula

    这样的话, 我们的锐化算法,也变得和之前的高斯平滑差不多了, 就是像素的加权平均值的计算就可以得到了。可以想见的事情是代码肯定也会出奇的一致! 这是那个template改掉了:

     

    [html] view plain copy
     
     print?
    1. void sharpenImage  (unsigned char* gray, unsigned char* smooth, int width, int height)    
    2. {    
    3.         
    4.     int templates[25] = { -1, -4, -7, -4, -1,     
    5.         -4, -16, -26, -16, -4,     
    6.         -7, -26, 505, -26, -7,    
    7.         -4, -16, -26, -16, -4,     
    8.         -1, -4, -7, -4, -1 };           
    9.     memcpy ( smooth, gray, width*height*sizeof(unsigned char) );    
    10.     for (int j=2;j<height-2;j++)    
    11.     {    
    12.         for (int i=2;i<width-2;i++)    
    13.         {    
    14.             int sum = 0;    
    15.             int index = 0;    
    16.             for ( int m=j-2; m<j+3; m++)    
    17.             {    
    18.                 for (int n=i-2; n<i+3; n++)    
    19.                 {    
    20.                     sum += gray [ m*width + n] * templates[index++] ;    
    21.                 }    
    22.             }    
    23.             sum /= 273;    
    24.             if (sum > 255)    
    25.                 sum = 255;    
    26.             if (sum <0)    
    27.                 sum = 0;    
    28.             smooth [ j*width+i ] = sum;    
    29.         }    
    30.     }    
    31. }    

    当然, 这个锐化算法或者说锐化的模板只是我根据前面的算式自己计算的来的,其实还是有非常主流的锐化模版可以供使用的, 比如说著名的拉普拉斯算子。

     

     

    参考资源:

    【1】http://blog.csdn.NET/hhygcy/article/details/4330939

    展开全文
  • 图像锐化处理

    2014-07-28 10:30:05
    图像锐化算法去除图像中噪声,可以直接使用与彩色图像刚和灰度图像的处理
  • 使用USM算法锐化图像的MATLAB程序,使用了模板相乘卷积原理,其中更改模板便可以更改算法,比如使用拉普拉斯锐化模板便就改造成了拉普拉斯滤波,可改造性及移植性较好,注释较多,适合初学者。
  • 1、掌握一阶锐化算法的工作原理和算法实现。 2、掌握二阶锐化算法的工作原理和算法实现。 实验内容 实现拉普拉斯锐化。测试图像:’Grayblur6.png’。 实验代码 im = imread('.\im\Grayblur6.png'); imshow(im); ...

    实验目的

    1、掌握一阶锐化算法的工作原理和算法实现。
    2、掌握二阶锐化算法的工作原理和算法实现。

    实验内容

    测试图片

    链接: https://pan.baidu.com/s/1-7zn44maHCCI7w9qaZjvxg

    提取码: dakh

    实现拉普拉斯锐化

    实验代码

    im = imread('.\im\Grayblur6.png');
    imshow(im); title('原始图像');
    im0 = im;
    im = double(im);
    
    H = [0 -1 0;-1 4 -1;0 -1 0];
    im1 = filter2(H,im);
    
    im2 = uint8(im1+im);
    figure; imshow(im2); title('Laplacian锐化叠加后图像');
    
    im_L0 = uint8(im1);
    figure; imshow(im_L0); title('Laplacian锐化');
    
    im=imread('im\Grayblur6.png')
    imshow(im);
    title('原始图像');
    im0=im;
    im=double(im);
    
    H=[0 -1 0;-1 4 -1;0 -1 0];
    im1=filter2(H,im);
    
    im2=uint8(im1+im);
    figure,imshow(im2);
    title('Laplacian锐化叠加后的图像');
    
    im_L0=uint8(im1);
    figure,imshow(im_L0);
    title('Laplacian锐化');
    
    maxV=max(max(im1));
    minV=min(min(im1));
    delta=0;
    if(minV<0)
        delta=abs(minV);
    end
    

    实验结果

    实现Sobel微分算子的代码

    实验代码

    im = imread('.\im\Grayblur6.png');
    imshow(im); title('原始图像');
    im = double(im);
    
    H = [-1 0 1;-2 0 2;-1 0 1];
    Dy = filter2(H,im);
    
    H = [-1 -2 -1;0 0 0;1 2 1];
    Dx = filter2(H,im);
    
    im_2 = sqrt(Dx.^2+Dy.^2);
    im_2 = uint8(im_2);
    figure; imshow(im_2); title('Sobel锐化图像'); %显示滤波后的图像
    
    im_3 = uint8(im+sqrt(Dx.^2+Dy.^2)*0.1);
    figure; imshow(im_3); title('Sobel锐化叠加图像'); %显示滤波后的图像
    

    实验结果

    实现交叉微分算法(Roberts算法)

    实验步骤

    读入图像到矩阵F
    得到F的行列数与颜色通道数:m,n,c
    如果颜色通道数c>1,则将彩色图像转化为灰度图rgb2gray
    初始化输出矩阵G
    对于F的每一行i(1到m-1)
         对于F的每一列j(1到n-1) 
         根据以下公式,由F(i,j)F(i+1,j)F(i,j+1)F(i+1,j+1)计算G(i,j)
    显示Roberts锐化图像
    显示Roberts锐化并叠加原图的结果图像
    

    实验代码

    im = imread('.\im\Grayblur6.png');
    imshow(im); title('原始图像');
    [row,col,k] = size(im);
    if(k>1) 
        im = rgb2gray(im);
    end
    im = double(im);
    G = zeros(row,col);
    for i=2:row-1
        for j=2:col-1
            G(i,j) = abs(im(i+1,j+1)-im(i,j)) + abs(im(i+1,j)-im(i,j+1));
        end
    end
    g = uint8(G);
    figure; imshow(g); title('Roberts锐化并叠加原图的结果图像')
    

    实验结果

    学如逆水行舟,不进则退
    
    展开全文
  • 图像处理的锐化算法

    千次阅读 2019-06-27 14:03:10
    图像锐化通过增加邻域像素对比度来减弱或消除图像模糊程度,使图像变得清晰,锐化和平滑恰恰相反。拉普拉斯锐化是采用拉普拉斯算子对图像进行操作。 对于扩散现象引起图像模糊,可以用下式来进行锐化:g(i,j)...

    拉普拉斯锐化

    图像锐化通过增加邻域像素的对比度来减弱或消除图像的模糊程度,使图像变得清晰,锐化和平滑恰恰相反。拉普拉斯锐化是采用拉普拉斯算子对图像进行操作。

    在这里插入图片描述对于扩散现象引起的图像模糊,可以用下式来进行锐化:g(i,j)=f(i,j)kτ2f(i,j)g(i, j)=f(i, j)-k\tau\nabla^2f(i, j),这里kτk\tau是与扩散效应有关的系数。该系数取值要合理,如果kτk\tau过大,图像轮廓会产生过冲;反之如果kτk\tau过小,锐化效果就不明显。如果令kτ=1k\tau=1,则变换公式为:g(i,j)=5f(i,j)f(i1,j)f(i+1,j)f(i,j+1)f(i,j1)g(i,j)=5f(i,j)-f(i-1,j)-f(i+1,j)-f(i,j+1)-f(i,j-1),用模板表示如下:
    [010151010] \begin{bmatrix} 0 &amp; -1 &amp;0 \\ -1 &amp; 5 &amp; -1\\ 0 &amp; -1 &amp; 0 \end{bmatrix}
    在日常中,还有一种比较常用的8邻域拉普拉斯算子:
    [111191111] \begin{bmatrix} -1 &amp; -1 &amp;-1 \\ -1 &amp; 9 &amp; -1\\ -1 &amp; -1 &amp; -1 \end{bmatrix}

    代码

    Mat LaplaceSharp(Mat src) {
    	int row = src.rows;
    	int col = src.cols;
    	int border = 1;
    	Mat dst(row, col, CV_8UC3);
    	for (int i = border; i < row - border; i++) {
    		for (int j = border; j < col - border; j++) {
    			for (int k = 0; k < 3; k++) {
    				int sum = 9 * src.at<Vec3b>(i, j)[k] - src.at<Vec3b>(i - 1, j - 1)[k] - src.at<Vec3b>(i - 1, j)[k]
    					- src.at<Vec3b>(i - 1, j + 1)[k] - src.at<Vec3b>(i, j - 1)[k] - src.at<Vec3b>(i, j + 1)[k]
    					- src.at<Vec3b>(i + 1, j - 1)[k] - src.at<Vec3b>(i + 1, j)[k] - src.at<Vec3b>(i + 1, j + 1)[k];
    				if (sum > 255) sum = 255;
    				else if (sum < 0) sum = 0;
    				dst.at<Vec3b>(i, j)[k] = sum;
    			}
    		}
    	}
    	return dst;
    }
    

    自由锐化

    这个算法实际上还是拉普拉斯锐化,不过添加了一个参数来调节锐化度,以实现调整整体的视觉效果。使得图像看起来更加自然,更符合审美。

    Mat FreeSharp(Mat src, float sharpDegree = 0.3) {
    	int row = src.rows;
    	int col = src.cols;
    	int border = 1;
    	Mat dst(row, col, CV_8UC3);
    	for (int i = border; i < row - border; i++) {
    		for (int j = border; j < col - border; j++) {
    			for (int k = 0; k < 3; k++) {
    				int sum = 9 * src.at<Vec3b>(i, j)[k] - src.at<Vec3b>(i - 1, j - 1)[k] - src.at<Vec3b>(i - 1, j)[k]
    					- src.at<Vec3b>(i - 1, j + 1)[k] - src.at<Vec3b>(i, j - 1)[k] - src.at<Vec3b>(i, j + 1)[k]
    					- src.at<Vec3b>(i + 1, j - 1)[k] - src.at<Vec3b>(i + 1, j)[k] - src.at<Vec3b>(i + 1, j + 1)[k];
    				sum = sum * sharpDegree + 0.5;
    				if (sum > 255) sum = 255;
    				else if (sum < 0) sum = 0;
    				dst.at<Vec3b>(i, j)[k] = sum;
    			}
    		}
    	}
    	return dst;
    }
    

    钝化蒙版

    先根据用户指定的钝化度对图像进行高斯模糊处理,再对高斯模糊处理结果与原图像进行钝化处理。 钝化度用来改变像素间的对比度强弱,钝化度,取值(0~100),钝化值越小,钝化的部分就越窄,仅仅会影响边缘像素; 钝化值越大,钝化的范围越宽,效果更明显。

    代码

    // degree:钝化度,取值(0~100)
    // 钝化度用来改变像素间的对比度强弱,钝化值越小,钝化的部分就越窄,仅仅会影响边缘像素
    // 钝化值越大,钝化的范围越宽,效果更明显
    Mat UnsharpMask(Mat src, int degree) {
    	int row = src.rows;
    	int col = src.cols;
    	if (degree < 1) degree = 1;
    	if (degree > 100) degree = 100;
    	Mat dst(row, col, CV_8UC3);
    	src.copyTo(src);
    	int border = 1;
    	for (int i = 0; i < degree; i++) {
    		GaussianBlur(dst, dst, Size(3, 3), 1.0);
    	}
    	for (int i = 0; i < row; i++) {
    		for (int j = 0; j < col; j++) {
    			for (int k = 0; k < 3; k++) {
    				int sum = 2 * src.at<Vec3b>(i, j)[k] - dst.at<Vec3b>(i, j)[k];
    				if (sum > 255) sum = 255;
    				else if (sum < 0) sum = 0;
    				dst.at<Vec3b>(i, j)[k] = sum;
    			}
    		}
    	}
    	return dst;
    }
    
    展开全文
  • 本文在掌握了图像锐化的原理,发展现状的基础上,展开研究锐化算法,提出了先用算法检出边缘,然后根据检出的边缘对图像进行高频增强的...实验结果表明,本文的算法比较可以为图像处理的后续环节提供一些有益的参考。
  • 图像锐化算法-sharpen

    万次阅读 2018-09-11 23:11:38
    图像锐化,是使图像边缘更清晰一种图像处理方法,细节增强(detail enhancement)我理解也包含了图像锐化,常用做法是提取图像高频分量,将其叠加到原图上。图像高频分量提取有两种做法,一种是用高通滤波器...

    图像锐化,是使图像边缘更清晰的一种图像处理方法,细节增强(detail enhancement)我理解也包含了图像锐化,常用的做法是提取图像的高频分量,将其叠加到原图上。图像高频分量的提取有两种做法,一种是用高通滤波器,得到高频分量,另一种是通过低通滤波,用原图减低频得以高频。

    直接提取高频的方法有sobel算法、laplcian算子,sobel算子是图像的一阶导数,提取的是梯度信息,分水平和垂直两种,常常用来做边缘检测、方向判别,sobel算子在斜坡处不为0,因此会产生较粗的边缘。laplcian算子是图像的二阶导,在图像开始变化和结束变化的地方值不为0,渐变时结果为0,因此laplacian比sobel算子更适合做sharpen。
    除了直接提取高频的方法外,我们也可以先提取低频,原图减去低频得到高频。这种方法称为非锐化掩模(unsharpen mask),我们常使用低通滤波器(高斯、双边)对图像进行滤波,这种方法滤波器很好控制(包括大小和强弱),从而可以控制高频分量的强弱。

    使用UM方向做sharpen时,常常加入另外三个参数:跟滤波器相关的参数(高斯滤波器的半径和方差)、增强的阀值threshold、strength。

    下面给出UM方法的三种实现:matlab、C和opencv。

    Matlab:
    Matlab提供了库函数imsharpen,该函数使用UM方法进行sharpen,low-pass filter为gaussian kernel。下面是我实现的UM代码。先将rgb转到ycbcr color space,对Y做sharpen,cb/cr不做处理(最好是使用Y的结果做补偿,这样偏色少),最后再进行ycbcr2rgb的转换。

    clc;
    clear;
    close all;
    imSrc = imread('D:\simuTest\picSimu\00_kodak_dataset\kodim05.png');
    imSrcYcbcr = rgb2ycbcr(imSrc);
    imSrcY = imSrcYcbcr(:,:,1);
    [hei, wid] = size(imSrc(:,:,1));
    size = 3;
    sigma = 1;  %gauss standard deviation sigma, default is 1
    amount = 1.5;
    threshold = 15;
    gaussFilter = fspecial('gaussian', [size, size], sigma);
    imSrcY_lf = imfilter(imSrcY, gaussFilter, 'symmetric');
    imSrcY_hf = imSrcY - imSrcY_lf;
    imLabel = (imSrcY_hf > threshold);
    imLabel = uint8(imLabel);
    imDstY = uint8(imSrcY + amount * imSrcY_hf .* imLabel);
    figure, imshow([imSrcY, imSrcY_lf, imSrcY_hf, imDstY]);
    imSrcYcbcr(:,:,1) = imDstY;
    imDst = ycbcr2rgb(uint8(imSrcYcbcr));
    figure, imshow([imSrc, imDst]);
    

    输入输出图像如下所示,左边为sharpen前图像,右边为sharpen后图像。
    这里写图片描述

    C代码:
    C有着matlab无法比拟的速度优势。下面是我用C写的UM代码,Srcp为输入源图像,dstp为输出的锐化后的图像,sharpen_coef为定点化后的增强系数(0-64),threshold为增强的阀值(高频分量大于该阈值,才做增强,典型值为15),低通滤波器模板为{{1,2,1},{2,4,2},{1,2,1}}的高斯核。

    void imageSharpenUM(uint8_t* srcp, uint8_t* dstp, int src_width, int src_height, int src_pitch, int sharpen_coef, int threshold)
    {
        //int gaussianMat[3][3] = {{6, 43, 6}, {43, 317, 43}, {6, 43, 6}};
        int gaussianMat[3][3] = {{1, 2, 1}, {2, 4, 2}, {1, 2, 1}};      // 定义低通滤波器
        int dstBlur;        // 低频图像
        int dstTexture;     // 细节图像
        int dstDetail;      // 细节加权重
        int src11 = 0;      // 11
        int src12 = 0;      // 12
        int src13 = 0;      // 13
        int src21 = 0;      // 21
        int src22 = 0;      // 22
        int src23 = 0;      // 23
        int src31 = 0;      // 31
        int src32 = 0;      // 32
        int src33 = 0;      // 33
    
        for(int ver = 0; ver < src_height; ++ver){
            for(int hor = 0; hor < src_width; ++hor){
                if(ver==0 || ver==(src_height-1) || hor==0 || hor==(src_width-1)){
                    dstp[ver * src_pitch + hor] = srcp[ver * src_pitch + hor];
                } else {
                    src11 = (int)srcp[(ver - 1) * src_pitch + hor - 1] * gaussianMat[0][0];
                    src12 = (int)srcp[(ver - 1) * src_pitch + hor] * gaussianMat[0][1];
                    src13 = (int)srcp[(ver - 1) * src_pitch + hor + 1] * gaussianMat[0][2];
    
                    src21 = (int)srcp[ver * src_pitch + hor - 1] * gaussianMat[1][0];
                    src22 = (int)srcp[ver * src_pitch + hor] * gaussianMat[1][1];
                    src23 = (int)srcp[ver * src_pitch + hor + 1] * gaussianMat[1][2];
    
                    src31 = (int)srcp[(ver + 1) * src_pitch + hor - 1] * gaussianMat[2][0];
                    src32 = (int)srcp[(ver + 1) * src_pitch + hor] * gaussianMat[2][1];
                    src33 = (int)srcp[(ver + 1) * src_pitch + hor + 1] * gaussianMat[2][2];
    
                    dstBlur = (src11 + src12 + src13 + src21 + src22 + src23 + src31 + src32 + src33) >> 4;
                    dstTexture = clip3(srcp[ver * src_pitch + hor] - dstBlur, 0, 255);
                    if(dstTexture > threshold) {
                        dstDetail = (dstTexture * sharpen_coef) >> 4;
                        dstp[ver * src_pitch + hor] = clip3((int)srcp[ver * src_pitch + hor] + dstDetail, 0, 255);
                    } else {
                        dstp[ver * src_pitch + hor] = srcp[ver * src_pitch + hor];
                    }
                }
            }
        }
    }
    

    使用下面函数来调用sharpenUM,输入输出图像如下所示,上图是输入图像,下图是锐化后的输出图像。

    imDst = sharpenUM(imSrc, 15, 2);
    

    这里写图片描述
    这里写图片描述

    硬件实现时往往使用LUT来做,根据不同的strength及threshold、偏好设计好LUT,使用高频图像进行查表,将查表的结果叠加到原图上。

    参考:
    [1] matlab -imsharpen
    [2] 数字图像处理,岗萨雷斯

    展开全文
  • 算法不同于传统图像锐化算法只基于局部对比度缺点, 在图像锐化过程中考虑图像边缘和噪声空间分布差异, 改善了传统边缘增强算法对噪声放大缺点。实验数据表明, 该锐化方法未引起信噪比降低, 具有良好...
  • 中北大学 课 程 设 计 说 明 书 学 院 信息商务学院 专 业 电子信息工程 题 目 信息处理综合实践: 基于MATLAB的图像锐化算法研究 指导教师 陈平 职称: 副教授 2013 年 12 月 15 日 中北大学 课程设计任务书 13/14 ...
  • 最近研究了图像锐化方法,使用matlab模拟了效果并实现了基于FPGA的图像锐化算法处理效果如图1.1、图1.2所示。经过算法处理后 上图右边为锐化算法处理结果,月球坑边界更加清晰。 1.图像锐化算法说明 图像...
  • 该文提出了一种基于拉普拉斯算法图像锐化方法,并在DSP 上实现其算法。首先研究拉普拉斯算子锐化图像的基本原理, 并推导出图像锐化的拉普拉斯算子。...比较实验结果,可知运用该算法锐化处理的图像比原来图像清晰。
  • 介绍了图像锐化处理的概念和拉普拉斯 算子的算法原理; 重点阐述了一种基于拉普拉斯算子, 在C# 1N ET 中构造功能函数并借助模板取样测试原理实 现彩色图像锐化处理的方法。实践证明, BM P、JPEG 格式的图像使用该方法...
  • FPGA图像处理10_常用算法_图像锐化

    千次阅读 2019-09-05 15:37:33
    锐化即在图像上增强显示图像内容边缘成分。 根据边缘成分计算方法,常用方法有高斯滤波锐化和拉普拉斯滤波锐化。 高斯滤波锐化将原始图像 x 减去高斯滤波(相当于低通滤波)后得到平滑图像 gaussian(x),...
  • 图像锐化算法sharpen

    2021-03-28 15:31:45
    图像锐化是使图像边缘更加清晰一种图像处理方法。常用做法是提取图像高频分量,将其叠加到原图上。 图像高频分量提取有两种做法:一种是用高通滤波器得到高频分量;另一种是用低通滤波器得到低频,然后用原图...
  • 数字图像处理的图像锐化

    千次阅读 2019-07-02 21:51:32
    数字图像处理中的图像锐化 图像锐化的作用: 突出增强边缘轮廓细节 空间域锐化处理方法: (空间锐化滤波) 梯度算法:(一阶差分)——景物边缘轮廓提取, (1): 正交梯度算法——水平垂直差分 (2): Roberts梯度算法——...
  • 图像锐化是一种补偿轮廓、突出边缘信息以使图像更为清晰的处理方法。锐化目标实质上是要增强原始图 像高频成分。常规锐化算法对整幅图像进行高频增强,结果呈现明显噪声。为此,在对锐化原理进行深入研究基础 ...
  • 6 图像的锐化处理 目录(一)图像锐化的概念(二)图像锐化的方法1)一阶微分锐化①单方向一阶锐化②无方向一阶锐化2)二阶微分锐化 (一)图像锐化的概念 图像锐化的概念 图像锐化的目的是加强图像中景物细节...
  • 图像处理程序中梯度锐化算法,vc编写,可靠实用。
  • MATLAB实现数字图像锐化处理

    热门讨论 2009-06-10 12:24:50
    讨论了数字图像增强技术中空域图像锐化的四种算 法及其用MATLAB实现;同时给出了利用四种算法进行图像锐化对照图像。
  • 数字图像处理图像锐化C++实现

    热门讨论 2013-06-26 11:14:12
    数字图像处理图像的各种锐化算法的代码实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 565
精华内容 226
关键字:

图像锐化处理的算法