UNIVERSIDAD NACIONAL DE TRUJILLO

Facultad de Ingeniería
Programa de Ingeniería Mecatrónica

LABORATORIO N° 01

“FUNDAMENTOS DE PYTHON Y NUMPY”

DESARROLLO DE GUIA DE LABORATORIO

Procesamiento de Imágenes Digitales

ESTUDIANTE(S) :
1. BEJARANO REYES, Mauricio Alonso
2. RODRIGUEZ CARBAJAL, Arnold Jair
3. SILVA VALERA, Giancarlo
4. SILVA ZUTA, Fray David

DOCENTE :
ING. ASTO RODRIGUEZ, Emerson

CICLO :
2020 I

Trujillo, Perú
2020
 INDICE

INDICE ..................................................................................................................................... ii

RESUMEN .................................................................................................................................1

1. DESARROLLO DEL LABORATORIO .............................................................................2

1.1. Resultados de la experiencia ........................................................................................2

a) Resultado 1 ..................................................................................................................2
b) Resultado 2 ..................................................................................................................2
1.2. Desarrollo de test de comprobación .............................................................................3
2. RECOMENDACIONES Y CONCLUSIONES....................................................................6

2.1. Recomendaciones ........................................................................................................6

2.2. Conclusiones ...............................................................................................................6
3. REFERENCIAS BIBLIOGRÁFICAS .................................................................................1

4. ANEXOS ............................................................................................................................2

ANEXO A1 ............................................................................................................................2
ANEXO A2 ............................................................................................................................4
 RESUMEN

En el presente laboratorio se trabajó la lectura y manipulaciones elementales sobre

imágenes con numpy, esto se logró reordenando una imagen dividida en partes y

desordenada, para esto primero se trabajó un ejemplo en el cual vimos los comandos

necesarios para importar, imprimir, dividir, separar por capas de color, cambiar formato

BGR a RGB, girar o transformar y exportar imágenes; estos comandos trabajan a la

imagen como un conjunto de vectores. Luego se pasó a manipular la imagen propuesta en

formato PNG para su posterior manipulación, aplicando los comandos correspondientes

para ordenar sólo una capa de la imagen y luego ordenar la imagen en conjunto de todas

sus capas de color. Al terminar con los códigos correspondientes a cada proceso, se logró

obtener una imagen ordenada a su forma original en una capa, así como en todas sus

capas. Es decir, una fue exportada en la capa G en escala de grises, mientras que la otra

imagen fue exportada en todas sus capas lo que genera que se vea a colores.
 1. DESARROLLO DEL LABORATORIO

1.1.Resultados de la experiencia

a) Resultado 1

Utilizando lo visto en la practica 2, se ordenó una capa de la imagen “puzzle.png”

suministrada. El resultado es el mostrado a continuación:

Figura 1: Resultado obtenido del ítem a.

El código trabajado mediante Jupyter Notebook se encuentra en el anexo A1.

b) Resultado 2

Creamos un procedimiento para ordenar la imagen “puzzle.png” a color. El

resultado es el mostrado a continuación:

 Figura 2: Resultado obtenido del ítem b.

El código trabajado mediante Jupyter Notebook se encuentra en el anexo A2.

1.2.Desarrollo de test de comprobación

a) Averigüe como leer y mostrar una imagen usando skimage. Muestre un ejemplo:

Tenemos una imagen llamada "lenna.png" en el mismo directorio de nuestro

código, luego, podemos utilizar el módulo iode scikit-image para leer y mostrar

esta imagen. Básicamente se procede como sigue:

Primero importamos el módulo correspondiente:

from skimage import io

Ahora utilizamos la función imread del módulo io para leer la imagen, y

guardamos esto en una variable, en la cual se almacenará un array de NumPy

con la información de los colores que componen la imagen.

img = io.imread('lenna.png')

Enseguida utilizamos la función imshow para mostrar la imagen que pasemos

como argumento y la función show para mostrar toda la ventana o figure que

contiene la(s) imágenes a desplegar en la pantalla.

io.imshow(img)

io.show()

Juntando este mini código nos quedaría algo como lo siguiente:

from skimage import io

img = io.imread("lenna.png")

io.imshow(img)

io.show()

Si ejecutamos lo anterior nos mostrará la imagen leída en una ventana o figure

de Matplotlib, tal como se aprecia en la siguiente imagen:

Figura 3: Impresión de una imagen mediante skimage (Santos, 2016).

b) Averigüe como leer y mostrar una imagen usando OpenCV. Muestre un ejemplo:

Tenemos una imagen llamada "car_plate.jpg " en el mismo directorio de nuestro

código, luego ejecutamos las librerías correspondientes:

import cv2

import numpy as np

import matplotlib.pyplot as plt

Ahora Importamos la imagen e imprimimos

img = cv2.imread("IMAGENES/car_plate.jpg")

plt.imshow(img)

plt.show()

Figura 4: Impresión de una imagen por OpenCV.

 2. RECOMENDACIONES Y CONCLUSIONES

2.1.Recomendaciones

a) Al importar la imagen, primero hay que asegurarse si la carpeta de su ubicación

está dentro de la carpeta de trabajo del jupyter notebook que estamos trabajando,

así como asegurarse que el nombre y el formato de la imagen sean los correctos.

b) Al momento de hacer las transformaciones a la imagen, sería mejor que primero

dividamos la imagen en los cuadrantes respectivos y en formato BGR para

analizar individualmente a cada uno y no confundirnos en los giros y

transformaciones a aplicar.

c) Trabajar cada capa de color por separado, imprimiendo 3 imágenes, una para

cada capa y cuando todas estén ordenadas, cambiar el formato de estás a RGB y

