数字图像处理的一些基本变换

最新推荐文章于 2024-06-08 16:55:55 发布
最新推荐文章于 2024-06-08 16:55:55 发布
阅读量310 收藏
点赞数
分类专栏： 数字图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mr_yuekitty/article/details/105777596
版权

目录

直方图均衡化

实现函数
# 绘制直方图
def histogram(img):
    if img.dtype == 'uint8':
        hist = np.zeros(256)
        l = 256
    elif img.dtype == 'uint16':
        hist = np.zeros(65536)
        l = 65536
    else:
        return 0
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            hist[img[i][j]] += 1
    return l, hist
实例
# 绘制直方图
def histogram(img):
    if img.dtype == 'uint8':
        hist = np.zeros(256)
        l = 256
    elif img.dtype == 'uint16':
        hist = np.zeros(65536)
        l = 65536
    else:
        return 0
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            hist[img[i][j]] += 1
    return l, hist

if __name__ == '__main__':
    img=cv2.imread('../image/lena-gray.png',-1)
    L,hist = histogram(img)

    Cumulative_histogram = {}
    tmp = 0
    for i in range(hist.size):
        if hist[i] != 0:
           Cumulative_histogram[i] = hist[i]/img.size+tmp
           tmp = Cumulative_histogram[i]
            
            
    for i in Cumulative_histogram.keys():
        tmp = math.floor((L-1) * Cumulative_histogram[i]+0.5)
        Cumulative_histogram[i] = tmp
        
    new_img = np.array(img)
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            if img[i][j] in Cumulative_histogram.keys():
                new_img[i][j] = Cumulative_histogram[img[i][j]]
    l,new_hist = histogram(new_img)
    
    x_ori = np.linspace(0,L,256)
    x_new = np.linspace(0,l,256)
    
    plt.subplot(231),plt.imshow(img,cmap = 'gray')
    plt.title('Input Image'), plt.xticks([]), plt.yticks([])
    plt.subplot(232),plt.bar(x_ori,hist)
    plt.title("histogram"),plt.xlabel("Bins")
    plt.ylabel("# of Pixels"),plt.xlim([0,256])
    plt.subplot(234),plt.imshow(new_img,cmap = 'gray')
    plt.title('Processed Image'), plt.xticks([]), plt.yticks([])
    plt.subplot(235),plt.bar(x_new,new_hist)
    plt.title("histogram"),plt.xlabel("Bins")
    plt.ylabel("# of Pixels"),plt.xlim([0,256])
    plt.show()

直方图归并化

## function: get the histogram of img
def histogram(img):
    if img.dtype=='uint8':
        hist = np.zeros(256)
        l = 256
    elif img.dtype=='uint16':
        hist = np.zeros(65536)
        l = 65536
    else:
        return 0
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
              hist[img[i][j]]+=1
    return l,hist

####   histogram Equalization  & histogram Regulation
if __name__ == '__main__':
    ### read image
    img = cv2.imread('../image/lena-gray.png',-1)
    ### Step1: get histogram
    L,hist = histogram(img)

    ### Step2: get Cumulative histogram
    ##  need to delete the gray-value that not exist in image = freq=0
    Cumulative_histogram = {}
    tmp = 0
    for i in range(hist.size):
        if hist[i] != 0:
           Cumulative_histogram[i] = hist[i]/img.size+tmp
           tmp = Cumulative_histogram[i]
    # print("Cumulative_histogram:",Cumulative_histogram)

    ### Step3 & 4: calculate the original-gray to new-gray
    ##  histogram Equalization
    # for i in Cumulative_histogram.keys():
    #     tmp = math.floor((L-1) * Cumulative_histogram[i]+0.5)
    #     Cumulative_histogram[i] = tmp

    ##  histogram Regulation SML
    tmp = random.sample(range(0,255), 50)
    keys = sorted(tmp)
    values = [0]*50
    tmp = 0
    for i in range(49):
        values[i] = 0.02*(i+1)

    # print(Cumulative_histogram)
    for i in Cumulative_histogram.keys():
        tmp1 = Cumulative_histogram[i]
        tmp = 1
        for j in range(50):
            if (abs(tmp1 - values[j]) < tmp):
                Cumulative_histogram[i] = keys[j]
                tmp = abs(tmp1 - values[j])
            else:
                break
    # # print("old-gary to new-gray:",Cumulative_histogram)
    #
    ### Step5: get new image
    new_img = np.array(img)
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            if img[i][j] in Cumulative_histogram.keys():
                new_img[i][j] = Cumulative_histogram[img[i][j]]
    l,new_hist = histogram(new_img)

    ### show image
    x_ori = np.linspace(0,L,256)
    x_new = np.linspace(0,l,256)
    values = [0.02*512*512]*50
    plt.subplot(231),plt.imshow(img,cmap = 'gray')
    plt.title('Input Image'), plt.xticks([]), plt.yticks([])
    plt.subplot(232),plt.bar(x_ori,hist)
    plt.title("histogram"),plt.xlabel("Bins")
    plt.ylabel("# of Pixels"),plt.xlim([0,256])
    plt.subplot(233),plt.bar(keys,values)
    plt.title("regulation histogram"),plt.xlabel("Bins")
    plt.ylabel("# of Pixels"),plt.xlim([0,256])
    plt.subplot(234),plt.imshow(new_img,cmap = 'gray')
    plt.title('Processed Image'), plt.xticks([]), plt.yticks([])
    plt.subplot(235),plt.bar(x_new,new_hist)
    plt.title("histogram"),plt.xlabel("Bins")
    plt.ylabel("# of Pixels"),plt.xlim([0,256])
    plt.show()

