图像增强灰度变换算法代码python

以下是一个简单的图像增强灰度变换算法的 Python 代码：

import cv2
import numpy as np

# 读取图像
img = cv2.imread('image.jpg', cv2.IMREAD_GRAYSCALE)

# 灰度变换
gamma = 0.5
img_enhanced = np.power(img / float(np.max(img)), gamma)
img_enhanced = np.uint8(img_enhanced * 255)

# 显示图像
cv2.imshow('Original Image', img)
cv2.imshow('Enhanced Image', img_enhanced)
cv2.waitKey(0)
cv2.destroyAllWindows()

其中，`gamma` 是灰度变换的参数，可以根据需要进行调整。

相关问题

带有高斯噪声攻击、椒盐噪声攻击、旋转攻击的基于DWT的数字图像信息隐藏算法代码，载体图像和水印图像进行灰度变换，用python实现

以下是基于DWT的数字图像信息隐藏算法代码，包括高斯噪声攻击、椒盐噪声攻击、旋转攻击，用Python实现。

import cv2
import numpy as np
from matplotlib import pyplot as plt
import math

# 将灰度图像转换为二进制序列
def gray2bin(gray_img):
    bin_img = ''
    for i in range(gray_img.shape[0]):
        for j in range(gray_img.shape[1]):
            bin_img += '{0:08b}'.format(gray_img[i][j])
    return bin_img

# 将二进制序列转换为灰度图像
def bin2gray(bin_str, row, col):
    bin_len = row * col * 8
    if len(bin_str) != bin_len:
        return None
    bin_arr = np.array(list(bin_str), dtype=np.uint8).reshape((row, col, 8))
    gray_arr = np.packbits(bin_arr, axis=2).reshape((row, col))
    return gray_arr

# 将灰度图像转换为水印序列
def gray2watermark(gray_img):
    bin_img = gray2bin(gray_img)
    watermark = ''
    for i in range(0, len(bin_img), 2):
        if bin_img[i] == '1' and bin_img[i+1] == '0':
            watermark += '1'
        else:
            watermark += '0'
    return watermark

# 将水印序列转换为灰度图像
def watermark2gray(watermark_str, row, col):
    bin_img = ''
    for i in range(0, len(watermark_str)):
        if watermark_str[i] == '1':
            bin_img += '10'
        else:
            bin_img += '00'
    gray_img = bin2gray(bin_img, row, col)
    return gray_img

# 将灰度图像的每个像素值加上指定的值，避免DWT变换后出现0值
def add_salt(gray_img, salt):
    salt_img = gray_img.astype(np.int16)
    salt_img += salt
    salt_img[salt_img < 0] = 0
    salt_img[salt_img > 255] = 255
    return salt_img.astype(np.uint8)

# 对灰度图像进行DWT变换
def dwt2(gray_img):
    coeffs = pywt.dwt2(gray_img, 'haar')
    LL, (LH, HL, HH) = coeffs
    return LL, LH, HL, HH

# 对DWT系数进行量化和修改，实现信息隐藏
def embed(LL, LH, HL, HH, watermark, alpha):
    LL = LL.astype(np.float)
    LH = LH.astype(np.float)
    HL = HL.astype(np.float)
    HH = HH.astype(np.float)
    LL_shape = LL.shape
    watermark_len = len(watermark)
    for i in range(LL_shape[0]):
        for j in range(LL_shape[1]):
            if i*LL_shape[1]+j < watermark_len:
                if watermark[i*LL_shape[1]+j] == '1':
                    LL[i][j] += alpha
                else:
                    LL[i][j] -= alpha
            LH[i][j] = round(LH[i][j] / alpha) * alpha
            HL[i][j] = round(HL[i][j] / alpha) * alpha
            HH[i][j] = round(HH[i][j] / alpha) * alpha
    return LL, LH, HL, HH

# 对DWT系数进行逆变换，得到修改后的灰度图像
def idwt2(LL, LH, HL, HH):
    coeffs = LL, (LH, HL, HH)
    img = pywt.idwt2(coeffs, 'haar')
    return img.astype(np.uint8)

# 对灰度图像进行加高斯噪声攻击
def add_gaussian_noise(gray_img, mean=0, std=15):
    noise = np.random.normal(mean, std, gray_img.shape)
    noisy_img = gray_img.astype(np.int16)
    noisy_img += noise.astype(np.int16)
    noisy_img[noisy_img < 0] = 0
    noisy_img[noisy_img > 255] = 255
    return noisy_img.astype(np.uint8)

# 对灰度图像进行加椒盐噪声攻击
def add_salt_pepper_noise(gray_img, prob=0.05):
    noise = np.random.rand(*gray_img.shape)
    noisy_img = gray_img.copy()
    noisy_img[noise < prob/2] = 0
    noisy_img[noise > 1-prob/2] = 255
    return noisy_img

# 对灰度图像进行旋转攻击
def rotate_img(gray_img, angle):
    # 对图像进行旋转
    rows, cols = gray_img.shape
    M = cv2.getRotationMatrix2D((cols/2,rows/2),angle,1)
    rotated_img = cv2.warpAffine(gray_img,M,(cols,rows))
    # 对旋转后的图像进行裁剪，避免黑边的影响
    height, width = rotated_img.shape
    left = int((width - cols) / 2)
    right = int((width + cols) / 2)
    top = int((height - rows) / 2)
    bottom = int((height + rows) / 2)
    rotated_img = rotated_img[top:bottom, left:right]
    return rotated_img

