裁剪操作

img=img[100:200,:,:]

通道置零

img[:,:,2]=0

侵蚀扩张

frame = cv2.erode(frame, kernel=np.ones((5, 5))) # 侵蚀运算
frame = cv2.dilate(frame,kernel=np.ones((15,15)))# 扩张运算
thresh, frame = cv2.threshold(frame, 60, 255, cv2.THRESH_BINARY)

索贝尔算子

img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_sobel_x = cv2.Sobel(img, -1, 1, 0, ksize=3)
img_sobel_y = cv2.Sobel(img, -1, 0, 1, ksize=3)
img_sobel_xy = cv2.Sobel(img, -1, 1, 1, ksize=3)

Python OpenCV直方图均衡化详解

equ = cv2.equalizeHist(img)
res = np.hstack((img,equ))

channels = cv2.split(img)eq_channels = []# 将 cv2.equalizeHist() 函数应用于每个通道for ch in channels:eq_channels.append(cv2.equalizeHist(ch))# 使用 cv2.merge() 合并所有结果通道eq_image = cv2.merge(eq_channels)

增强

             hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)  # 色彩空间转换, BGR->HSV# 调节通道强度lutWeaken = np.array([int(0.6 * i) for i in range(256)]).astype("uint8")lutEqual = np.array([i for i in range(256)]).astype("uint8")lutRaisen = np.array([int(102 + 0.6 * i) for i in range(256)]).astype("uint8")# 调节饱和度lutSWeaken = np.dstack((lutEqual, lutWeaken, lutEqual))  # Saturation weakenlutSRaisen = np.dstack((lutEqual, lutRaisen, lutEqual))  # Saturation raisen# 调节明度lutVWeaken = np.dstack((lutEqual, lutEqual, lutWeaken))  # Value weakenlutVRaisen = np.dstack((lutEqual, lutEqual, lutRaisen))  # Value raisenblendSWeaken = cv2.LUT(hsv, lutSWeaken)  # 饱和度降低blendSRaisen = cv2.LUT(hsv, lutSRaisen)  # 饱和度增大blendVWeaken = cv2.LUT(hsv, lutVWeaken)  # 明度降低blendVRaisen = cv2.LUT(hsv, lutVRaisen)  # 明度升高frame =cv2.cvtColor(blendSRaisen, cv2.COLOR_HSV2RGB)

dct变换

from imageio import imread,imsave
import cv2
import numpy as npimport cv2
import numpy as np
import mathdef psnr(img1, img2): # https://blog.csdn.net/u010886794/article/details/84784453mse = np.mean((img1 / 255. - img2 / 255.) ** 2)PIXEL_MAX = 1return 20 * math.log10(PIXEL_MAX / math.sqrt(mse))def mse(img1, img2):return  np.mean((img1 / 255. - img2 / 255.) ** 2)img = cv2.imread(r"***.bmp")
img = img[:,:,0]
print(img.shape)
img = np.float32(img)
img_dct = cv2.dct(img)
print(img_dct.shape)
img_recor = cv2.idct(img_dct)
imsave('normalfour.png',img_recor )print(psnr(img_recor,img))
print(mse(img_recor,img))

光照平衡 Retinex理论

一个简单的MSR 算法实现
模型
I(x,y)=L(x,y)∗R(x,y)I(x,y)相机图像；L(x,y)光照影响；R(x,y)信息图像。所以logR=logI−logLL由对I高通滤波得到这样就能计算得到Log[R(x,y)]了，最后exp处理即可(但实际都用以下的放缩操作)I(x,y)= L(x,y) *R(x,y)\\I(x,y)相机图像；L(x,y) 光照影响；R(x,y) 信息图像。\\ 所以 log R= logI-logL\\ L由对I高通滤波得到\\ 这样就能计算得到 Log[R(x,y)]了，\\ 最后exp处理即可(但实际都用以下的放缩操作)I(x,y)=L(x,y)∗R(x,y)I(x,y)相机图像；L(x,y)光照影响；R(x,y)信息图像。所以logR=logI−logLL由对I高通滤波得到这样就能计算得到Log[R(x,y)]了，最后exp处理即可(但实际都用以下的放缩操作)

%SSR:
min1 = min(min(SSR1)); # matlab中求二维最值的方法https://blog.csdn.net/ResumeProject/article/details/125297892
max1 = max(max(SSR1));
SSR1 = uint8(255*(SSR1-min1)/(max1-min1));

完整代码，代码来源https://github.com/you2mu/msrcr，下边也有python的实现

