Cálculo de varios atributos de imágenes.

cálculo del canal oscuro

import cv2
import numpy as np
import matplotlib.pyplot as plt
def dark_channel(image, window_size=15):
    # 计算图像的暗通道
    rows, cols, _ = image.shape
    dark_channel = np.zeros((rows, cols), dtype=np.uint8)
    for i in range(rows):
        for j in range(cols):
            start_x, end_x = max(i - window_size//2, 0), min(i + window_size//2, rows-1)
            start_y, end_y = max(j - window_size//2, 0), min(j + window_size//2, cols-1)
            patch = image[start_x:end_x+1, start_y:end_y+1, :]
            dark_channel[i, j] = np.min(patch)
    return dark_channel
# 读取图像
image = cv2.imread(file)

print(image.shape)
# 计算图像暗通道
dark_channel_img = dark_channel(image)

# 可视化原图和暗通道图
plt.subplot(121)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(dark_channel_img, cmap='gray')
plt.title('Dark Channel Image')
plt.axis('off')

plt.show()

Cálculo de contraste

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

def contrast_image(image):
    # 计算图像的均值
    mean_value = np.mean(image)

    # 计算图像的对比度图像
    contrast_img = np.abs(image - mean_value)
    
    # 将对比度图像归一化到0到255的范围
    contrast_img = (255 * (contrast_img / np.max(contrast_img))).astype(np.uint8)

    return contrast_img
# 读取图像
image = cv2.imread(file)

# 将图像转换为灰度图像
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 计算对比度图像
contrast_img = contrast_image(gray_image)

# 可视化原图和对比度图像
plt.subplot(121)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(contrast_img, cmap='gray')
plt.title('Contrast Image')
plt.axis('off')

plt.show()

Cálculo de saturación

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

def saturation_image(image):
    # 将图像从BGR颜色空间转换为HSV颜色空间
    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

    # 获取HSV图像的饱和度分量
    saturation_img = hsv_image[:, :, 1]

    # 将饱和度图像归一化到0到255的范围
    saturation_img = (255 * (saturation_img / np.max(saturation_img))).astype(np.uint8)

    return saturation_img

# 读取图像
image = cv2.imread(file)

# 计算饱和度图像
saturation_img = saturation_image(image)

# 可视化原图和饱和度图像
plt.subplot(121)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(saturation_img, cmap='gray')
plt.title('Saturation Image')
plt.axis('off')

plt.show()

Cálculo de croma

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

def chroma_image(image):
    # 将图像从BGR颜色空间转换为HSV颜色空间
    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

    # 获取HSV图像的色度分量
    chroma_img = hsv_image[:, :, 0]

    # 将色度图像归一化到0到255的范围
    chroma_img = (255 * (chroma_img / np.max(chroma_img))).astype(np.uint8)

    return chroma_img

# 读取图像
image = cv2.imread(file)

# 计算色度图像
chroma_img = chroma_image(image)

# 可视化原图和色度图像
plt.subplot(121)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(chroma_img, cmap='gray')
plt.title('Chroma Image')
plt.axis('off')

plt.show()

Cálculo de la variación de cromaticidad

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

def chroma_variance_image(image):
    # 将图像从BGR颜色空间转换为HSV颜色空间
    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

    # 获取HSV图像的色度分量
    chroma_img = hsv_image[:, :, 0]

    # 计算色度分量的方差
    chroma_variance_img = cv2.Sobel(chroma_img, cv2.CV_64F, 1, 0, ksize=3)**2

    # 将方差图像归一化到0到255的范围
    chroma_variance_img = (255 * (chroma_variance_img / np.max(chroma_variance_img))).astype(np.uint8)

    return chroma_variance_img

# 读取图像
image = cv2.imread(file)

# 计算色度方差图像
chroma_variance_img = chroma_variance_image(image)

# 可视化原图和色度方差图像
plt.subplot(121)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(chroma_variance_img, cmap='gray')

Cálculo de la riqueza del color.

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

def colorfulness_image(image):
    # 将图像从BGR颜色空间转换为HSV颜色空间
    hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

    # 获取HSV图像的饱和度和亮度分量
    saturation = hsv_image[:, :, 1]
    value = hsv_image[:, :, 2]

    # 计算饱和度和亮度分量的方差
    saturation_variance = cv2.Sobel(saturation, cv2.CV_64F, 1, 0, ksize=3)**2
    value_variance = cv2.Sobel(value, cv2.CV_64F, 1, 0, ksize=3)**2

    # 计算色彩丰富度
    colorfulness_img = np.sqrt(saturation_variance + value_variance)

    # 将色彩丰富度图像归一化到0到255的范围
    colorfulness_img = (255 * (colorfulness_img / np.max(colorfulness_img))).astype(np.uint8)

    return colorfulness_img

# 读取图像
image = cv2.imread(file)

# 计算色彩丰富度图像
colorfulness_img = colorfulness_image(image)

# 可视化原图和色彩丰富度图像
plt.subplot(121)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(colorfulness_img, cmap='gray')
plt.title('Colorfulness Image')
plt.axis('off')

plt.show()

Cálculo de nitidez

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

def sharpness_image(image):
    # 将图像转换为灰度图像
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # 计算图像的梯度
    gradient_x = cv2.Sobel(gray_image, cv2.CV_64F, 1, 0, ksize=3)
    gradient_y = cv2.Sobel(gray_image, cv2.CV_64F, 0, 1, ksize=3)

    # 计算锐度图像
    sharpness_img = np.sqrt(gradient_x**2 + gradient_y**2)

    # 将锐度图像归一化到0到255的范围
    sharpness_img = (255 * (sharpness_img / np.max(sharpness_img))).astype(np.uint8)

    return sharpness_img

# 读取图像
image = cv2.imread(file)

# 计算锐度图像
sharpness_img = sharpness_image(image)

# 可视化原图和锐度图像
plt.subplot(121)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(sharpness_img, cmap='gray')
plt.title('Sharpness Image')
plt.axis('off')

plt.show()

Cálculo de entropía de imagen

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

def entropy_image(image):
    # 将图像转换为灰度图像
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # 计算图像的灰度直方图
    hist = cv2.calcHist([gray_image], [0], None, [256], [0, 256])

    # 将直方图归一化，得到概率分布
    hist_prob = hist / np.sum(hist)

    # 计算图像的熵
    entropy = -np.sum(hist_prob * np.log2(hist_prob + 1e-8))

    # 创建与图像大小相同的熵图像
    entropy_img = np.ones_like(gray_image) * entropy

    return entropy_img
file = "D:\\My_Document\\Task\\Github_Project_Package\\image_recognition_visibility\\examples\\class4\\19.51_share_data5_VIDEO_PIC_tianjinHighway_20230210_123306000000022044_202302100630.jpg"
# 读取图像
image = cv2.imread(file)

# 计算熵图像
entropy_img = entropy_image(image)

# 可视化原图和熵图像
plt.subplot(121)
plt.imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')

plt.subplot(122)
plt.imshow(entropy_img, cmap='gray')
plt.title('Entropy Image')
plt.axis('off')

plt.show()