# 读取载体图像和水印图像
carrier_img = cv2.imread('carrier.png', cv2.IMREAD_GRAYSCALE)
watermark_img = cv2.imread('watermark.png', cv2.IMREAD_GRAYSCALE)
# 将灰度值减去128，避免DWT变换后出现负值
carrier_img = add_salt(carrier_img, -128)
# 将水印图像转换为水印序列
watermark = gray2watermark(watermark_img)
# 对载体图像进行DWT变换，得到DWT系数
LL, LH, HL, HH = dwt2(carrier_img)
# 将水印信息嵌入DWT系数中，得到修改后的DWT系数
alpha = 15
LL_new, LH_new, HL_new, HH_new = embed(LL, LH, HL, HH, watermark, alpha)
# 对修改后的DWT系数进行逆变换，得到修改后的灰度图像
carrier_img_new = idwt2(LL_new, LH_new, HL_new, HH_new)
# 将灰度值加上128，得到最终的灰度图像
carrier_img_new = add_salt(carrier_img_new, 128)
# 对最终的灰度图像进行高斯噪声攻击
carrier_img_noisy = add_gaussian_noise(carrier_img_new)
# 对最终的灰度图像进行椒盐噪声攻击
carrier_img_noisy = add_salt_pepper_noise(carrier_img_new)
# 对最终的灰度图像进行旋转攻击
carrier_img_noisy = rotate_img(carrier_img_new, 30)
# 将嵌入水印的灰度图像、加高斯噪声攻击的灰度图像、加椒盐噪声攻击的灰度图像、旋转攻击后的灰度图像保存为文件
cv2.imwrite('carrier_new.png', carrier_img_new)
cv2.imwrite('carrier_noisy.png', carrier_img_noisy)
cv2.imwrite('carrier_salt_pepper.png', carrier_img_noisy)
cv2.imwrite('carrier_rotated.png', carrier_img_noisy)

其中，载体图像和水印图像可以任意选择，需要将两幅图像放在代码所在目录下，并分别命名为`carrier.png`和`watermark.png`。

以上代码中用到了`pywt`库，需要先安装该库，可以使用以下命令进行安装：

pip install pywavelets

运行以上代码后，会生成以下四幅图像：

- carrier_new.png：嵌入水印的灰度图像
- carrier_noisy.png：加高斯噪声攻击后的灰度图像
- carrier_salt_pepper.png：加椒盐噪声攻击后的灰度图像
- carrier_rotated.png：旋转攻击后的灰度图像

可以通过以下代码进行展示：

# 读取四幅图像进行展示
carrier_img = cv2.imread('carrier.png', cv2.IMREAD_GRAYSCALE)
carrier_img_new = cv2.imread('carrier_new.png', cv2.IMREAD_GRAYSCALE)
carrier_img_noisy = cv2.imread('carrier_noisy.png', cv2.IMREAD_GRAYSCALE)
carrier_img_salt_pepper = cv2.imread('carrier_salt_pepper.png', cv2.IMREAD_GRAYSCALE)
carrier_img_rotated = cv2.imread('carrier_rotated.png', cv2.IMREAD_GRAYSCALE)
watermark_img = cv2.imread('watermark.png', cv2.IMREAD_GRAYSCALE)
# 显示图像
plt.figure(figsize=(10,10))
plt.subplot(2, 3, 1)
plt.imshow(carrier_img, cmap='gray')
plt.title('Carrier Image')
plt.subplot(2, 3, 2)
plt.imshow(watermark_img, cmap='gray')
plt.title('Watermark Image')
plt.subplot(2, 3, 3)
plt.imshow(carrier_img_new, cmap='gray')
plt.title('Embedded Image')
plt.subplot(2, 3, 4)
plt.imshow(carrier_img_noisy, cmap='gray')
plt.title('Noisy Image')
plt.subplot(2, 3, 5)
plt.imshow(carrier_img_salt_pepper, cmap='gray')
plt.title('Salt and Pepper Image')
plt.subplot(2, 3, 6)
plt.imshow(carrier_img_rotated, cmap='gray')
plt.title('Rotated Image')
plt.show()

运行以上代码后，会将四幅图像展示在一个窗口中。

小波变换图像增强代码

小波变换是一种基于信号分解的分析方法，可以将图像分解成不同频率的子带，从而实现图像的局部处理和增强。小波变换图像增强的代码实现可以大致分为以下几个步骤：

1. 读取原始图像，并将其转换成灰度图像。

2. 对图像进行小波变换，得到不同频率的子带。

3. 对每个子带进行局部增强，可以使用直方图均衡化或者其他的增强算法。

4. 将处理后的子带合并成一幅图像，得到增强后的图像。

下面是一个简单的Python代码示例，实现了基于小波变换的图像增强：

import cv2
import numpy as np
import pywt

# 读取原始图像
img = cv2.imread('input.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 小波变换
coeffs = pywt.dwt2(gray, 'haar')
cA, (cH, cV, cD) = coeffs

# 局部增强
cA = cv2.equalizeHist(np.uint8(cA))
cH = cv2.equalizeHist(np.uint8(cH))
cV = cv2.equalizeHist(np.uint8(cV))
cD = cv2.equalizeHist(np.uint8(cD))

# 合并子带
coeffs = cA, (cH, cV, cD)
enhanced = pywt.idwt2(coeffs, 'haar')

# 显示结果
cv2.imshow('Input', gray)
cv2.imshow('Enhanced', enhanced)
cv2.waitKey(0)