No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Manejo de imágenes con Python

7/25
Recursos

Aportes 29

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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)
```js rows, cols = im.shape[:2] M = cv2.getRotationMatrix2D((cols/3, rows/3), 20, .8) rotated_img = cv2.warpAffine(im, M, (cols, rows)) im_neg_pos = 255-rotated_img kernel_sharpen = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]) sharpen_img = cv2.filter2D(im_neg_pos, -1, kernel_sharpen) plt.imshow(sharpen_img) plt.show() ```![](https://static.platzi.com/media/user_upload/image-680e9cef-e470-445b-85cf-5ba83b58407b.jpg)
El manejo de imágenes en Python es fundamental en muchas aplicaciones, especialmente en el aprendizaje automático y la visión por computadora. A continuación, te presento una explicación teórica y un ejemplo práctico de cómo trabajar con imágenes en Python utilizando bibliotecas como \*\*PIL\*\* (Pillow) y \*\*OpenCV\*\*. \### Teoría \#### 1. \*\*Carga de Imágenes\*\* \- Las imágenes se pueden cargar desde archivos utilizando bibliotecas como Pillow o OpenCV. Al cargar una imagen, se convierte en un objeto que puede ser manipulado. \#### 2. \*\*Manipulación de Imágenes\*\* \- \*\*Redimensionamiento\*\*: Cambiar el tamaño de la imagen a dimensiones específicas. \- \*\*Recorte\*\*: Extraer una región específica de la imagen. \- \*\*Rotación\*\*: Girar la imagen a un ángulo específico. \- \*\*Cambio de Formato\*\*: Convertir imágenes entre diferentes formatos (por ejemplo, JPG a PNG). \#### 3. \*\*Transformaciones\*\* \- Las transformaciones como el escalado, la inversión de colores, y la aplicación de filtros son comunes en el preprocesamiento de imágenes. \#### 4. \*\*Visualización\*\* \- Usar bibliotecas como Matplotlib para mostrar imágenes. \#### 5. \*\*Guardado de Imágenes\*\* \- Se pueden guardar imágenes manipuladas en el disco en diferentes formatos. \### Ejemplo Práctico A continuación se muestra un ejemplo utilizando Pillow y Matplotlib para cargar, manipular y mostrar imágenes. \#### Instalación de Bibliotecas Asegúrate de tener instaladas las bibliotecas necesarias. Puedes instalarlas utilizando pip: ```bash pip install pillow matplotlib ``` \#### Código Ejemplo ```python from PIL import Image import matplotlib.pyplot as plt \# Cargar una imagen image\_path = 'ruta/a/tu/imagen.jpg' # Cambia esta ruta a tu imagen image = Image.open(image\_path) \# Mostrar la imagen original plt.figure(figsize=(6, 6)) plt.imshow(image) plt.title("Imagen Original") plt.axis('off') # Oculta los ejes plt.show() \# Redimensionar la imagen resized\_image = image.resize((100, 100)) # Cambiar a 100x100 píxeles \# Recortar la imagen (izquierda, arriba, derecha, abajo) cropped\_image = image.crop((50, 50, 200, 200)) # Recorta la región deseada \# Rotar la imagen rotated\_image = image.rotate(45) # Rota 45 grados \# Mostrar las imágenes manipuladas plt.figure(figsize=(12, 12)) plt.subplot(1, 3, 1) plt.imshow(resized\_image) plt.title("Imagen Redimensionada") plt.axis('off') plt.subplot(1, 3, 2) plt.imshow(cropped\_image) plt.title("Imagen Recortada") plt.axis('off') plt.subplot(1, 3, 3) plt.imshow(rotated\_image) plt.title("Imagen Rotada") plt.axis('off') plt.show() \# Guardar la imagen redimensionada resized\_image.save('imagen\_redimensionada.jpg') ``` \### Explicación del Código 1\. \*\*Carga de Imagen\*\*: Utilizamos `Image.open()` para cargar la imagen desde el disco. 2\. \*\*Visualización\*\*: Usamos `matplotlib.pyplot` para mostrar la imagen original. 3\. \*\*Redimensionamiento\*\*: Utilizamos el método `resize()` para cambiar el tamaño de la imagen. 4\. \*\*Recorte\*\*: Utilizamos el método `crop()` para extraer una región específica de la imagen. 5\. \*\*Rotación\*\*: Utilizamos el método `rotate()` para girar la imagen. 6\. \*\*Guardar Imagen\*\*: Finalmente, guardamos la imagen redimensionada utilizando el método `save()`. \### Conclusión Este ejemplo te da una introducción a cómo manejar imágenes en Python utilizando Pillow y Matplotlib. Puedes explorar más funcionalidades en la documentación de \[Pillow]\(https://pillow.readthedocs.io/en/stable/) y \[OpenCV]\(https://opencv-python-tutroals.readthedocs.io/en/latest/). ¡Experimenta con diferentes operaciones y transforma tus imágenes!
## Img\_neg por canal![](https://static.platzi.com/media/user_upload/image-396de832-e9e8-42b5-b2a0-3af3f3f9b528.jpg) ## PCA (3C.) de la imagen original, obs: con los 3 primeros componentes capturamos bastante informacion de la estructura general de los colores![](https://static.platzi.com/media/user_upload/image-83aeecdf-9df0-4f0f-bdf9-3f900645578c.jpg) ## ![](https://static.platzi.com/media/user_upload/image-eca43bc6-3051-4ac8-b995-744b11144769.jpg) Reduccion de la dimensionalidad con colores de tres componentes principales, se distingue una figura en el centro, pasto o pradera y detras un fondo particularmente ordenado.![](https://static.platzi.com/media/user_upload/image-ce98ff2c-d19e-4dce-addf-303b315b3380.jpg)
Un negativo de la imagen , sin la capa green ![](https://static.platzi.com/media/user_upload/image-597e996f-2203-4bd1-a8f4-fd5f42c56735.jpg)
![](https://static.platzi.com/media/user_upload/image-c2c09804-fa12-4d5d-bb47-d95c731f8fc8.jpg) mara sobresaturada!

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

```js rows, cols = im.shape[:2] M = cv2.getRotationMatrix2D((cols/3, rows/3), 20, .8) rotated_img = cv2.warpAffine(im, M, (cols, rows)) im_neg_pos = 255-rotated_img kernel_sharpen = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]]) sharpen_img = cv2.filter2D(im_neg_pos, -1, kernel_sharpen) plt.imshow(sharpen_img) plt.show() ```rows, cols = im.shape\[:2]M = cv2.getRotationMatrix2D((cols/3, rows/3), 20, .8)rotated\_img = cv2.warpAffine(im, M, (cols, rows))im\_neg\_pos = 255-rotated\_img kernel\_sharpen = np.array(\[\[0, -1, 0],                          \[-1, 5, -1],                          \[0, -1, 0]])sharpen\_img = cv2.filter2D(im\_neg\_pos, -1, kernel\_sharpen) plt.imshow(sharpen\_img)plt.show() ![](https://static.platzi.com/media/user_upload/image-b730fb2e-2d2c-4541-9cd4-712588213989.jpg)
# Img\_neg por canal ![](https://static.platzi.com/media/user_upload/image-ba589b53-98e8-477e-abb3-5665e1cff641.jpg)