Lab1paralela Version 4

Fase N1 Procesamiento de Imgenes digitales
Integrantes Aldo Aguilar Freddy Aravena Manuel Astudillo Gerson Leiva Camilo Torres Acadmico Oscar Magna 2 Semestre , 2013
Universidad Tecnolgica Metropolitana Facultad de Ingeniera. Departamento de Informtica y Computacin. Escuela de Informtica. Computacin Paralela INF-762.
Resumen En el presente informe, se abordar de manera tcnica, la implementacin y el anlisis de aplicaciones paralelas y secuenciales, desarrolladas en C, para el procesamiento de imgenes digitales. Se partir estableciendo, un marco terico, sobre el procesamiento de imgenes, cmo por ejemplo tcnicas, con el objetivo de orientar y contextualizar el presente documento, explicando en que estn basados los cdigos que se utilizaron Luego, sigue la seccin que describe los objetivos generales y especficos del proyecto Tambin se expone la justificacin del proyecto, exponiendo cuales son las ventajas que se tendrn, a partir de las tcnicas aqu expuestas. Despus de enunciar la justificacin, se describir la metodologa empleada para el desarrollo del trabajo. Luego de este tem se pasarn a describir las herramientas utilizadas, adems de caracterizar el hardware ocupado para la implementacin del clster y la ejecucin de las aplicaciones. Se sigue con la descripcin de la topologa de red usada en el clster, permitiendo la comunicacin entre los diferentes nodos en uso. A continuacin, se enuncian las herramientas de implementacin del clster y cmo estas son configuradas. Luego se pasar a mostrar los resultados de las pruebas de implementacin, ya que se recopilaron y analizaron los resultados para despus compararlos utilizando mtricas. Para finalizar, se presentarn las conclusiones finales, de la parte 1 del laboratorio.
Fase 1 Procesamiento de Imgenes
Tabla de contenido
1. 2. 3. Introduccin ...................................................................................................................... 5 Descripcin del problema ................................................................................................ 5 Objetivos. .......................................................................................................................... 6 3.1. 3.2. 4. 5. 6. 7. 8. Objetivos Generales. ................................................................................................... 6 Objetivos Especficos. .................................................................................................. 6
Alcance del proyecto ........................................................................................................ 6 Metodologa de trabajo general. ...................................................................................... 7 Herramientas de desarrollo .............................................................................................. 7 Pruebas de implementacin............................................................................................. 9 Tratamiento de Imagen ....................................................................................................11 8.1. 8.2. Proceso Algoritmo Secuencial ....................................................................................11 Proceso Algoritmo Paralelo .....................................................................................12
9.
Tcnicas de Procesamiento de Imgenes Utilizadas ....................................................12 9.1. 9.2. 9.3. 9.4. Escala de grises (grayscale) ....................................................................................13 Inversin de colores .................................................................................................13 Ajustar Brillo .............................................................................................................14 Generacin de efectos por Convolucin.................................................................14 Topologa de red. .........................................................................................................16 Especificaciones tcnicas ...........................................................................................17 Especificacin de los nodos ................................................................................17 Especificacin del router ......................................................................................17
10. 11.
11.1. 11.2. 12.
Mtricas de desempeo ...............................................................................................18 Mtricas para Invertir Color ..................................................................................18 Mtrica para Escala de Grises ..............................................................................19 Mtricas para Ajustar Brillo ......................................................................................20
12.1. 12.2. 12.3. 13.
Mejores Tiempos ..........................................................................................................21
Invertir Color ...........................................................................................................................21 14. 15. 16. 17. Graficas de Speedup ....................................................................................................23 Graficas de Eficiencia ..................................................................................................25 Conclusiones ................................................................................................................27 Bibliografa ...................................................................................................................28 3
Anexo 1: Invertir colores ........................................................................................................29 Anexo 2: Escala de Grises .....................................................................................................30 Anexo 3: Ajustar Brillo ...........................................................................................................31 Anexo 4: Convolucion ............................................................................................................32 Anexo 5: Montaje de Clster ..................................................................................................33 Anexo 6: Formato BMP ...........................................................................................................37 Anexo 7: Conceptos involucrados en el procesamiento de imgenes ...............................40 Anexo 8: Cdigo Secuencial ..................................................................................................44 Anexo 9: Cdigo Paralelo .......................................................................................................53
1. Introduccin El procesamiento digital de imgenes es un campo fascinante que forma parte de nuestra vida diaria. En sus inicios el procesamiento de imgenes estaba restringido a campos de investigacin de ciencias de la computacin, matemticas y astronoma. Lo que constitua una labor tardada, impredecible y de alto costo, se ha convertido en una disciplina en s misma, con la ayuda de microprocesadores baratos, dispositivos de gran memoria y componentes de procesamiento de seales; volvindose as una herramienta invaluable en diversas aplicaciones, tales como la robtica, control industrial, medicina, telecomunicaciones, entre otras. El procesamiento de imagen por definicin hace referencia al conjunto de tcnicas que se aplican a las imgenes digitales con el objetivo de mejorar la calidad, realizar cambios o facilitar la bsqueda de informacin en ellas. Uno de los problemas ms frecuentes que presenta esta disciplina es el excesivo tiempo de procesamiento que demandan los equipos dedicados al tratamiento de las imgenes. Bajo este contexto nuestro equipo de trabajo propone en primera instancia desarrollar una solucin de tipo clster para mejorar los tiempos de procesamiento que llevan las distintas tareas, para posteriormente ahondar un poco ms en el tema enfocndonos en la representacin de imgenes como vectores bidimensionales (matrices), en el que cada elemento de la matriz corresponde a un pixel. Con estos datos veremos que pasa cuando alteramos las matrices, proponiendo variados escenarios, finalmente realizaremos un anlisis de desempeo a cada una de las alternativas propuestas y comprobaremos si es que la solucin de tipo clster es realmente efectiva para los casos de procesamiento de imgenes.
2. Descripcin del problema Se debe resolver el caso propuesto sobre la transformacin y procesamiento de imgenes, diseando e implementando una plataforma en paralelo; clster, de tres nodos como mnimo. Generando los cdigos compatibles de forma secuencial y paralelo, para luego proceder a realizar las correspondientes pruebas de desempeo y determinar las conclusiones pertinentes.
3. Objetivos. 3.1. Objetivos Generales.
Conocer, analizar e implementar una plataforma en ambiente paralelo, que permita el tratamiento y solucin de problemas de procesamiento de imgenes digitales, de modo tal que se puedan evaluar y comparar estas con las soluciones secuenciales. 3.2. Objetivos Especficos. Implementar un clster de 3 nodos. Trabajar sobre imgenes en formato bmp. Implementar la solucin computacional secuencial Plantear la estrategia de paralizacin. Implementar la solucin computacional paralela. Medir el rendimiento de las soluciones desarrolladas. Comparar y analizar el rendimiento del ambiente en paralelo en relacin al secuencial. Generar un informe con todas las implicaciones del proyecto.
4. Alcance del proyecto El sistema a desarrollar est orientado a trabajar con diferentes tcnicas en lo que comprende al tratamiento y procesamiento de imgenes, comprendiendo bsicamente al realce, filtrado y mejora, las cuales se podrn encontrar bajo distintas resoluciones. Una vez dominados estos problemas de visualistica computacional indirecta, se proceder a extraer informacin de la misma imagen para luego trabajar con esta informacin. El enfoque del proyecto a ser desarrollado se encuentra basado en la manipulacin de una imagen en formato a eleccin de dimensiones diferentes. Se identifican las tareas a realizar con respecto a la imagen origen tales como: Resolucin del problema utilizando un Clster. Trabajar con imagen en formato .bmp. Realizar clculos especficos con la matriz de pixeles generada a partir de la imagen. Clculo de mtricas de desempeo para las soluciones presentadas. Conclusiones respecto a las mtricas evaluadas.
5. Metodologa de trabajo general. La metodologa a utilizar se basar en el montaje de un clster tipo Beowulf sobre tres equipos o nodos corriendo Ubuntu versin 12.04. Entre estos nodos existir un maestro y dos esclavos, los cuales estarn conectados a una red local mediante un router. Una vez ya instalados y configurados todos los nodos, se proceder a la interconexin de estos por medio de los protocolo SSH y NFS. Finalmente los nodos se comunicarn, ejecutarn y resolvern una problemtica realizada en C. Esta comunicacin se realizar mediante la API OpenMPI. 6. Herramientas de desarrollo Ubuntu. Es un sistema operativo basado en ncleo Linux, bajo la denominacin de software libre y de cdigo abierto. Este sistema se encuentra pre compilado y empaquetado para funcionar en mltiples arquitecturas. SSH. El intrprete de rdenes segura (SSH), es el nombre de un protocolo y programa que permite acceder a equipos remotos de forma segura, adems de permitir el control de estos a travs de comandos por consola. SSH permite adems copiar datos de forma segura con el uso de claves. NFS. El sistema de archivos de red (NFS) es un protocolo del modelo OSI a nivel de aplicacin. Posibilita que varios computadores en red puedan acceder a archivos y ficheros dentro de esta, de la misma manera que se hara dentro de un fichero local. El protocolo NFS est incluido por defecto en los Sistemas Operativos UNIX y la mayora de las distribuciones de Linux. NFS tiene dos partes principales: un servidor y uno o ms clientes, que acceden a los archivos en forma remota. Los datos se almacenan en el servidor, no es necesario replicarlos en los clientes. Es posible compartir dispositivos de almacenamiento masivo tales como: CD-ROM, USB, DVD, etc.
MPI. La Interfaz de Paso de Mensajes (MPI), es un protocolo de comunicacin entre computadores. Es una especificacin estndar para una librera de funciones de paso de mensajes, independiente de la plataforma y de dominio pblico. Proporciona funciones para ser utilizadas con lenguajes de programacin como C, C++, Fortran, etc. MPI debe ser implementado sobre un entorno que se preocupe del manejo de los procesos y la E/S por ejemplo, puesto que MPI slo se ocupa de la capa de comunicacin, necesita un ambiente de programacin paralelo nativo. Los programas y bibliotecas MPI son portables y rpidas, debido a que se han implementado en casi todas las arquitecturas de memoria distribuida y han sido optimizados para el hardware en el que se ejecuta. Pero, como slo especifica el mtodo de paso de mensajes, el resto del entorno puede ser totalmente diferente en cada implementacin, por lo que se impide esa portabilidad que tericamente tiene. Geany Geany es un pequeo y ligero entorno de desarrollo integrado. Fue desarrollado para proporcionar un IDE pequeo y rpido, que slo tiene unas pocas dependencias de otros paquetes. Otro objetivo era ser lo ms independiente posible de un entorno de escritorio especial como KDE o GNOME - Geany slo requiere de las bibliotecas de tiempo de ejecucin GTK2. Algunas de las caractersticas bsicas de Geany: El resaltado de sintaxis Plegado de cdigo Nombre de smbolo de autocompletar Construir finalizacin / snippets Auto-cierre de XML y HTML etiquetas Llame consejos Muchos tipos de archivos soportados, incluyendo C, Java, PHP, HTML, Python, Perl, Pascal Listas de smbolos Navegacin Cdigo El sistema de generacin de compilar y ejecutar el cdigo Administracin simple proyecto Interfaz de Programas
7. Pruebas de implementacin Para la implementacin se usaron cuatro tcnicas: Invertir colores Escala de grises Ajustar Brillo Convolucion
A continuacin se muestra el resultado obtenido para cada tcnica:
Figura 1. Imagen Original
Figura 2.Invertir colores
Figura 3. Escala de gris
Figura 4. Ajustar Brillo -127
Figura 5. Ajustar Brillo 127
Figura 6. Convolucion
10
8. Tratamiento de Imagen Para tratar la imagen, se representa en forma de matriz de M filas x N columnas, donde cada elemento de la matriz es un pixel de tres componentes (Azul, Verde, Rojo).
8.1.
Proceso Algoritmo Secuencial
Los pasos de ejecucin para todos los algoritmos en secuencial son los siguientes:
Abrir el fichero (imagen), leer los datos de la imagen y se crea el fichero de salida. Realiza las correspondientes operaciones sobre la imagen; Invertir, transpon, etc. Escribir en el fichero de salida los datos modificados de la Imagen.
11
8.2.
Proceso Algoritmo Paralelo
La metodologa de procesamiento en paralelo que se utiliz para la implementacin de las soluciones; fue la de paralelismo de datos: se utilizan mltiples unidades funcionales (nodos) para aplicar la misma operacin simultnea a elementos de un conjunto de datos, en este caso a la matriz de componente de cada color. En la siguiente imagen se ilustra que es el paralelismo de datos:
Aplicacin Paralelismo de Datos
9. Tcnicas de Procesamiento de Imgenes Utilizadas Las tcnicas que existen para procesar imgenes, se pueden agrupar en tres grandes grupos: Invertir Colores Aplicar escala de grises Ajustar brillo de la imagen.
Para el desarrollo de este proyecto se aplicaron las tcnicas de modificacin de color (escala de grises, inversin de colores, ajustes de brillo). Algunas de las tcnicas ms conocidas que estn relacionadas con la modificacin que se hace a los pixeles de una imagen sin que estos cambien de posicin.
12
9.1.
Escala de grises (grayscale)
En el espacio de colores, los vectores en la direccin del vector (1, 1, 1) representan diferentes tonalidades de gris. As, cualquier pxel (r, g, b) de una imagen, proyectado sobre este vector nos dar su contribucin gris a una nueva imagen que formaran con todas las proyecciones de los pixeles originales.
Figura 7. Espacio vectorial de colores
9.2.
Inversin de colores
El valor ms grande que puede tomar un color es 255 y el ms pequeo 0, entonces si deseamos invertir las contribuciones de los diferentes pixeles a la formacin de una imagen, se debe restar su color de 255 y esta diferencia tomarla como la contribucin al color de la nueva imagen.
Figura 8. Frmula para inversin de colores
13
9.3.
Ajustar Brillo
Aumentar el brillo de una imagen consiste en sumar o restar una constante a los colores que constituye un pxel, cuidando siempre de nunca rebasar los lmites 0 y 255. Si observamos la siguiente figura, aumentar o disminuir el brillo en una imagen consiste en aumentar o disminuir la ordenada al origen de la lnea recta con pendiente a 45 grados que representa los grises.
Figura 9. Aumento o Disminucin de brillo
As, la frmula que tenemos que aplicar en este tipo de transformacin tiene la forma siguiente: Ntese que esta frmula representa una familia de rectas que pasan por el punto (128,128) con diferentes pendientes. 9.4. Generacin de efectos por Convolucin
La Convolucin es una matriz (o arreglo bidimensional) que se aplica a una imagen. Los elementos de este arreglo son valores enteros. El resultado de esta operacin es una imagen nueva que ha sido filtrada. Bsicamente la Convolucin modifica el color de un pixel en funcin del color de los pixeles circunvecinos. Para cada canal, el valor de color para cada pixel se calcula del color original y del color de los pixeles que lo rodean. La Convolucin se aplica multiplicando el color de un pixel y el de sus pixeles circundantes por una matriz. Esta matriz se llama el kernel de Convolucin. El kernel se mueve por cada uno de los pixeles de la imagen original y cada pixel que queda bajo la matriz se multiplica por un valor de la matriz, el resultado se suma y divide despus por un valor especfico. El resultado de esta operacin es el nuevo color del pixel que cae en el centro de la matriz. A continuacin se presenta un ejemplo muy sencillo de un kernel de Convolucin
14
Figura 10. Matriz o arreglo dimensional
Los kernels pueden tener tamaos arbitrarios, pero los de 3 x 3 son los ms usados en la mayora de las situaciones (tambin debido a que son los ms rpidos), ya que solo toma en consideracin el valor del pixel mismo y el de sus 8 vecinos. Ahora, para aplicar este kernel a una imagen debe colocarse el kernel sobre la imagen y multiplicar los valores de color por 1 o 4. El resultado se suma y divide por 12, en este caso (la suma de los elementos del kernel). A continuacin se presenta una seccin de una imagen en grises, sobre la que se aplicar el kernel de convolucin.
Figura 11. Seccin de imagen en grises
Se ha escogido en grises para facilitar la explicacin, ahora bien sobre cada uno de los pixeles de esta seccin de imagen, colocamos el valor de su color, teniendo como entendido que por ejemplo 150 = (150, 150, 150) en sus componentes rojo, verde y azul.
Figura 12.Imagen con el valor de su color
15
Ahora se coloca el kernel sobre los pixeles de la imagen y el primer pixel que obtenemos es el (2,2), luego al desplazarnos con el kernel a la derecha el siguiente pixel que obtendremos ser el (2,3) y as sucesivamente.
Figura 13. Imagen con el Kernel sobre los pixeles
Si se tratara de una imagen no de grises, esto mismo hay que hacer para cada una de las tres componentes (R, V, A) que constituyen al pixel, originando 9 multiplicaciones 8 sumas y una divisin por un factor de tres para cada uno de los pixeles de la imagen que se vayan a procesar. Por ejemplo si contamos con una imagen de 512 x 384 pixeles hay que realizar alrededor de 10. 5 millones de operaciones para obtener la imagen filtrada. Si nos fijamos bien, los pixeles de la orilla no pueden ser procesados porque no cuentan con todos sus vecinos para aplicar el algoritmo entonces se tienen que desechar. 10. Topologa de red. Para los procesos de carga entre los equipos (interaccin y distribucin), es fundamental fijar la arquitectura de red. La arquitectura de la red es bsicamente del tipo estrella, cuyo switch est conectado a un sistema mayor conformado por una serie de switchs y hubs.
16
Esquema topolgico.
Figura 14. Topologa red estrella utilizada para el clster.
11. Especificaciones tcnicas 11.1. Especificacin de los nodos
La plataforma de hardware se compondr de 2 nodos de iguales caractersticas. A continuacin se procede a dar las especificaciones tcnicas del hardware: Procesador Codename Frecuencia Ncleos/Hilos L1 cache/L2 cache/ L3 cache RAM Frecuencia 11.2. Especificacin del router Linksys WRT54GL Inalmbrica G 2,4 GHz IEEE 802.3, IEEE 802.3u, IEEE 802.11g, IEEE 802.11b 2 (externas) 4 x 10/100 17 Intel-Core i7-3770k Ivi Bridge 3.5 GHz-3.9 GHz 4 ncleos/ 8 hilos 4x32 KB / 4x256/ 8MB 4GB (2x4GB) DDR3 SDRAM 1600 MHZ
Tabla 1. Especificacin tcnica nodos
Modelo Tecnologa Bandas Estandares Antenas Puertos Ethernet x velocidad Fase 1 Procesamiento de Imgenes
Tabla 2. Especificacin tcnica de router
12. Mtricas de desempeo 12.1.

