Python - Dúvida exercício Processamento de Imagens

[Malfurion Tempesfuria]

Estou fazendo um exercício de processamento de imagens no google colab em python, e estou em duvida em uma questão...

Alguém poderia me ajudar?

Segue o enunciado:

Crie uma função que receba uma imagem e modifique ela para que fique quadrada. Se a imagem estiver na orientação paisagem, você precisará adicionar espaço na parte superior e inferior. Da mesma forma, para retrato (mais alto que largo), você adicionará espaço nas laterais. Certifique-se de que seu programa centralize a imagem entre o espaço.

Para preecher o novo espaço, você deverá testar apresentar as duas variações a seguir:

Supondo que o novo espaço possua uma quantidade de n linhas ou colunas, você deverá preenchê-lo com as n linhas ou colunas vizinhas da imagem. Depois disso, você deverá aplicar uma filtro de média nessa região.

Você deverá criar seu próprio filtro de média. Não é permitido usar nenhuma função pronta para isso. Considere sempre que será criado padding na imagem para que o filtro resulte em uma imagem do mesmo tamanho. Considere também que a máscara sempre será quadrada e com tamanho ímpar.

Supondo que o novo espaço possua uma quantidade de n linhas ou colunas, você deverá preencher com a média de todos os valores RGB das n linhas ou colunas vizinhas da imagem.

Teste a função nas imagens praia.jpg e houses.jpg. E exiba o resultado das imagens.

Obs. Neste exercício, não é permitido usar usada nenhuma função pronta da OpenCV. Além disso, as únicas funções prontas do Numpy que podem ser usada são np.pad, np.mean, np.sum, np.ones e np.zeros.

Segue anexo imagem que deverá ser utilizada.

[Jeremias Dev]

Para ajudar a resolver esse exercício de processamento de imagens no Google Colab, vamos criar uma função em Python que segue o enunciado que você descreveu. Primeiro, vamos definir a função que faz o ajuste da imagem para que fique quadrada, adicionando espaço conforme necessário e preenchendo este espaço de acordo com as especificações do exercício. Em seguida, criaremos um filtro de média conforme definido.

Aqui está uma sugestão de como você pode implementar isso:

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt

def make_square(img, fill_mode='extend'):
    # Converte a imagem para array numpy
    img_array = np.array(img)
    
    height, width, channels = img_array.shape
    if height == width:
        return img_array  # A imagem já é quadrada
    
    # Determina a quantidade de espaço a adicionar em cada lado
    size_diff = abs(height - width)
    pad_width = size_diff // 2
    extra_pad = size_diff % 2
    
    if height > width:
        # Modo retrato, adiciona espaço nas laterais
        if fill_mode == 'extend':
            # Repete as colunas adjacentes
            left_padding = np.tile(img_array[:, 0, :], (pad_width, 1)).reshape(pad_width, height, channels)
            right_padding = np.tile(img_array[:, -1, :], (pad_width + extra_pad, 1)).reshape(pad_width + extra_pad, height, channels)
        elif fill_mode == 'mean':
            # Preenche com a média das colunas adjacentes
            mean_color = np.mean(img_array[:, :pad_width, :], axis=1, keepdims=True)
            left_padding = np.tile(mean_color, (pad_width, 1, 1))
            right_padding = np.tile(mean_color, (pad_width + extra_pad, 1, 1))
        
        new_img_array = np.hstack((left_padding, img_array, right_padding))
        
    else:
        # Modo paisagem, adiciona espaço superior e inferior
        if fill_mode == 'extend':
            # Repete as linhas adjacentes
            top_padding = np.tile(img_array[0, :, :], (pad_width, 1)).reshape(pad_width, width, channels)
            bottom_padding = np.tile(img_array[-1, :, :], (pad_width + extra_pad, 1)).reshape(pad_width + extra_pad, width, channels)
        elif fill_mode == 'mean':
            # Preenche com a média das linhas adjacentes
            mean_color = np.mean(img_array[:pad_width, :, :], axis=0, keepdims=True)
            top_padding = np.tile(mean_color, (pad_width, 1, 1))
            bottom_padding = np.tile(mean_color, (pad_width + extra_pad, 1, 1))
        
        new_img_array = np.vstack((top_padding, img_array, bottom_padding))
    
    return new_img_array

# Carrega as imagens e aplica a função
img_praia = Image.open("praia.jpg")
img_houses = Image.open("houses.jpg")

# Aplica a função para ambas as imagens e ambos os modos de preenchimento
result_praia_extend = make_square(img_praia, fill_mode='extend')
result_houses_extend = make_square(img_houses, fill_mode='extend')
result_praia_mean = make_square(img_praia, fill_mode='mean')
result_houses_mean = make_square(img_houses, fill_mode='mean')

# Função para exibir imagens
def show_images(images, titles):
    plt.figure(figsize=(12, 6))
    for i, (image, title) in enumerate(zip(images, titles), 1):
        plt.subplot(1, len(images), i)
        plt.imshow(image)
        plt.title(title)
        plt.axis('off')
    plt.show()

# Exibir os resultados
show_images([result_praia_extend, result_houses_extend, result_praia_mean, result_houses_mean],
            ['Praia Extend', 'Houses Extend', 'Praia Mean', 'Houses Mean'])

Note que a função make_square assume que a imagem de entrada é um objeto Image do PIL e que a saída é um array do numpy modificado para ser quadrado. O método extend copia as linhas/colunas adjacentes, enquanto o método mean usa a média das cores RGB.

Certifique-se de ter os arquivos das imagens "praia.jpg" e "houses.jpg" disponíveis no seu ambiente Colab para que o código funcione corretamente. Além disso, você pode ajustar a visualização conforme necessário.