模拟卷积函数



#########################  template process  ########################

##   average-neighborhood
##   template convolution
def template_convolution(img,temp):
    r,c = img.shape
    h1,v1 = temp.shape
    h = math.floor(h1 / 2)  ## threshold of row
    v = math.floor(v1 / 2)  ## threshold ofColumn
    N = sum(sum(temp))
    new_img = np.zeros((r,c))
    for i in range(h,r-h):
        for j in range(v,c-v):
            if N !=0:
                new_img[i][j] = abs(np.sum(img[i-h:i+h+1,j-v:j+v+1] * temp))/N
            else:
                new_img[i][j] = abs(np.sum(img[i-h:i+h+1,j-v:j+v+1] * temp))
    return new_img
if __name__ == '__main__':
    img = cv2.imread('../image/lena-gray.png', -1)
    ##   define the template
    t_3 = np.ones((3,3))
    t_11 = np.ones((11,11))
    # t_Gaussian = np.array([[1,4,7,4,1],[4,16,26,16,4],[7,26,41,26,7],[4,16,26,16,4],[1,4,5,4,1]])
    # t_Lap = np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]])
    # new_img3 = template_convolution(img,t_3)
    # new_img11 = template_convolution(img,t_11)
    # new_imgG = template_convolution(img,t_Gaussian)
    # new_imgL = template_convolution(img,t_Lap)
    # plt.subplot(231),plt.imshow(img,cmap = 'gray')
    # plt.title('Input Image'), plt.xticks([]), plt.yticks([])
    # plt.subplot(232),plt.imshow(new_img3,cmap = 'gray')
    # plt.title('3*3 Average'), plt.xticks([]), plt.yticks([])
    # plt.subplot(233),plt.imshow(new_img11,cmap = 'gray')
    # plt.title('11*11 Average'), plt.xticks([]), plt.yticks([])
    # plt.subplot(234),plt.imshow(new_imgG,cmap = 'gray')
    # plt.title('Gaussian Average'), plt.xticks([]), plt.yticks([])
    # plt.subplot(235),plt.imshow(new_imgL,cmap = 'gray')
    # plt.title('Laplace sharp'), plt.xticks([]), plt.yticks([])
    # plt.show()
##   template_sort for max\min\median\mean
##   flag = None is mean, =1 is max, =-1 is min =0 is median
##   temp is the size of the template(row and column are euqal)
def template_sort(img,temp,flag=None):
    r,c = img.shape
    h = math.floor(temp/2)  ## threshold of row and column
    new_img = np.zeros((r,c))
    for i in range(h,r-h):
        for j in range(h,c-h):
            if flag == None:
                new_img[i][j] = np.mean(img[i-h:i+h+1,j-h:j+h+1])
            elif flag == 1:
                new_img[i][j] = np.max(img[i-h:i+h+1,j-h:j+h+1])
            elif flag == -1:
                new_img[i][j] = np.min(img[i-h:i+h+1,j-h:j+h+1])
            elif flag == 0:
                new_img[i][j] = np.median(img[i-h:i+h+1,j-h:j+h+1])
    return new_img
##   smooth filter with template
if __name__ == '__main__':
    img = cv2.imread('lena-gray.png', -1)
    new_img_mean = template_sort(img, 3)
    new_img_max = template_sort(img, 3, 1)
    new_img_min = template_sort(img, 3, -1)
    new_img_median = template_sort(img, 3, 0)

    plt.subplot(231),plt.imshow(img,cmap = 'gray')
    plt.title('Input Image'), plt.xticks([]), plt.yticks([])
    plt.subplot(232),plt.imshow(new_img_mean,cmap = 'gray')
    plt.title('3*3 mean'), plt.xticks([]), plt.yticks([])
    plt.subplot(233),plt.imshow(new_img_max,cmap = 'gray')
    plt.title('3*3 max'), plt.xticks([]), plt.yticks([])
    plt.subplot(234),plt.imshow(new_img_min,cmap = 'gray')
    plt.title('3*3 min'), plt.xticks([]), plt.yticks([])
    plt.subplot(235),plt.imshow(new_img_median,cmap = 'gray')
    plt.title('3*3 median'), plt.xticks([]), plt.yticks([])
    plt.show()

