Aplicación de Visión por Computadora 15-Aplicación del modelo de cálculo de ángulo del código de verificación de rotación de imagen para resolver el problema de corrección de imagen rotada

Hola a todos, soy Wei Xue AI. Hoy les presentaré la aplicación de visión por computadora 15: la aplicación del modelo de cálculo de ángulos del código de verificación de rotación de imágenes para resolver el problema de la corrección de imágenes rotadas. En el campo de CV, se utiliza el modelo de cálculo de ángulo del código de verificación de rotación de imagen. Se usa ampliamente para resolver el problema de la corrección de imagen rotada y resuelve efectivamente el problema del reconocimiento automático de códigos de verificación de imagen. Los códigos de verificación de imágenes rotadas se utilizan a menudo para verificar la identidad del usuario, pero debido a que la imagen puede rotarse en diferentes ángulos, es difícil de identificar. Este artículo propone un modelo de cálculo de ángulo basado en aprendizaje profundo que puede estimar con precisión el ángulo de una imagen rotada y corregirlo automáticamente a través del ángulo de rotación.
Este artículo ha utilizado redes neuronales convolucionales profundas para realizar extracción de características y aprendizaje de representación en imágenes rotadas para obtener representaciones abstractas de alto nivel. Al agregar un cabezal de regresión y utilizar los datos de la etiqueta del ángulo de rotación para el entrenamiento, el modelo puede predecir el ángulo de la imagen rotada. Los resultados experimentales muestran que nuestro modelo propuesto logra un rendimiento excelente en múltiples conjuntos de datos y puede resolver eficazmente el problema de la corrección de imágenes rotadas. El modelo tiene buena robustez y amplia adaptabilidad, y puede mejorar la precisión del reconocimiento y la experiencia del usuario de los códigos de verificación en aplicaciones prácticas.

1. Cómo se genera el conjunto de datos

Usaré los siguientes pasos:

1. Primero, podemos optar por descargar una gran cantidad de imágenes de paisajes y luego procesarlas.

2. Utilice opencv para cortar la imagen en un círculo y generar una imagen circular.

3. Gire aleatoriamente la imagen circular de 60 grados a 180 grados y guárdela como datos del diccionario: incluida la dirección de la imagen recortada y el valor de la etiqueta del ángulo de rotación. El código es el siguiente:

import cv2
import numpy as np

