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)** é uma poderosa biblioteca de código aberto projetada para visão computacional em tempo real e processamento de imagens. Oferece ferramentas para manipulação de imagens, detecção de objetos e até mesmo para trabalhar com modelos de aprendizado profundo.

Definição

## Leitura e Exibição de uma Imagem
Antes de realizar transformações, primeiro carregue e exiba uma imagem usando o OpenCV. Já importamos a foto. Mas, no seu computador local, para uma leitura e exibição simples da foto, utilize:

```
import cv2

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

## Redimensionamento de uma Imagem

O redimensionamento é útil para aumentar ou diminuir imagens mantendo a **proporção** (`fx` e `fy`),
onde `fx` e `fy` definem o fator de escala para largura e altura.

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

Você também pode especificar **dimensões exatas em pixels** (parâmetro `dsize`),
onde `dsize` é a forma de saída `(new_y, new_x)`.

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

## Rotacionando uma Imagem
Para rotacionar uma imagem por um ângulo específico, utiliza-se `cv2.getRotationMatrix2D()` e `cv2.warpAffine()`.

- `cv2.getRotationMatrix2D(center, angle, scale)` define a matriz de rotação;
- `cv2.warpAffine(image, matrix, output_size)` aplica a transformação.

```
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))
```


## Recortando uma Imagem
O recorte extrai uma região específica de uma imagem. É realizado utilizando fatiamento do NumPy.
A sintaxe `image[start_y:end_y, start_x:end_x]` seleciona uma região de interesse.

```
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

Aprofunde-se em visão computacional dominando redes neurais convolucionais (CNNs) com TensorFlow e Keras. Este curso avançado aborda conceitos essenciais e habilidades práticas, incluindo pré-processamento de imagens, operações de convolução e pooling, construção e treinamento de arquiteturas CNN, implementação de detecção de objetos e aplicação de aprendizado por transferência para enfrentar desafios visuais do mundo real. Adquira experiência prática na resolução de problemas complexos de visão utilizando ferramentas e técnicas padrão da indústria.

Transformações Básicas

Leitura e Exibição de uma Imagem

Redimensionamento de uma Imagem

Rotacionando uma Imagem

Recortando uma Imagem

Solução