傅里叶变换

import cv2
import numpy as np
from matplotlib import pyplot as plt
import math
import random
import datetime
import pywt

########   2-dimensional discrete Fourier Transform
######   -------------------Method 1 start ----------------------
def DFT(sig):
    N = sig.size
    V = np.array([[np.exp(-1j*2*np.pi*v*y/N) for v in range(N)] for y in range(N)])
    return sig.dot(V)

def FFT(x):
    N = x.shape[1] # 只需考虑第二个维度，然后在第一个维度循环
    if N % 2 > 0:
        raise ValueError("size of x must be a power of 2")
    elif N <= 8:  # this cutoff should be optimized
        return np.array([DFT(x[i,:]) for i in range(x.shape[0])])
    else:
        X_even = FFT(x[:,::2])
        X_odd = FFT(x[:,1::2])
        factor = np.array([np.exp(-2j * np.pi * np.arange(N/2) / N) for i in range(x.shape[0])])
        return np.hstack([X_even + np.multiply(factor[:,:int(N/2)],X_odd),
                               X_even - np.multiply(factor[:,:int(N/2)],X_odd)])

def FFT2D(img):
    return FFT(FFT(img).T).T

def FFT_SHIFT(img):
    M,N = img.shape
    M = int(M/2)
    N = int(N/2)
    return np.vstack((np.hstack((img[M:,N:],img[M:,:N])),np.hstack((img[:M,N:],img[:M,:N]))))
######   -------------------Method 1 end   ----------------------

######   -------------------Method 2 start ----------------------
# 对输入数据进行倒序排列
def forward_input_data(input_data, num):
    j = num / 2
    for i in range(1, num - 2):
        if (i < j):
            complex_tmp = input_data[i]
            input_data[i] = input_data[int(j)]
            input_data[int(j)] = complex_tmp
            # print("forward x[%d] <==> x[%d]" % (i, j))
        k = num / 2
        while (j >= k):
            j = j - k
            k = k / 2
        j = j + k
    return input_data
# 实现1D FFT
def fft_1d(in_data, num):
    PI = np.pi
    in_data = forward_input_data(in_data,num)  # 倒序输入数据
    # 计算蝶形级数，也就是迭代次数
    M = 1  # num = 2^m
    tmp = num / 2;
    while (tmp != 1):
        M = M + 1
        tmp = tmp / 2
    # print("FFT level：%d" % M)
    for L in range(1, M + 1):
        B = int(math.pow(2, L - 1))  # B为指数函数返回值，为float，需要转换integer
        for J in range(0, B):
            P = math.pow(2, M - L) * J
            for K in range(J, num, int(math.pow(2, L))):
                # print("L:%d B:%d, J:%d, K:%d, P:%f" % (L, B, J, K, P))
                complex_ret = complex(math.cos((2 * PI / num) * P),math.sin((2 * PI / num) * P))
                complex_mul = complex_ret*in_data[K + B]
                complex_add = in_data[K]+complex_mul
                complex_sub = in_data[K]-complex_mul
                in_data[K] = complex_add
                in_data[K + B] = complex_sub
    return in_data
######   -------------------Method 2 end ----------------------

