Manejo de imágenes con Python

Siguiendo el reto del profe, decidí hacer un especie de collage un poco más divertido:

Dejo el código aquí:

#Extraer Capas R G y B de la img:
Cr = Im[:,:,0]
Cg = Im[:,:,1]
Cb = Im[:,:,2]

#Dimensión de la imagen:
fil,col,capas = Im.shape

#Calculo la mitad del alto y ancho de la img:
y = int(fil/2)
x = int(col/2)

#Imagen auxiliar de zeros:
aux_dim = np.zeros([y,x])

#Genero cuadrante 1:
aux_C1 = Im[0:y,0:x]

#Genero cuadrante 2:
r_aux = Cr[0:y,x:col]
aux_C2 = np.dstack((r_aux,aux_dim,aux_dim)).astype(np.uint8)

#Genero cuadrante 3:
g_aux = Cg[y:fil,0:x]
aux_C3 = np.dstack((aux_dim,g_aux,aux_dim)).astype(np.uint8)

#Genero cuadrante 4:
b_aux = Cb[y:fil,x:col]
aux_C4 = np.dstack((aux_dim,aux_dim,b_aux)).astype(np.uint8)

#Contatenar la parte de arriba y de abajo
ParteArriba = cv2.hconcat([aux_C1,aux_C2])
ParteAbajo = cv2.hconcat([aux_C3,aux_C4])

#Concatenar imagen final 
ImgFinal = cv2.vconcat([ParteArriba,ParteAbajo])

plt.figure()
plt.figure(figsize=(7,7))
plt.imshow(ImgFinal)

No estoy del todo seguro con lo que plantea el profesor al inicio de la clase y para ello traigo 4 ejemplos de Nhaga

Mi solucion del reto

Yo hice un código que permita dividir en sectores rectangulares la imagen de Mara y pinte con los diferentes filtros que aprendimos en esta clase (Puedes determinar cuantas columnas y filas deseas en la imagen)

DivisionesV=2
DivisionesH=2

AnchoActual = im.shape[1]//DivisionesV
AlturaActual = im.shape[0]//DivisionesH
fila = im[0:AlturaActual,0:1]
elemento = np.concatenate((im[0:1,0:im.shape[1]],im[0:1,0:1]), axis=1)
k=0

for j in range(DivisionesH):
    for i in range(DivisionesV):
        if(k%4==0):
            fila = np.concatenate((fila, (red[AlturaActual*j:AlturaActual*(j+1),AnchoActual*i:AnchoActual*(i+1)])), axis=1)
        if(k%4==1):
            fila = np.concatenate((fila, (green[AlturaActual*j:AlturaActual*(j+1),AnchoActual*i:AnchoActual*(i+1)])), axis=1)
        if(k%4==2):
            fila = np.concatenate((fila, (blue[AlturaActual*j:AlturaActual*(j+1),AnchoActual*i:AnchoActual*(i+1)])), axis=1)
        if(k%4==3):
            fila = np.concatenate((fila, (im[AlturaActual*j:AlturaActual*(j+1),AnchoActual*i:AnchoActual*(i+1)])), axis=1)
        k=k+1
    elemento = np.concatenate((elemento, fila))
    fila = im[0:AlturaActual,0:1]
    

plt.imshow(elemento)

Algo de código:

from skimage import io

image_color = io.imread(os.path.join(WORK_DIRECTORY,'photo_validation','a.jpg'))
image_color[270:420,90:240,:]=255-image_color[270:420,75:225,:]
image_color[0:250,250:440,1:2]=0
plt.imshow(image_color)

Oh no pequeña Marta, q te hize. Yo solo quería sacar un promedio de los canales RGB XD

Use PCA para ver como quedaba la imagen, use n_componentes=300. Me guie con este articulo para ello.

Una librerìa en python que abstrae todos estos conceptos de las imagenes es Pillow

Estoy realizando el mismo ejercicio pero con una imagen diferente

Pero no me aparecen las capas de datos que la conforman. En ese caso ¿qué se debería hacer?
Gracias
pd: el curso está increíble

Pude copiar una seccion de la imagen, voltearla y pegarla en otra seccion

En la imagen se puede apreciar que Brownie es la perrita mas linda

Realizando algunos pequeños cambios para las matrices negativas.

Quise superponer una imagen sobre otra aplicando un filtro y cierta transparencia, este es mi resultado:

import cv2
imr = cv2.imread('/kaggle/input/cnn-data-sources/Mara.jpeg')
imzoom_neg_pos = cv2.imread('/kaggle/input/cnn-data-sources/Mara.jpeg')

zoom = im[270:530, 150:400]
imzoom_neg_pos = cv2.resize(zoom, (imzoom_neg_pos.shape[1], imzoom_neg_pos.shape[0]))
overlay = cv2.addWeighted(im, 1, imzoom_neg_pos, 1, 0)

plt.imshow(cv2.cvtColor(overlay, cv2.COLOR_BGR2RGB))

🤭😅

im_p=io.imread('/kaggle/input/cnn-data-sources/yo.png')
rp= im_p[:,:,0]
plt.imshow(rp[0:250,110:290],cmap='twilight')

Yo modifique asi la imagen

Experimentando ando

Apliqué un filtro sepia

sepia_rojo = 0.393 * r + 0.769 * g + 0.189 * b
sepia_verde = 0.349 * r + 0.686 * g + 0.168 * b
sepia_azul = 0.272 * r + 0.534 * g + 0.131 * b

sepia_rojo[sepia_rojo > 255] = 255
sepia_verde[sepia_verde > 255] = 255
sepia_azul[sepia_azul > 255] = 255

sepia = np.dstack((sepia_rojo, sepia_verde, sepia_azul)).astype(np.uint8)


plt.imshow(sepia)

Usar Data Augmentation o crear imágenes; el problema acá surge en quien o que parámetros se establecen para clasificar las imágenes para que puedan ser entrenadas. Solo los humanos los que clasificamos el conjunto de entrenamiento.

• Data Augmentation permite generar muchos conjuntos de datos con las mismas imágenes.
• Genera más datos de entrenamientos sobre las imágenes conservando las características.
• Observa la imagen cada vez de manera distinta, con lo cual no conlleva al overfitting.

Hice la siguiente modificación de la imagen de Mara

im_masked = im[:,:,0].copy()
mask = im_masked < 50
im_masked[mask] = 255
plt.imshow(im_masked, cmap='gray')

Comparto también la siguiente nota donde se habla de algunas las herramientas para el manejo de imágenes.

https://opensource.com/article/19/3/python-image-manipulation-tools

Aquí Mara en los diferentes canales de color y con un zoom a la carita