python 拉普拉斯锐化_（二十四）用二阶微分（拉普拉斯算子）实现图像锐化

时间为友，记录点滴。

我们已经了解过了梯度(一阶微分)的作用，那么为什么要引入二阶微分呢？二阶微分的作用是什么？

还是看图说话：

很明显，一阶微分已经可以把轮廓辨识出来，但是，对于变化较缓的地方，一阶微分会给出一个比较长的序列，对应到图像上就是轮廓比较“粗”， 二阶微分只识别跳变的边缘，对应到图像上就是比较“细”。而且对像素的陡变的地方，二阶微分会出现有“零交叉”的两个点，这种点对边缘定位非常有作用。

所以，在细节增强方面，二阶微分要比一阶微分好的多。

怎么实现二阶微分？

我在《数字图像处理》中已经介绍了拉普拉斯算子， 简单的说就是对上一章的梯度再做一次梯度：

拉普拉斯在就为我们定义了二阶微分形式，所以我们就直接把它拓展到二维图像

上：

因为任意阶微分都是线性操作，所以拉普拉斯变换也是一个线性算子。为了离散地表达这个共识，我们套用上一章的一个公式变换：

X方向：

Y方向：

综合一下：

有了公式，就容易得到基于拉普拉斯算子的模板：

因为拉普拉斯是一种二阶微分算子，因此其强调的是图像中灰度的突变，并不强调图像的缓慢变换区域。这样一些渐变的浅灰色边线就会变成图片轮廓的背景色。如果我们想要保持原图像并且看到增强的边缘图像，可以把原图和拉普拉斯图像简单叠加。

套用以下公式：

为原图

为拉普拉斯处理后的图像

为处理的系数

为最终保持原图像并且增强边缘的图像

好了，有了上面理论做指导，我们实现一下，看看效果。

在OpenCV中，有现成的API可以给我们使用：

CV_EXPORTS_W void Laplacian( InputArray src, OutputArray dst, int ddepth,

int ksize = 1, double scale = 1, double delta = 0,

int borderType = BORDER_DEFAULT );src_gray，输入图像

dst，Laplace操作结果

ddepth，输出图像深度，因为输入图像一般为CV_8U，为了避免数据溢出，输出图像深度应该设置为CV_16S或者更高

kernel_size，filter mask的规模，我们的mask时3x3的，所以这里应该设置为3

scale,delta,BORDER_DEFAULT，默认设置就好

C++:

注意点：1. 因为拉普拉斯是二阶微分，对噪点非常敏感，所以在做锐化之前可以用kernelSize=3的高斯滤波先。

2. 不知道为什么，做出来的拉普拉斯噪声值比较大。

#include #include #include

using namespace std;

using namespace cv;

static bool laplaceTest(Mat imgOri, bool needResize = false, bool needBlur = false);

static void showImgPara(Mat &img);

int main()

{

Mat imgOri = imread("Fig0338(a)(blurry_moon).tif");

laplaceTest(imgOri);

Mat imgGril = imread("Gril.jpg");

//laplaceTest(imgGril, true, false);

waitKey(0);

return true;

}

static bool laplaceTest(Mat imgOri, bool needResize, bool needBlur)

{

Mat imgLaplace, imgLaplaceDelta, imgLaplaceAdd1;

float fx = 0, fy = 0;

showImgPara(imgOri);

imshow("laplaceTest imgOri", imgOri);

if (needBlur)

{

GaussianBlur(imgOri, imgOri, Size(7, 7), 0, 0);

}

if (needResize)

{

resize(imgOri, imgOri, Size(imgOri.cols * 0.5, imgOri.rows * 0.5), fx = 0, fy = 0, INTER_LINEAR);

}

if (1 != imgOri.channels())

{

cvtColor(imgOri, imgOri, COLOR_BGR2GRAY);

}

// Laplace without deltaLaplacian(imgOri, imgLaplace, CV_16S, 3, 1, 0);

convertScaleAbs(imgLaplace, imgLaplace);

imshow("laplaceTest imgLaplace", imgLaplace);

// Laplace with deltaLaplacian(imgOri, imgLaplaceDelta, CV_16S, 3, 1, 100);

convertScaleAbs(imgLaplaceDelta, imgLaplaceDelta);

imshow("laplaceTest imgLaplaceDelta", imgLaplaceDelta);

// Laplace add originaladdWeighted(imgOri, 1.0, imgLaplace, -1.0, 0.0, imgLaplaceAdd1, CV_32F);

convertScaleAbs(imgLaplaceAdd1, imgLaplaceAdd1);

imshow("laplaceTest imgLaplaceAdd1", imgLaplaceAdd1);

return true;

}

static void showImgPara(Mat &img)

{

cout << "sizeof(img) is: " << sizeof(img) << ", img size is: " << img.size << endl;

cout << "rows x cols: (" << img.rows << " x " << img.cols << ")" << endl;

cout << "dims: " << img.dims << endl;

cout << "channels: " << img.channels() << endl;

cout << "type: " << img.type() << endl;

cout << "depth:" << img.depth() << endl;

cout << "elemSize:" << img.elemSize() << " (Bytes per element)" << endl;

cout << "elemSize1:" << img.elemSize1() << "(Bytes per channel)" << endl;

cout << "step[0]: " << img.step[0] << " (Bytes per cows only when 2 dims)" << endl;

cout << "step[1]: " << img.step[1] << " (Bytes per element only when 2 dims)" << endl;

cout << "step1(0): " << img.step1(0) << ", step1(1): " << img.step1(1) << " (step / elemSize1)" << endl;

cout << "----- showImgPara End ----\n" << endl;

}

运行结果：

Python:

#!/usr/bin/env python

# -*- coding: utf-8 -*-

# author：lowkeyway time:8/24/2019

import sys

import cv2 as cv

import numpy as np

def laplaceTest(imgOri, needResize = False, needBlur = False):

cv.imshow("imgOri", imgOri)

if len(imgOri.shape) is not 2:

imgOri = cv.cvtColor(imgOri, cv.COLOR_BGR2GRAY)

if needResize:

imgOri = cv.resize(imgOri, (int(imgOri.shape[1]*0.5), int(imgOri.shape[0]*0.5)))

if needBlur:

imgOri = cv.GaussianBlur(imgOri, (3, 3), 1)

# Laplace only

imgLap = cv.Laplacian(imgOri, cv.CV_16S)

imgLap = cv.convertScaleAbs(imgLap)

cv.imshow("imglap", imgLap)

# Laplace Delta

imgLapDelta = cv.Laplacian(imgOri, cv.CV_16S, delta=100)

imgLapDelta = cv.convertScaleAbs(imgLapDelta)

cv.imshow("imgLapDelta", imgLapDelta)

# Laplace Add

imgLapAdd = cv.addWeighted(imgOri, 1.0, imgLap, -1.0, 0, dtype=cv.CV_32F)

imgLapAdd = cv.convertScaleAbs(imgLapAdd)

cv.imshow("imgLapAdd", imgLapAdd)

def main_func(argv):

imgMoon = cv.imread("Fig0338(a)(blurry_moon).tif")

# laplaceTest(imgMoon)

imgGril = cv.imread("Gril.jpg")

laplaceTest(imgGril, True, True)

cv.waitKey(0)

if __name__ == '__main__':

main_func(sys.argv)