2017-06-15 16:10:53 wl1070325332 阅读数 1885
	//打开指定路径下的一幅图像
	Mat src = imread("E:\\学习之路\\OpenCV 练习程序\\Fig0316(a)(moon).tif",0);
	if(!src.data)
	{
		cout << "打开图像失败" << endl;
		return ;
	}
	//创建一幅图像,用以保存经过拉普拉斯锐化最终的效果图像
	Mat dst = src.clone();
	//创建一幅用于保存拉普拉斯处理后的子图像
	Mat lap;
	lap.create(src.size(),src.type());
	vector<int> table;
	//将每个像素使用3*3掩模处理
	for(int r = 1;r < src.rows - 1;r++)
	{
		const uchar* up = src.ptr<uchar>(r + 1);
		const uchar* mid = src.ptr<uchar>(r);
		const uchar* down = src.ptr<uchar>(r - 1);
		
		for(int c = 1;c < src.cols - 1;c++)
		{
			int sum = 0;
			for(int i = -1;i < 2;i++)
			{
				if(i == 0)
					sum = sum + 8 * mid[c + i] - up[c + i] - down[c + i];
				else
				{
					sum = sum - up[c + i] - mid[c + i] - down[c + i];
				}
			}
			table.push_back(sum);
		}
	}
	int max = 0;
	int min = 0;
	//计算得出经过处理后的像素最大值,以及最小值
	for(int i = 0;i < table.size();i++)
	{
		if(max < table[i])
		{
			max = table[i];
		}
		if(min > table[i])
			min = table[i];
	}
	int index = 0;
	//将对比拉升后的图像保存至lap中
	for(int i = 1;i < lap.rows - 1;i++)
	{
		uchar* data = lap.ptr<uchar>(i);
		for(int c = 1;c < lap.cols - 1;c++)
		{
			data[c] = (uchar)(255 * ((table[index++] - min) * 1.0 / (max - min)));
		}
	}
	//将拉普拉斯处理图像与原图像混合叠加,得到最终效果图
	for(int r = 1;r < lap.rows;r++)
	{
		uchar* data = dst.ptr<uchar>(r);
		uchar* tmp = lap.ptr<uchar>(r);
		for(int c = 1;c < lap.cols;c++)
		{
			//要减去拉升时得到的最小灰度值,否则会造成图像整体灰度值增加
			int tmp1 = (int)data[c] + (int)tmp[c] - (255 * ((0 - min) * 1.0 / (max - min)));
			if(tmp1 > 255)
				tmp1 = 255;
			else if(tmp1 < 0)
				tmp1 = 0;
			data[c] = (uchar)tmp1;
		}
	}
	imshow("原图",src);
	imshow("laplace锐化",dst);
	waitKey(0);

原图:


最终效果图:


未减去拉升后最低灰度值时的效果图:


2019-11-25 22:07:17 qq_43309286 阅读数 70

数字图像处理——拉普拉斯算子【像素级别处理】(python)

简介:

拉普拉斯算子是一种微分算子常在图像处理中强调灰度值的突变,不强调灰度变换缓慢的地方,得到的图层与原图像叠加在一起可以得到锐化的效果

一个二维图像的拉普拉斯算子可以定义为2f=2fx2+2fy2\nabla^{2}f=\frac{\partial^2 f}{\partial x^2}+\frac{\partial^2 f}{\partial y^2}

所以:
在X方向上存在2fx=f(x+1,y)+f(x1,y)2f(x,y)\frac{\partial^2 f}{\partial x}=f(x+1,y)+f(x-1,y)-2f(x,y)

在Y方向上存在2fy=f(x,y+1)+f(x,y1)2f(x,y)\frac{\partial^2 f}{\partial y}=f(x,y+1)+f(x,y-1)-2f(x,y)

可得:
2f=f(x+1,y)+f(x1,y)+f(x,y+1)+f(x,y1)4f(x,y)\nabla^2f=f(x+1,y)+f(x-1,y)+f(x,y+1)+f(x,y-1)-4f(x,y)

扩展至对角线:
2f=f(x+1,y)+f(x1,y)+f(x,y+1)+f(x,y1)+f(x1,y1)+f(x1,y+1)+f(x+1,y1)+f(x+1,y+1)8f(x,y)\nabla^2f=f(x+1,y)+f(x-1,y)+f(x,y+1)+f(x,y-1)+f(x-1,y-1)+f(x-1,y+1)+f(x+1,y-1)+f(x+1,y+1)-8f(x,y)