unirlas en sus respectivas ubicaciones en los vectores de la imagen original.

2.2.Conclusiones

a) Es factible aplicar métodos de procesamiento de imágenes para ordenar una imagen

que haya sido dividida en cuadrantes y girada.

b) A pesar de que dividir una imagen en cuadrantes y luego transformarlos facilita el

entendimiento de las transformaciones que deben de aplicarse para cada uno, es

 mejor aplicar una transformación directa de la imagen completa usando las

coordenadas pues nos ahorra líneas de código.

c) Para poner transformar una imagen por partes según sus coordenadas, primero es

necesario separar esta imagen en sus capas de color en formato BGR y luego

transformar cada capa de color y luego juntarlas.

d) En las pruebas realizadas para las imágenes en clase como en el laboratorio, un

elemento adicional es la configuración de la extensión de la imagen, siendo PNG

(Portable Network Graphics) el formato de compresión sin pérdida de nitidez, muy

adecuado por su calidad y menor peso de almacenamiento en comparación con

otros formatos como tiff, jpg, etcétera.

 3. REFERENCIAS BIBLIOGRÁFICAS

(Utilizar normas APA)

Freund, J., Rücker, B., & Hitpass, B. (2014). BPMN 2.0 Manual de Referencia y Guía

Práctica. Santiago de Chile: Empresas Dimacofi.

Santos, P. J. (29 de 01 de 2016). numython. Obtenido de numython:

https://numython.github.io/posts/2016/01/introduccion-scikit-image-procesamiento/

Sanz, J. (2005). Técnicas y procesos en las instalaciones. Madrid: Paraninfo.

Zarate , A. (2015). Rediseño del proceso de atención de solicitudes referidas a citas

médicas en ESSALUD, mediante la metodología BPM. Universidad Nacional del

Centro del Perú, Huancayo.

 4. ANEXOS

ANEXO A1

# Importamos las librerias

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Importamos la imagen e imprimimos

img = cv2.imread("Imagenes/puzzle.png")

plt.imshow(img)

plt.show()

# Dividimos las capas de colores en formato BGR

img_b=img[:,:,0]

img_g=img[:,:,1]

img_r=img[:,:,2]

# Imprimimos las dimensiones de la imagen

print(img.shape)

# Dividimos la imagen e imprimimos en escala de gris

c1 = img_g[0:150,0:150]

c2 = img_g[0:150,150:]

c3 = img_g[150:,0:150]

c4 = img_g[150:,150:]
plt.subplot(221)

plt.imshow(c1, cmap="gray")

plt.subplot(222)

plt.imshow(c2, cmap="gray")

plt.subplot(223)

plt.imshow(c3, cmap="gray")

plt.subplot(224)

plt.imshow(c4, cmap="gray")

plt.show()

# Hacemos las transformaciones respectivas a cada división

c1=c1.T

c2=c2.T.T[::-1,:]

c3=c3.T.T[::-1,:]

c4=c4.T[:,::-1]

plt.subplot(221)

plt.imshow(c1, cmap="gray")

plt.subplot(222)

plt.imshow(c2, cmap="gray")

plt.subplot(223)

plt.imshow(c3, cmap="gray")

plt.subplot(224)

plt.imshow(c4, cmap="gray")

plt.show()
# Unimos las divisiones

img_g[0:150,0:150]=c1

img_g[0:150,150:]=c2

img_g[150:,0:150]=c3

img_g[150:,150:]=c4

plt.imshow(img_g, cmap="gray")

plt.show()

# Exportamos la imagen en escala de grises

plt.imsave("Puzzle_Reconstruido_g.png",img_g, cmap="gray")

ANEXO A2

# Importamos las librerias

import cv2

import numpy as np

import matplotlib.pyplot as plt

# Importamos la imagen e imprimimos

img = cv2.imread("IMAGENES/puzzle.png")

plt.imshow(img)

plt.show()

# Dividimos las capas de colores en formato BGR

img_b=img[:,:,0]

img_g=img[:,:,1]

img_r=img[:,:,2]
# Imprimimos las dimensiones de la imagen

print(img.shape)

#Reconstruccion de la imagen en B

img_b[0:150,0:150]=img_b[0:150,0:150].T

img_b[0:150,150:]=img_b[0:150,150:][::-1,:]

img_b[150:,0:150]=img_b[150:,0:150][::-1,:]

img_b[150:,150:]=img_b[150:,150:].T[:,::-1]

#Reconstruccion de la imagen en G

img_g[0:150,0:150]=img_g[0:150,0:150].T

img_g[0:150,150:]=img_g[0:150,150:][::-1,:]

img_g[150:,0:150]=img_g[150:,0:150][::-1,:]

img_g[150:,150:]=img_g[150:,150:].T[:,::-1]

#Reconstruccion de la imagen en R

img_r[0:150,0:150]=img_r[0:150,0:150].T

img_r[0:150,150:]=img_r[0:150,150:][::-1,:]

img_r[150:,0:150]=img_r[150:,0:150][::-1,:]

img_r[150:,150:]=img_r[150:,150:].T[:,::-1]

#Ploteo de las imagenes

plt.subplots(1,3,figsize=(18,6))

plt.subplot(131)

plt.imshow(img_r)

plt.subplot(132)

plt.imshow(img_g)
plt.subplot(133)

plt.imshow(img_b)

plt.show()

#Cambiando de BGR a RGB

img=np.zeros((300,300,3),dtype=np.uint8)

img[:,:,0]=img_r

img[:,:,1]=img_g

img[:,:,2]=img_b

plt.imshow(img)

plt.show()

#Cambiando de BGR a RGB

plt.imsave("Puzzle_Reconstruido.png",img)