Nombre de Imagen
Mtricas para Invertir Color

Mejor Tiempo secuen cial (segund os) 0.03 0.04 0.05 0.09 0.31 0.38 0.83 0.89 0.94 1.46 1.34 2.29 3.27 4.47 3.43 3.83 5.84 7.48 9.06 Tiempo Paralelo con 4 procesa dores (1 Nodo) 0.01 0.01 0.01 0.01 0.05 0.06 0.12 0.13 0.14 0.16 0.2 0.26 0.37 0.51 0.51 0.58 0.66 0.84 1.04 Speed up 4 proce sador es 3.000 4.000 5.000 9.000 6.200 6.333 6.917 6.846 6.714 9.125 6.700 8.808 8.838 8.765 6.725 6.603 8.848 8.905 8.712 Eficie ncia 4 proce sador es 0.75 1.000 1.250 2.250 1.550 1.583 1.729 1.712 1.679 2.281 1.675 2.202 2.209 2.191 1.681 1.651 2.212 2.226 2.178 Tiempo Paralelo con 8 procesa dores (2 Nodos) 0.530 0.560 0.770 1.110 4.460 4.880 10.010 14.520 15.360 17.800 21.850 27.810 41.960 57.130 58.560 65.570 74.630 94.430 116.710 Speed up 8 procesa dores Eficienc ia 8 procesa dores Tiempo Paralelo con 12 procesa dores (3 Nodos) 0.71 0.77 1.03 1.49 5.95 6.51 13.36 19.34 20.46 23.74 29.12 37.09 53.42 72.69 74.53 83.36 94.94 120.15 148.11 Speed up 12 procesad ores Eficiencia 12 procesad ores
Dimensiones
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
1600x1200 1920x1080 2008x1384 2000x2000 4000x4000 4940x3554 6000x6000 11038x4730 11709x4716 8000x8000 10799x7274 10000x10000 12000x12000 14000x14000 14173x14173 15000x15000 16000x16000 18000x18000 20000x20000
0.057 0.071 0.065 0.081 0.070 0.078 0.083 0.061 0.061 0.082 0.061 0.082 0.078 0.078 0.059 0.058 0.078 0.079 0.078
0.007 0.009 0.008 0.010 0.009 0.010 0.010 0.008 0.008 0.010 0.008 0.010 0.010 0.010 0.007 0.007 0.010 0.010 0.010
0.042 0.052 0.049 0.060 0.052 0.058 0.062 0.046 0.046 0.061 0.046 0.062 0.061 0.061 0.046 0.046 0.062 0.062 0.061
0.004 0.004 0.004 0.005 0.004 0.005 0.005 0.004 0.004 0.005 0.004 0.005 0.005 0.005 0.004 0.004 0.005 0.005 0.005
Tabla 3. Mtricas Invertir color
18
12.2.
Nombre de Imagen
Mtrica para Escala de Grises

Mejor Tiempo secuen cial (segund os) Tiempo Paralelo con 4 procesa dores (1 Nodo) Speed up 4 proce sador es Eficie ncia 4 proce sador es Tiemp o Parale lo con 8 proce sador es (2 Nodo s) 0.53 0.58 0.77 1.11 4.45 4.88 10 14.53 15.37 17.8 21.85 27.81 41.96 57.13 58.54 65.58 74.61 94.44 116.66 Speed up 8 proce sador es Eficie ncia 8 proce sador es Tiempo Paralelo con 12 procesa dores (3 Nodos) Speed up 12 procesad ores Eficiencia 12 procesad ores
Dimensiones
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
0.04 0.5 0.7 0.09 0.38 0.4 0.83 1.18 1.25 1.46 1.78 2.29 3.27 4.47 4.55 5.09 5.84 7.48 9.06
0.01 0.01 0.01 0.01 0.05 0.05 0.12 0.18 0.19 0.22 0.27 0.35 0.51 0.7 0.7 0.78 0.9 1.14 1.41
4.000 50.000 70.000 9.000 7.600 8.000 6.917 6.556 6.579 6.636 6.593 6.543 6.412 6.386 6.500 6.526 6.489 6.561 6.426
1 12.500 17.500 2.250 1.900 2.000 1.729 1.639 1.645 1.659 1.648 1.636 1.603 1.596 1.625 1.631 1.622 1.640 1.606
0.075 0.862 0.909 0.081 0.085 0.082 0.083 0.081 0.081 0.082 0.081 0.082 0.078 0.078 0.078 0.078 0.078 0.079 0.078
0.009 0.108 0.114 0.010 0.011 0.010 0.010 0.010 0.010 0.010 0.010 0.010 0.010 0.010 0.010 0.010 0.010 0.010 0.010
0.72 0.77 1.03 1.5 5.94 6.52 13.36 19.38 20.48 23.73 29.13 37.07 53.66 72.69 74.6 83.58 94.93 120.14 148.46
0.056 0.649 0.680 0.060 0.064 0.061 0.062 0.061 0.061 0.062 0.061 0.062 0.061 0.061 0.061 0.061 0.062 0.062 0.061
0.005 0.054 0.057 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005
Tabla 4. Mtricas Escala de Grises.
19
12.3.
Nombre de Imagen
Mtricas para Ajustar Brillo