代码实现

import cv2
import numpy as np
import matplotlib.pyplot as plt

img = cv2.imread('Fig0338.tif')  # 测试图片
H = img.shape[0]
W = img.shape[1]

pixa = np.zeros((H, W), np.int32)
mImgae = np.zeros((H, W, 3), np.uint8)  # 标定(scale)前的滤波图像
smImga = np.zeros((H, W, 3), np.uint8)  # 标定(scale)后的滤波图像
pixb = np.zeros((H, W), np.int32)
mImgbe = np.zeros((H, W, 3), np.uint8)  # 标定前的滤波图像
smImgb = np.zeros((H, W, 3), np.uint8)  # 标定后的滤波图像
imga = np.zeros((H, W, 3), np.uint8)  # xy方向模板滤波后图像
imgb = np.zeros((H, W, 3), np.uint8)  # 加上对角方向模板滤波后图像

# a用到的算子是        b用到的算子是
# 0  1  0            1  1  1
# 1 -4  1            1 -8  1
# 0  1  0            1  1  1
# 先绘制标定滤波图像
# 标定指的是最小值设置为0,最大值设置为255的进行归一化的结果
for i in range(1, H - 1):
    for j in range(1, W - 1):
        pixa[i, j] = int(img[i - 1, j, 0]) + img[i + 1, j, 0] + img[i, j - 1, 0] + img[i, j + 1, 0] - 4 * int(
            img[i, j, 0])
        pixb[i, j] = int(img[i - 1, j - 1, 0]) + img[i - 1, j, 0] + img[i - 1, j + 1, 0] + img[i, j - 1, 0] + img[
            i, j + 1, 0] + img[i + 1, j - 1, 0] + img[i + 1, j, 0] + img[i + 1, j + 1, 0] - 8 * int(img[i, j, 0])

maxa = 0
maxb = 0
mina = 255
minb = 255

for i in range(H):
    for j in range(W):
        # 求出像素最大值和最小值,以利于scale
        if pixa[i, j] > maxa:
            maxa = pixa[i, j]
        if pixa[i, j] < mina:
            mina = pixa[i, j]
        if pixb[i, j] > maxb:
            maxb = pixb[i, j]
        if pixb[i, j] < minb:
            minb = pixb[i, j]
        if pixa[i, j] < 0:
            mImgae[i, j] = [0, 0, 0]
        else:
            mImgae[i, j, 0] = pixa[i, j]
            mImgae[i, j, 1] = pixa[i, j]
            mImgae[i, j, 2] = pixa[i, j]
        if pixb[i, j] < 0:
            mImgbe[i, j] = [0, 0, 0]
        else:
            mImgbe[i, j, 0] = pixb[i, j]
            mImgbe[i, j, 1] = pixb[i, j]
            mImgbe[i, j, 2] = pixb[i, j]

ka = 0
kb = 0
if maxa > mina:
    ka = 255 / (maxa - mina)
if maxb > minb:
    kb = 255 / (maxb - minb)

# scale处理
for i in range(H):
    for j in range(W):
        smImga[i, j, 0] = (pixa[i, j] - mina) * ka
        smImga[i, j, 1] = smImga[i, j, 0]
        smImga[i, j, 2] = smImga[i, j, 0]
        smImgb[i, j, 0] = (pixb[i, j] - minb) * kb
        smImgb[i, j, 1] = smImgb[i, j, 0]
        smImgb[i, j, 2] = smImgb[i, j, 0]

# 加上拉普拉斯算子
# pixa和pixb里面就是两个算子的结果
# lapa和lapb是原图加算子的结果,用来裁剪或者scale的原始数据
lapa = np.zeros((H, W), np.int32)
lapb = np.zeros((H, W), np.int32)

# 缩放处理
# maxa = 0
# maxb = 0
# mina = 255
# minb = 255

for i in range(H):
    for j in range(W):
        lapa[i, j] = img[i, j, 0] - pixa[i, j]
        lapb[i, j] = img[i, j, 0] - pixb[i, j]
        # 裁剪处理
        if lapa[i, j] > 255:
            lapa[i, j] = 255
        if lapa[i, j] < 0:
            lapa[i, j] = 0
        if lapb[i, j] > 255:
            lapb[i, j] = 255
        if lapb[i, j] < 0:
            lapb[i, j] = 0
        # 缩放处理
        # if lapa[i, j] > maxa:
        #     maxa = lapa[i, j]
        # if lapa[i, j] < mina:
        #     mina = lapa[i, j]
        # if lapb[i, j] > maxb:
        #     maxb = lapb[i, j]
        # if lapb[i, j] < minb:
        #     minb = lapb[i, j]