if __name__ == '__main__':
    img = cv2.imread('../image/lena-gray.png', -1)
    m,n = img.shape


    ####  method 1
    start = datetime.datetime.now()
    my_fft = (FFT2D(img))  # F(0,0)
    end = datetime.datetime.now()
    print("the time spent of method1:", end - start)

    my_fft = abs(FFT_SHIFT(my_fft))
    method1_spectrum = 20 * np.log(np.abs(my_fft))

    ###  method 2
    start = datetime.datetime.now()
    fft_result = np.zeros(img.shape, dtype=np.complex)
    # row transform
    for i in range(m):
        # 将数据转换为complex类的形式，存储在变量data中
        fft_result[i] = fft_1d(img[i, :].astype(np.complex), n)
    # column transform
    for i in range(n):
        fft_result[:, i] = fft_1d(fft_result[:, i], m)
    end = datetime.datetime.now()
    print("the time spent of method2:", end - start)
    # 调用fftshift()函数转移到中间位置
    fshift = np.fft.fftshift(fft_result)
    # fft结果是复数, 其绝对值结果是振幅
    method2_spectrum = 20 * np.log(np.abs(fshift))

    ### np.fft
    # 快速傅里叶变换算法得到频率分布
    start = datetime.datetime.now()
    f = np.fft.fft2(img)
    # left_mid_spectrum = 20*np.log(np.abs(f))
    end = datetime.datetime.now()
    print("the time spent of np-fft:", end - start)
    # 默认结果中心点位置是在左上角,
    # 调用fftshift()函数转移到中间位置
    fshift = np.fft.fftshift(f)
    # fft结果是复数, 其绝对值结果是振幅
    np_spectrum = 20 * np.log(np.abs(fshift))
    # #傅里叶逆变换
    # ishift = np.fft.ifftshift(fshift)
    # iimg = np.fft.ifft2(ishift)
    # iimg = np.abs(iimg)

    #### opencv.fft
    start = datetime.datetime.now()
    dft = cv2.dft(np.float32(img), flags=cv2.DFT_COMPLEX_OUTPUT)
    end = datetime.datetime.now()
    print("the time spent of opencv-fft:", end - start)
    dft_shift = np.fft.fftshift(dft)
    opencv_spectrum = 20 * np.log(cv2.magnitude(dft_shift[:, :, 0], dft_shift[:, :, 1]))

    plt.subplot(231), plt.imshow(img, cmap='gray')
    plt.title('Input Image'), plt.xticks([]), plt.yticks([])
    plt.subplot(232), plt.imshow(method1_spectrum, cmap='gray')
    plt.title('method1 Spectrum'), plt.xticks([]), plt.yticks([])
    plt.subplot(233), plt.imshow(method2_spectrum, cmap='gray')
    plt.title('method2 Spectrum'), plt.xticks([]), plt.yticks([])
    plt.subplot(234), plt.imshow(np_spectrum, cmap='gray')
    plt.title('np Spectrum'), plt.xticks([]), plt.yticks([])
    plt.subplot(235), plt.imshow(opencv_spectrum, cmap='gray')
    plt.title('opencv Spectrum'), plt.xticks([]), plt.yticks([])
    plt.show()
    ###
    # Resize_res = cv2.resize(img, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
    # M = cv2.getRotationMatrix2D((m / 2, n / 2), 45, 1)
    # Rotation_dst = cv2.warpAffine(img, M, (n, m))
    # Translation_res = cv2.warpAffine(img, np.float32([[1,0,50],[0,1,100]]), (m, n))
    # plt.subplot(231),plt.imshow(img, cmap = 'gray')
    # plt.title('Input Image'), plt.xticks([]), plt.yticks([])
    # plt.subplot(232),plt.imshow(Resize_res, cmap = 'gray')
    # plt.title('Resize'), plt.xticks([]), plt.yticks([])
    # plt.subplot(233),plt.imshow(Rotation_dst, cmap = 'gray')
    # plt.title('Rotation'), plt.xticks([]), plt.yticks([])
    # plt.subplot(234),plt.imshow(Translation_res, cmap = 'gray')
    # plt.title('Translation'), plt.xticks([]), plt.yticks([])
    # plt.show()

    # # 二维小波一级变换
    # coeffs = pywt.dwt2(img, 'haar')
    # cA, (cH, cV, cD) = coeffs
    # # 二维图像多级分解
    # coeffs = pywt.wavedec2(img, 'haar', level=2)
    # cA2, (cH2, cV2, cD2), (cH1, cV1, cD1) = coeffs
    #
    # level1_img = np.zeros(img.shape)
    # level1_img[:math.ceil(m / 2), :math.ceil(n/2)] = cA
    # level1_img[:math.ceil(m / 2), math.ceil(n / 2):] = cH
    # level1_img[math.ceil(m / 2):, :math.ceil(n / 2)] = cV
    # level1_img[math.ceil(m / 2):, math.ceil(n / 2):] = cD
    # plt.subplot(121),plt.imshow(img, cmap = 'gray')
    # plt.title('Input Image'), plt.xticks([]), plt.yticks([])
    # plt.subplot(122),plt.imshow(level1_img, cmap = 'gray')
    # plt.title('level1_img'), plt.xticks([]), plt.yticks([])
    # plt.show()

小波变换

import pywt

##########   wavelet transform  ###########
img = cv2.imread('../image/lena-gray.png', -1)
m,n = img.shape

# 二维小波一级变换
coeffs = pywt.dwt2(img, 'haar')
cA, (cH, cV, cD) = coeffs

# 合并图像
level1_img = np.zeros(img.shape)
level1_img[:math.ceil(m / 2), :math.ceil(n/2)] = cA
level1_img[:math.ceil(m / 2), math.ceil(n / 2):] = cH
level1_img[math.ceil(m / 2):, :math.ceil(n / 2)] = cV
level1_img[math.ceil(m / 2):, math.ceil(n / 2):] = cD
plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(level1_img, cmap = 'gray')
plt.title('level1_img'), plt.xticks([]), plt.yticks([])
plt.show()

