Summary  
This chapter covers how to load an image as a multidimensional array and perform basic geometric transformations—resizing with scaling factors or exact dimensions, rotating via affine matrices, and cropping through array slicing.  

General domain of usage  
Image processing

**OpenCV (Open Source Computer Vision Library)** es una potente biblioteca de código abierto diseñada para la visión por computadora en tiempo real y el procesamiento de imágenes. Proporciona herramientas para manipular imágenes, detectar objetos e incluso trabajar con modelos de aprendizaje profundo.

Definición

## Lectura y visualización de una imagen
Antes de realizar transformaciones, primero cargue y visualice una imagen utilizando OpenCV. Ya hemos importado la foto. Pero en su computadora local, para una lectura y visualización sencilla de la foto, debe usar:

```
import cv2

image = cv2.imread('path/to/image.jpg')
cv2.imshow('Image title', image)
```

## Redimensionamiento de una imagen

El redimensionamiento es útil para escalar imágenes hacia arriba o hacia abajo manteniendo la **proporción** (`fx` y `fy`),
donde `fx` y `fy` definen el factor de escala para el ancho y la altura.

```
resized_image = cv2.resize(image, fx=0.7, fy=0.5)
```

También es posible especificar **dimensiones exactas en píxeles** (parámetro `dsize`),
donde `dsize` es la forma de salida `(new_y, new_x)`.

```
resized = cv2.resize(image, (100, 100))
```

## Rotación de una imagen
Para rotar una imagen por un ángulo específico, se utilizan `cv2.getRotationMatrix2D()` y `cv2.warpAffine()`.

- `cv2.getRotationMatrix2D(center, angle, scale)` define la matriz de rotación;
- `cv2.warpAffine(image, matrix, output_size)` aplica la transformación.

```
height, width = image.shape[:2]
centre = (width // 2, height // 2)

rotation_matrix = cv2.getRotationMatrix2D(centre, 180, 1)
rotated = cv2.warpAffine(image, rotation_matrix, (width, height))
```


## Recorte de una imagen
El recorte extrae una región específica de una imagen. Se realiza utilizando el corte de NumPy.
La sintaxis `image[start_y:end_y, start_x:end_x]` selecciona una región de interés.

```
cropped = image[450:500, 250:350]
```

import unittest
import importlib
import numpy as np
import cv2

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestImageProcessing(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        global user_code
        user_code = importlib.import_module("user_code")

    def test_variables_existence_and_types(self):
        """Check all necessary variables are declared and have correct types."""

        variables_to_check = {
            'image': np.ndarray,
            'resized': np.ndarray,
            'rotation_matrix': np.ndarray,
            'rotated': np.ndarray,
            'cropped': np.ndarray,
        }

        for var_name, expected_type in variables_to_check.items():
            with self.subTest(variable=var_name):
                var = getattr(user_code, var_name, None)
                condition = var is not None and isinstance(var, expected_type)
                if var is None:
                    failure_message = f"The variable `{var_name}` is not declared."
                elif not isinstance(var, expected_type):
                    failure_message = f"The variable `{var_name}` should be of type `{expected_type.__name__}`, but got `{type(var).__name__}`."
                else:
                    failure_message = ""
                _dynamic_test(
                    self,
                    condition,
                    f"The variable `{var_name}` exists and has the correct type `{expected_type.__name__}`.",
                    failure_message
                )

    def test_resized_image_shape(self):
        """Check that the resized image has the correct shape (100, 100)."""
        expected_shape = (100, 100)
        actual_shape = user_code.resized.shape[:2]

        _dynamic_test(
            self,
            actual_shape == expected_shape,
            f"The resized image has the correct shape {expected_shape}.",
            f"Expected resized image shape {expected_shape}, but got {actual_shape}."
        )

    def test_rotation_matrix_correctness(self):
        """Check that the rotation matrix is correctly computed."""
        height, width = user_code.image.shape[:2]
        expected_matrix = cv2.getRotationMatrix2D((width // 2, height // 2), 90, 1)

        try:
            np.testing.assert_array_almost_equal(user_code.rotation_matrix, expected_matrix, decimal=5)
            condition = True
            success_message = "The rotation matrix matches the expected values."
            failure_message = "Rotation matrix mismatch (values differ)."
        except AssertionError:
            condition = False
            success_message = "Rotation matrix check unexpectedly passed."  # needed to avoid UnboundLocalError
            failure_message = "Rotation matrix mismatch (values differ)."

        _dynamic_test(
            self,
            condition,
            success_message,
            failure_message
        )

    def test_rotated_image_shape_matches_original(self):
        """Check that the rotated image shape matches the original image shape."""
        original_shape = user_code.image.shape
        rotated_shape = user_code.rotated.shape

        _dynamic_test(
            self,
            original_shape == rotated_shape,
            "The rotated image shape matches the original image shape.",
            f"Expected rotated image shape {original_shape}, but got {rotated_shape}."
        )

    def test_cropped_image_shape_correctness(self):
        """Check that the cropped image has the correct dimensions."""
        cropped_height, cropped_width = user_code.cropped.shape[:2]
        expected_shape = (450 - 100, 600 - 250)

        _dynamic_test(
            self,
            (cropped_height, cropped_width) == expected_shape,
            f"The cropped image has the correct dimensions {expected_shape}.",
            f"Expected cropped image dimensions {expected_shape}, but got {(cropped_height, cropped_width)}."
        )

    def test_cropped_image_pixel_values(self):
        """Check that the cropped image matches the expected pixel values."""
        expected_cropped = user_code.image[100:450, 250:600]

        try:
            np.testing.assert_array_equal(user_code.cropped, expected_cropped)
            condition = True
            success_message = "The cropped image contains the correct pixel values."
            failure_message = "Cropped pixel values mismatch (values differ)."
        except AssertionError:
            condition = False
            success_message = "Cropped pixel values check unexpectedly passed."
            failure_message = "Cropped pixel values mismatch (values differ)."

        _dynamic_test(
            self,
            condition,
            success_message,
            failure_message
        )

if __name__ == "__main__":
    unittest.main()


test_code.py

Sumérgete en la visión por computadora dominando las redes neuronales convolucionales (CNN) con TensorFlow y Keras. Este curso avanzado abarca conceptos esenciales y habilidades prácticas, incluyendo el preprocesamiento de imágenes, operaciones de convolución y agrupamiento, construcción y entrenamiento de arquitecturas CNN, implementación de detección de objetos y aplicación de aprendizaje por transferencia para abordar desafíos visuales del mundo real. Obtén experiencia práctica resolviendo problemas complejos de visión utilizando herramientas y técnicas estándar de la industria.

Transformaciones Básicas

Lectura y visualización de una imagen

Redimensionamiento de una imagen

Rotación de una imagen

Recorte de una imagen

Solución