def crop_to_circle(image_path):
    # 加载图像
    image = cv2.imread(image_path)

    # 创建一个与图像大小相同的黑色背景
    mask = np.zeros_like(image)

    # 获取图像的中心点坐标
    height, width, _ = image.shape
    center = (width // 2, height // 2)

    # 定义半径为图像宽高中的较小值
    radius = min(center[0], center[1])

    # 在mask上绘制一个白色圆形区域
    cv2.circle(mask, center, radius, (255, 255, 255), -1)

    # 将mask作为掩模，将图像与掩模进行按位与操作
    masked_image = cv2.bitwise_and(image, mask)

    cropped_image =  "circular_cropped_image.jpg"
    # 保存裁剪后的图像
    cv2.imwrite(cropped_image, masked_image)

    # 随机生成旋转角度
    random_angle = np.random.randint(60, 181)

    # 对图像进行旋转
    M = cv2.getRotationMatrix2D(center, random_angle, 1.0)
    rotated_image = cv2.warpAffine(masked_image, M, (width, height))

    # 显示结果
    cv2.imshow("Original Image", image)
    cv2.imshow("Circular Cropped + Rotated Image", rotated_image)

    # 保存裁剪加旋转后的图像
    rotated_image_path = "rotated_image.jpg"
    cv2.imwrite(rotated_image_path, rotated_image)

    cv2.waitKey(0)
    cv2.destroyAllWindows()

    return cropped_image, rotated_image_path,random_angle

# 使用示例
image_path = "111.png"
cropped_image,rotated_image_path,random_angle = crop_to_circle(image_path)

# 保存图片地址和旋转角度标签的字典数据
data = {
    
    
    "image_path":"111.png",
    'cropped_image':cropped_image,
    "rotated_path": rotated_image_path,
    "rotation_angle": random_angle
}
print(data)

2. Principio de reconocimiento de imágenes rotadas.

Supongamos que tenemos una imagen y queremos rotarla en sentido antihorario un ángulo $\theta$ . Podemos dividir el proceso de rotación en los siguientes pasos:

1. Traducción de coordenadas: mueva el punto central de la imagen al origen $(0,0)$ lugar. Podemos restar las coordenadas del centro de la imagen de las coordenadas de cada píxel para que el centro de la imagen quede alineado con el origen.

2. Transformación de rotación: para cada punto de píxel $P(x,y)$ , aplique la transformación de matriz de rotación para calcular nuevas coordenadas${PAG}^{\prime }(x^{\prime },y^{\prime })$. La matriz de rotación se expresa como:

$$R\left(yo\right)=\left[\begin{array}{cc}\mathrm{porque}\left(\theta \right)& -\mathrm{pecado}\left(\theta \right)\\ \mathrm{pecado}(\theta & \mathrm{porque}(\theta \end{array}\right]$$

donde, $\theta$ es el ángulo de rotación,$\cos$ y$\sin$ son las funciones coseno y seno.

3. Traducción de coordenadas: mueva el punto central de la imagen a su posición original. Podemos agregar las coordenadas de cada píxel a las coordenadas del centro de la imagen para devolver la imagen a su posición original.

4. Procesamiento de interpolación: las coordenadas del punto decimal pueden aparecer en las coordenadas rotadas, mientras que las coordenadas de los píxeles son números enteros. Por lo tanto, necesitamos utilizar métodos de interpolación para determinar los valores de píxeles en las coordenadas rotadas. Los métodos de interpolación comúnmente utilizados incluyen la interpolación del vecino más cercano, la interpolación bilineal, etc.

3. Seleccionar modelo

Este artículo utiliza principalmente el modelo modificado de resnet50. La estructura específica del modelo se omite aquí. Para facilitar el uso rápido de todos, aquí está la descarga del modelo entrenado:

Enlace: https://pan.baidu.com/s/1aJQ4OD6LwQlLlVwJsMj6aA?pwd=rypwCódigo
de extracción: rypw

Podemos crear la carpeta de modelos y colocar el archivo resnet50_keras2.hdf5 en la carpeta.

Código:

from keras.applications.imagenet_utils import preprocess_input
from keras.models import load_model
from keras.optimizers import SGD
import keras.backend as K

import os
import math
import cv2
import numpy as np
import requests


class RotateCaptcha():
    def __init__(self):
        # 加载模型
        model_location = os.path.join('.', 'models', 'resnet50_keras2.hdf5')
        self.model = load_model(model_location, custom_objects={
    
    'angle_error': self.angle_error})
        self.model.compile(loss='categorical_crossentropy',
                           optimizer=SGD(lr=0.01, momentum=0.9),
                           metrics=[self.angle_error])
        # 图像长宽尺寸
        self.size = (224, 224)

    def showImg(self, image):
        '''
        展示图片
        '''
        cv2.imshow('image', image)
        cv2.waitKey(0)

    def getImgFromDisk(self, imgPath):
        image = cv2.imread(imgPath)
        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
        return image

    def predictAngle(self, image):
        diameter = image.shape[0]  # 直径
        side_length = math.floor((diameter / 2) * 1.414)  # 圆内正方形最大边长
        cropped = math.floor((diameter - side_length) / 2)
        image = image[cropped:cropped + side_length, cropped:cropped + side_length]
        image = cv2.resize(image, self.size)

        image = np.expand_dims(image, axis=0)

        x = preprocess_input(image)
        y_pred = np.argmax(self.model.predict(x), axis=1)

        return y_pred[0]

    def rotate(self, image, angle):

        image_size = (image.shape[1], image.shape[0])
        image_center = tuple(np.array(image_size) / 2)

        # 将 OpenCV 3x2旋转矩阵转换为3x3
        rot_mat = np.vstack(
            [cv2.getRotationMatrix2D(image_center, angle, 1.0), [0, 0, 1]]
        )

        rot_mat_notranslate = np.matrix(rot_mat[0:2, 0:2])

        image_w2 = image_size[0] * 0.5
        image_h2 = image_size[1] * 0.5

        # 获取图像角点的旋转坐标
        rotated_coords = [
            (np.array([-image_w2, image_h2]) * rot_mat_notranslate).A[0],
            (np.array([image_w2, image_h2]) * rot_mat_notranslate).A[0],
            (np.array([-image_w2, -image_h2]) * rot_mat_notranslate).A[0],
            (np.array([image_w2, -image_h2]) * rot_mat_notranslate).A[0]
        ]

        # 查找新图像的大小
        x_coords = [pt[0] for pt in rotated_coords]
        x_pos = [x for x in x_coords if x > 0]
        x_neg = [x for x in x_coords if x < 0]

        y_coords = [pt[1] for pt in rotated_coords]
        y_pos = [y for y in y_coords if y > 0]
        y_neg = [y for y in y_coords if y < 0]

        right_bound = max(x_pos)
        left_bound = min(x_neg)
        top_bound = max(y_pos)
        bot_bound = min(y_neg)

        new_w = int(abs(right_bound - left_bound))
        new_h = int(abs(top_bound - bot_bound))


        trans_mat = np.matrix([
            [1, 0, int(new_w * 0.5 - image_w2)],
            [0, 1, int(new_h * 0.5 - image_h2)],
            [0, 0, 1]
        ])

        affine_mat = (np.matrix(trans_mat) * np.matrix(rot_mat))[0:2, :]


        result = cv2.warpAffine(
            image,
            affine_mat,
            (new_w, new_h),
            flags=cv2.INTER_LINEAR
        )

        return result

    def angle_difference(self, x, y):

        return 180 - abs(abs(x - y) - 180)

    def angle_error(self, y_true, y_pred):

        diff = self.angle_difference(K.argmax(y_true), K.argmax(y_pred))
        return K.mean(K.cast(K.abs(diff), K.floatx()))


if __name__ == '__main__':
    rotateCaptcha = RotateCaptcha()
    rotated_image = rotateCaptcha.getImgFromDisk('222.jpg')

    predicted_angle = rotateCaptcha.predictAngle(rotated_image)  # 预测还原角度
    print("需旋转角度：{}".format(predicted_angle))

    corrected_image = rotateCaptcha.rotate(rotated_image, -predicted_angle)  
    rotateCaptcha.showImg(corrected_image)

Resultados de carrera:
1/1 [==============================] - 1 s 668 ms/paso
Ángulo de rotación requerido: 51

El resultado generado devolverá el ángulo que debe seleccionarse. Realizaremos la siguiente rotación del código de verificación según el ángulo a verificar.