Summary  
This chapter demonstrates how to load and display image data and apply fundamental geometric transformations—resizing (by scale factors or explicit dimensions), rotating (using affine matrices), and cropping (via array slicing).  

General domain of usage  
Computer vision

## Leitura e Exibição de uma Imagem
Antes de realizar transformações, primeiro vamos carregar e exibir uma imagem usando o OpenCV. Já importamos a foto. Mas, no seu computador local, para simplesmente ler e exibir a foto, você deve usar:

## 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.

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

## 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.


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


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

Introdução abrangente à Visão Computacional, com foco na percepção e interpretação de dados visuais por máquinas. Abrange pré-processamento de imagens, extração de características, detecção de objetos e técnicas de aprendizado profundo utilizadas em sistemas de visão modernos.

A visão computacional permite que máquinas interpretem e analisem dados visuais, imitando a percepção humana. Esta seção aborda os fundamentos da representação de imagens, modelos de cor e bases matemáticas essenciais para compreender como os computadores processam imagens. Serão exploradas aplicações do mundo real, desde veículos autônomos até imagens médicas, além de como a visão computacional se integra à IA e ao aprendizado de máquina.

OpenCV é uma biblioteca poderosa para manipulação de imagens e tarefas de visão computacional. Esta seção aborda técnicas essenciais como filtragem de imagens, transformações, detecção de bordas e segmentação. Você aprenderá a realizar desfoque, limiarização, detecção de contornos e extração de características para aprimorar e analisar imagens de forma eficiente.

As CNNs processam dados visuais utilizando camadas de convolução, pooling e ativação para extrair características em tarefas como classificação de imagens e detecção de objetos. Os principais componentes incluem padding, convolução para extração de características, pooling para redução de complexidade e ativação para introdução de não linearidade. Arquiteturas populares como AlexNet, VGG e ResNet impulsionam a IA em saúde, autonomia e segurança.

A detecção de objetos é uma tarefa fundamental em visão computacional que envolve a identificação e localização de objetos dentro de uma imagem. Diferentemente da classificação de imagens, que atribui um único rótulo a toda a imagem, a detecção de objetos não apenas classifica os objetos, mas também determina suas posições utilizando caixas delimitadoras. Esta seção aborda as principais técnicas e algoritmos utilizados em detecção de objetos, abrangendo desde métodos tradicionais até abordagens baseadas em aprendizado profundo, como YOLO e U-Net.

A visão computacional avançou significativamente ao longo dos anos, passando de métodos básicos de processamento de imagens para técnicas complexas de deep learning. Esta seção aborda as inovações mais recentes em visão computacional, com foco em transfer learning, reconhecimento facial e geração de imagens. Serão explorados os benefícios de modelos pré-treinados no desempenho, os princípios da tecnologia de reconhecimento facial e a forma como a IA cria imagens por meio de deep learning.

Transformações Básicas

Leitura e Exibição de uma Imagem

Redimensionamento de uma Imagem

Rotacionando uma Imagem

Recortando uma Imagem