'''
author:you2mu
msr，msrcr算法的实现
R(x,y) = ∑w(exp(log(I)-log(I*F)))  多尺度
'''import numpy as np
import scipy.ndimage as image
import scipy.fftpack as fft
import matplotlib.pyplot as pltdef gaussian(r, c, sigma):  # r为高斯半径，sigma为高斯核x, y = np.mgrid[-(r - 1) / 2:(r - 1) / 2 + 1, -(c - 1) / 2:(c - 1) / 2 + 1]gauss = (1 / (2 * np.pi * sigma ** 2)) * np.exp(-(x ** 2 + y ** 2) / (2 * sigma))return gaussdef msr(i, kernel):fkernel = fft.fft2(kernel)fkernel = fft.fftshift(fkernel)I = fft.fft2(i)R = fft.ifft2(I * fkernel)R = np.abs(R)min1 = np.min(R)R = np.log(i + 1) - np.log(R - min1 + 1)return Rdef ShineBlance(img):result = []r, c, _ = img.shapegauss15 = gaussian(r, c, 15)gauss80 = gaussian(r, c, 80)gauss250 = gaussian(r, c, 250)mg = img[:, :, 0] + img[:, :, 1] + img[:, :, 2]for i in range(3):t = img[:, :, i]t = np.double(t)g = (np.log(125 * t + 1) - np.log(mg + 1)) * 46result15 = msr(t, gauss15)result80 = msr(t, gauss80)result250 = msr(t, gauss250)m = (result15 + result80 + result250) / 3min1 = np.min(m)max1 = np.max(m)m = np.uint8(255 * (m - min1) / (max1 - min1))  # msrr = 192 * (g * m - 30)min1 = np.min(r)max1 = np.max(r)r = np.uint8(255 * (r - min1) / (max1 - min1))result.append(r)result = np.dstack((result[0], result[1], result[2]))return resultimg = np.array(plt.imread('origin.jpg'))
img = np.double(img)msrcr = ShineBlance(img)
plt.imsave('out.jpg', msrcr)
plt.imshow(msrcr)
plt.show()

代码来源https://github.com/dongb5/Retinex/blob/master/retinex.py

import numpy as np
import cv2def singleScaleRetinex(img, sigma):retinex = np.log10(img) - np.log10(cv2.GaussianBlur(img, (0, 0), sigma))return retinexdef multiScaleRetinex(img, sigma_list):retinex = np.zeros_like(img)for sigma in sigma_list:retinex += singleScaleRetinex(img, sigma)retinex = retinex / len(sigma_list)return retinexdef colorRestoration(img, alpha, beta):img_sum = np.sum(img, axis=2, keepdims=True)color_restoration = beta * (np.log10(alpha * img) - np.log10(img_sum))return color_restorationdef simplestColorBalance(img, low_clip, high_clip):    total = img.shape[0] * img.shape[1]for i in range(img.shape[2]):unique, counts = np.unique(img[:, :, i], return_counts=True)current = 0for u, c in zip(unique, counts):            if float(current) / total < low_clip:low_val = uif float(current) / total < high_clip:high_val = ucurrent += cimg[:, :, i] = np.maximum(np.minimum(img[:, :, i], high_val), low_val)return img    def MSRCR(img, sigma_list, G, b, alpha, beta, low_clip, high_clip):img = np.float64(img) + 1.0img_retinex = multiScaleRetinex(img, sigma_list)    img_color = colorRestoration(img, alpha, beta)    img_msrcr = G * (img_retinex * img_color + b)for i in range(img_msrcr.shape[2]):img_msrcr[:, :, i] = (img_msrcr[:, :, i] - np.min(img_msrcr[:, :, i])) / \(np.max(img_msrcr[:, :, i]) - np.min(img_msrcr[:, :, i])) * \255img_msrcr = np.uint8(np.minimum(np.maximum(img_msrcr, 0), 255))img_msrcr = simplestColorBalance(img_msrcr, low_clip, high_clip)       return img_msrcrdef automatedMSRCR(img, sigma_list):img = np.float64(img) + 1.0img_retinex = multiScaleRetinex(img, sigma_list)for i in range(img_retinex.shape[2]):unique, count = np.unique(np.int32(img_retinex[:, :, i] * 100), return_counts=True)for u, c in zip(unique, count):if u == 0:zero_count = cbreaklow_val = unique[0] / 100.0high_val = unique[-1] / 100.0for u, c in zip(unique, count):if u < 0 and c < zero_count * 0.1:low_val = u / 100.0if u > 0 and c < zero_count * 0.1:high_val = u / 100.0breakimg_retinex[:, :, i] = np.maximum(np.minimum(img_retinex[:, :, i], high_val), low_val)img_retinex[:, :, i] = (img_retinex[:, :, i] - np.min(img_retinex[:, :, i])) / \(np.max(img_retinex[:, :, i]) - np.min(img_retinex[:, :, i])) \* 255img_retinex = np.uint8(img_retinex)return img_retinexdef MSRCP(img, sigma_list, low_clip, high_clip):img = np.float64(img) + 1.0intensity = np.sum(img, axis=2) / img.shape[2]    retinex = multiScaleRetinex(intensity, sigma_list)intensity = np.expand_dims(intensity, 2)retinex = np.expand_dims(retinex, 2)intensity1 = simplestColorBalance(retinex, low_clip, high_clip)intensity1 = (intensity1 - np.min(intensity1)) / \(np.max(intensity1) - np.min(intensity1)) * \255.0 + 1.0img_msrcp = np.zeros_like(img)for y in range(img_msrcp.shape[0]):for x in range(img_msrcp.shape[1]):B = np.max(img[y, x])A = np.minimum(256.0 / B, intensity1[y, x, 0] / intensity[y, x, 0])img_msrcp[y, x, 0] = A * img[y, x, 0]img_msrcp[y, x, 1] = A * img[y, x, 1]img_msrcp[y, x, 2] = A * img[y, x, 2]img_msrcp = np.uint8(img_msrcp - 1.0)return img_msrcp