Mejor Tiemp o secue ncial (segu ndos) 0.04 0.05 0.07 0.1 0.35 0.39 0.82 1.17 1.22 1.51 1.72 2.24 3.12 4.27 3.57 4.02 4.56 5.75 7.16 Tiempo Paralelo con 4 procesa dores (1 Nodo) 0.01 0.01 0.01 0.01 0.06 0.06 0.15 0.15 0.2 0.27 0.29 0.42 0.62 0.82 0.57 0.62 1.07 1.36 1.12 Speed up 4 proce sador es Eficie ncia 4 proce sador es Tiempo Paralelo con 8 procesa dores (2 Nodos) 0.53 0.58 0.77 1.11 4.45 4.88 10.01 14.52 15.37 17.8 21.84 27.81 41.95 57.13 58.56 65.56 74.69 94.47 116.62 Speed up 8 proce sador es Eficie ncia 8 proce sador es Tiempo Paralelo con 12 procesa dores (3 Nodos) 0.73 0.77 1.04 1.49 5.94 6.51 13.36 19.33 20.41 23.73 29.13 37.07 53.66 72.68 74.94 74.56 83.48 120.14 148.89 Speed up 12 procesa dores Eficie ncia 12 proce sador es 0.005 0.005 0.006 0.006 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.003 0.004 0.005 0.004 0.004
Dimensiones
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
4.000 5.000 7.000 10.000 5.833 6.500 5.467 7.800 6.100 5.593 5.931 5.333 5.032 5.207 6.263 6.484 4.262 4.228 6.393
1 1.250 1.750 2.500 1.458 1.625 1.367 1.950 1.525 1.398 1.483 1.333 1.258 1.302 1.566 1.621 1.065 1.057 1.598
0.075 0.086 0.091 0.090 0.079 0.080 0.082 0.081 0.079 0.085 0.079 0.081 0.074 0.075 0.061 0.061 0.061 0.061 0.061
0.009 0.011 0.011 0.011 0.010 0.010 0.010 0.010 0.010 0.011 0.010 0.010 0.009 0.009 0.008 0.008 0.008 0.008 0.008
0.055 0.065 0.067 0.067 0.059 0.060 0.061 0.061 0.060 0.064 0.059 0.060 0.058 0.059 0.038 0.054 0.055 0.048 0.048
Tabla 5.Metrica Ajustar Brillo
El clculo de las mtricas speed up y eficiencia mostradas en las tablas [3], [4] y [5] se lograron obteniendo los datos en tiempo real, para esto se realizaron pruebas de los algoritmos tanto para la versin secuencial como paralela (cuatro, ocho y doce ncleos). Se realiz el mismo procedimiento para los tres filtros, utilizando los datos y formulas correspondientes. Para el caso del Speed Up se utiliz la relacin: Speed up: Tiempo secuencial/Tiempo paralelo Y para la eficiencia se utiliz: Eficiencia: Speed up/ Numero de procesadores
20
13. Mejores Tiempos Invertir Color
Figura 15. Mejores tiempos en Invertir color
Escala de grises
Figura 16. Mejores tiempos en Escala de grises
21
Ajustar brillo
Figura 17. Mejores tiempos en Ajuste de brillo
Se puede observar en cada grfica que el modelo de ejecucin del algoritmo con cuatro procesadores y un nodo es la opcin ms ptima para ejecutar los algoritmos y que ejecuta en menos tiempo, en el caso de que se agreguen ms procesadores y por consecuencia nodos el algoritmo utilizado degrada el sistema, esto se debe a que la tasa de transferencia de datos es muy baja o no es lo suficientemente grande como para satisfacer las necesidades del sistema.
22
14. Graficas de Speedup Invertir Color
Figura 18. Speedup Invertir color
Escala de Grises
Figura 19. Speedup Escala de grises
23
Ajustar Brillo
Figura 20. Speedup Ajustar Brillo
Las figuras [18], [19] y [20] corresponden a los speed ups de las tres tcnicas de filtro. Al igual que el caso anterior se puede observar que las curvas que representan los Speed Up, para los casos de ocho y doce procesadores con dos y tres nodos respectivamente, muestran la degradacin del sistema esto se debe a causas de costos de comunicacin.
Curva Speed Up de inversin de color con cuatro procesadores y un nodo: o En esta grfica se puede distinguir que la relacin tamao de imagen y Speed Up no representan una relacin lineal o exponencial, sino que se ve reflejada por una sinusoidal por lo que a cada cierta cantidad de incremento de dimensiones de imagen la ganancia de velocidad puede ser mayor o menor, en cuanto a comparacin con las versiones de dos y tres nodos se puede concluir que por lejos la mejor es la opcin de un nodo, ya que refleja un real incremento en cuanto a la versin del algoritmo secuencial Curva Speed Up de escala de grises con cuatro procesadores y un nodo: o En esta grfica se puede distinguir que la relacin tamao de imagen y Speed Up ademas de verse reflejada como una sinusoidal, se le agrega un factor exponencial negativo, el cual se puede expresar matemticamente como : S(x)=e-xcos(x), ya que la cota que encierra esta relacin disminuye su rango a medida que el tamao de imagen empieza a incrementar, al igual que el caso anterior se puede concluir la mejor es la opcin de un nodo, ya que refleja un real incremento en cuanto a la versin del algoritmo secuencial Curva Speed Up de ajuste de brillo con cuatro procesadores y un nodo: o En esta grfica al igual que la grafica de inversin de colores se logra distinguir una relacin representada por una sinusoidal, pero que tiende a hacerse constante y cada vez menor, al igual que los casos anteriores se puede concluir
24
la mejor es la opcin de un nodo, ya que refleja un real incremento en cuanto a la versin del algoritmo secuencial
15. Graficas de Eficiencia Invertir Color
Figura 21. Eficiencia Invertir Color
Escala de Grises
Figura 22. Eficiencia Escala de grises
25
Ajuste de Brillo
Figura 23. Eficiencia Ajuste de Brillo
Al igual que el caso anterior se puede observar que las curvas que representan la Eficiencia, para los casos de ocho y doce procesadores con dos y tres nodos respectivamente, muestran la degradacin del sistema esto se debe a causas de costos de comunicacin, ademas las curvas de eficiencia son parecidas a las curvas de Speed Up con la nica diferencia que el rango de las cotas cambia, ademas se puede observar que para los algoritmos paralelos ejecutados en 4 procesadores (1 nodo) son mayormente eficiente en razn de lo esperado, esto se debe a que no se debe lidiar con costos de comunicacin de transferencia de datos y que existe un mejor manejo de memoria.
26
16. Conclusiones Gracias al desarrollo de este proyecto, el grupo de trabajo a podido identificar la importancia de la computacin paralela, en el funcionamiento de procesos que requieran un gran poder de procesamiento. En este caso los procesos corresponden a tcnicas de filtrado de procesamiento de imgenes. Para poder ver que tan til resulta la computacin paralela se realizaron algoritmos de cuatro diferentes tcnicas de procesamiento de imgenes, las cuales tiene dos versiones, una versin secuencial y otra versin paralela, la cual a su misma vez se ejecuta con cuatro procesadores (un nodo), ocho procesadores (dos nodos) y doce procesadores (tres nodos).
Cmo se ve en (Figura 15,16,17) Cuando se utilizan las versiones paralelizadas de los algoritmos de filtrado, ya sea tanto para ocho como para doce procesadores (dos y tres nodos respectivamente), se puede observar que los tiempos de ejecucin de dichas implementaciones son considerablemente mayores que las de sus versiones secuenciales, no obstante el caso de la paralelizacin de cuatro procesadores (llevada a cabo en un nodo), logra cumplir el objetivo el cual es disminuir el tiempo de ejecucin respecto a su versin secuencial. Este fenmeno se debe a un factor en particular, el cual es considerado como el principal cuello de botella dentro del sistema, la velocidad de transferencia de datos a travs de la red. En el caso de la versin secuencial no se debe lidiar con una comunicacin de datos y la versin paralelizada con cuatro procesadores (un nodo), la espera de la comunicacin de datos se puede despreciar, ya que los datos son compartidos dentro de una misma mquina por sus cuatro procesadores.
Para el caso en el cual se deben compartir datos entre diferentes equipos (dos y tres nodos) la tarjeta de red y la velocidad de transferencia de los datos generan un cuello de botella, si bien el algoritmo paralelo se ejecuta con mayor rapidez que su versin secuencial, el costo de envio de datos asociado a el tamao de la imagen es muy grande, ya que la tasa de transferencia es muy baja, por lo que el tamao de la imagen a tratar se convierte en un factor clave en el incremento exagerado del tiempo de ejecucin del algoritmo, ya que como se puede observar en las tablas (Figura 15,16,17) los tiempos de ejecucin de cada tcnica de filtrado de procesamiento de imgenes, para la misma imagen, y con la misma cantidad de procesadores y nodos; es muy cercano y en la mayora de los casos es igual, lo que se puede traducir simplemente a costos de transferencia de datos a una tasa menor que la necesaria, este problema que afecta en gran medida el tiempo de ejecucin del algoritmo se puede solucionar aumentando la velocidad de transferencia de la red para que el traspaso de informacin sea mayor en menos tiempo. Debido a lo anterior, es posible concluir que la computacin paralela es una alternativa conveniente para realizar cmputos o procesos de altas prestaciones a bajos costos (por ejemplo tiempo). Posibilita incrementar la productividad, si las condiciones se dan, interviniendo de manera importante la estrategia de paralelizacin de algoritmos, el tipo de red a utilizar, los componentes de la res (entindase por esto la cantidad y la calidad), entre otros.
27
17. Bibliografa [1] http://www2.uacj.mx/Publicaciones/GeneracionImagenes/imagenesCap8.pdf [2] http://www.ie.itcr.ac.cr/palvarado/pmwiki/index.php/PabloAlvarado/MScProcesamiento Digital DeIm%C3%A1genes [3] http://upload.wikimedia.org/wikipedia/commons/c/c4/BMPfileFormat.png [4] http://processing.org/tutorials/pixels/ [5] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.36.2566 [6] http://www.uazuay.edu.ec/estudios/sistemas/teleproceso/apuntes_1/estrella.htm
28
Anexo 1: Invertir colores

Nombre de Imgenes Dimensiones Peso (MB) Tiempos Mejor Tiempo secuen cial (segund os) 0,03 0,04 0,05 0.09 0,31 0.38 0.83 0,89 0,94 1.46 1,34 2.29 3.27 4.47 3.43 3.83 5.84 7.48 9.06 Tiempo Paralelo con 4 procesadores (1 Nodo) Tiempo Paralelo con 8 procesadores (2 Nodos) Tiempo Paralelo con 12 procesadores (3 Nodos)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
5.8 6.2 8.3 12 48 52.7 108 156.6 165.7 192 235.7 300 432 588 602.6 675 768 972 1228.8
0,03 0,04 0,04 0,05 0,06 0.09 - 0.10 0,31 0,32 0.38 - 0.39 0.83 0,89 0,9 0,91 0,94 0,95 1.46 - 1.47 1,34 1,35 2.29 - 2.3 3.27 - 3.28 - 3.29 4.47 - 4.48 3.43 - 3.48 - 3.5 3.83 - 3.89 - 3.9 5.84 - 5.85 7.48 - 7.51 - 7.52 9.06 - 9.12 - 9.15
0.01 - 0.02 0.01 - 0.02 0.01 - 0.02 0.01 - 0.02 0.05-0.06 0.04 - 0.06- 0.07 0.09-0.1-0.12 0.13 - 0.14 0.14 - 0.15 0.16-0.17 0.20 - 0.21 0.26-0.27 0.37-038 0.51-0.52-0.55 0.51 - 0.52 - 0.53 0.58 - 0.59 0.66-0.67-0.68 0.84-0.86 1.04 - 1.05
0.53-0.54 0.56-0.57-0.58 0.77-0.78 1.11-1.12 4.46 4.88-4.89-4.90 10.01-10.02 14.52 15.36-15.37 17.80-17.82 21.85-21.86 27.81-27.82 41.96-41.97 57.13-57.14 58.56 65.57 74.63 94.43 116.71
0.71 - 0.72 0.77 - 0.78 1.03 - 1.04 1.49 5.95 6.51 - 6.52 - 6.53 13.36 19.34 - 19.36 - 19.37 20.46 - 20.51 - 20.53 23.74 29.12 - 29.14 37.09 53.42 72.69 74.53 - 74.64 -74.93 83.36 - 83.49 - 83.79 94.94 120.15 148.11 - 149.13 - 150.62
Tabla 6. Mediciones para Invertir Colores.
29
Anexo 2: Escala de Grises