同态滤波

import cv2
import numpy as np
from matplotlib import pyplot as plt
import math
import random
import datetime
import pywt

##########   wavelet transform  ###########
img = cv2.imread('../image/lena-gray.png', -1)
m,n = img.shape

# # 二维小波一级变换
# coeffs = pywt.dwt2(img, 'haar')
# cA, (cH, cV, cD) = coeffs
# # 二维图像多级分解
# coeffs = pywt.wavedec2(img, 'haar', level=2)
# cA2, (cH2, cV2, cD2), (cH1, cV1, cD1) = coeffs
# print(cA2.shape,cH2.shape, cV2.shape, cD2.shape,cH1.shape, cV1.shape, cD1.shape)
#
# plt.figure().suptitle('level =1 wave transform')
# level1_img = np.zeros(img.shape)
# level1_img[:math.ceil(m / 2), :math.ceil(n/2)] = cA
# level1_img[:math.ceil(m / 2), math.ceil(n / 2):] = cH
# level1_img[math.ceil(m / 2):, :math.ceil(n / 2)] = cV
# level1_img[math.ceil(m / 2):, math.ceil(n / 2):] = cD
# plt.subplot(121),plt.imshow(img, cmap = 'gray')
# plt.title('Input Image'), plt.xticks([]), plt.yticks([])
# plt.subplot(122),plt.imshow(level1_img, cmap = 'gray')
# plt.title('level1_img'), plt.xticks([]), plt.yticks([])
# plt.figure().suptitle('level = 2 wave transform')
# level2_img = np.zeros(img.shape)
# level2_img[:math.ceil(m / 4), :math.ceil(n/4)] = cA2
# level2_img[:math.ceil(m / 4), math.ceil(n/4):math.ceil(n/2)] = cH2
# level2_img[math.ceil(m / 4):math.ceil(m / 2), :math.ceil(n/4)] = cV2
# level2_img[math.ceil(m / 4):math.ceil(m / 2), math.ceil(n/4):math.ceil(n/2)] = cD2
# level2_img[:math.ceil(m / 2), math.ceil(n / 2):] = cH1
# level2_img[math.ceil(m / 2):, :math.ceil(n / 2)] = cV1
# level2_img[math.ceil(m / 2):, math.ceil(n / 2):] = cD1
# plt.subplot(121),plt.imshow(img, cmap = 'gray')
# plt.title('Input Image'), plt.xticks([]), plt.yticks([])
# plt.subplot(122),plt.imshow(level2_img, cmap = 'gray')
# plt.title('level1_img'), plt.xticks([]), plt.yticks([])
# plt.show()

##########   image enhancement  ###########
def template_convolution(img,temp):
    r,c = img.shape
    h1,v1 = temp.shape
    h = math.floor(h1 / 2)  ## threshold of row
    v = math.floor(v1 / 2)  ## threshold ofColumn
    N = sum(sum(temp))
    new_img = np.zeros((r,c))
    for i in range(h,r-h):
        for j in range(v,c-v):
            if N !=0:
                new_img[i][j] = abs(np.sum(img[i-h:i+h+1,j-v:j+v+1] * temp))/N
            else:
                new_img[i][j] = abs(np.sum(img[i-h:i+h+1,j-v:j+v+1] * temp))
    return new_img