matlab实现

function retinex()
close all;
clc;
I = imread('1.jpg');
Ir=I(:,:,1);
Ig=I(:,:,2);
Ib=I(:,:,3); %%%%%%%%%%设定所需参数%%%%%%
G = 192;
b = -30;
alpha = 125;
beta = 46;
Ir_double=double(Ir);
Ig_double=double(Ig);
Ib_double=double(Ib); %%%%%%%%%%设定高斯参数%%%%%%
sigma_1=15;   %三个高斯核
sigma_2=80;
sigma_3=250;
[x y]=meshgrid((-(size(Ir,2)-1)/2):(size(Ir,2)/2),(-(size(Ir,1)-1)/2):(size(Ir,1)/2));
gauss_1=exp(-(x.^2+y.^2)/(2*sigma_1*sigma_1));  %计算高斯函数
Gauss_1=gauss_1/sum(gauss_1(:));  %归一化处理
gauss_2=exp(-(x.^2+y.^2)/(2*sigma_2*sigma_2));
Gauss_2=gauss_2/sum(gauss_2(:));
gauss_3=exp(-(x.^2+y.^2)/(2*sigma_3*sigma_3));
Gauss_3=gauss_3/sum(gauss_3(:)); %%%%%%%%%%对R分量操作%%%%%%%
% MSR部分
Ir_log=log(Ir_double+1);  %将图像转换到对数域
f_Ir=fft2(Ir_double);  %对图像进行傅立叶变换,转换到频域中 %sigam=15的处理结果
fgauss=fft2(Gauss_1,size(Ir,1),size(Ir,2));
fgauss=fftshift(fgauss);  %将频域中心移到零点
Rr=ifft2(fgauss.*f_Ir);  %做卷积后变换回空域中
min1=min(min(Rr));
Rr_log= log(Rr - min1+1);
Rr1=Ir_log-Rr_log;  %sigam=80
fgauss=fft2(Gauss_2,size(Ir,1),size(Ir,2));
fgauss=fftshift(fgauss);
Rr= ifft2(fgauss.*f_Ir);
min1=min(min(Rr));
Rr_log= log(Rr - min1+1);
Rr2=Ir_log-Rr_log;  %sigam=250
fgauss=fft2(Gauss_3,size(Ir,1),size(Ir,2));
fgauss=fftshift(fgauss);
Rr= ifft2(fgauss.*f_Ir);
min1=min(min(Rr));
Rr_log= log(Rr - min1+1);
Rr3=Ir_log-Rr_log; Rr=0.33*Rr1+0.34*Rr2+0.33*Rr3;   %加权求和
MSR1 = Rr;
SSR1 = Rr2;
%计算CR
CRr = beta*(log(alpha*Ir_double+1)-log(Ir_double+Ig_double+Ib_double+1)); %SSR:
min1 = min(min(SSR1));
max1 = max(max(SSR1));
SSR1 = uint8(255*(SSR1-min1)/(max1-min1)); %MSR
min1 = min(min(MSR1));
max1 = max(max(MSR1));
MSR1 = uint8(255*(MSR1-min1)/(max1-min1)); %MSRCR
Rr = G*(CRr.*Rr+b);
min1 = min(min(Rr));
max1 = max(max(Rr));
Rr_final = uint8(255*(Rr-min1)/(max1-min1)); %%%%%%%%%%对g分量操作%%%%%%%
Ig_double=double(Ig);
Ig_log=log(Ig_double+1);  %将图像转换到对数域
f_Ig=fft2(Ig_double);  %对图像进行傅立叶变换,转换到频域中 fgauss=fft2(Gauss_1,size(Ig,1),size(Ig,2));
fgauss=fftshift(fgauss);  %将频域中心移到零点
Rg= ifft2(fgauss.*f_Ig);  %做卷积后变换回空域中
min2=min(min(Rg));
Rg_log= log(Rg-min2+1);
Rg1=Ig_log-Rg_log;  %sigam=15的处理结果 fgauss=fft2(Gauss_2,size(Ig,1),size(Ig,2));
fgauss=fftshift(fgauss);
Rg= ifft2(fgauss.*f_Ig);
min2=min(min(Rg));
Rg_log= log(Rg-min2+1);
Rg2=Ig_log-Rg_log;  %sigam=80 fgauss=fft2(Gauss_3,size(Ig,1),size(Ig,2));
fgauss=fftshift(fgauss);
Rg= ifft2(fgauss.*f_Ig);
min2=min(min(Rg));
Rg_log= log(Rg-min2+1);
Rg3=Ig_log-Rg_log;  %sigam=250 Rg=0.33*Rg1+0.34*Rg2+0.33*Rg3;   %加权求和
SSR2 = Rg2;
MSR2 = Rg;
%计算CR
CRg = beta*(log(alpha*Ig_double+1)-log(Ir_double+Ig_double+Ib_double+1)); %SSR:
min2 = min(min(SSR2));
max2 = max(max(SSR2));
SSR2 = uint8(255*(SSR2-min2)/(max2-min2)); %MSR
min2 = min(min(MSR2));
max2 = max(max(MSR2));
MSR2 = uint8(255*(MSR2-min2)/(max2-min2)); %MSRCR
Rg = G*(CRg.*Rg+b);
min2 = min(min(Rg));
max2 = max(max(Rg));
Rg_final = uint8(255*(Rg-min2)/(max2-min2)); %%%%%%%%%%对B分量操作同R分量%%%%%%%
Ib_double=double(Ib);
Ib_log=log(Ib_double+1);
f_Ib=fft2(Ib_double); fgauss=fft2(Gauss_1,size(Ib,1),size(Ib,2));
fgauss=fftshift(fgauss);
Rb= ifft2(fgauss.*f_Ib);
min3=min(min(Rb));
Rb_log= log(Rb-min3+1);
Rb1=Ib_log-Rb_log; fgauss=fft2(Gauss_2,size(Ib,1),size(Ib,2));
fgauss=fftshift(fgauss);
Rb= ifft2(fgauss.*f_Ib);
min3=min(min(Rb));
Rb_log= log(Rb-min3+1);
Rb2=Ib_log-Rb_log; fgauss=fft2(Gauss_3,size(Ib,1),size(Ib,2));
fgauss=fftshift(fgauss);
Rb= ifft2(fgauss.*f_Ib);
min3=min(min(Rb));
Rb_log= log(Rb-min3+1);
Rb3=Ib_log-Rb_log; Rb=0.33*Rb1+0.34*Rb2+0.33*Rb3; %计算CR
CRb = beta*(log(alpha*Ib_double+1)-log(Ir_double+Ig_double+Ib_double+1));
SSR3 = Rb2;
MSR3 = Rb;
%SSR:
min3 = min(min(SSR3));
max3 = max(max(SSR3));
SSR3 = uint8(255*(SSR3-min3)/(max3-min3));%MSR
min3 = min(min(MSR3));
max3 = max(max(MSR3));
MSR3 = uint8(255*(MSR3-min3)/(max3-min3));%MSRCR
Rb = G*(CRb.*Rb+b);
min3 = min(min(Rb));
max3 = max(max(Rb));
Rb_final = uint8(255*(Rb-min3)/(max3-min3)); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ssr = cat(3,SSR1,SSR2,SSR3);
msr = cat(3,MSR1,MSR2,MSR3);
msrcr=cat(3,Rr_final,Rg_final,Rb_final);  %将三通道图像合并 subplot(2,2,1);imshow(I);title('原图')  %显示原始图像
subplot(2,2,2);imshow(ssr);title('SSR')
subplot(2,2,3);imshow(msr);title('MSR')
subplot(2,2,4);imshow(msrcr);title('MSRCR')  %显示处理后的图像