# 缩放处理
# ka = 0
# kb = 0
# if maxa > mina:
#     ka = 255 / maxa
# if maxb > minb:
#     kb = 255 / maxb

# scale处理
for i in range(H):
    for j in range(W):
        # 裁剪处理
        imga[i, j, 0] = lapa[i, j]
        imga[i, j, 1] = lapa[i, j]
        imga[i, j, 2] = lapa[i, j]
        imgb[i, j, 0] = lapb[i, j]
        imgb[i, j, 1] = lapb[i, j]
        imgb[i, j, 2] = lapb[i, j]
        # 缩放处理
        # if lapa[i, j] > 0:
        #     imga[i, j, 0] = lapa[i, j] * ka
        # else:
        #     imga[i, j, 0] = 0
        # imga[i, j, 1] = imga[i, j, 0]
        # imga[i, j, 2] = imga[i, j, 0]
        # if lapb[i, j] > 0:
        #     imgb[i, j, 0] = lapb[i, j] * kb
        # else:
        #     imgb[i, j, 0] = 0
        # imgb[i, j, 1] = imgb[i, j, 0]
        # imgb[i, j, 2] = imgb[i, j, 0]

# 原图
plt.subplot(1, 4, 1)
plt.axis('off')
plt.title('Original image')
plt.imshow(img)

# 图3.37a的模板
plt.subplot(2, 4, 2)
plt.axis('off')
plt.title('Before sale a')
plt.imshow(mImgae)

# scale后图3.37a的模板
plt.subplot(2, 4, 3)
plt.axis('off')
plt.title('After sale a')
plt.imshow(smImga)

# 图3.37a的模板锐化后的图像
plt.subplot(2, 4, 4)
plt.axis('off')
plt.title('Sharpened Image a')
plt.imshow(imga)

# 图3.37b的模板
plt.subplot(2, 4, 6)
plt.axis('off')
plt.title('Before sale b')
plt.imshow(mImgbe)

# scale后图3.37b的模板
plt.subplot(2, 4, 7)
plt.axis('off')
plt.title('After sale b')
plt.imshow(smImgb)

# 图3.37b的模板锐化后的图像
plt.subplot(2, 4, 8)
plt.axis('off')
plt.title('Sharpened Image b')
plt.imshow(imgb)

plt.show()

2018-04-15 09:21:13 qq_34793133 阅读数 2551

本文是博主个人学习数字图像处理整理知识点所用,如有错误希望得到大家指点

一、图像拉普拉斯锐化模板:四方向模板:Laplace1=[0 -1 0;-1 4 -1;0 -1 0]

                                          八方向模板:Laplace2=[-1 -1 -1 ;-1 8 -1;-1 -1 -1]

     下面具体介绍拉普拉斯模板

    1.理论知识

          拉普拉斯算子是一个是n维欧几里德空间中的一个二阶微分算子,它的定义如下:

                 

         在x方向上

                

        在y方向上

                

       合起来就是

               

     拉普拉斯强调的是图像中灰度的突变,并不强调图像的灰度缓变(灰度缓变由一阶微分,也就是梯度,图像应用是sobel算子,具体下面介绍)

    根据上边的表达式,可以确定拉普拉斯算子的模板

    例如:

          [ 0 1 0

            1 -4 0

            0  1  0]

     这是以90度增量旋转的拉普拉斯算子,如果以45度增量旋转会是怎样的结果呢,结果如下:

          [1 1 1

           1 -8 1

           1  1 1]

八邻域表示法:


观察模板发现:当邻域内像素灰度相同时,卷积结果为0;当中心像素值高于邻域内其他像素平均灰度时,卷积结果为正;当中心像素灰度低于邻域其他像素平均灰度时候,卷积结果为负数,最后把卷积结果加到原中心像素,这样可以加剧中心像素与邻域像素灰度值的“贫富分化”,因而达到“锐化”目的。


代码实现:

不用库函数

  1. %拉普拉斯算子锐化图像,用二阶微分  
  2. %四邻接g(x,y)=[f(x+1,y)+f(x-1,y)+f(x,y+1)+f(x,y-1)]-4f(x,y)  
  3. clear  
  4. clc  
  5. I1=imread('D:\BingZhouWork\Image\lena.jpg');  
  6. I=im2double(I1);  
  7. [m,n,c]=size(I);  
  8. A=zeros(m,n,c);  
  9. %分别处理R、G、B  
  10. %先对R进行处理  
  11. for i=2:m-1  
  12.     for j=2:n-1  
  13.         A(i,j,1)=I(i+1,j,1)+I(i-1,j,1)+I(i,j+1,1)+I(i,j-1,1)-4*I(i,j,1);  
  14.     end  
  15. end  
  16.   
  17. %再对G进行处理  
  18. for i=2:m-1  
  19.     for j=2:n-1  
  20.         A(i,j,2)=I(i+1,j,2)+I(i-1,j,2)+I(i,j+1,2)+I(i,j-1,2)-4*I(i,j,2);  
  21.     end  
  22. end  
  23.   
  24. %最后对B进行处理  
  25. for i=2:m-1  
  26.     for j=2:n-1  
  27.         A(i,j,3)=I(i+1,j,3)+I(i-1,j,3)+I(i,j+1,3)+I(i,j-1,3)-4*I(i,j,3);  
  28.     end  
  29. end  
  30. B=I-A;  
  31.   
  32.  imwrite(B,'lena.tif','tif');  
  33.  imshow('D:\BingZhouWork\Image\lena.jpg');title('不清晰图像');figure  
  34.  imshow('lena.tif');title('得到的清晰图像')  

用matlab自带的fspecial函数实现:

[plain] view plain copy
  1. %matlab直接调用拉普拉斯方法  
  2. clear  
  3. clc  
  4. f=imread('D:\BingZhouWork\Image\unclear.jpg');  
  5. f2=im2double(f); %将f转换归一化的double类图像,然后进行滤波  
  6. w=fspecial('laplacian',0);  
  7. g1=imfilter(f,w,'replicate');  
  8. g=f-g1;  
  9. imshow(f);figure  
  10. imshow(g);  

图像锐化结果:


整理更新中...

参考:https://blog.csdn.net/zb1165048017/article/details/49330171


转载需注明出处:https://blog.csdn.net/qq_34793133/article/details/79946463

2019-03-25 21:25:42 weixin_44018318 阅读数 3246

博主本学习选修数字图像处理课程,用到的教材是冈萨雷斯的《数字图像处理》,作业要求完成图像拉普拉斯变化,虽然用Matalb比较容易就能实现,但还是想尝试用python完成。
Python+OpenCV拉普拉斯图像锐化这一篇博客是我实现代码的基础,但博主给出的代码有一部分错不,到后期无法实现拉普拉斯变化,而且灰度图像比较繁琐,因此做了一部分的改进。

原理参考

拉普拉斯滤波实现图像增强

代码实现

# -*- coding: utf-8 -*-
"""
Created on Mon Mar 18 20:47:35 2019

@author: hy
"""

import numpy as np
import cv2
from PIL import Image
from matplotlib import pyplot as plt


ori = Image.open(r'C:\Users\hy\Desktop\iml\leina.jpg')
ori_gray = ori.convert('L')

ori = np.array(ori)
ori_gray = np.array(ori_gray )
weight = ori.shape[0]
height = ori.shape[1]


ori_pad = np.pad(ori_gray,((1,1),(1,1)),'edge')


t1 = np.array([[0,1,0],[1,-4,1],[0,1,0]])
img = np.zeros((weight,height))
for i in range(weight-2):
    for j in range(height-2):
        img[i,j]=np.sum(ori_pad[i:i+3,j:j+3]*t1)
        if img[i,j] < 0:
            img[i,j] = 0

img_sharp = np.zeros((weight,height))
img_sharp = ori_gray - img

其中阻挡我很久的部分在于这里:


img = np.zeros((weight,height))
for i in range(weight-2):
    for j in range(height-2):
        img[i,j]=np.sum(ori_pad[i:i+3,j:j+3]*t1)
        if img[i,j] < 0:
            img[i,j] = 0

参考博客中用 img = np.zeros((weight,height),np.uint8),导致最后计算出来的负数全部转化为8位形式,而实际上拉普拉斯算子中,负数像元全部转为0。

代码实现

原图原始图片
灰度后的雷娜灰度后的雷娜
拉普拉斯变化后的雷娜拉普拉斯变化后的雷娜
锐化后的雷娜锐化后的雷娜

拉普拉斯锐化图像

阅读数 30187

拉普拉斯实现图像锐化,matlab实现

博文 来自: zb1165048017
没有更多推荐了,返回首页