### np.fft
# # #快速傅里叶变换算法得到频率分布
# f = np.fft.fft2(img)
# # 默认结果中心点位置是在左上角,
# # 调用fftshift()函数转移到中间位置
# fshift = np.fft.fftshift(f)
# # # fft结果是复数, 其绝对值结果是振幅
# np_spectrum = 20 * np.log(np.abs(fshift))
# # # low pass filter
# fm, fn = fshift.shape
# dm, dn = fm/2, fn/2
# low_pass_spectrum = np.zeros((fm,fn))
# low_pass_filter = np.array(fshift)
# low_pass_filter[int((fm-dm)/2):int((fm+dm)/2),int((fn-dn)/2):int((fn+dn)/2)] = 0
# low_pass_filter = fshift - low_pass_filter
# low_pass_spectrum[int((fm-dm)/2):int((fm+dm)/2),int((fn-dn)/2):int((fn+dn)/2)]\
#     =np_spectrum[int((fm-dm)/2):int((fm+dm)/2),int((fn-dn)/2):int((fn+dn)/2)]
# #
# high_pass_filter = fshift - low_pass_filter
# high_pass_spectrum = np_spectrum - low_pass_spectrum
# #
# # # #傅里叶逆变换
# ishift = np.fft.ifftshift(fshift)
# iimg = np.fft.ifft2(ishift)
# iimg = np.abs(iimg)
# # #
# ishift = np.fft.ifftshift(low_pass_filter)
# iimg1 = np.fft.ifft2(ishift)
# iimg1 = np.abs(iimg1)
# # #
# ishift = np.fft.ifftshift(high_pass_filter)
# iimg2 = np.fft.ifft2(ishift)
# iimg2 = np.abs(iimg2)
# #
# t_3 = np.ones((3,3))
# t_11 = np.ones((11,11))
# t_Gaussian = np.array([[1,4,7,4,1],[4,16,26,16,4],[7,26,41,26,7],[4,16,26,16,4],[1,4,5,4,1]])
# t_Lap = np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]])
# new_img11 = template_convolution(img,t_11)
# new_imgG = template_convolution(img,t_Gaussian)
# new_imgL = template_convolution(img,t_Lap)
# # #
# plt.figure().suptitle('Frequency domain image enhancement')
# plt.subplot(241),plt.imshow(img, cmap = 'gray')
# plt.title('Input Image'), plt.xticks([]), plt.yticks([])
# plt.subplot(242),plt.imshow(np_spectrum, cmap = 'gray')
# plt.title('np_spectrum'), plt.xticks([]), plt.yticks([])
# plt.subplot(243),plt.imshow(low_pass_spectrum, cmap = 'gray')
# plt.title('low_pass_spectrum'), plt.xticks([]), plt.yticks([])
# plt.subplot(244),plt.imshow(high_pass_spectrum, cmap = 'gray')
# plt.title('high_pass_spectrum'), plt.xticks([]), plt.yticks([])
# plt.subplot(246),plt.imshow(iimg, cmap = 'gray')
# plt.title('np_Inverse'), plt.xticks([]), plt.yticks([])
# plt.subplot(247),plt.imshow(iimg1, cmap = 'gray')
# plt.title('low_Inverse'), plt.xticks([]), plt.yticks([])
# plt.subplot(248),plt.imshow(iimg2, cmap = 'gray')
# plt.title('high_Inverse'), plt.xticks([]), plt.yticks([])
# # plt.show()
# #
# plt.figure().suptitle('Spatial domain image enhancement')
# plt.subplot(131),plt.imshow(new_img11,cmap = 'gray')
# plt.title('Conv 11*11 Average'), plt.xticks([]), plt.yticks([])
# plt.subplot(132),plt.imshow(new_imgG,cmap = 'gray')
# plt.title('Conv Gaussian Average'), plt.xticks([]), plt.yticks([])
# plt.subplot(133),plt.imshow(new_imgL,cmap = 'gray')
# plt.title('Conv Laplace sharp'), plt.xticks([]), plt.yticks([])
# plt.show()

##############  homo enhance
####  the parameter of H(u,v)
def homoenhance(img,rL=0.5,rH=2,c=2,d0=20):
    if len(img.shape) > 2:
        b_img = homofilter1(img[:, :, 0], rL, rH, c, d0)
        g_img = homofilter1(img[:, :, 1], rL, rH, c, d0)
        r_img = homofilter1(img[:, :, 2], rL, rH, c, d0)
        dst_img =cv2.merge([b_img,g_img,r_img])
    else:
        dst_img = homofilter1(img,  rL, rH, c, d0)
    return dst_img
def homofilter(img,rL=0.5,rH=2,c=2,d0=20):
    ### Build H(u,v)
    m,n = img.shape
    if m % 2 > 0:
        img = img[:m-1,:]
    elif n % 2 > 0:
        img = img[:,:n-1]
    m1 = np.floor(m/2)
    n1 = np.floor(n/2)
    M, N = np.meshgrid(np.arange(-n1, n1), np.arange(-m1, m1))
    D = M ** 2 + N ** 2
    d0 = d0 ** 2
    Huv = (rH-rL) * (1-np.exp(-c * (D / d0))) + rL
    imglog = np.log(img+1)                    ### log
    Fuv = np.fft.fft2(imglog.astype(np.uint8))       ### FFT
    imgifft = np.fft.ifft2(Huv*Fuv)           ### H(u,v)*F(u,v)  and iFFT
    dst_img = np.real(np.exp(imgifft)-1)      ### exp
    dst_img = np.uint8(np.clip(dst_img, 0, 255))
    return dst_img

