Universidad de Santiago de Chile

Facultad de Ingeniera Mdulo Bsico de Ingeniera

FUNDAMENTOS DE COMPUTACIN Y PROGRAMACIN

Enunciado Control de Laboratorio N3

Santiago, Diciembre de 2013

Enunciado Control de Laboratorio N3

2013

I.

Objetivos

Aplicar los conocimientos de Programacin vistos en Ctedra y Laboratorio para generar un programa en Python que realice operaciones sobre matrices.

II.

Problema

Como se sabe de las primeras clases del curso, el computador es una mquina capaz de realizar operaciones aritmtico-lgicas representando tanto entradas como salidas en lgica binaria, esto puesto en trminos simples, significa que un computador bsicamente slo trabaja con valores 0s y 1s, sin embargo, en la actualidad somos testigos de cmo distintos elementos son visibles y manipulables por nosotros en un computador. Esto se debe a que se ha conseguido utilizar distintas abstracciones de datos para representar distintos elementos, ya sean videos, msica, datos e imgenes, entre otros.

En particular, el caso que nos convoca es el de las imgenes, puesto que a pesar de las mltiples representaciones para dimensiones, colores, tamaos y otros aspectos de ellas, la mayora coincide en que una imagen puede representarse como una estructura que nos resulta familiar: matrices de datos, es decir, listas compuestas de listas.

Por ejemplo, la figura 1 muestra una pequea imagen de 10x10 pixeles, la cual puede ser representada como una matriz de 10 por 10, donde cada celda de la matriz representa el color del pixel, en este caso para la primera fila tenemos que: El primer (0, 0) y segundo (0,1) elemento corresponden a pixeles de color negro. Desde el tercer elemento (0,2) hasta el octavo elemento (0,7), tenemos celdas con valores que representan el color verde. Los dos ltimos elementos (0,8 y 0,9) respectivamente, corresponden a celdas que representan el color negro nuevamente. De este modo se siguen representando las filas de la matriz para conseguir la imagen completa, de acuerdo a la posicin de sus pixeles y mientras ms grande sea la imagen, esta se representar simplemente con una matriz con ms filas o ms columnas dependiendo del caso.

1|Pgina

0 0 1 2 3 4 5

6
7 8 9

Figura 1: Ejemplo de imagen

Con esta abstraccin para representar los pixeles de la matriz, slo resta entender: Cmo representa el computador cada color en una imagen?

Si bien existen diversas formas de representar colores en computacin, una de las codificaciones ms utilizadas es la composicin a travs de los colores primarios de la luz (Figura 2), conocida como RGB. En esta representacin se utilizan 3 canales o componentes cuya combinacin determina el color, dichas componentes son Rojo (R), Verde (V) y Azul (A).

Figura 2: Colores primarios de la luz

Enunciado Control de Laboratorio N3

2013

De esta forma, la intensidad de cada una de las componentes se divide en una escala de 2 8 valores posibles (1 byte), que van desde 0 a 255 y la combinacin de las tres componentes, entrega el color que se desea representar.

Con esta representacin el rojo puro se obtiene con (255, 0, 0), es decir, no existe verde, ni azul en la mezcla. El verde con (0, 255, 0) y el azul con (0, 0, 255). Para representar la ausencia de color, es decir el negro se utiliza la ausencia de las 3 componentes, es decir (0, 0, 0), del mismo modo, para obtener el blanco, situamos todas las componentes en su mximo, es decir (255, 255, 255), por lo tanto si se cumple que: R = G = B tendremos un valor de la escala de grises. Finalmente, el anular slo una de las componentes, nos da paso a los colores secundarios de la luz, el cian como ausencia de rojo (0, 255, 255), el magenta como ausencia de verde (255, 0, 255) y el amarillo como ausencia de azul (255, 255, 0).