参考与更多

Retinex相关的还有一个：低光照图像增强网络-RetinexNet，有兴趣的也可以去看看。
高维几何分析图像色彩增强
图像处理基础（十六）低光照增强

相位恢复

相位恢复是信号处理中的一个重要问题，它是从信号在某个变换域的幅度测量值来恢复该信号．其问题背景如下：将待测物体（信号）放置在指定位置，用透射光照射，经过衍射成像，可以由探测器得到其振幅分布．我们需要从该振幅分布中恢复出原始信号的信息．由 Fraunhofer 衍射方程可知，探测器处的光场可以被观测物体的傅里叶变换很好地逼近．但是因为实际中的探测器只能测量光的强度，因此我们只能得到振幅信息．

python opencv 常用增强 dct变换+侵蚀+扩张+索贝尔算子+直方图均衡化+光照平衡+相关推荐

图像算法一：【图像点运算】灰度直方图、伽马变换、灰度阈值变换、分段线性变换、直方图均衡化
灰度直方图:imhist() %描述了图像灰度统计信息,主要应用于图像分割和图像灰度变换.>>Img=imread( ' xxx.jpg' ); %读图>>I=imhist(I ...
Python OpenCV -- 霍夫线变换（十二）
霍夫线变换 1. 霍夫线变换是一种用来寻找直线的方法. 2. 是用霍夫线变换之前, 首先要对图像进行边缘检测的处理,也即霍夫线变换的直接输入只能是边缘二值图像. 实现: 1. 一条直线在图像二维空间 ...
Python+Opencv常用小工具集合
目录一.小工具1-URL转化为图片二.小工具2-鼠标响应参考资料注意事项一.小工具1-URL转化为图片 1.代码实现 # coding=utf-8 # 导入python包 import nu ...
python opencv投影变换增强
边缘填充: image = cv2.copyMakeBorder(image, add_width, add_width, add_width, add_width, cv2.BORDER_REPLI ...
OpenCV之灰度空间变换
OpenCV入门之灰度空间变换本系列博客主要以数字图像处理第三版为算法基础,以OpenCV为工具进行图像处理基础知识的分享.该教材的前两张基础知识这里不详述,有需要的读者自行查阅.本篇博客介绍第三章 ...
python opencv 直方图均衡_深入理解OpenCV+Python直方图均衡化
原标题:深入理解OpenCV+Python直方图均衡化正文直方图均衡化是图像处理领域中利用图像直方图对对比度进行调整的方法. 基本思想:把原始图的直方图变换为均匀分布的形式,这样就增加了像素灰度 ...
[Python图像处理] 三十八.OpenCV图像增强和图像去雾万字详解（直方图均衡化、局部直方图均衡化、自动色彩均衡化）
该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门.OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子.图像增强技术.图像分割等,后期结合深度学习研究图像识别 ...
图像细节增强（直方图均衡化，对数变换，Gamma变换（校正））
图像细节增强(直方图均衡化,对数变换,Gamma变换(校正)) 文章目录一.直方图均衡化 1.定义 2.原理 3.方法步骤二.对数变换 1.原理三.Gamma校正 1.原理 # 前言重新梳理图 ...
OpenCV图像处理学习二十，图像直方图均衡化原理与实现
一.图像直方图的概念图像直方图,是指对整个图像在灰度范围内的像素值(0~255)统计出现频率次数,据此生成的直方图,称为图像直方图.直方图反映了图像灰度的分布情况,是图像的统计学特征.图像的灰度直方 ...

python opencv 常用增强 dct变换+侵蚀+扩张+索贝尔算子+直方图均衡化+光照平衡+

裁剪操作

通道置零

侵蚀扩张

索贝尔算子

Python OpenCV直方图均衡化详解

增强

dct变换

光照平衡 Retinex理论

matlab实现

参考与更多

相位恢复

python opencv 常用增强 dct变换+侵蚀+扩张+索贝尔算子+直方图均衡化+光照平衡+相关推荐

最新文章

热门文章

python opencv 常用增强 dct变换+侵蚀+扩张+索贝尔算子+直方图均衡化+光照平衡+

裁剪操作

通道置零

侵蚀 扩张

索贝尔算子

Python OpenCV直方图均衡化详解

增强

dct变换

光照平衡 Retinex理论

matlab实现

参考与更多

相位恢复

python opencv 常用增强 dct变换+侵蚀+扩张+索贝尔算子+直方图均衡化+光照平衡+相关推荐

最新文章

热门文章

侵蚀扩张