def homofilter1(src, d0=10, r1=0.5, rh=2, c=4, h=2.0, l=0.5):
    gray = src.copy()
    if len(src.shape) > 2:
        gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
    gray = np.float64(gray)
    rows, cols = gray.shape
    if m % 2 > 0:
        gray = gray[:m-1,:]
    elif n % 2 > 0:
        gray = gray[:,:n-1]
    gray_fft = np.fft.fft2(gray)
    gray_fftshift = np.fft.fftshift(gray_fft)
    dst_fftshift = np.zeros_like(gray_fftshift)
    M, N = np.meshgrid(np.arange(-cols // 2, cols // 2), np.arange(-rows // 2, rows // 2))
    D = np.sqrt(M ** 2 + N ** 2)
    Z = (rh - r1) * (1 - np.exp(-c * (D ** 2 / d0 ** 2))) + r1
    dst_fftshift = Z * gray_fftshift
    dst_fftshift = (h - l) * dst_fftshift + l
    dst_ifftshift = np.fft.ifftshift(dst_fftshift)
    dst_ifft = np.fft.ifft2(dst_ifftshift)
    dst = np.real(dst_ifft)
    dst = np.uint8(np.clip(dst, 0, 255))
    return dst
#
#
if __name__ == '__main__':
    img = cv2.imread('../image/homotest1.png')
    img =cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    homoresult1 = homoenhance(img)
    if len(img.shape) > 2:
        b,g,r = cv2.split(img)
        img = cv2.merge([r, g, b])
        b,g,r = cv2.split(homoresult1)
        homoresult1 = cv2.merge([r, g, b])
        plt.subplot(131),plt.imshow(img)
        plt.title('original image'), plt.xticks([]), plt.yticks([])
        plt.subplot(132),plt.imshow(homoresult1)
        plt.title('homo result'), plt.xticks([]), plt.yticks([])
        plt.show()
    else:
        plt.subplot(131),plt.imshow(img,cmap='gray')
        plt.title('original image'), plt.xticks([]), plt.yticks([])
        plt.subplot(132),plt.imshow(homoresult1,cmap='gray')
        plt.title('homo result'), plt.xticks([]), plt.yticks([])
        plt.show()
Mr_yuekitty
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数字图像处理的基本步骤.doc
06-25
数字图像处理的基本步骤 数字图像处理是指对图像进行分析、加工、和处理，使其满足视觉、心理以及其他要求的技术。图像处理是信号处理在图像域上的一个应用。目前大多数的图像是以数字形式存储，因而图像处理很多...
数字图像处理（dip）
麦田里的守望者
01-11 6389
原文 学科：数字图像处理（Digital Image Processing -video） 作者：zhuhonggen 计算机视觉入门基础 0概念介绍 0.1数字图像处理概念 0.1.1图像的高频分量和低频分量 总得来说，低频分量（低频信号）代表着图像中亮度或者灰度值变化缓慢的区域，也就是图像中大片平坦的区域，描述了图像的主要部分。高频分量（高频信号）对应着图像变化剧烈的部分，也就是图像的边缘（轮廓）或者噪声以及细节部分。 之所以说噪声也对应着高频分量，是因为图像噪声在大部分情况下都是高频的。 低频分量
数字图像处理-图像增强-复习总结
Java攻城狮修炼中
12-13 5033
文章目录数字图像处理空域图像增强背景知识直方图概念 （掌握）灰度级变换（点处理）直方图处理（点处理）（掌握）算数运算（点处理）（掌握）空域滤波（领域处理）（掌握）频域图像增强滤波基础低通滤波器高通滤波器带通、带阻与陷波滤波器空域滤波与频域滤波的关系练习题 数字图像处理 空域图像增强 图像增强技术：包括空域和频域两部分 主要目标：通过对图像的处理，使图像处理更适合一个特定的应用。 应用：显示、打印、印刷、识别、分析等。 处理：去除噪声、边缘增强、提高对比度、增加亮度、改善颜色效果、改善细微层次等——通常与改
【计算机视觉】数字图像处理基础：以像素为单位的图像基本运算（点运算、代数运算、逻辑运算、几何运算、插值）
最新发布
Yaoyao2024的博客
06-08 2017
在上篇文章中，我们对什么是数字图像、以及数字图像的组成（离散的像素点）进行了讲解🔗。我们知道，数字图像其实就是像素点组成的二维矩阵。本节我们要讲的就是基于这个二维矩阵进行一些数学上的基本运算（本质就是就是矩阵的计算——线性代数），对图像进行处理，这些基本运算也是数字图像处理的基础和基本算法，本节我们将介绍这些基本算法。分别有以下几类Tips: 我们在进行下面的基本运算时，都是将像素值进行归一化到[0, 1]的取值范围的，方便变换和计算。在对应变换的时候也需要注意这点，避免产生误解。
【计算机视觉】数字图像处理（三）—— 图像变换原理分析
haoweixl的博客
01-02 1万+
数字图像处理（三）—— 图像变换原理分析图像变换的目的与用途傅里叶变换3、离散函数的傅立叶变换傅里叶变换的性质可分离性卷积与相关定理傅里叶变换的实例与应用 图像变换的目的与用途 图像变换的目的主要有以下三点： ① 使图像处理问题简化； ② 有利于图像特征提取（我们知道特征提取的目的是为了对影像进行分析，根据特征从影像中提取目标等有用信息，特征提取对从影像中提取目标非常重要）； ③ 有助于从概念或者物理上增强对图像信息的理解。 图像变换其实就是对图像的另外一种表达 正如我们可以将一个函数分解表示为奇偶函数、直
数字图像处理MATLAB大作业：基础版
热门推荐
qq_53384631的博客
11-22 1万+
基于MATLAB实现数字图像处理
数字图像处理(5)：幂次变换（C语言实现）
ZhaoDongyu_AK47的博客
06-26 7265
文章目录幂次变换核磁共振图像代码实现遇到问题附代码： 幂次变换 幂次变换，点运算的一种，运算公式为s=crγ，其中，c和γ是正常数。 当γ<1，此时扩展低灰度级，压缩高灰度级，在正比函数上方，使图像变亮； 当γ>1，此时扩展高灰度级，压缩低灰度级，在正比函数下方，使图像变暗。 核磁共振图像 是利用核磁共振（nuclear magnetic resonance，简称NMR）原理，依据所释放的能量在物质内部不同结构环境中不同的衰减，通过外加梯度磁场检测所发射出的电磁波，即可得知构成这一物体原子核的
数字图像处理的基本方法.docx
06-25
"数字图像处理的基本方法" 数字图像处理是一个非常广泛的概念，它可以分为两类，即输入输出都是一副图像和输入一张图像输出不再是图像的数据。图像处理的目的可以是将一幅图像加工成我们想要的效果，例如图像的降噪...
数字图像处理实验_matlab图像处理_图像变换_
10-04
在这个名为“数字图像处理实验_matlab图像处理_图像变换_”的资源包中，包含了MATLAB实现的基本二维离散傅里叶变换（2D DFT）、离散余弦变换（DCT）以及小波变换等关键图像处理技术。 一、二维离散傅里叶变换（2D ...
数字图像处理基本概念大纲
01-15
### 数字图像处理基本概念大纲 #### 一、图像、模拟图像和数字图像 - **图像**：人类视觉系统接收并处理的物体反射或透射的电磁波信息，在大脑中形成的印象。 - **模拟图像**：空间坐标和灰度值均为连续的图像，即...
数字图像处理期末考试题库.doc
06-14
数字图像处理是一门涉及多方面知识的学科，主要包含图像获取、图像变换、图像增强、图像恢复、图像压缩、图像分析、图像识别和图像理解等多个环节。这一领域注重处理精度高、再现性好的特点，同时也强调处理的多样性...
lena 512*512灰度、彩色图（bmp,mat,pgm,tiff)）
12-01
图像处理最为经典的lena图片，包含彩色(tiff格式)，灰度（bmp,mat,pgm格式），图片大小512*512
图像变换的基本模型
02-10
变换模型是指根据待匹配图像与背景图像之间几何畸变的情况，所选择的能最佳拟合两幅图像之间变化的几何变换模型。可采用的变换模型有如下几种:刚性变换、仿射变换、透视变换和非线形变换等
lena_gray_512.tif
09-28
图像处理最为经典的lena图片，tiff格式。
lena 图片 512*512 gray and color
04-23
lena 的标准图片，512*512 的，有灰度和彩色的，自己刚
数字图像处理取指数代码
04-21
精通系列\精通Visual C++数字图像处理技术与工程案例\chap01\取指数.rar
数字图像处理的python实践(2)——灰度线性、对数、指数变换
baidu_41902768的博客
06-27 1万+
我们目前比较好处理的对象是灰度图，因为它只有一个通道，也就意味着很多计算我们减少了一个维度，自然轻松一些。对于灰度图，首先要了解的是灰度直方图，也就是整体的图像中，灰度值的分布情况，通过直方图的形式来显示图片中是高灰度值的区域偏多还是低灰度值的区域偏多或者是其他情况，来指导我们后续的其他操作。以我们的之前转灰度的图片为例，结合matplotlib.pyplot库绘制归一化直方图的代...
【数字图像处理】实验（1）——图像基本变换
m0_52435951的博客
04-29 1万+
（1）将彩色图像采用不同的灰度化方法实现灰度化； （2）将彩色图像变换到 YCbCr、HSV 空间，熟悉各分量数据并显示； （3）不采用 Matlab 函数，自行设计基于双线性插值的图像放大程序。
数字图像处理：几何变换与MATLAB实现
"《数字图像处理》课程设计报告——图像几何变换系统设计" 在数字图像处理领域，几何变换是至关重要的一个部分，它涉及到图像在二维空间中的位置和形状变化。本篇报告主要探讨了四种基本的几何变换：平移、裁剪、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值