裁剪操作
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 weaken
lutSRaisen = np.dstack((lutEqual, lutRaisen, lutEqual)) # Saturation raisen
# 调节明度
lutVWeaken = np.dstack((lutEqual, lutEqual, lutWeaken)) # Value weaken
lutVRaisen = np.dstack((lutEqual, lutEqual, lutRaisen)) # Value raisen
blendSWeaken = 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 np
import cv2
import numpy as np
import math
def psnr(img1, img2): # https://blog.csdn.net/u010886794/article/details/84784453
mse = np.mean((img1 / 255. - img2 / 255.) ** 2)
PIXEL_MAX = 1
return 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 ) 信 息 图 像 。 所 以 l o g R = l o g I − l o g L L 由 对 I 高 通 滤 波 得 到 这 样 就 能 计 算 得 到 L o g [ R ( x , y ) ] 了 ， 最 后 e x p 处 理 即 可 ( 但 实 际 都 用 以 下 的 放 缩 操 作 ) 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 plt
def 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 gauss
def 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 R
def ShineBlance(img):
result = []
r, c, _ = img.shape
gauss15 = 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)) * 46
result15 = msr(t, gauss15)
result80 = msr(t, gauss80)
result250 = msr(t, gauss250)
m = (result15 + result80 + result250) / 3
min1 = np.min(m)
max1 = np.max(m)
m = np.uint8(255 * (m - min1) / (max1 - min1)) # msr
r = 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 result
img = 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 cv2
def singleScaleRetinex(img, sigma):
retinex = np.log10(img) - np.log10(cv2.GaussianBlur(img, (0, 0), sigma))
return retinex
def multiScaleRetinex(img, sigma_list):
retinex = np.zeros_like(img)
for sigma in sigma_list:
retinex += singleScaleRetinex(img, sigma)
retinex = retinex / len(sigma_list)
return retinex
def 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_restoration
def 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 = 0
for u, c in zip(unique, counts):
if float(current) / total < low_clip:
low_val = u
if float(current) / total < high_clip:
high_val = u
current += c
img[:, :, 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.0
img_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])) * \
255
img_msrcr = np.uint8(np.minimum(np.maximum(img_msrcr, 0), 255))
img_msrcr = simplestColorBalance(img_msrcr, low_clip, high_clip)
return img_msrcr
def automatedMSRCR(img, sigma_list):
img = np.float64(img) + 1.0
img_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 = c
break
low_val = unique[0] / 100.0
high_val = unique[-1] / 100.0
for u, c in zip(unique, count):
if u < 0 and c < zero_count * 0.1:
low_val = u / 100.0
if u > 0 and c < zero_count * 0.1:
high_val = u / 100.0
break
img_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])) \
* 255
img_retinex = np.uint8(img_retinex)
return img_retinex
def MSRCP(img, sigma_list, low_clip, high_clip):
img = np.float64(img) + 1.0
intensity = 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.0
img_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 衍射方程可知，探测器处的光场可以被观测物体的傅里叶变换很好地逼近．但是因为实际中的探测器只能测量光的强度，因此我们只能得到振幅信息．
1772
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