Nombre de Imgenes Dimensiones Peso (MB) Tiempos Mejor Tiempo secuencial (segundos) 0,04 0,5 0,7 0.09 0.38 Tiempo Paralelo con 4 procesadores (1 Nodo) 0.01 - 0.02 0.01 - 0.02 0.01 - 0.02 0.01 - 0.02 0.05 - 0.06 0.07 - 0.08 0.05 - 0.06 0.07 - 0.08 0.12-0.13-0.14 0.18 - 0.19 0.20 0.19 - 0.20 0.21 0.22-0.23 0.27 - 0.28 0.29 - 0.30 0.35-0.36 0.51-0.52-0.53 Tiempo Paralelo con 8 procesadores (2 Nodos) 0.53-0.54-0.55 0.58-0.57 0.77-0.78 1.11-1.12 4.45-4.46 Tiempo Paralelo con 12 procesadores (3 Nodos) 0.72 0.77 - 0.78 1.03 - 1.04 1.5 5.94
1 2 3 4 5
1600x1200 1920x1080 2008x1384 2000x2000 4000x4000
5.8 6.2 8.3 12 48
0,04 0,05 0,05 - 0,06 0,07 0.09 - 0.10 0.38 - 0.39
4940x3554
52.7
0,4 0,41
0,4
4.88-4.89-4.90
6.52
7 8
6000x6000 11038x4730
108 156.6
0.83 1,18 1,19
0.83 1,18
10-10.01 14.53
13.36 19.38 - 19.39 - 19.42
11709x4716
165.7
1,25 1,27
1,25
15.37
20.48 - 20.49 - 20.51
10 11
8000x8000 10799x7274
192 235.7
1.46 - 1.47 1,78
1.46 1,78
17.80-17.81 21.85-21.8621.87 27.81-27.82 41.96-41.97
23.73 29.13 - 29.15
12 13
10000x10000 12000x12000
300 432
2.29 - 2.3 3.27 - 3.28 3.29 4.47 - 4.48 4.55 - 4.56 4.57 - 4.59 4.61 5.09 - 5.1 5.11 - 5.14 5.84 - 5.85 7.48 - 7.51 7.52 9.06 - 9.07 9.09 - 9.12 9.15
2.29 3.27
37.07 53.66
14 15
14000x14000 14173x14173
588 602.6
4.47 4.55
0.7 0.70 - 0.71 0.72
57.13-57.14 58.54
72.69 74.60 - 74.75 - 74.83
16
15000x15000
675
5.09
0.78 - 0.79 0.80 0.90-0.91 1.14-1.16
65.58
83.58 - 83.59
17 18
16000x16000 18000x18000
768 972
5.84 7.48
74.61 94.44
94.93 120.14
19
20000x20000
1228.8
9.06
1.41 - 1.42
116.66
148.46 - 149.56 150.29
Tabla 7. Mediciones para Escala de grises.
30
Anexo 3: Ajustar Brillo

Nombre de Imgenes Dimensiones Peso (MB) Tiempos Mejor Tiempo secuen cial (segund os) 0,04 0,05 0,07 0.1 0.35 Tiempo Paralelo con 4 procesadores (1 Nodo) Tiempo Paralelo con 8 procesadores (2 Nodos) Tiempo Paralelo con 12 procesadores (3 Nodos)
1 2 3 4 5
1600x1200 1920x1080 2008x1384 2000x2000 4000x4000
5.8 6.2 8.3 12 48
0,04 0,05 0,05 - 0,06 0,07 0,08 0.1 - 0.11 - 0.1 0.35-0.410.38 0,39 0,41 0,43 0.82 - 0.85 0.86 1,17 1.181.19-1.22-1,23 1,22 1,30
0.01 - 0.02 0.01 - 0.02 0.01 - 0.02 0.01 - 0.02 0.06-0.07
0.53-0.54-0.55 0.58-0.59 0.77-0.78 1.11-1.12 4.45-4.46-4.47
0.73 - 0.93 - 0.98 0.77 - 0.78 1.04 1.49 5.94
4940x3554
52.7
0,39
0.05 - 0.06 - 0.07 0.08 0.15-0.16-0.17
4.88-4.89-4.90
6.51 - 6.53
6000x6000
108
0.82
10.01
13.36
11038x4730
156.6
1,17
0.15 - 0.20 - 0.23
14.52 -14.59
19.33 - 19.38 19.43 20.41 - 20.45 20.49 - 20.54 23.73 29.13 - 29.14
11709x4716
165.7
1,22
0.20 - 0.22 - 0.23 0.24 0.27-0.28 0.29 - 0.30 - 0.33 0.34 0.42-0.43-0.44 0.62-0.63-0.64 0.82-0.86-0.87
15.37-15.40-15.42
10 11
8000x8000 10799x7274
192 235.7
1.52-1.51-1.52 1,72 1,84 1,85 2.24-2.36-2.35 3.12-3.39-3.39 4.27 - 4.63 4.62 3.57 - 3.58 3.61 - 3.93 4.76 4.02 - 5.11 5.26 - 5.27 5.28 5.41 - 6.01 4.56 6.76 - 7.61 5.75 7.16 - 8.61 9.35
1.51 1,72
17.80-17.81 21.84-21.85
12 13 14
10000x10000 12000x12000 14000x14000
300 432 588
2.24 3.12 4.27
27.81-27.82 41.95-41.96-41.97 57.13-57.14
37.07 53.66 72.68
15
14173x14173
602.6
3.57
0.57 - 0.75 - 0.86 0.87
58.56
94.94
16
15000x15000
675
4.02
0.62 - 0.63 - 0.81 0.82 - 0.93 - 0.96
65.56
74.56 - 74.82 74.91
17
16000x16000
768
4.56
1.07-1.11-1.12
74.69
83.48 - 83.77 83.86 120.14
18
18000x18000
972
5.75
1.36-1.40-1.41
94.47
19
20000x20000
1228.8
7.16
1.12 - 1.44 - 1.46 1.73 - 1.74
116.62
148.89 - 149.01 149.06
Tabla 8. Mediciones para Ajustar Brillo
31
Anexo 4: Convolucion con deteccin de bordes

Nombre de Imgenes Dimensiones Peso (MB) Tiempos Mejor Tiempo secuencial (segundos) Tiempo Paralelo con 4 procesadores (1 Nodo) 0.26 0.27 0.37 0.53 2.13 2.33 4.83 6.95 7.35 8.49 10.4 13.37 19.28 26.06 26.64 29.74 33.94 42.75 52.97 Tiempo Paralelo con 8 procesadores (2 Nodos) 0.55 0.6 0.82 1.17 4.67 5.13 10.49 15.22 16.09 18.65 22.89 29.14 41.96 57.12 58.54 65.58 74.73 94.44 116.66 Tiempo Paralelo con 12 procesadores (3 Nodos) 0.72 0.78 1.04 1.49 5.96 6.52 13.36 19.38 23.75
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
5.8 6.2 8.3 12 48 52.7 108 156.6 165.7 192 235.7 300 432 588 602.6 675 768 972 1228.8
1.86 - 1.89 - 1.9 2.02 - 2.04 2.05 2.7 - 2.73 3.85 - 3.86 3.88 15.41 - 15 .57 17.15 - 17.16 17.2 34.76 - 34.79 50.61 - 50.63 50.65 53.49 - 53.51 53.52 62.24 - 62.47 76.27 - 76.29 76.3 97.15 - 98.4 140.96 - 142.2 189.04 - 192.31 194.67 - 194.69 217.53 - 217.55 - 217.56 247.8 - 250.5 311.59 - 313.07 387.77 - 387.90
1.86 2.02 2.7 3.85 15.41 17.15 34.76 50.61 53.49 62.24 76.27 97.15 140.96 189.04 194.67 217.53 247.8 311.59 387.77
Tabla 9. Mediciones para Convolucion
32
Anexo 5: Montaje de Clster 1-Preparativos El primer paso para el montaje de Clster es tener instalado el SO en base Linux, en este caso Ubuntu, en cada computador y verificar que funcione correctamente, terminado este paso se debe verificar que el nombre de usuario para cada computador debe ser el mismo, el cual fue clster, y como nombre de mquina se utiliz la nomenclatura nXX donde las X representan el valor de los ltimos dos dgitos de direccin ip asignadas a cada computador para conectarse a la red; adems de tener operativo el sistema se debe verificar que la red TCP/IP est configurada y que el SO est actualizado. Para lograr lo anteriormente mencionado se debe abrir la terminal e ingresar lo siguiente: $ifconfig ; para comprobar los datos conexin a la red $ping -c n direccin Web ; para comprobar que existe conexin a internet, donde n es la cantidad de paquetes recibidos . $sudo apt-get update && sudo apt-get -y upgrade; para actualizar el sistema.
Verificando que todo funcione correctamente se puede pasar a la siguiente etapa la cual es el montaje de herramientas bases. 2-Montaje de Herramientas bases Las herramientas bases necesarias para poder montar el clster tanto en el nodo maestro como en los nodos esclavos son las siguientes:

gcc y g++ (Compiladores de lenguajes C y C++ respectivamente) OpenMpi (Interfaz de paso de mensajes) ssh (Intrprete de rdenes segura) nfs (Sistema de archivos de red)
Para instalar estas herramientas se debe abrir una terminal e ingresar como sper usuario (root) para poder instalar dichas herramientas como ser descrito a continuacin:
33
$sudo su #apt-get install -y gcc g++ #apt-get install -y openmpi-bin openmpi-common libopenmpi1.3 libopenmpi-dev #apt-get install -y ssh #apt-get install -y nfs-kernel-server nfs-common portmap #apt-get install -y build-essential
Finalmente se cierra la sesin superusuario. 3-Crear carpeta compartida En primer lugar se ubica en la carpeta de usuario, para este caso /home/cluster, y posteriormente se crea la carpeta .ssh, luego se le otorga permisos para el usuario comn, luego se crea la carpeta compartida en el directorio raz , nombrada mpi; esto se debe hacer en cada nodo del futuro clster, los pasos anteriormente nombrados sern descritos a continuacin: $cd /home/cluster $mkdir .ssh $chmod 777 .ssh $sudo su #cd / #mkdir mpi #chown cluster /mpi Cumplido estos pasos el montaje se divide para el nodo maestro y los nodos esclavos 3. a-Montaje de Nodo Maestro Esta etapa debe ser realizada paralelamente al montaje de Nodos Esclavos y se deben seguir los siguientes pasos: 1. Modificar el archivo host ubicado en etc. e incluir los datos de nodos definiendo el nodo maestro y los nodos esclavos. 2. Modificar el archivo exports ubicado en etc. y asignar el valor de lectura y escritura para la carpeta maestra compartida. 3. Compartir la carpeta con los nodos esclavos, este paso se debe realizar una vez que todos los nodos se encuentren configurados. Para realizar estos pasos se ingresa a la lnea de comandos y se ingresa:
34
$sudo gedit /etc/fstabs // Agregar lo siguiente y guardar: (Ip de Nodo) usuario nombre de equipo # Nodo Maestro (Ip de Nodo) usuario nombre de equipo # Nodo Esclavo 1 (Ip de Nodo) usuario nombre de equipo # Nodo Esclavo 2 (Ip de Nodo) usuario nombre de equipo # Nodo Esclavo 3 (Ip de Nodo) usuario nombre de equipo # Nodo Esclavo n // $sudo gedit /etc/exports // Agregar lo siguiente y guardar (Ruta Carpeta Maestra)*(rw,sync) // $sudo service nfs-kernel-server restart
3. b-Montaje de Nodos Esclavos Terminadas las etapas anteriores se debe proceder montar la carpeta maestra compartida para esto en cada nodo esclavo se debe abrir una terminal e ingresar: $sudo mount (ip nodo maestro):(Ruta carpeta maestra) (ruta carpeta compartida) Donde la ip de nodo maestro es 10.1.10.125, la ruta de la carpeta maestra es /mpi y la ruta de la carpeta compartida es /mpi Terminado esto se procede a modificar el fichero fstab que se ubica en la carpeta etc. y se modifica para que el montaje sea automtico que ser descrito a continuacin: $sudo gedit /etc/fstab // Se incluye lo siguiente en el archivo: (ip nodo maestro):(Ruta carpeta maestra) (ruta carpeta compartida) nfs y se guarda // $sudo mount -a Terminado estos pasos, ya se tienen configurados los Nodos Esclavos. Fase 1 Procesamiento de Imgenes 35
4- Configuracin SSH Esta etapa solo se debe realizar en el nodo maestro y se debe la carpeta maestra se sincronice correctamente en cada uno de los nodos, tanto maestro como esclavos. Para configurar el ssh en el nodo maestro se debe posicionar la carpeta .ssh en la terminal de comandos e ingresarlo siguiente: $ssh-keygen -t rsa //Presionar Enter a todo $cat id_rsa.pub >> authorized_keys Luego de esto se utiliza el comando para crear una conexin ssh con cada nodo para esto se ingresa en la terminal: $ssh-copy-id (ip nodo esclavo) E ingresar la clave del nodo esclavo. Para verificar que este paso se realiz con xito se debe ingresar en la terminal: $ ssh (ip nodo esclavo) Si el proceso se ejecut correctamente el ingreso es automtico y sin el ingreso de contrasea. 5- Compilar y ejecutar cdigo Para compilar cdigo Mpi c se guarda el archivo de cdigo de fuente en la carpeta compartida y en el nodo maestro se establece como ubicacin en la terminal y se ingresa lo siguiente: $mpicc codigodefuente.c -o ejecutable Para poder ejecutar el archivo generado se ingresa el siguiente comando:

Asignando manualmente los nodos : $ mpirun -np cantidad procesadores -host nombre nodo esclavo ejecutable Asignando archivo de hostfile: $ mpirun -np cantidad procesadores -hostfile rutahostfile ejecutable
Comprobado que esta etapa se ejecut con xito se tiene completamente configurado el clster.
36
Anexo 6: Formato BMP
37
Encabezado del archivo El encabezado del archivo proporciona informacin acerca del tipo de archivo (mapa de bits) y su tamao, as como tambin indica dnde comienza realmente la informacin de la imagen. El encabezado comprende cuatro campos: La firma (en 2 bytes), que indica que se trata de un archivo BMP con dos caracteres BM, 424D en hexadecimal, que indica que se trata de un mapa de bits de Windows BA que indica que se trata de un mapa de bits OS/2 CI que indica que se trata de un icono de color de OS/2 CP indica que es un puntero de color de OS/2 IC indica que es un icono de OS/2 PT indica que es un puntero de OS/2 El tamao total del archivo en bytes (codificado en 4 bytes) Un campo reservado (en 4 bytes) El desajuste de la imagen (en 4 bytes), es decir, la ubicacin del comienzo de la informacin de la imagen en relacin con el comienzo del archivo
Encabezado de informacin del mapa de bits El encabezado de informacin del mapa de bits proporciona informacin acerca de la imagen, en especial las dimensiones y los colores. La informacin del mapa de bits comprende cuatro campos: El tamao del encabezado de informacin del mapa de bits en bytes (codificado en 4 bytes). Los siguientes valores hexadecimales son posibles segn el tipo de formato BMP: 28 para Windows 3.1x, 95, NT 0C para OS/2 1.x F0 para OS/2 2.x El ancho de la imagen (en 4 bytes), es decir, el nmero de pxeles contados de forma horizontal La altura de la imagen (en 4 bytes), es decir, el nmero de pxeles contados de forma vertical El nmero de planos (en 2 bytes). Este valor es siempre 1 La profundidad del modelo de color (en 2 bytes), es decir, el nmero de bits usados para codificar el color. Este valor puede ser equivalente a 1, 4, 8, 16, 24 32 El mtodo de compresin (en 4 bytes). Este valor es 0 cuando la imagen no est comprimida o 1, 2 3 segn el tipo de compresin usado:
38
1 para la codificacin RLE de 8 bits por pxel 2 para la codificacin RLE de 4 bits por pxel 3 para la codificacin de campo de bits, lo que significa que el color fue codificado por una mscara triple representada por la paleta. El tamao total de la imagen en bytes (en 4 bytes). La resolucin horizontal (en 4 bytes), es decir, el nmero de pxeles por metro contado de forma horizontal. La resolucin vertical (en 4 bytes), es decir, el nmero de pxeles por metro contado de forma vertical. El nmero de colores de la paleta (en 4 bytes). El nmero de colores importantes de la paleta (en 4 bytes). Este campo puede equivaler a 0 cuando todos los colores son importantes.
Paleta de imgenes La paleta es opcional. Cuando se define la paleta, sta contiene 4 bytes de forma sucesiva para cada una de las entradas, que representan: El componente azul (en un byte). El componente verde (en un byte). El componente rojo (en un byte). Un campo reservado (en un byte).
Codificacin de imgenes La codificacin de imgenes se realiza escribiendo en forma sucesiva los bits que corresponden a cada pxel, lnea por lnea, comenzando por el pxel del extremo inferior izquierdo. Las imgenes de 2 colores usan 1 bit por pxel, lo que significa que un byte permite codificar 8 pxeles Las imgenes de 16 colores usan 4 bits por pxel, lo que significa que un byte permite codificar 2 pxeles Las imgenes de 256 colores usan 8 bits por pxel, lo que significa que se necesita un byte para codificar cada pxel Las imgenes de colores reales usan 24 bits por pxel, lo que significa que se necesitan 3 bytes para codificar cada pxel, respetando la alternancia del orden de los colores para el azul, el verde y el rojo.
39
Cada lnea de la imagen debe comprender un nmero total de bytes que sea mltiplo de 4; si este esquema no se cumple, la lnea se debe completar con todos los 0 necesarios para respetar el criterio.
Anexo 7: Conceptos involucrados en el procesamiento de imgenes Imagen: es una representacin visual, que manifiesta la apariencia visual de un objeto real o imaginario. Aunque el trmino suele entenderse como sinnimo de representacin visual, tambin se aplica como extensin para otros tipos de percepcin, como imgenes auditivas, olfativas, tctiles, sinestsicas, etctera. Imagen Digital: La imagen digital es la representacin bidimensional de una imagen empleando bits, unidad mnima de informacin compuesta por dgitos binarios (1 y 0), que se emplea a instancias de la informtica y cualquier dispositivo de tipo digital. Imgenes Bitmap: Las imgenes de mapa de bits estn construidas mediante una gran cantidad de cuadraditos, llamados pixel. Cada uno de estos cuadraditos est relleno de un color uniforme, pero la sensacin obtenida es el resultado de integrar visualmente, en la retina, las variaciones de color y luminosidad entre pxeles vecinos
Figura 24. Imagen Bitmap
Las imgenes de mapa de bits, tambin llamadas bitmap, son la alternativa ideal para reproducir objetos sutilmente iluminados y escenas con gran variacin tonal. De hecho, es el tipo de imagen utilizado para la fotografa y el cine. Obviamente, la calidad de la imagen depender de la cantidad de pxeles utilizados para representarla. Las imgenes bitmap no permiten el cambio de escala. Observando, en la imagen siguiente, lo que pasa al hacer zoom sobre las flores de la imagen anterior: los pxeles son evidentes y la representacin es totalmente irreal. Este efecto, que se conoce con el nombre de pixelado se hace ms evidente en las lneas curvas y en las zonas en las que hay cambios bruscos de luminosidad.
40
Figura 25. Zoom de la figura anterior
Afortunadamente, existe una alternativa de software libre llamada The Gimp, un programa excelente, potente y profesional, que tiene muy poco que envidiar al costoso Photoshop. Las imgenes en mapa de bits, en cambio, son perfectas cuando la gama de colores cambia sutilmente. En este caso, la imagen debe generarse teniendo muy en cuenta dnde y cmo va a mostrarse, con una cantidad de pxeles y una gama de colores adaptados al soporte en el que va a reproducirse. Una vez hecha, las modificaciones comportarn prdida de calidad Resolucin Podemos definir la resolucin como la capacidad de reproducir fielmente los detalles de una imagen. Utilizaremos esta palabra, lgicamente, al referirnos a la resolucin de una imagen digital, pero tambin, al referirnos a una impresora, un monitor, una cmara o un escner. As pues, se trata de un concepto fundamental, que posee distintas acepciones, segn el contexto en el que lo utilizamos. A partir de ahora nos referiremos a la tecnologa bitmap, que es la ms exigente en lo que concierne a la resolucin. Hay que tener presente este concepto en todas las etapas de la vida de la imagen, desde su captura con una cmara digital o un escner hasta la reproduccin en el soporte elegido. Resolucin de una imagen La resolucin de una imagen es la cantidad de pxeles que la componen. Suele medirse en pxeles por pulgada (ppi)1 o pxeles por centmetro (pcm). Cuanto mayor es la resolucin de una imagen ms calidad tendr su presentacin pero, desgraciadamente, ms espacio ocupar en el disco el archivo grfico que la contiene. Por ejemplo, una imagen con una resolucin de 72 ppi, que es muy comn en las pginas web, necesitar 5184 pxeles en cada pulgada cuadrada, que es un cuadrado de 2,54 centmetros de lado (ya s que es una lata tener que manejar las unidades anglosajonas, pero hay que utilizarlas). Una resolucin de 72 ppi es adecuada para imgenes que se muestran en el monitor de un ordenador. La nitidez de los detalles es suficiente y la reproduccin de las distintas tonalidades es correcta. Sin embargo, podra ser insuficiente para una impresin en papel. Fase 1 Procesamiento de Imgenes 41
Afortunadamente, muchos de los programas de tratamiento de imgenes nos permiten expresarnos en centmetros y milmetros. As que, para poner otro ejemplo, supongamos que queremos hacer una imagen con una resolucin de 30 pixel por centmetro (30 pcm). Cada centmetro cuadrado necesitar 900 pxeles y, si nuestra imagen es una fotografa de 13 x 18 centmetros, cuya superficie es de 234 cm2, necesitar en total 210600 pxeles. Lgicamente cuanto ms alta es la resolucin de una imagen, ms finamente reproduce los detalles y los cambios sutiles de tonalidad pero, a la vez, ms pesado ser el archivo. Profundidad de color Cada uno de los pxeles de una imagen bitmap est coloreado con un color homogneo. As pues, el archivo que contiene los datos de la imagen debe contener la informacin del color de cada uno de los pxeles. Cuntos bits se emplean para albergar esta informacin? Eso es lo que se conoce con el trmino profundidad de color de una imagen. Profundidad de color es el nmero de bits utilizados para describir el color de cada pixel de la imagen. Es obvio que, cuanto mayor sea la profundidad de color de una imagen, ms colores tendr la paleta disponible y, por tanto, la representacin de la realidad podr hacerse con ms matices, con colores ms sutiles. Por ejemplo, si slo disponemos de 1 bit para describir el color de cada pixel, tan slo podremos elegir entre dos colores: un color si el bit tiene el valor 0 (habitualmente negro) y otro color si el bit vale 1 (habitualmente blanco).
Figura 26. Imagen con 1 bit (blanco y negro)
Figura 27. Imagen con 8 bits
La primera fotografa tiene con una profundidad de 1 bit, que tiene el aspecto de una fotocopia de mala calidad, en cambio la segunda ya est ms definida con 8 bit con una calidad tonal ms suficiente. Fase 1 Procesamiento de Imgenes 42
Si disponemos de 8 bit para describir el color de cada pixel, podremos elegir entre 256 colores, porque 2^8=256. Esta es una profundidad de color suficiente para las imgenes construidas en el modo denominado escala de grises, porque con 8 bits cada pixel puede adoptar un tono entre 256 valores posibles de gris, entre el negro absoluto (00000000) y el blanco absoluto (11111111).Y as, cuanto mayor sea la profundidad se utilizar una cantidad mayor de colores para describir la imagen. En la tabla siguiente tienes el clculo de los colores disponibles para cada profundidad: Profundidad Colores 1 bit 2 4 bit 16 8 bit 256 16 bit 65536 17 bit 4294967296
Tabla 10. Profundidad, Color
43
Anexo 8: Cdigo Secuencial