Con esta informacin, podemos representar la imagen de la figura 1, como una matriz, donde cada celda de la matriz corresponde a una lista con 3 elementos, obteniendo la siguiente matriz de listas:
M = [[[0, 0, 0], [0, 0, 0], [34, 177, 76], [34, 177, 76], [34, 177, 76], [34, 177, 76], [34, 177, 76], [34, 177, 76], [0, 0, 0], [0, 0, 0]], [[0, 0, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [34, 177, 76], [0, 0, 0]], [[34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76]], [[34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76]], [[34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76]], [[34, 177, 76], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [34, 177, 76]], [[34, 177, 76], [255, 242, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [34, 177, 76], [255, 242, 0], [34, 177, 76]], [[34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76], [34, 177, 76], [34, 177, 76], [34, 177, 76], [255, 242, 0], [255, 242, 0], [34, 177, 76]], [[0, 0, 0], [34, 177, 76], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [255, 242, 0], [34, 177, 76], [0, 0, 0]],

3|Pgina

[[0, 0, 0], [0, 0, 0], [34, 177, 76], [34, 177, 76], [34, 177, 76], [34, 177, 76], [34, 177, 76], [34, 177, 76], [0, 0, 0], [0, 0, 0]]]

La estructura (a la cual se le han aadido saltos de lnea para visualizar mejor, representa en una lista cada fila de la matriz, lo que a su vez, es una nueva lista, para cada posicin en la fila (el pixel), que a su vez se representa por la lista de las 3 componentes, R, G y B. Como podemos apreciar, en la matriz M, el valor M[0][0], entregara la lista [0, 0, 0], que a su vez corresponde al color negro del primer pixel de la figura 1 debido a lo explicado anteriormente.

Teniendo en cuenta lo indicado anteriormente, se le har entrega de un programa en Python (Control3.py) que realiza las siguientes operaciones (Figura 3):

A partir de una imagen .bmp (El programa funciona para imgenes .jpg, .png, sin embargo en estos casos puede darse una prdida de resolucin entre conversiones), el programa lee dicha matriz a travs de una funcin, y la escribe en un archivo de texto.

Luego, se lee el archivo generado para crear una matriz de la forma representada anteriormente. A partir de dicha matriz, se crea una copia idntica en memoria, la cul ser usada para realizar una operacin sobre sus pixeles. Sobre la copia de la matriz se realiza la operacin Aislar verde, la cual recorre la matriz, e iguala en cada pixel el componente Rojo a cero y el componente azul a cero, dejando una matriz donde todos los valores que no representen verdes sean ceros.

Para la matriz copia, que fue modificada por la operacin Aislar verde y la matriz original, se guarda la estructura de datos como imagen, generando como salidas, una copia de la imagen original (tambin en formato .bpm, aunque nuevamente puede almacenarse en .jpg, .png considerando prdidas menores de resolucin dado los formatos de compresin) y una nueva imagen, la cual posee slo los valores de verde de la imagen original.

IMPORTANTE: Considere que el programa ha sido probado con imgenes de hasta 300x300 pixeles, y que el tamao de la imagen influye directamente en el tiempo en que Python se demorar en entregar una respuesta.

Enunciado Control de Laboratorio N3

2013

Funcin que lee una imagen en el mismo directorio del programa y entrega un archivo de texto que representa la matriz

Funcin que lee un archivo de texto y a partir de ste, genera la estructura de matriz de listas, requerida para operar

Convertir de Imagen a Archivo

Leer archivo

imagen.bmp

archivo.txt

Aislar verde

Crear Copia

Matriz original

Copia idntica de matriz original

Guardar imagen

Funcin que crea una copia idntica a la matriz original a fin de trabajar con esta copia, sin alterar la matriz original

Guardar imagen

Matriz donde todos los valores de R y B se han igualado a 0

Funcin que a partir de la matriz de listas, guarda una imagen en el mismo directorio dnde se encuentra el programa

verde.bmp

copia.bmp

Figura 3: Proceso del bloque principal del programa ejemplo

A partir de dicho programa, se requiere que se implementen otras operaciones sobre las matrices. Es decir, generar ms funcionalidades, adems del Aislar Verde, las cules se detallan en el apartado FUNCIONES REQUERIDAS. Junto a ello, se requiere un men que permita a un usuario escoger entre las distintas opciones que se le solicitar.

5|Pgina

II.1.
Python 2.6.

Requisitos previos

El trabajo solicitado debe desarrollarse en Python, en la versin utilizada en el curso, es decir

Para ejecutar el programa ejemplo se requiere la instalacin de dos mdulos adicionales a Python (no deber aprender a usarlos, slo los necesita para las funciones predefinidas y que no deben modificarse), los mdulos requeridos, que estarn disponibles junto a este enunciado en la plataforma USACHVIRTUAL, son los siguientes:

PIL o Pillow (Python Image Library): Mdulo de Python que aade soporte para abrir y manipular distintos formatos de imagen. A partir de ste mdulo se obtendrn y generarn los distintos archivos de imagen requeridos para este programa. (Pillow2.2.2.win)

NUMPY: Mdulo de Python que agrega soporte para la lectura y transformacin de grandes colecciones de datos, como matrices, adems de funciones matemticas de alto nivel. En este trabajo se utilizar nicamente para transformar la imagen a datos y viceversa. (numpy-MKL-1.8.0.win)

Considere que deber instalar cada mdulo en base a la arquitectura de su mquina, en la plataforma existir una versin de numpy y de Pillow tanto para computadores de 32 bits (win32), como para computadores de arquitecturas de 64 bits (-amd64). Para averiguar el tipo de arquitectura de un computador, se debe ir a Equipo->Propiedades->Sistema->Tipo de Sistema.

II.2.

Funciones requeridas

Para este trabajo, se le ha entregado el programa que se incluye al final de ste documento, a partir de l, se debe realizar la generacin de diversas funciones sobre imgenes en Python, las cules se han dividido en dos tipos: Funciones sobre pixeles y funciones sobre componentes.

Enunciado Control de Laboratorio N3

2013

II.2.1.

Funciones sobre pixeles

son aquellas que no requieren modificar los valores de las

Las funciones sobre pixeles

componentes, en cambio, stas deben realizar modificaciones sobre las posiciones de cada pixel en la matriz, las funciones sobre pixeles solicitadas son:

ROTAR 90 A travs de modificaciones en las posiciones de la matriz, se requiere que el programa permita crear una imagen con rotacin de 90. Original Resultado

ROTAR 180 A travs de modificaciones en las posiciones de la matriz, se requiere que el programa permita crear una imagen con rotacin de 180. Original Resultado

7|Pgina

ROTAR 270 A travs de modificaciones en las posiciones de la matriz, se requiere que el programa permita crear una imagen con rotacin de 270. Original Resultado

ESPEJAR HORIZONTALMENTE Se requiere una funcin espejar, capaz de mostrar como la imagen original se vera a travs de un espejo. Original Resultado

Enunciado Control de Laboratorio N3

2013

ESPEJAR VERTICALMENTE Se requiere una funcin espejar, capaz de mostrar como la imagen original se vera a travs de un espejo sobre la componente vertical. Original Resultado

II.2.2.

Funciones sobre componentes

Las funciones sobre componentes son aquellas que alteran el comportamiento de los colores de las imgenes, para poder resolverlas, se hace necesario realizar modificaciones sobre uno o ms colores del pixel. Las funciones requeridas sobre componentes son:

ESCALA DE GRISES Se requiere una funcin capaz de mostrar la imagen original en escala de grises. Original Resultado

9|Pgina

NEGATIVO Se requiere una funcin capaz de invertir el color de cada pixel. Considere para ello la escala de 0 a 255. Original Resultado

BLANCO Y NEGRO Se requiere una funcin capaz de generar una imagen nicamente con tonos de blanco y negro a partir de una original, decidiendo que tonos sern blancos y que tonos sern negros. (El resultado es una gua, debido a que la tolerancia la establece el programador, pueden quedar resultados con ms blanco o ms negro) Original Resultado

Enunciado Control de Laboratorio N3

2013

SUAVIZAR Para generar el suavizar, se debe seguir la siguiente secuencia de pasos: Para cada pixel en la matriz Hacer que el valor de la componente roja sea igual al promedio de las componentes rojas de los pixeles adyacentes Hacer que el valor de la componente verde sea igual al promedio de las componentes verdes de los pixeles adyacentes Hacer que el valor de la componente azul sea igual al promedio de las componentes verdes de los pixeles adyacentes De este modo se genera una imagen suavizada, con las lneas menos definidas, como se muestra a continuacin Original Resultado

Adems de estas funciones, se requiere que genere dos filtros de color adicionales, los cules sern de su diseo, dichos filtros sern evaluados en base a la originalidad como a la complejidad al programarlos, a continuacin se presentan dos ejemplos de filtros de color realizados modificando el programa.

11 | P g i n a

Original

Filtro 1: ColorEX

Original

Filtro 2: tubeFuzz

II.3.

Respecto a la representacin en Python

Considere que este trabajo fue conscientemente diseado para ser resuelto utilizando nicamente los contenidos vistos hasta el momento, por lo que no es necesario investigar o aadir otras libreras adems de las requeridas para ejecutar el cdigo. Se recomienda leer detenidamente el documento, e identificar que informacin del enunciado es relevante para el problema y cul corresponde a informacin irrelevante. Del mismo modo considere que aunque las entradas y salidas del programa son imgenes, se requiere que usted trabaje nica y exclusivamente sobre matrices y listas.

Enunciado Control de Laboratorio N3

2013

Considere que se evaluar la estructura de programas en Python, por lo que a pesar de la envergadura del programa este DEBE estar subdividido en funciones claramente definidas, comentadas, indicando sus entradas, salidas y lo que stas entregan, y de ser necesario ir comentando paso a paso las instrucciones.

Los bloques de programa deben ir claramente definidos, y como mnimo debiera diferenciar:

Encabezado: Indicado la informacin relevante del programa. Definicin de constantes: Indicando la importacin y definicin de valores constantes en el programa. Definicin de funciones: Indicando las funciones necesarias para la ejecucin del programa, adems, se recomienda dividir dichas funciones de acuerdo a: Funciones sobre pixeles: Presentando las funciones que modifican la posicin de los pixeles en la matriz Funciones sobre componentes: Presentando las funciones que realizan operaciones directamente sobre el color. Funciones auxiliares: Funciones que apoyan o subdividen los problemas. Filtros diseados: Filtros de color diseados e implementados por el equipo.

Considere que identificando y dividiendo el programa en sub-procesos, el problema resultar ms sencillo de abordar para el equipo de trabajo, en caso de alcanzar slo parcialmente los objetivos del control, se sugiere colocar en los comentarios las abstracciones de datos y procesos implementados y no implementados.

III.

Entrega

El plazo mximo para entregar el programa ser el da jueves 2 de enero a ms tardar a las 13:00 horas.

Se requiere entregar un archivo .py con el programa desarrollado en Python, con los RUT de sus integrantes (sin puntos, ni guin) por nombre de archivo siguiendo el formato <RUT N1><RUT N2>.py por ejemplo: 173454322-18984321K.py

13 | P g i n a

Adems en el cdigo, se debe aadir el siguiente encabezado del programa, con los siguientes datos para identificar su trabajo (Rellene el encabezado del programa con los datos en formato IDNTICO al indicado en el ejemplo a continuacin):
# -*- coding: cp1252 -*# SECCIN DE LABORATORIO: L-1 # PROFESOR DE LABORATORIO: JUAN PADILLA # INTEGRANTES # 1. # NOMBRE: Juan Carlos Perez Gonzalez # RUT: 17.345.432-2 # CARRERA: Ingeniera Civil Mecnica # PROFESOR DE CTEDRA: Andrs Rice # # # # # 2. NOMBRE: Javier Rojas Madariaga RUT: 18.984.321-K CARRERA: Ingeniera de Ejecucin en Computacin e Informtica PROFESOR DE CTEDRA: Csar Silva

# DESCRIPCIN DEL PROGRAMA ...<CONTINE CON EL PROGRAMA A PARTIR DE AQU>

Se requiere que suba este archivo a la plataforma USACHVIRTUAL y, como respaldo, enviar una copia al mail de su profesor de laboratorio y de su ayudante de laboratorio ANTES del plazo establecido.

En caso de tener ms archivos en su implementacin, considere que el encabezado debe ser parte de cada uno de los archivos y se debe entregar el trabajo completo en un archivo comprimido de extensin .zip o .rar con el mismo nombre que se indic anteriormente. Considere que archivos sin identificador de autores tanto en el nombre como dentro del encabezado del cdigo, no sern revisados, ni evaluados.

Del mismo modo considere que archivos enviados nicamente al correo del profesor, sin copia en UsachVirtual, no sern considerados en la revisin.

Enunciado Control de Laboratorio N3

2013

IV. Evaluacin
Respecto a la evaluacin tenga en consideracin las siguientes instrucciones (El no seguimiento de una o ms de stas normas puede significarle ser evaluado con la nota mnima): Los grupos estarn compuestos por un mximo de dos personas, ambas pertenecientes a la misma seccin de laboratorio. Se permite el trabajo individual, sin embargo, esto no significa una disminucin en los criterios de evaluacin. En caso de detectar programas iguales, o con suficientes similitudes entre s, tanto en una misma seccin como en secciones distintas, ser considerado un acto de copia y calificado con nota mnima. Se compararn programas con un algoritmo de reconocimiento de texto y adems se pasar por un proceso de validacin visual por personal de la coordinacin de Fundamentos de Computacin y Programacin para realizar dicha deteccin. Grupos que entreguen fuera del plazo establecido sern calificados con la nota mnima. Grupos que sean descubiertos en actos deshonestos sern sancionados con la nota mnima. Grupos que revelen aspectos claves de su implementacin en UsachVirtual u otras plataformas (Incluyendo redes sociales) sern calificados con nota mnima. Considere que la implementacin de su programa es de responsabilidad nica de los integrantes del grupo, y que tanto en ctedra como en laboratorio se han entregado todas las herramientas y los contenidos para el desarrollo de sta, por lo que cualquier indicio de intervencin de un tercero, ser sancionado con la nota mnima. La difusin de este enunciado, solicitando ayuda, ofreciendo dinero a cambio de la resolucin e incluso la publicacin de ste dentro del plazo de desarrollo de la tarea, se considera un acto deshonesto, que daa la imagen de la Facultad de Ingeniera y de la Universidad de Santiago y ser calificado inapelablemente con nota mnima. Se sancionar con descuentos sobre la calificacin final a los grupos que no cumplan con las instrucciones del programa y de entrega publicados en el enunciado. Se bonificar a los grupos que aadan funcionalidades adicionales, aspectos de presentacin ms elaborados y que en general no se limiten simplemente a resolver el

15 | P g i n a

problema dado (en estos casos indicar en los comentarios o en un archivo .txt, requisitos, modo de uso, funcionalidades extras, etc). Considere que se evaluar el cdigo mismo, las funcionalidades conseguidas, la estructura del programa, la ejecucin del programa, la respuesta a eventos inesperados y los comentarios en el cdigo fuente. Cualquier situacin no contemplada en este documento ser dirimida por la Facultad de Ingeniera.

La nota final de esta evaluacin vale como una nota del total de notas de laboratorio, y esta se divide en dos partes, la implementacin y el test de salida con las siguientes caractersticas:

El test de salida, corresponde a un control que ser tomado en la siguiente semana luego de la entrega del trabajo, en horario de laboratorio o el que el profesor de cada laboratorio convenga con su seccin de laboratorio, a fin de verificar que el grupo que presenta un trabajo que es de su autora, en el cul se le preguntar respecto a aspectos funcionales de SU implementacin o la resolucin sin el intrprete de Python de alguno de los sub-problemas del enunciado. Si su nota del test es superior a 4,0, la ponderacin es 10% test de salida y 90% programa. Si su nota en el test de salida es inferior a 4,0, la ponderacin del trabajo es 100% la nota ms baja entre el control de salida y la nota del programa.

Enunciado Control de Laboratorio N3

2013

V. ANEXO: PROGRAMA DE PARTIDA

# # # # -*- coding: cp1252 -*AUTOR: Coordinacin de Fundamentos de Computacin y Programacin FECHA: 22 de Diciembre de 2013 VERSIN: 1.0

# Programa que realiza operaciones sobre imgenes # IMPORTANTE: Considere que este programa ha sido testeado con imgenes de # hasta 300X300 pixeles. # CONSTANTES # NO SE REQUIEREN CONSTANTES ############################################################################ # # FUNCIONES # ############################################################################ ############################################################################ # # IMPORTACIN DE FUNCIONES # ############################################################################ # Desde el mdulo PIL importo las operaciones sobre imgenes from PIL import Image # Importo el mdulo numpy completo con sus operaciones numricas import numpy ############################################################################ # # DEFINICIN DE FUNCIONES PROPIAS # ############################################################################ # Funcin que lee una imagen, la codifica a una matriz de componentes RGB # y la escribe en un archivo de salida .txt # ENTRADA: String que representa el nombre y la extensin de la imagen, # por ejemplo "imagen.bmp" # String que representa el nombre y la extensin del archivo de # destino, por ejemplo "salida.txt" # SALIDA: Entrega true si el archivo fue escrito correctamente # REQUIERE: Que la imagen exista y se encuentre en el mismo directorio del programa # # IMPORTANTE: NO SE REQUIERE, NI SE DEBE MODIFICAR ESTA FUNCIN

17 | P g i n a

# def convertirImagenAArchivo(nombreImagen, nombreDestino): # Se abre la imagen y se le almacena en una variable llamada imagen imagen = Image.open(nombreImagen) # Se codifica la imagen a codificacin RGB para mantener el formato solicitado imagen = imagen.convert('RGB') # Se convierte la imagen a una matriz del mdulo numpy # (No se puede operar con ella) matrizNumpy = numpy.array(imagen) # Se abre el archivo con el nombre entregado en los parmetros formales # en modo de escritura archivo = open(nombreDestino, 'w') # Para cada fila de la matrizNumpy for fila in matrizNumpy: # Para cada lista de 3 componentes (RGB) en la fila # es decir, para cada pixel en la fila for pixel in fila : # Para cada componente en el pixel for componente in pixel : # Se escribe en el archivo un espacio el valor del componente # se transforma el valor del componente a string para permitir # que python lo escriba archivo.write( ' ' + str(componente)) # Se separan los pixeles de cada fila escribiendo una coma cada vez que # se escriben los 3 componentes del pixel archivo.write(',') # Se escribe un salto de lnea cada vez que se ha recorrido una fila de la # matriz archivo.write('\n') # Se cierra el archivo archivo.close() # Se retorna el valor booleano True, indicando que la operacin se realiz return True # Funcin que lee un archivo .txt que representa una imagen y devuelve una matriz # de listas. # ENTRADA: String que representa el nombre y la extensin del archivo de # a leer, por ejemplo "entrada.txt" # SALIDA: Entrega una matriz de listas, representando una imagen # REQUIERE: Que el archivo .txt exista y se encuentre en el mismo directorio # del programa # # IMPORTANTE: NO SE REQUIERE MODIFICAR ESTA FUNCIN # def leerArchivo(nombreEntrada): # Se abre el archivo con el nombre entregado como parmetro formal # en modo de escritura archivo = open(nombreEntrada,'r') # Se crea una matriz vacia para almacenar la salida

Enunciado Control de Laboratorio N3

2013

matriz = [] # Para cada linea del archivo for i in archivo : # Se genera una lista vaca que servir para operar lista = [] # Se genera una lista vaca que almacenar la fila completa de # la imagen fila = [] # Se elimina la ltima coma (,) y el \n de la fila utilizando strip # luego se divide por las comas restantes utilizando split lista = i.strip(",\n").split(',') # Para cada pixel en la lista for pixel in lista : # Se divide el pixel por los espacios para obtener una lista con # las tres componentes aux = pixel.split() # Para cada uno de los 3 elementos de aux # se usa un range para recorrer por ndice y no por elemento for e in range(3) : # Se transforma el valor a entero aux[e] = int(aux[e]) # Se aade aux, que es una lista de 3 elementos representando el # valor de rojo, verde y azul, a la fila de la matriz fila.append(aux) # Una vez que se ha recorrido la fila completa, sta se aade a la matriz matriz.append(fila) # Se retorna la matriz return matriz # Funcin que recibe una matriz de listas y entrega una copia exacta de la entrada # # ENTRADA: Matriz, donde cada celda de la matriz es una lista de 3 elementos # SALIDA: Matriz, donde cada celda de la matriz es una lista de 3 elementos # REQUIERE: Que la matriz exista y tenga el formato indicado # # IMPORTANTE: NO SE REQUIERE MODIFICAR ESTA FUNCIN def copiarMatriz(matriz): # Se genera una matriz vaca para almacenar la copia de la matriz matrizResultado = [] # Se almacena la cantidad de filas en una variable filas filas = len(matriz) # Se almacena la cantidad de elementos por fila en una variable columnas columnas = len(matriz[0]) # Para cada elemento entre 0 y la cantidad de filas for i in range(filas): # Se genera una fila vaca nuevaFila = [] # Para cada elemento (Pixel) entre 0 y la cantidad de elementos por fila for j in range(columnas):

19 | P g i n a

# Se obtiene la componente roja (R) de cada pixel rojo = matriz[i][j][0] # Se obtiene la componente verde (G) de cada pixel verde = matriz [i][j][1] # Se obtiene la componente azul (B) de cada pixel azul = matriz[i][j][2] # Se crea una nueva lista con las componentes rojo, verde y azul de cada pixel pixel = [rojo, verde, azul] # Se agrega el pixel a la fila de la nueva matriz nuevaFila.append(pixel) # Una vez agregados todos los pixeles de la fila original a la fila nueva, # se agrega la nueva fila a la matriz matrizResultado.append(nuevaFila) # Una vez agregadas todas las filas a la matriz nueva, esta se retorna return matrizResultado # Funcin que recibe una matriz de listas y transforma a 0 todos los componentes # de la lista que no estn representando el verde # ENTRADA: Matriz, donde cada celda de la matriz es una lista de 3 elementos # SALIDA: Matriz, donde cada celda de la matriz es una lista de 3 elementos, # donde cada lista ser de la forma [0, valor, 0] # REQUIERE: Que la matriz exista y tenga el formato indicado # # IMPORTANTE: NO SE REQUIERE MODIFICAR ESTA FUNCIN def aislarVerde(m): # Se llama dentro de la funcin aislar verde a la funcin # copiaMatriz, asegurando de este modo que siempre las operaciones de esta funcin # se realizarn sobre una matriz distinta a la original matriz = copiarMatriz(m) # Para cada fila en la matriz for fila in matriz : # Para cada pixel en la fila for pixel in fila : # Se modifica el valor de la componente roja (La primera de la lista pixel) # igualndola a 0 pixel[0] = 0 # Se modifica el valor de la componente azul (La tercera de la lista pixel) # igualndola a 2 pixel[2] = 0 # Se puede observar que la componente verde no se ha alterado, por lo que # pixel[1] = pixel[1], operacin que no impactara en el resultado # Se retorna la matriz con todos los valores rojos y azules modificados return matriz # Funcin que recibe una matriz de listas y crea el archivo de imagen que est representando

Enunciado Control de Laboratorio N3

2013

# ENTRADA: Matriz, donde cada celda de la matriz es una lista de 3 elementos # String representando el nombre y la extensin del archivo de salida # SALIDA: Entrega True si el archivo fue escrito correctamente # REQUIERE: Que la matriz exista y tenga el formato indicado # # IMPORTANTE: NO SE REQUIERE MODIFICAR ESTA FUNCIN def convertirMatrizAImagen(matriz, nombreSalida): # Se convierte la matriz a un tipo de dato del mdulo numpy para poder # realizar la conversin a imagen arr = numpy.array(matriz) # Se transforma el arr de numpy a la matriz, indicando la codificacin que # el dato representa, el rango de los nmeros y el formato de los nmeros im = Image.fromarray(arr.clip(0,255).astype('uint8'), 'RGB') # Se guarda la imagen en el archivo de salida que se indic en los parmetros formales im.save(nombreSalida) return True ############################################################################## ################ # # # BLOQUE PRINCIPAL # # ############################################################################## ################ # # ENTRADA # print "Ingrese la imagen a procesar,", nombreEntrada = raw_input("por ejemplo, imagen.bmp: ") print "Ingrese el nombre del archivo de destino,", nombreSalida = raw_input("por ejemplo, salida.txt ") archivoExitoso=convertirImagenAArchivo(nombreEntrada, nombreSalida) if archivoExitoso: print "El archivo ", nombreSalida, " se ha creado exitosamente" matriz = leerArchivo(nombreSalida) # # PROCESAMIENTO # copiaOriginal = copiarMatriz(matriz) copiaSoloVerde = aislarVerde(matriz) # # SALIDA # copiaExitosa = convertirMatrizAImagen(copiaOriginal, "copia.bmp") copiaVerdeExitosa = convertirMatrizAImagen(copiaSoloVerde, "verde.bmp")

21 | P g i n a

if copiaExitosa and copiaVerdeExitosa : print "Los archivos copia.bmp y verde.bmp se han creado correctamente" else : print "Error al leer ", nonbreEntrada, "compruebe que la ruta y el nombre del archivo son correctos"