#include #include #include #include <stdio.h> <stdlib.h> <string.h> <time.h>
#define filterWidth 5 #define filterHeight 5 #pragma pack(1) typedef struct { unsigned char R; unsigned char G; unsigned char B; }pixel; struct fileHeader { char tipo[2]; //tipo de archivo BitMap int size; //tamao del archivo BMP (en bytes) short int reserved1; //espacio reservado para la aplicacion que crea la imagen short int reserved2; //espacio reservado para la aplicacion que crea la imagen int offset; //desplazamiento a la matriz de pixeles, desde el inicio del archivo }; struct imageHeader { int size; //tamao en bytes de esta cabecera signed int width; //ancho de la imagen, en pixeles signed int height; //alto de la imagen en pixeles short int colorPlanes; //numero de planos de color, debe setearse a 1 short int bpp; //bits por pixel, o profundidad de color int compression; //metodo de compresion para la imagen int imageSize; //tamao de la imagen (de la matriz de pixeles, incluyendo el padding de cada row) signed int resolutionY; //resolucion horizontal de la imagen, en pixeles/metro signed int resolutionX; //resolucion vertical de la imagen, en pixeles/metro int colorPalette; //numero de colores de la paleta de colores, 0 para dejarlo por defecto hasta 2^n int importantColors; //numero de colores importantes, 0 si todos son importantes }; struct image { struct fileHeader fh; struct imageHeader ih; pixel *array; }; void setPixel(pixel *m, int row, int col, char b, int width) { int i=0; i = width * row + col; unsigned char r, unsigned char g, unsigned
44
m[i].R = r; m[i].G = g; m[i].B = b; } pixel getPixel(pixel *m, int x, int y, int width) { int i=0; i = width * x + y; return m[i]; } int nextMultiple(int x) { while(x%4 != 0) x++; return x; } void initializeImage(struct image *im, signed int width, signed int height, short int bpp) { //setting up the FILEHEADER///// //BM image type memcpy((*im).fh.tipo, "\x42\x4d", 2); //calculating the bmp file size int rowSize = nextMultiple(width * (bpp/8)); (*im).fh.size = 14 + 40 + rowSize * height; //adding the reserved space short int r=0; (*im).fh.reserved1 = r; (*im).fh.reserved2 = r; //adding the pixel array offset (*im).fh.offset = 54; //////////////////////////////// //size of the BITMAPINFOHEADER which we are using (*im).ih.size = 40; //width of the image, in pixels (*im).ih.width = width; //height of the image, in pixels (*im).ih.height = height; //number of color planes (*im).ih.colorPlanes = 1; //bits per pixel or color depth (*im).ih.bpp = bpp; //compression of the image (*im).ih.compression = 0;
45
////////////////////////////////////////////////////////////// //size of the raw bitmap data, can be 0 if no compression used int tmpwidth = ((*im).ih.bpp/8) * ((*im).ih.width); //round up to a multiple of 4 for the row while(tmpwidth%4 != 0) {tmpwidth++;} (*im).ih.imageSize = tmpwidth*height; ////////////////////////////////////////////////////////////// //horizontal resolution of the image, in pixels/meter (*im).ih.resolutionY = 2835; //vertical resolution of the image, in pixels/meter (*im).ih.resolutionX = 2835; //color palette, 0 for default (*im).ih.colorPalette = 0; //important colors, 0 mean all important (*im).ih.importantColors = 0; //allocating memory for the pixel array (*im).array = (pixel *)calloc(width * height, sizeof(pixel));
} void saveImage(struct image *im, char *filename) { //openin file to write on it FILE * file = fopen(filename, "wb"); //writing the file header fwrite(&(*im).fh, sizeof(struct fileHeader), 1, file); //writing the image header fwrite(&(*im).ih, sizeof(struct imageHeader), 1, file); pixel tmp; int i=0, j=0, aux=0; for(i=0; i < (*im).ih.height; i++) { for(j=0; j < (*im).ih.width; j++) { //write a 3 bytes (24bits) pixel tmp = getPixel((*im).array, i, j, (*im).ih.width); fwrite(&tmp.R, 1, 1, file); fwrite(&tmp.G, 1, 1, file); fwrite(&tmp.B, 1, 1, file); } //write the padding for each row up to the following multiple of 4 aux = (j)*((*im).ih.bpp)/8; while(aux%4 != 0) {fwrite("\x0ff", 1, 1, file); aux++;} }
46
fclose(file); } void clear(struct image *im, int r, int g, int b) { int i=0, j=0; for(i=0; i < (*im).ih.height; i++) { for(j=0; j < (*im).ih.width; j++) { //write a 3 bytes (24bits) pixel setPixel((*im).array, i, j, r, g, b, (*im).ih.width); } } } /* void clear(struct image *im, int r, int g, int b) { //openin file to write on it FILE * file = fopen("prueba.bmp", "wb"); //writing the file header fwrite(&(*im).fh, sizeof(struct fileHeader), 1, file); //writing the image header fwrite(&(*im).ih, sizeof(struct imageHeader), 1, file); //printf("width: %d\nheight: %d\n(width*height): %d\n", width, height, (width*height)); int i=0, j=0, aux=0; for(i=1; i <= (*im).ih.height; i++) { for(j=1; j <= (*im).ih.width; j++) { //write a 3 bytes (24bits) pixel fwrite(&b, 1, 1, file); fwrite(&g, 1, 1, file); fwrite(&r, 1, 1, file); } //write the padding for each row up to the following multiple of 4 aux = (j-1)*((*im).ih.bpp)/8; while(aux%4 != 0) {fwrite("\x0ff", 1, 1, file); aux++;} } fclose(file); } */ void loadImage(struct image *im, char *filename) { //struct image im_tmp; FILE * file = fopen(filename, "rb"); fread(&(*im).fh, sizeof(struct fileHeader), 1, file); fread(&(*im).ih, sizeof(struct imageHeader), 1, file); //allocate memory for the pixel array
47
(*im).array = (pixel *)calloc((*im).ih.width * (*im).ih.height, sizeof(pixel)); //loading the pixel array in the image int i=0, j=0; //pixel *p; //int total_pixels = (*im).ih.width * (*im).ih.height; //int aux = total_pixels / (*im).ih.height; int auxi, ps; char *temp; for (i=0; i<(*im).ih.height; i++) { for (j=0; j<(*im).ih.width; j++) { ps = (*im).ih.width * i + j; fread(&(*im).array[ps], sizeof(pixel), 1, file); } //write the padding for each row up to the following multiple of 4 auxi = (j)*((*im).ih.bpp)/8; while (auxi%4 != 0) { //move the pointer 1 byte per each padding pixel fread(&temp, 1, 1, file); auxi++; } } fclose(file); } void invertColor(struct image *im) { int i,j; pixel tmp; for (i=0; i<(*im).ih.height; i++) { for (j=0; j<(*im).ih.width; j++) { tmp = getPixel((*im).array, i, j, (*im).ih.width); setPixel((*im).array, i, j, 255-tmp.R, 255-tmp.G, 255-tmp.B, (*im).ih.width); } } } void brightImage(struct image *im, int c) { int i,j; pixel tmp;
48
for (i=0; i<(*im).ih.height; i++) { for (j=0; j<(*im).ih.width; j++) { tmp = getPixel((*im).array, i, j, (*im).ih.width); if(tmp.R + c > 255) tmp.R = 255; else if(tmp.R + c < 0) tmp.R = 0; else tmp.R = tmp.R + c; if(tmp.G + c > 255) tmp.G = 255; else if(tmp.G + c < 0) tmp.G = 0; else tmp.G = tmp.G + c; if(tmp.B + c > 255) tmp.B = 255; else if(tmp.B + c < 0) tmp.B = 0; else tmp.B = tmp.B + c; setPixel((*im).array, i, j, tmp.R, tmp.G, tmp.B, (*im).ih.width); } } } void grayScale(struct image *im) { int i,j,lum; pixel tmp; for (i=0; i<(*im).ih.height; i++) { for (j=0; j<(*im).ih.width; j++) { tmp = getPixel((*im).array, i, j, (*im).ih.width); lum = (tmp.R*0.30) + (tmp.G*0.59) + (tmp.B*0.11); setPixel((*im).array, i, j, lum, lum, lum, (*im).ih.width); } } } void runningTime(clock_t begin, clock_t end) { double time_spent; time_spent = (double)(end - begin) / CLOCKS_PER_SEC; printf("\n\nRunning Time: %f\n\n", time_spent); } void conv(struct image *im) { double filter[filterWidth][filterHeight] = {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {-1, -1, 2, 0, 0}, {0, 0, 0, 0, 0},
49
{0,
0,
0, };
0,
0},
double factor = 1.0; double bias = 0.0; int filterX = 0; int filterY = 0; int imageX; int imageY; double red; double green; double blue; unsigned char new_red; unsigned char new_green; unsigned char new_blue; int new_red_int, new_green_int, new_blue_int; int x; int y; struct image imagen_salida; initializeImage(&imagen_salida, (*im).ih.width, (*im).ih.height, 24); //apply for(x = for(y = { red the filter 0; x < (*im).ih.height; x++) 0; y < (*im).ih.width; y++) = 0.0, green = 0.0, blue = 0.0;
//multiply every value of the filter with corresponding image pixel for(filterX = 0; filterX < filterHeight; filterX++) for(filterY = 0; filterY < filterWidth; filterY++) { imageX = (x - filterHeight / 2 + filterX + (*im).ih.height) % (*im).ih.height; imageY = (y - filterWidth / 2 + filterY + (*im).ih.width) % (*im).ih.width; red += getPixel((*im).array, imageX, imageY, (*im).ih.width).R * filter[filterX][filterY]; green += getPixel((*im).array, imageX, imageY, (*im).ih.width).G * filter[filterX][filterY]; blue += getPixel((*im).array, imageX, imageY, (*im).ih.width).B * filter[filterX][filterY]; } //truncate values smaller than zero and larger than 255 new_red_int = (int)(factor * red + bias); new_green_int = (int)(factor * green + bias); new_blue_int = (int)(factor * blue + bias);
50
if(new_red_int < 0) new_red = new_red_int * -1; if(new_red_int > 255) new_red = 255; if(new_green_int < 0) new_green = new_green_int * -1; if(new_green_int > 255) new_green = 255; if(new_blue_int < 0) new_blue = new_blue_int * -1; if(new_blue_int > 255) new_blue = 255; setPixel(imagen_salida.array, x, y, new_red, new_green, new_blue, imagen_salida.ih.width); } int i,j; pixel tmp; for (i=0; i<imagen_salida.ih.height; i++) { for (j=0; j<imagen_salida.ih.width; j++) { tmp = getPixel(imagen_salida.array, i, j, imagen_salida.ih.width); setPixel((*im).array, i, j, tmp.R, tmp.G, tmp.B, (*im).ih.width); } } //saveImage(&imagen_salida, "out.bmp"); free(imagen_salida.array); } int main() { //////////time counter clock_t begin;
//struct image image1; //initializeImage(&image1, 10000, 10000, 24); //clear(&image1, 128, 255, 0); //saveImage(&image1, "prueba.bmp");
int op=1; char filename_toload[50]; int bright_number=0; struct image image2; printf("Escriba el nombre de la imagen BMP que desea cargar: "); scanf("%s", filename_toload); loadImage(&image2, filename_toload); while(op != 0) { //system("clear"); printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"); printf("Bienvenido a Procesamiento Digital de Imagenes\n\n");
51
printf("\t1.printf("\t2.printf("\t3.printf("\t4.printf("\t5.printf("\t0.-
Invertir colores\n"); Aplicar escala de grises\n"); Ajustar brillo\n"); Convolucion: Deteccion de Bordes\n"); Guardar imagen\n"); Salir\n\t");
scanf("%d", &op); switch(op) { case 1: begin = clock(); invertColor(&image2); runningTime(begin, clock()); printf("Se invirtieron los colores de la imagen\n\n"); break; case 2: begin = clock(); grayScale(&image2); runningTime(begin, clock()); printf("Se transformo a blanco y negro la imagen\n\n"); break; case 3: printf("\n\tIngrese brillo (-127 a 127): "); scanf("%d", &bright_number); begin = clock(); brightImage(&image2, bright_number); runningTime(begin, clock()); printf("Se ajusto el brillo de la imagen\n\n"); break; case 4: begin = clock(); conv(&image2); runningTime(begin, clock()); printf("Se aplico convolucion para detectar bordes\n\n"); break; case 5: begin = clock(); fflush(stdin); saveImage(&image2, "imagen_procesada.bmp"); runningTime(begin, clock()); printf("Imagen guardada correctamente\n\n"); break; } } free(image2.array); return 0; }
52
Anexo 9: Cdigo Paralelo

#include #include #include #include #include <stdio.h> <stdlib.h> <string.h> <time.h> "mpi.h"
#define MASTER_TO_SLAVE_TAG 1 //tag for messages sent from master to slaves #define SLAVE_TO_MASTER_TAG 10 //tag for messages sent from slaves to master #define filterWidth 5 #define filterHeight 5 #pragma pack(1) typedef struct { unsigned char R; unsigned char G; unsigned char B; }pixel; struct fileHeader { char tipo[2]; //tipo de archivo BitMap int size; //tamao del archivo BMP (en bytes) short int reserved1; //espacio reservado para la aplicacion que crea la imagen short int reserved2; //espacio reservado para la aplicacion que crea la imagen int offset; //desplazamiento a la matriz de pixeles, desde el inicio del archivo }; struct imageHeader { int size; //tamao en bytes de esta cabecera signed int width; //ancho de la imagen, en pixeles signed int height; //alto de la imagen en pixeles short int colorPlanes; //numero de planos de color, debe setearse a 1 short int bpp; //bits por pixel, o profundidad de color int compression; //metodo de compresion para la imagen int imageSize; //tamao de la imagen (de la matriz de pixeles, incluyendo el padding de cada row) signed int resolutionY; //resolucion horizontal de la imagen, en pixeles/metro signed int resolutionX; //resolucion vertical de la imagen, en pixeles/metro int colorPalette; //numero de colores de la paleta de colores, 0 para dejarlo por defecto hasta 2^n int importantColors; //numero de colores importantes, 0 si todos son importantes }; struct image { struct fileHeader fh; struct imageHeader ih; pixel *array; }; void setPixel(pixel *m, int row, int col, char b, int width) unsigned char r, unsigned char g, unsigned
53
{ int i=0; i = width * row + col; m[i].R = r; m[i].G = g; m[i].B = b; } pixel getPixel(pixel *m, int x, int y, int width) { int i=0; i = width * x + y; return m[i]; } int nextMultiple(int x) { while(x%4 != 0) x++; return x; } void initializeImage(struct image *im, signed int width, signed int height, short int bpp) { //setting up the FILEHEADER///// //BM image type memcpy((*im).fh.tipo, "\x42\x4d", 2); //calculating the bmp file size int rowSize = nextMultiple(width * (bpp/8)); (*im).fh.size = 14 + 40 + rowSize * height; //adding the reserved space short int r=0; (*im).fh.reserved1 = r; (*im).fh.reserved2 = r; //adding the pixel array offset (*im).fh.offset = 54; //////////////////////////////// //size of the BITMAPINFOHEADER which we are using (*im).ih.size = 40; //width of the image, in pixels (*im).ih.width = width; //height of the image, in pixels (*im).ih.height = height; //number of color planes (*im).ih.colorPlanes = 1; //bits per pixel or color depth
54
(*im).ih.bpp = bpp; //compression of the image (*im).ih.compression = 0; ////////////////////////////////////////////////////////////// //size of the raw bitmap data, can be 0 if no compression used int tmpwidth = ((*im).ih.bpp/8) * ((*im).ih.width); //round up to a multiple of 4 for the row while(tmpwidth%4 != 0) {tmpwidth++;} (*im).ih.imageSize = tmpwidth*height; ////////////////////////////////////////////////////////////// //horizontal resolution of the image, in pixels/meter (*im).ih.resolutionY = 2835; //vertical resolution of the image, in pixels/meter (*im).ih.resolutionX = 2835; //color palette, 0 for default (*im).ih.colorPalette = 0; //important colors, 0 mean all important (*im).ih.importantColors = 0; //allocating memory for the pixel array (*im).array = (pixel *)calloc(width * height, sizeof(pixel));
} void saveImage(struct image *im, char *filename) { //openin file to write on it FILE * file = fopen(filename, "wb"); //writing the file header fwrite(&(*im).fh, sizeof(struct fileHeader), 1, file); //writing the image header fwrite(&(*im).ih, sizeof(struct imageHeader), 1, file); pixel tmp; int i=0, j=0, aux=0; for(i=0; i < (*im).ih.height; i++) { for(j=0; j < (*im).ih.width; j++) { //write a 3 bytes (24bits) pixel tmp = getPixel((*im).array, i, j, (*im).ih.width); fwrite(&tmp.R, 1, 1, file); fwrite(&tmp.G, 1, 1, file); fwrite(&tmp.B, 1, 1, file); }
55
//write the padding for each row up to the following multiple of 4 aux = (j)*((*im).ih.bpp)/8; while(aux%4 != 0) {fwrite("\x0ff", 1, 1, file); aux++;} } fclose(file); } void clear(struct image *im, int r, int g, int b) { int i=0, j=0; for(i=0; i < (*im).ih.height; i++) { for(j=0; j < (*im).ih.width; j++) { //write a 3 bytes (24bits) pixel setPixel((*im).array, i, j, r, g, b, (*im).ih.width); } } } void loadImage(struct image *im, char *filename) { //struct image im_tmp; FILE * file = fopen(filename, "rb"); fread(&(*im).fh, sizeof(struct fileHeader), 1, file); fread(&(*im).ih, sizeof(struct imageHeader), 1, file); //allocate memory for the pixel array (*im).array = (pixel *)calloc((*im).ih.width * (*im).ih.height, sizeof(pixel)); //loading the pixel array in the image int i=0, j=0; //pixel *p; //int total_pixels = (*im).ih.width * (*im).ih.height; //int aux = total_pixels / (*im).ih.height; int auxi, ps; char *temp; for (i=0; i<(*im).ih.height; i++) { for (j=0; j<(*im).ih.width; j++) { ps = (*im).ih.width * i + j; fread(&(*im).array[ps], sizeof(pixel), 1, file); } //write the padding for each row up to the following multiple of 4 auxi = (j)*((*im).ih.bpp)/8; while (auxi%4 != 0) { //move the pointer 1 byte per each padding pixel fread(&temp, 1, 1, file);
56
auxi++; } } fclose(file); } void invertColor(struct image *im) { int i,j; pixel tmp; for (i=0; i<(*im).ih.height; i++) { for (j=0; j<(*im).ih.width; j++) { tmp = getPixel((*im).array, i, j, (*im).ih.width); setPixel((*im).array, i, j, 255-tmp.R, 255-tmp.G, 255-tmp.B, (*im).ih.width); } } } void brightImage(struct image *im, int c) { int i,j; pixel tmp; for (i=0; i<(*im).ih.height; i++) { for (j=0; j<(*im).ih.width; j++) { tmp = getPixel((*im).array, i, j, (*im).ih.width); if(tmp.R + c > 255) tmp.R = 255; else if(tmp.R + c < 0) tmp.R = 0; else tmp.R = tmp.R + c; if(tmp.G + c > 255) tmp.G = 255; else if(tmp.G + c < 0) tmp.G = 0; else tmp.G = tmp.G + c; if(tmp.B + c > 255) tmp.B = 255; else if(tmp.B + c < 0) tmp.B = 0; else tmp.B = tmp.B + c; setPixel((*im).array, i, j, tmp.R, tmp.G, tmp.B, (*im).ih.width); } } } void grayScale(struct image *im)
57
{ int i,j,lum; pixel tmp; for (i=0; i<(*im).ih.height; i++) { for (j=0; j<(*im).ih.width; j++) { tmp = getPixel((*im).array, i, j, (*im).ih.width); lum = (tmp.R*0.30) + (tmp.G*0.59) + (tmp.B*0.11); setPixel((*im).array, i, j, lum, lum, lum, (*im).ih.width); } } } void grayScale_Parallel(struct image *im, int size, int rank) { int i,j,lum,aux,r; int total_pixels = (*im).ih.width * (*im).ih.height; int qty = total_pixels/(size-1); int rest = total_pixels % (size-1); MPI_Status status; //printf("\n%d\n", rank); if(rank == 0) { for(i=1; i<size; i++){ j = i*qty - qty; aux = j; if(rest != 0 && i==size-1) {qty=qty+rest;} //para distrubuir toda la carga //printf("\nj: %d qty: %d rest: %d\n", j, qty, rest); MPI_Send(&aux, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG+1, MPI_COMM_WORLD); MPI_Send(&qty, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG+2, MPI_COMM_WORLD); MPI_Send(&(*im).array[j], qty*3, MPI_BYTE, i, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD); //printf("\nSending to node=%d, sender node=%d\n", i, rank); } } else { MPI_Recv(&aux, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+1, MPI_COMM_WORLD,&status); MPI_Recv(&qty, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+2, MPI_COMM_WORLD,&status); pixel *arreglo = (pixel *)calloc(qty, sizeof(pixel)); MPI_Recv(&arreglo[0], qty*3, MPI_BYTE, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD,&status);
58
//printf("Receiving node=%d, message=%d\n", rank, aux); for(i=0;i<qty;i++) { lum = (arreglo[i].R*0.30) + (arreglo[i].G*0.59) + (arreglo[i].B*0.11); arreglo[i].R = lum; arreglo[i].G = lum; arreglo[i].B = lum; } MPI_Send(&aux, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG+1, MPI_COMM_WORLD); MPI_Send(&qty, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG+2, MPI_COMM_WORLD); MPI_Send(&arreglo[0], qty*3, MPI_BYTE, 0, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD); free(arreglo); }
if (rank==0){ //printf("\nrank: %d\n", rank); for (i=1; i<size; i++) // untill all slaves have handed back the processed data { MPI_Recv(&aux, 1, MPI_INT, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG+1, MPI_COMM_WORLD,&status); MPI_Recv(&qty, 1, MPI_INT, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG+2, MPI_COMM_WORLD,&status); MPI_Recv(&(*im).array[aux], qty*3, MPI_BYTE, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD,&status); } } } void invertColor_Parallel(struct image *im, int size, int rank) { int i,j,lum,aux,r; int total_pixels = (*im).ih.width * (*im).ih.height; int qty = total_pixels/(size-1); int rest = total_pixels % (size-1); MPI_Status status; //printf("\n%d\n", rank); if(rank == 0) { for(i=1; i<size; i++){ j = i*qty - qty; aux = j; if(rest != 0 && i==size-1) {qty=qty+rest;} //para distrubuir toda la carga //printf("\nj: %d qty: %d rest: %d\n", j, qty, rest);
59
MPI_Send(&aux, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG+1, MPI_COMM_WORLD); MPI_Send(&qty, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG+2, MPI_COMM_WORLD); MPI_Send(&(*im).array[j], qty*3, MPI_BYTE, i, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD); //printf("\nSending to node=%d, sender node=%d\n", i, rank); } } else { MPI_Recv(&aux, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+1, MPI_COMM_WORLD,&status); MPI_Recv(&qty, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+2, MPI_COMM_WORLD,&status); pixel *arreglo = (pixel *)calloc(qty, sizeof(pixel)); MPI_Recv(&arreglo[0], qty*3, MPI_BYTE, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD,&status); //printf("Receiving node=%d, message=%d\n", rank, aux); for(i=0;i<qty;i++) { arreglo[i].R = 255-arreglo[i].R; arreglo[i].G = 255-arreglo[i].G; arreglo[i].B = 255-arreglo[i].B; } MPI_Send(&aux, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG+1, MPI_COMM_WORLD); MPI_Send(&qty, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG+2, MPI_COMM_WORLD); MPI_Send(&arreglo[0], qty*3, MPI_BYTE, 0, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD); free(arreglo); }
if (rank==0){ //printf("\nrank: %d\n", rank); for (i=1; i<size; i++) // untill all slaves have handed back the processed data { MPI_Recv(&aux, 1, MPI_INT, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG+1, MPI_COMM_WORLD,&status); MPI_Recv(&qty, 1, MPI_INT, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG+2, MPI_COMM_WORLD,&status); MPI_Recv(&(*im).array[aux], qty*3, MPI_BYTE, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD,&status); } } } void brightImage_Parallel(struct image *im, int c, int size, int rank) { int i,j,aux,r;
60
int total_pixels = (*im).ih.width * (*im).ih.height; int qty = total_pixels/(size-1); int rest = total_pixels % (size-1); MPI_Status status; //printf("\n%d\n", rank); if(rank == 0) { for(i=1; i<size; i++){ j = i*qty - qty; aux = j; if(rest != 0 && i==size-1) {qty=qty+rest;} //para distrubuir toda la carga //printf("\nj: %d qty: %d rest: %d\n", j, qty, rest); MPI_Send(&aux, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG+1, MPI_COMM_WORLD); MPI_Send(&qty, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG+2, MPI_COMM_WORLD); MPI_Send(&(*im).array[j], qty*3, MPI_BYTE, i, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD); //printf("\nSending to node=%d, sender node=%d\n", i, rank); } } else { MPI_Recv(&aux, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+1, MPI_COMM_WORLD,&status); MPI_Recv(&qty, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+2, MPI_COMM_WORLD,&status); pixel *arreglo = (pixel *)calloc(qty, sizeof(pixel)); MPI_Recv(&arreglo[0], qty*3, MPI_BYTE, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD,&status); //printf("Receiving node=%d, message=%d\n", rank, aux); for(i=0;i<qty;i++) { if(arreglo[i].R + c > 255) arreglo[i].R = 255; else if(arreglo[i].R + c < 0) arreglo[i].R = 0; else arreglo[i].R = arreglo[i].R + c; if(arreglo[i].G + c > 255) arreglo[i].G = 255; else if(arreglo[i].G + c < 0) arreglo[i].G = 0; else arreglo[i].G = arreglo[i].G + c; if(arreglo[i].B + c > 255) arreglo[i].B = 255; else if(arreglo[i].B + c < 0) arreglo[i].B = 0; else arreglo[i].B = arreglo[i].B + c;
61
} MPI_Send(&aux, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG+1, MPI_COMM_WORLD); MPI_Send(&qty, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG+2, MPI_COMM_WORLD); MPI_Send(&arreglo[0], qty*3, MPI_BYTE, 0, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD); free(arreglo); }
if (rank==0){ //printf("\nrank: %d\n", rank); for (i=1; i<size; i++) // untill all slaves have handed back the processed data { MPI_Recv(&aux, 1, MPI_INT, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG+1, MPI_COMM_WORLD,&status); MPI_Recv(&qty, 1, MPI_INT, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG+2, MPI_COMM_WORLD,&status); MPI_Recv(&(*im).array[aux], qty*3, MPI_BYTE, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD,&status); } } } void conv_Parallel(struct image *im, int size, int rank) { int i,j,aux,r; pixel tmp;
int total_pixels = (*im).ih.width * (*im).ih.height; int qty = total_pixels/(size-1); int rest = total_pixels % (size-1);
int int int int
alto; ancho; st; st2;
MPI_Status status; //////////////////////////////////////////// double filter[filterWidth][filterHeight] = {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {-1, -1, 2, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, }; double factor = 1.0;
62
double bias = 0.0; int filterX = 0; int filterY = 0; int imageX; int imageY; double red; double green; double blue; unsigned char new_red; unsigned char new_green; unsigned char new_blue; int new_red_int, new_green_int, new_blue_int; int x; int y; ////////////////////////////////////////////
if(rank == 0) { for(i=1; i<size; i++){ j = i*qty - qty; aux = j; if(rest != 0 && i==size-1) {qty=qty+rest;} //para distrubuir toda la carga //printf("\nj: %d qty: %d rest: %d\n", j, qty, rest); MPI_Send(&aux, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG+1, MPI_COMM_WORLD); MPI_Send(&qty, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG+2, MPI_COMM_WORLD); MPI_Send(&(*im).ih.height, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG + 3, MPI_COMM_WORLD); MPI_Send(&(*im).ih.width, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG + 4, MPI_COMM_WORLD); MPI_Send(&(*im).array[j], qty*3, MPI_BYTE, i, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD); //printf("\nSending to node=%d, sender node=%d\n", i, rank); } } else { MPI_Recv(&aux, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+1, MPI_COMM_WORLD,&status); MPI_Recv(&qty, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+2, MPI_COMM_WORLD,&status); MPI_Recv(&alto, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+3, MPI_COMM_WORLD,&status); MPI_Recv(&ancho, 1, MPI_INT, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG+4, MPI_COMM_WORLD,&status);
63
pixel *arreglo = (pixel *)calloc(qty, sizeof(pixel)); MPI_Recv(&arreglo[0], qty*3, MPI_BYTE, MPI_ANY_SOURCE, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD,&status); //printf("Receiving node=%d, message=%d\n", rank, aux); pixel *arreglo_salida = (pixel *)calloc(qty, sizeof(pixel));
//ancho = qty/2; alto = (int)qty/ancho; //apply the filter for(x = 0; x < alto; x++) for(y = 0; y < ancho; y++) { red = 0.0, green = 0.0, blue = 0.0; //multiply every value of the filter with corresponding image pixel for(filterX = 0; filterX < filterHeight; filterX++) for(filterY = 0; filterY < filterWidth; filterY++) { imageX = (x - filterHeight / 2 + filterX + alto) % alto; imageY = (y - filterWidth / 2 + filterY + ancho) % ancho; st = ancho * imageX + imageY; red += arreglo[st].R * filter[filterX][filterY]; green += arreglo[st].G * filter[filterX][filterY]; blue += arreglo[st].B * filter[filterX][filterY]; } //truncate values smaller than zero and larger than 255 new_red_int = (int)(factor * red + bias); new_green_int = (int)(factor * green + bias); new_blue_int = (int)(factor * blue + bias); if(new_red_int < 0) new_red = new_red_int * -1; if(new_red_int > 255) new_red = 255; if(new_green_int < 0) new_green = new_green_int * -1; if(new_green_int > 255) new_green = 255; if(new_blue_int < 0) new_blue = new_blue_int * -1; if(new_blue_int > 255) new_blue = 255; //setPixel(imagen_salida.array, x, y, new_red, new_green, new_blue, imagen_salida.ih.width); st2 = ancho * x + y; arreglo_salida[st2].R = new_red; arreglo_salida[st2].G = new_green; arreglo_salida[st2].B = new_blue; } MPI_Send(&aux, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG+1, MPI_COMM_WORLD); MPI_Send(&qty, 1, MPI_INT, 0, SLAVE_TO_MASTER_TAG+2, MPI_COMM_WORLD);
64
MPI_Send(&arreglo_salida[0], qty*3, MPI_BYTE, 0, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD); free(arreglo_salida); }
if (rank==0){ //printf("\nrank: %d\n", rank); for (i=1; i<size; i++) // untill all slaves have handed back the processed data { MPI_Recv(&aux, 1, MPI_INT, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG+1, MPI_COMM_WORLD,&status); MPI_Recv(&qty, 1, MPI_INT, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG+2, MPI_COMM_WORLD,&status); MPI_Recv(&(*im).array[aux], qty*3, MPI_BYTE, MPI_ANY_SOURCE, SLAVE_TO_MASTER_TAG, MPI_COMM_WORLD,&status); } } } void runningTime(clock_t begin, clock_t end) { double time_spent; time_spent = (double)(end - begin) / CLOCKS_PER_SEC; printf("\n\nRunning Time: %f\n\n", time_spent); } int main(int argc, char *argv[]) { //////////time counter clock_t begin; /* struct image image1; initializeImage(&image1, 10000, 10000, 24);
clear(&image1, 128, 255, 0); //saveImage(&image1, "prueba.bmp"); */ int rank, size; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Status status; int op=1; char filename_toload[50]; int bright_number=0; struct image image2;
65
if (rank==0) { printf("Escriba el nombre de la imagen BMP que desea cargar: \n"); scanf("%s", filename_toload); //sprintf(filename_toload, "paisaje.bmp"); loadImage(&image2, filename_toload); } while(op != 0) { if (rank==0) { printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"); printf("Bienvenido a Procesamiento Digital de Imagenes\n\n"); printf("\t1.- Invertir colores\n"); printf("\t2.- Aplicar escala de grises\n"); printf("\t3.- Ajustar brillo\n"); printf("\t4.- Convolucion: Deteccion de Bordes\n"); printf("\t5.- Guardar imagen\n"); printf("\t0.- Salir\n\t"); scanf("%d", &op); } //Broadcast the user's choice to all other ranks MPI_Bcast(&op, 1, MPI_INT, 0, MPI_COMM_WORLD); switch(op) { case 1: if (rank==0) {begin = clock();} MPI_Barrier(MPI_COMM_WORLD); invertColor_Parallel(&image2, size, rank); MPI_Barrier(MPI_COMM_WORLD); if (rank==0) {runningTime(begin, clock()); printf("Se invirtieron los colores de la imagen\n\n");} break; case 2: if (rank==0) {begin = clock();} MPI_Barrier(MPI_COMM_WORLD); grayScale_Parallel(&image2, size, rank); MPI_Barrier(MPI_COMM_WORLD); if (rank==0) {runningTime(begin, clock()); printf("Se transformo a blanco y negro la imagen\n\n");} break; case 3: if (rank==0) { printf("\n\tIngrese brillo (-127 a 127): "); fflush(stdout); scanf("%d", &bright_number); begin = clock(); }
66
MPI_Bcast(&bright_number, 1, MPI_INT, 0, MPI_COMM_WORLD); MPI_Barrier(MPI_COMM_WORLD); brightImage_Parallel(&image2, bright_number, size, rank); if (rank==0) {runningTime(begin, clock()); printf("Se ajusto el brillo de la imagen\n\n");} break; case 4: if (rank==0) {begin = clock();} MPI_Barrier(MPI_COMM_WORLD); conv_Parallel(&image2, size, rank); MPI_Barrier(MPI_COMM_WORLD); if (rank==0) {runningTime(begin, clock()); printf("Se aplico convolucion para detectar bordes\n\n");} break; case 5: if (rank==0) {begin = clock();} if (rank==0) {saveImage(&image2, "imagen_procesada.bmp");} MPI_Barrier(MPI_COMM_WORLD); if (rank==0) {runningTime(begin, clock()); printf("Imagen guardada correctamente\n\n");} break; } } if (rank==0) free(image2.array); MPI_Finalize(); return 0; }
67

Lab1paralela Version 4

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Lab1paralela Version 4

Hochgeladen von

Copyright:

Verfügbare Formate

Fase N1 Procesamiento de Imgenes digitales

Fase 1 Procesamiento de Imgenes

11.1. 11.2. 12.

12.1. 12.2. 12.3. 13.

Mejores Tiempos ..........................................................................................................21

Fase 1 Procesamiento de Imgenes

Fase 1 Procesamiento de Imgenes

Fase 1 Procesamiento de Imgenes

3. Objetivos. 3.1. Objetivos Generales.

Fase 1 Procesamiento de Imgenes

Fase 1 Procesamiento de Imgenes

Fase 1 Procesamiento de Imgenes

A continuacin se muestra el resultado obtenido para cada tcnica:

Figura 1. Imagen Original

Figura 2.Invertir colores

Figura 3. Escala de gris

Fase 1 Procesamiento de Imgenes

Figura 4. Ajustar Brillo -127

Figura 5. Ajustar Brillo 127

Fase 1 Procesamiento de Imgenes

Proceso Algoritmo Secuencial

Fase 1 Procesamiento de Imgenes

Proceso Algoritmo Paralelo

Aplicacin Paralelismo de Datos

Fase 1 Procesamiento de Imgenes

Escala de grises (grayscale)

Figura 7. Espacio vectorial de colores

Figura 8. Frmula para inversin de colores

Fase 1 Procesamiento de Imgenes

Figura 9. Aumento o Disminucin de brillo

Fase 1 Procesamiento de Imgenes

Figura 10. Matriz o arreglo dimensional

Figura 11. Seccin de imagen en grises

Figura 12.Imagen con el valor de su color

Fase 1 Procesamiento de Imgenes

Figura 13. Imagen con el Kernel sobre los pixeles

Fase 1 Procesamiento de Imgenes

Figura 14. Topologa red estrella utilizada para el clster.

11. Especificaciones tcnicas 11.1. Especificacin de los nodos

Tabla 1. Especificacin tcnica nodos

Tabla 2. Especificacin tcnica de router

12. Mtricas de desempeo 12.1.

Mtricas para Invertir Color

Tabla 3. Mtricas Invertir color

Fase 1 Procesamiento de Imgenes

Mtrica para Escala de Grises

Tabla 4. Mtricas Escala de Grises.

Fase 1 Procesamiento de Imgenes

Mtricas para Ajustar Brillo

Tabla 5.Metrica Ajustar Brillo

Fase 1 Procesamiento de Imgenes

13. Mejores Tiempos Invertir Color

Figura 15. Mejores tiempos en Invertir color

Figura 16. Mejores tiempos en Escala de grises

Fase 1 Procesamiento de Imgenes

Figura 17. Mejores tiempos en Ajuste de brillo

Fase 1 Procesamiento de Imgenes

14. Graficas de Speedup Invertir Color

Figura 18. Speedup Invertir color

Figura 19. Speedup Escala de grises

Fase 1 Procesamiento de Imgenes

Figura 20. Speedup Ajustar Brillo

Fase 1 Procesamiento de Imgenes

Figura 21. Eficiencia Invertir Color