Lab1paralela Version 4

Fase N°1“Procesamiento de Imágenes digitales”

Integrantes

Aldo AguilarFreddy AravenaManuel AstudilloGerson LeivaCamilo Torres

Académico Oscar Magna2 º Semestre , 2013

Universidad Tecnológica MetropolitanaFacultad de Ingeniería.Departamento de Informática y Computación.Escuela de Informática.Computación Paralela INF-762.

Resumen

En el presente informe, se abordará de manera técnica, la implementación y el análisis de aplicaciones paralelas y secuenciales, desarrolladas en C, para el procesamiento de imágenes digitales.

Se partirá estableciendo, un marco teórico, sobre el procesamiento de imágenes, cómo por ejemplo técnicas, con el objetivo de orientar y contextualizar el presente documento, explicando en que están basados los códigos que se utilizaron

Luego, sigue la sección que describe los objetivos generales y específicos del proyecto También se expone la justificación del proyecto, exponiendo cuales son las ventajas que se tendrán, a partir de las técnicas aquí expuestas.

Después de enunciar la justificación, se describirá la metodología empleada para el desarrollo del trabajo. Luego de este ítem se pasarán a describir las herramientas utilizadas, además de caracterizar el hardware ocupado para la implementación del clúster y la ejecución de las aplicaciones.

Se sigue con la descripción de la topología de red usada en el clúster, permitiendo la comunicación entre los diferentes nodos en uso.

A continuación, se enuncian las herramientas de implementación del clúster y cómo estas son configuradas.

Luego se pasará a mostrar los resultados de las pruebas de implementación, ya que se recopilaron y analizaron los resultados para después compararlos utilizando métricas.

Para finalizar, se presentarán las conclusiones finales, de la parte 1 del laboratorio.

Fase 1 “Procesamiento de Imágenes” 2


Tabla de contenido1. Introducción..........................................................................................................................5

2. Descripción del problema...................................................................................................5

3. Objetivos...............................................................................................................................6

3.1. Objetivos Generales........................................................................................................6

3.2. Objetivos Específicos......................................................................................................6

4. Alcance del proyecto...........................................................................................................6

5. Metodología de trabajo general..........................................................................................7

6. Herramientas de desarrollo.................................................................................................7

7. Pruebas de implementación................................................................................................9

8. Tratamiento de Imagen......................................................................................................11

8.1. Proceso Algoritmo Secuencial......................................................................................11

8.2. Proceso Algoritmo Paralelo.......................................................................................12

9. Técnicas de Procesamiento de Imágenes Utilizadas.....................................................12

9.1. Escala de grises (grayscale)......................................................................................13

9.2. Inversión de colores...................................................................................................13

9.3. Ajustar Brillo................................................................................................................14

9.4. Generación de efectos por Convolución..................................................................14

10. Topología de red.............................................................................................................16

11. Especificaciones técnicas.............................................................................................17

11.1. Especificación de los nodos..................................................................................17

11.2. Especificación del router........................................................................................17

12. Métricas de desempeño.................................................................................................18

12.1. Métricas para Invertir Color....................................................................................18

12.2. Métrica para Escala de Grises................................................................................19

12.3. Métricas para Ajustar Brillo........................................................................................20

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

Invertir Color..............................................................................................................................21

14. Graficas de Speedup......................................................................................................23

15. Graficas de Eficiencia....................................................................................................25

16. Conclusiones..................................................................................................................28



17. Bibliografía......................................................................................................................29

Anexo 1: Invertir colores..........................................................................................................30

Anexo 2: Escala de Grises........................................................................................................31

Anexo 3: Ajustar Brillo..............................................................................................................32

Anexo 4: Convolucion...............................................................................................................33

Anexo 5: Montaje de Clúster....................................................................................................34

Anexo 6: Formato BMP.............................................................................................................38

Anexo 7: Conceptos involucrados en el procesamiento de imágenes................................41

Anexo 8: Código Secuencial....................................................................................................45

Anexo 9: Código Paralelo.........................................................................................................54



1. Introducción

El procesamiento digital de imágenes es un campo fascinante que forma parte de nuestra vida diaria. En sus inicios el procesamiento de imágenes estaba restringido a campos de investigación de ciencias de la computación, matemáticas y astronomía.Lo que constituía 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 señales; volviéndose así una herramienta invaluable en diversas aplicaciones, tales como la robótica, control industrial, medicina, telecomunicaciones, entre otras.

El procesamiento de imagen por definición hace referencia al conjunto de técnicas que se aplican a las imágenes digitales con el objetivo de mejorar la calidad, realizar cambios o facilitar la búsqueda de información en ellas. Uno de los problemas más frecuentes que presenta esta disciplina es el excesivo tiempo de procesamiento que demandan los equipos dedicados al tratamiento de las imágenes. Bajo este contexto nuestro equipo de trabajo propone en primera instancia desarrollar una solución de tipo clúster para mejorar los tiempos de procesamiento que llevan las distintas tareas, para posteriormente ahondar un poco más en el tema enfocándonos en la representación de imágenes 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 análisis de desempeño a cada una de las alternativas propuestas y comprobaremos si es que la solución de tipo clúster es realmente efectiva para los casos de procesamiento de imágenes.

2. Descripción del problema

Se debe resolver el caso propuesto sobre la transformación y procesamiento de imágenes, diseñando e implementando una plataforma en paralelo; clúster, de tres nodos como mínimo. Generando los códigos compatibles de forma secuencial y paralelo, para luego proceder a realizar las correspondientes pruebas de desempeño 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 solución de problemas de procesamiento de imágenes digitales, de modo tal que se puedan evaluar y comparar estas con las soluciones secuenciales.

3.2. Objetivos Específicos.

● Implementar un clúster de 3 nodos.● Trabajar sobre imágenes en formato bmp.● Implementar la solución computacional secuencial● Plantear la estrategia de paralización.● Implementar la solución computacional paralela.● Medir el rendimiento de las soluciones desarrolladas.● Comparar y analizar el rendimiento del ambiente en paralelo en relación 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 técnicas en lo que comprende al tratamiento y procesamiento de imágenes, comprendiendo básicamente al realce, filtrado y mejora, las cuales se podrán encontrar bajo distintas resoluciones. Una vez dominados estos problemas de visualistica computacional indirecta, se procederá a extraer información de la misma imagen para luego trabajar con esta información.

El enfoque del proyecto a ser desarrollado se encuentra basado en la manipulación de una imagen en formato a elección de dimensiones diferentes. Se identifican las tareas a realizar con respecto a la imagen origen tales como:

Resolución del problema utilizando un Clúster. Trabajar con imagen en formato .bmp. Realizar cálculos específicos con la matriz de pixeles generada a partir de la imagen. Cálculo de métricas de desempeño para las soluciones presentadas. Conclusiones respecto a las métricas evaluadas.



5. Metodología de trabajo general.

La metodología a utilizar se basará en el montaje de un clúster tipo Beowulf sobre tres equipos o nodos corriendo Ubuntu versión 12.04. Entre estos nodos existirá un maestro y dos esclavos, los cuales estarán conectados a una red local mediante un router.Una vez ya instalados y configurados todos los nodos, se procederá a la interconexión de estos por medio de los protocolo SSH y NFS.Finalmente los nodos se comunicarán, ejecutarán y resolverán una problemática realizada en C. Esta comunicación se realizará mediante la API OpenMPI.

6. Herramientas de desarrollo

Ubuntu.

Es un sistema operativo basado en núcleo Linux, bajo la denominación de software libre y de código abierto. Este sistema se encuentra pre compilado y empaquetado para funcionar en múltiples arquitecturas.

SSH.

El intérprete de órdenes segura (SSH), es el nombre de un protocolo y programa que permite acceder a equipos remotos de forma segura, además de permitir el control de estos a través de comandos por consola. SSH permite además 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 aplicación. Posibilita que varios computadores en red puedan acceder a archivos y ficheros dentro de esta, de la misma manera que se haría dentro de un fichero local.

● El protocolo NFS está incluido por defecto en los Sistemas Operativos UNIX y la mayoría de las distribuciones de Linux.

● NFS tiene dos partes principales: un servidor y uno o más 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 comunicación entre computadores. Es una especificación estándar para una librería de funciones de paso de mensajes, independiente de la plataforma y de dominio público.Proporciona funciones para ser utilizadas con lenguajes de programación 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 sólo se ocupa de la capa de comunicación, necesita un ambiente de programación paralelo nativo.Los programas y bibliotecas MPI son portables y rápidas, 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 sólo especifica el método de paso de mensajes, el resto del entorno puede ser totalmente diferente en cada implementación, por lo que se impide esa portabilidad que teóricamente tiene.

Geany

Geany es un pequeño y ligero entorno de desarrollo integrado. Fue desarrollado para proporcionar un IDE pequeño y rápido, que sólo tiene unas pocas dependencias de otros paquetes. Otro objetivo era ser lo más independiente posible de un entorno de escritorio especial como KDE o GNOME - Geany sólo requiere de las bibliotecas de tiempo de ejecución GTK2.

Algunas de las características básicas de Geany: El resaltado de sintaxis Plegado de código Nombre de símbolo de autocompletar Construir finalización / 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 símbolos Navegación Código El sistema de generación de compilar y ejecutar el código Administración simple proyecto Interfaz de Programas



7. Pruebas de implementación

Para la implementación se usaron cuatro técnicas:

Invertir colores

Escala de grises

Ajustar Brillo

Convolucion

A continuación se muestra el resultado obtenido para cada técnica:

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



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 ejecución 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.



8.2. Proceso Algoritmo Paralelo

La metodología de procesamiento en paralelo que se utilizó para la implementación de

las soluciones; fue la de paralelismo de datos: se utilizan múltiples unidades funcionales

(nodos) para aplicar la misma operación simultánea 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:

Aplicación Paralelismo de Datos

9. Técnicas de Procesamiento de Imágenes Utilizadas

Las técnicas que existen para procesar imágenes, 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 técnicas de modificación de color (escala de grises, inversión de colores, ajustes de brillo).Algunas de las técnicas más conocidas que están relacionadas con la modificación que se hace a los pixeles de una imagen sin que estos cambien de posición.



9.1. Escala de grises (grayscale)

En el espacio de colores, los vectores en la dirección del vector (1, 1, 1) representan diferentes tonalidades de gris. Así, cualquier píxel (r, g, b) de una imagen, proyectado sobre este vector nos dará su contribución gris a una nueva imagen que formaran con todas las proyecciones de los pixeles originales.

Figura 7. Espacio vectorial de colores

9.2. Inversión de colores

El valor más grande que puede tomar un color es 255 y el más pequeño 0, entonces si deseamos invertir las contribuciones de los diferentes pixeles a la formación de una imagen, se debe restar su color de 255 y esta diferencia tomarla como la contribución al color de la nueva imagen.

Figura 8. Fórmula para inversión de colores



9.3. Ajustar Brillo

Aumentar el brillo de una imagen consiste en sumar o restar una constante a los colores que constituye un píxel, cuidando siempre de nunca rebasar los límites 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 línea recta con pendiente a 45 grados que representa los grises.

Figura 9. Aumento o Disminución de brillo

Así, la fórmula que tenemos que aplicar en este tipo de transformación tiene la forma siguiente:Nótese que esta fórmula representa una familia de rectas que pasan por el punto (128,128) con diferentes pendientes.

9.4. Generación de efectos por Convolución

La Convolución es una matriz (o arreglo bidimensional) que se aplica a una imagen. Los elementos de este arreglo son valores enteros. El resultado de esta operación es una imagen nueva que ha sido filtrada.

Básicamente la Convolución modifica el color de un pixel en función 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 Convolución se aplica multiplicando el color de un pixel y el de sus pixeles circundantes por una matriz. Esta matriz se llama el kernel de Convolución. 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 después por un valor específico. El resultado de esta operación es el nuevo color del pixel que cae en el centro de la matriz. A continuación se presenta un ejemplo muy sencillo de un kernel de Convolución



Figura 10. Matriz o arreglo dimensional

Los kernels pueden tener tamaños arbitrarios, pero los de 3 x 3 son los más usados en la mayoría de las situaciones (también debido a que son los más rápidos), ya que solo toma en consideración 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 continuación se presenta una sección de una imagen en grises, sobre la que se aplicará el kernel de convolución.

Figura 11. Sección de imagen en grises

Se ha escogido en grises para facilitar la explicación, ahora bien sobre cada uno de los pixeles de esta sección 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



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 división 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. Topología de red.

Para los procesos de carga entre los equipos (interacción y distribución), es fundamental fijar la arquitectura de red. La arquitectura de la red es básicamente del tipo estrella, cuyo switch está conectado a un sistema mayor conformado por una serie de switchs y hubs.



Esquema topológico.

Figura 14. Topología red estrella utilizada para el clúster.

11. Especificaciones técnicas

11.1. Especificación de los nodos

La plataforma de hardware se compondrá de 2 nodos de iguales características. A continuación se procede a dar las especificaciones técnicas del hardware:

Procesador Intel-Core i7-3770kCodename Ivi BridgeFrecuencia 3.5 GHz-3.9 GHzNúcleos/Hilos 4 núcleos/ 8 hilosL1 cache/L2 cache/ L3 cache 4x32 KB / 4x256/ 8MBRAM 4GB (2x4GB) DDR3 SDRAMFrecuencia 1600 MHZ

Tabla 1. Especificación técnica nodos

11.2. Especificación del router

Modelo Linksys WRT54GLTecnología Inalámbrica GBandas 2,4 GHzEstandares IEEE 802.3, IEEE 802.3u, IEEE 802.11g,

IEEE 802.11bAntenas 2 (externas)Puertos Ethernet x velocidad 4 x 10/100

Tabla 2. Especificación técnica de router



12. Métricas de desempeño

12.1. Métricas para Invertir Color

Nombre de

Imagen

Dimensiones Mejor Tiempo secuen

cial (segund

os)

Tiempo Paralelo

con 4 procesadores (1 Nodo)

Speed up 4

procesador

es

Eficiencia 4 procesador

es

Tiempo Paralelo

con 8 procesadores (2 Nodos)

Speed up 8

procesadores

Eficiencia 8

procesadores

Tiempo Paralelo con 12

procesadores (3 Nodos)

Speed up 12

procesadores

Eficiencia 12

procesadores

1 1600x1200 0.03 0.01 3.000 0.75 0.530 0.057 0.007 0.71 0.042 0.004

2 1920x1080 0.04 0.01 4.000 1.000 0.560 0.071 0.009 0.77 0.052 0.004

3 2008x1384 0.05 0.01 5.000 1.250 0.770 0.065 0.008 1.03 0.049 0.004

4 2000x2000 0.09 0.01 9.000 2.250 1.110 0.081 0.010 1.49 0.060 0.005

5 4000x4000 0.31 0.05 6.200 1.550 4.460 0.070 0.009 5.95 0.052 0.004

6 4940x3554 0.38 0.06 6.333 1.583 4.880 0.078 0.010 6.51 0.058 0.005

7 6000x6000 0.83 0.12 6.917 1.729 10.010 0.083 0.010 13.36 0.062 0.005

8 11038x4730 0.89 0.13 6.846 1.712 14.520 0.061 0.008 19.34 0.046 0.004

9 11709x4716 0.94 0.14 6.714 1.679 15.360 0.061 0.008 20.46 0.046 0.004

10 8000x8000 1.46 0.16 9.125 2.281 17.800 0.082 0.010 23.74 0.061 0.005

11 10799x7274 1.34 0.2 6.700 1.675 21.850 0.061 0.008 29.12 0.046 0.004

12 10000x10000 2.29 0.26 8.808 2.202 27.810 0.082 0.010 37.09 0.062 0.005

13 12000x12000 3.27 0.37 8.838 2.209 41.960 0.078 0.010 53.42 0.061 0.005

14 14000x14000 4.47 0.51 8.765 2.191 57.130 0.078 0.010 72.69 0.061 0.005

15 14173x14173 3.43 0.51 6.725 1.681 58.560 0.059 0.007 74.53 0.046 0.004

16 15000x15000 3.83 0.58 6.603 1.651 65.570 0.058 0.007 83.36 0.046 0.004

17 16000x16000 5.84 0.66 8.848 2.212 74.630 0.078 0.010 94.94 0.062 0.005

18 18000x18000 7.48 0.84 8.905 2.226 94.430 0.079 0.010 120.15 0.062 0.005

19 20000x20000 9.06 1.04 8.712 2.178 116.710 0.078 0.010 148.11 0.061 0.005

Tabla 3. Métricas Invertir color



12.2. Métrica para Escala de Grises

Nombre de

Imagen

Dimensiones Mejor Tiempo secuen

cial (segund

os)

Tiempo Paralelo


Speed up 4

procesador

es


es

Tiempo

Paralelo con

8 procesadores (2 Nodo

s)

Speed up 8

procesador

es


es



Speed up 12

procesadores

Eficiencia 12

procesadores

1 1600x1200 0.04 0.01 4.000 1 0.53 0.075 0.009 0.72 0.056 0.005

2 1920x1080 0.5 0.01 50.000 12.500 0.58 0.862 0.108 0.77 0.649 0.054

3 2008x1384 0.7 0.01 70.000 17.500 0.77 0.909 0.114 1.03 0.680 0.057

4 2000x2000 0.09 0.01 9.000 2.250 1.11 0.081 0.010 1.5 0.060 0.005

5 4000x4000 0.38 0.05 7.600 1.900 4.45 0.085 0.011 5.94 0.064 0.005

6 4940x3554 0.4 0.05 8.000 2.000 4.88 0.082 0.010 6.52 0.061 0.005

7 6000x6000 0.83 0.12 6.917 1.729 10 0.083 0.010 13.36 0.062 0.005

8 11038x4730 1.18 0.18 6.556 1.639 14.53 0.081 0.010 19.38 0.061 0.005

9 11709x4716 1.25 0.19 6.579 1.645 15.37 0.081 0.010 20.48 0.061 0.005

10 8000x8000 1.46 0.22 6.636 1.659 17.8 0.082 0.010 23.73 0.062 0.005

11 10799x7274 1.78 0.27 6.593 1.648 21.85 0.081 0.010 29.13 0.061 0.005

12 10000x10000 2.29 0.35 6.543 1.636 27.81 0.082 0.010 37.07 0.062 0.005

13 12000x12000 3.27 0.51 6.412 1.603 41.96 0.078 0.010 53.66 0.061 0.005

14 14000x14000 4.47 0.7 6.386 1.596 57.13 0.078 0.010 72.69 0.061 0.005

15 14173x14173 4.55 0.7 6.500 1.625 58.54 0.078 0.010 74.6 0.061 0.005

16 15000x15000 5.09 0.78 6.526 1.631 65.58 0.078 0.010 83.58 0.061 0.005

17 16000x16000 5.84 0.9 6.489 1.622 74.61 0.078 0.010 94.93 0.062 0.005

18 18000x18000 7.48 1.14 6.561 1.640 94.44 0.079 0.010 120.14 0.062 0.005

19 20000x20000 9.06 1.41 6.426 1.606 116.66 0.078 0.010 148.46 0.061 0.005

Tabla 4. Métricas Escala de Grises.



12.3. Métricas para Ajustar Brillo

Nombre de

Imagen

Dimensiones Mejor Tiemp

o secuencial (segundos)

Tiempo Paralelo


Speed up 4

procesador

es


es

Tiempo Paralelo

con 8 procesadores (2 Nodos)

Speed up 8

procesador

es


es



Speed up 12

procesadores

Eficiencia 12

procesador

es

1 1600x1200 0.04 0.01 4.000 1 0.53 0.075 0.009 0.73 0.055 0.005

2 1920x1080 0.05 0.01 5.000 1.250 0.58 0.086 0.011 0.77 0.065 0.005

3 2008x1384 0.07 0.01 7.000 1.750 0.77 0.091 0.011 1.04 0.067 0.006

4 2000x2000 0.1 0.01 10.000 2.500 1.11 0.090 0.011 1.49 0.067 0.006

5 4000x4000 0.35 0.06 5.833 1.458 4.45 0.079 0.010 5.94 0.059 0.005

6 4940x3554 0.39 0.06 6.500 1.625 4.88 0.080 0.010 6.51 0.060 0.005

7 6000x6000 0.82 0.15 5.467 1.367 10.01 0.082 0.010 13.36 0.061 0.005

8 11038x4730 1.17 0.15 7.800 1.950 14.52 0.081 0.010 19.33 0.061 0.005

9 11709x4716 1.22 0.2 6.100 1.525 15.37 0.079 0.010 20.41 0.060 0.005

10 8000x8000 1.51 0.27 5.593 1.398 17.8 0.085 0.011 23.73 0.064 0.005

11 10799x7274 1.72 0.29 5.931 1.483 21.84 0.079 0.010 29.13 0.059 0.005

12 10000x10000 2.24 0.42 5.333 1.333 27.81 0.081 0.010 37.07 0.060 0.005

13 12000x12000 3.12 0.62 5.032 1.258 41.95 0.074 0.009 53.66 0.058 0.005

14 14000x14000 4.27 0.82 5.207 1.302 57.13 0.075 0.009 72.68 0.059 0.005

15 14173x14173 3.57 0.57 6.263 1.566 58.56 0.061 0.008 74.94 0.038 0.003

16 15000x15000 4.02 0.62 6.484 1.621 65.56 0.061 0.008 74.56 0.054 0.004

17 16000x16000 4.56 1.07 4.262 1.065 74.69 0.061 0.008 83.48 0.055 0.005

18 18000x18000 5.75 1.36 4.228 1.057 94.47 0.061 0.008 120.14 0.048 0.004

19 20000x20000 7.16 1.12 6.393 1.598 116.62 0.061 0.008 148.89 0.048 0.004

Tabla 5.Metrica Ajustar Brillo

El cálculo de las métricas 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 versión secuencial como paralela (cuatro, ocho y doce núcleos). Se realizó el mismo procedimiento para los tres filtros, utilizando los datos y formulas correspondientes.

Para el caso del Speed Up se utilizó la relación:

Speed up: Tiempo secuencial/Tiempo paralelo

Y para la eficiencia se utilizó:

Eficiencia: Speed up/ Numero de procesadores



13. Mejores Tiempos

Invertir Color

Figura 15. Mejores tiempos en Invertir color

Escala de grises

Figura 16. Mejores tiempos en Escala de grises



Ajustar brillo

Figura 17. Mejores tiempos en Ajuste de brillo

Se puede observar en cada gráfica que el modelo de ejecución del algoritmo con cuatro procesadores y un nodo es la opción más óptima para ejecutar los algoritmos y que ejecuta en menos tiempo, en el caso de que se agreguen más 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.



14. Graficas de Speedup

Invertir Color

Figura 18. Speedup Invertir color

Escala de Grises

Figura 19. Speedup Escala de grises



Ajustar Brillo

Figura 20. Speedup Ajustar Brillo

Las figuras [18], [19] y [20] corresponden a los speed ups de las tres técnicas 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 degradación del sistema esto se debe a causas de costos de comunicación.

Curva Speed Up de inversión de color con cuatro procesadores y un nodo:o En esta gráfica se puede distinguir que la relación tamaño de imagen y Speed

Up no representan una relación 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 comparación con las versiones de dos y tres nodos se puede concluir que por lejos la mejor es la opción de un nodo, ya que refleja un real incremento en cuanto a la versión del algoritmo secuencial

Curva Speed Up de escala de grises con cuatro procesadores y un nodo:o En esta gráfica se puede distinguir que la relación tamaño de imagen y Speed

Up ademas de verse reflejada como una sinusoidal, se le agrega un factor exponencial negativo, el cual se puede expresar matemáticamente como : S(x)=e-xcos(x), ya que la cota que encierra esta relación disminuye su rango a medida que el tamaño de imagen empieza a incrementar, al igual que el caso anterior se puede concluir la mejor es la opción de un nodo, ya que refleja un real incremento en cuanto a la versión del algoritmo secuencial

Curva Speed Up de ajuste de brillo con cuatro procesadores y un nodo:o En esta gráfica al igual que la grafica de inversión de colores se logra distinguir

una relación representada por una sinusoidal, pero que tiende a hacerse constante y cada vez menor, al igual que los casos anteriores se puede concluir



la mejor es la opción de un nodo, ya que refleja un real incremento en cuanto a la versión del algoritmo secuencial

15. Graficas de Eficiencia

Invertir Color

Figura 21. Eficiencia Invertir Color

Escala de Grises

Figura 22. Eficiencia Escala de grises



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 degradación del sistema esto se debe a causas de costos de comunicación, 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 razón de lo esperado, esto se debe a que no se debe lidiar con costos de comunicación de transferencia de datos y que existe un mejor manejo de memoria.



16. Conclusiones

Gracias al desarrollo de este proyecto, el grupo de trabajo a podido identificar la importancia de la computación paralela, en el funcionamiento de procesos que requieran un gran poder de procesamiento. En este caso los procesos corresponden a técnicas de filtrado de procesamiento de imágenes. Para poder ver que tan útil resulta la computación paralela se realizaron algoritmos de cuatro diferentes técnicas de procesamiento de imágenes, las cuales tiene dos versiones, una versión secuencial y otra versión paralela, la cual a su misma vez se ejecuta con cuatro procesadores (un nodo), ocho procesadores (dos nodos) y doce procesadores (tres nodos).

Cómo 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 ejecución de dichas implementaciones son considerablemente mayores que las de sus versiones secuenciales, no obstante el caso de la paralelización de cuatro procesadores (llevada a cabo en un nodo), logra cumplir el objetivo el cual es disminuir el tiempo de ejecución respecto a su versión secuencial. Este fenómeno 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 través de la red. En el caso de la versión secuencial no se debe lidiar con una comunicación de datos y la versión paralelizada con cuatro procesadores (un nodo), la espera de la comunicación de datos se puede despreciar, ya que los datos son compartidos dentro de una misma máquina 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 versión secuencial, el costo de envio de datos asociado a el tamaño de la imagen es muy grande, ya que la tasa de transferencia es muy baja, por lo que el tamaño de la imagen a tratar se convierte en un factor clave en el incremento exagerado del tiempo de ejecución del algoritmo, ya que como se puede observar en las tablas (Figura 15,16,17) los tiempos de ejecución de cada técnica de filtrado de procesamiento de imágenes, para la misma imagen, y con la misma cantidad de procesadores y nodos; es muy cercano y en la mayoría 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 ejecución del algoritmo se puede solucionar aumentando la velocidad de transferencia de la red para que el traspaso de información sea mayor en menos tiempo.

Debido a lo anterior, es posible concluir que la computación paralela es una alternativa conveniente para realizar cómputos 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 paralelización de algoritmos, el tipo de red a utilizar, los componentes de la res (entiéndase por esto la cantidad y la calidad), entre otros.



17. Bibliografía

[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


http://www.uazuay.edu.ec/estudios/sistemas/teleproceso/apuntes_1/estrella.htm

http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.36.2566

http://processing.org/tutorials/pixels/

http://upload.wikimedia.org/wikipedia/commons/c/c4/BMPfileFormat.png

http://www.ie.itcr.ac.cr/palvarado/pmwiki/index.php/PabloAlvarado/MScProcesamiento


Anexo 1: Invertir coloresNombre de Imágenes

Dimensiones Peso (MB)

Tiempos Mejor Tiempo secuen

cial (segund

os)


procesadores (1 Nodo)

Tiempo Paralelo con 8 procesadores

(2 Nodos)

Tiempo Paralelo con 12 procesadores (3

Nodos)

1 1600x1200 5.8 0,03 – 0,04 0,03 0.01 - 0.02 0.53-0.54 0.71 - 0.72

2 1920x1080 6.2 0,04 0,04 0.01 - 0.02 0.56-0.57-0.58 0.77 - 0.78

3 2008x1384 8.3 0,05 – 0,06 0,05 0.01 - 0.02 0.77-0.78 1.03 - 1.04

4 2000x2000 12 0.09 - 0.10 0.09 0.01 - 0.02 1.11-1.12 1.49

5 4000x4000 48 0,31 – 0,32 0,31 0.05-0.06 4.46 5.95

6 4940x3554 52.7 0.38 - 0.39 0.38 0.04 - 0.06- 0.07 4.88-4.89-4.90 6.51 - 6.52 - 6.53

7 6000x6000 108 0.83 0.83 0.09-0.1-0.12 10.01-10.02 13.36

8 11038x4730 156.6 0,89 – 0,9 – 0,91 0,89 0.13 - 0.14 14.52 19.34 - 19.36 - 19.37

9 11709x4716 165.7 0,94 – 0,95 0,94 0.14 - 0.15 15.36-15.37 20.46 - 20.51 - 20.53

10 8000x8000 192 1.46 - 1.47 1.46 0.16-0.17 17.80-17.82 23.74

11 10799x7274 235.7 1,34 – 1,35 1,34 0.20 - 0.21 21.85-21.86 29.12 - 29.14

12 10000x10000 300 2.29 - 2.3 2.29 0.26-0.27 27.81-27.82 37.09

13 12000x12000 432 3.27 - 3.28 - 3.29 3.27 0.37-038 41.96-41.97 53.42

14 14000x14000 588 4.47 - 4.48 4.47 0.51-0.52-0.55 57.13-57.14 72.69

15 14173x14173 602.6 3.43 - 3.48 - 3.5 3.43 0.51 - 0.52 - 0.53 58.56 74.53 - 74.64 -74.93

16 15000x15000 675 3.83 - 3.89 - 3.9 3.83 0.58 - 0.59 65.57 83.36 - 83.49 - 83.79

17 16000x16000 768 5.84 - 5.85 5.84 0.66-0.67-0.68 74.63 94.94

18 18000x18000 972 7.48 - 7.51 - 7.52 7.48 0.84-0.86 94.43 120.15

19 20000x20000 1228.8 9.06 - 9.12 - 9.15 9.06 1.04 - 1.05 116.71 148.11 - 149.13 - 150.62

Tabla 6. Mediciones para Invertir Colores.



Anexo 2: Escala de GrisesNombre

de Imágenes


Tiempos Mejor Tiempo

secuencial (segundos)


(1 Nodo)


(2 Nodos)



1 1600x1200 5.8 0,04 – 0,05 0,04 0.01 - 0.02 0.53-0.54-0.55 0.72

2 1920x1080 6.2 0,05 - 0,06 0,5 0.01 - 0.02 0.58-0.57 0.77 - 0.78

3 2008x1384 8.3 0,07 0,7 0.01 - 0.02 0.77-0.78 1.03 - 1.04

4 2000x2000 12 0.09 - 0.10 0.09 0.01 - 0.02 1.11-1.12 1.5

5 4000x4000 48 0.38 - 0.39 0.38 0.05 - 0.06 - 0.07 - 0.08

4.45-4.46 5.94

6 4940x3554 52.7 0,4 – 0,41 0,4 0.05 - 0.06 - 0.07 - 0.08

4.88-4.89-4.90 6.52

7 6000x6000 108 0.83 0.83 0.12-0.13-0.14 10-10.01 13.36

8 11038x4730 156.6 1,18 – 1,19 1,18 0.18 - 0.19 - 0.20

14.53 19.38 - 19.39 - 19.42

9 11709x4716 165.7 1,25 – 1,27 1,25 0.19 - 0.20 - 0.21

15.37 20.48 - 20.49 - 20.51

10 8000x8000 192 1.46 - 1.47 1.46 0.22-0.23 17.80-17.81 23.73

11 10799x7274 235.7 1,78 1,78 0.27 - 0.28 - 0.29 - 0.30

21.85-21.86-21.87

29.13 - 29.15

12 10000x10000 300 2.29 - 2.3 2.29 0.35-0.36 27.81-27.82 37.07

13 12000x12000 432 3.27 - 3.28 - 3.29

3.27 0.51-0.52-0.53 41.96-41.97 53.66

14 14000x14000 588 4.47 - 4.48 4.47 0.7 57.13-57.14 72.69

15 14173x14173 602.6 4.55 - 4.56 - 4.57 - 4.59 -

4.61

4.55 0.70 - 0.71 - 0.72

58.54 74.60 - 74.75 - 74.83

16 15000x15000 675 5.09 - 5.1 - 5.11 - 5.14

5.09 0.78 - 0.79 - 0.80

65.58 83.58 - 83.59

17 16000x16000 768 5.84 - 5.85 5.84 0.90-0.91 74.61 94.93

18 18000x18000 972 7.48 - 7.51 - 7.52

7.48 1.14-1.16 94.44 120.14

19 20000x20000 1228.8 9.06 - 9.07 - 9.09 - 9.12 -

9.15

9.06 1.41 - 1.42 116.66 148.46 - 149.56 - 150.29

Tabla 7. Mediciones para Escala de grises.



Anexo 3: Ajustar BrilloNombre

de Imágenes


Tiempos Mejor Tiempo secuen

cial (segund

os)


procesadores (1 Nodo)





1 1600x1200 5.8 0,04 – 0,05 0,04 0.01 - 0.02 0.53-0.54-0.55 0.73 - 0.93 - 0.98

2 1920x1080 6.2 0,05 - 0,06 0,05 0.01 - 0.02 0.58-0.59 0.77 - 0.78

3 2008x1384 8.3 0,07 – 0,08 0,07 0.01 - 0.02 0.77-0.78 1.04

4 2000x2000 12 0.1 - 0.11 - 0.1 0.1 0.01 - 0.02 1.11-1.12 1.49

5 4000x4000 48 0.35-0.41- 0.38

0.35 0.06-0.07 4.45-4.46-4.47 5.94

6 4940x3554 52.7 0,39 – 0,41 – 0,43

0,39 0.05 - 0.06 - 0.07 - 0.08

4.88-4.89-4.90 6.51 - 6.53

7 6000x6000 108 0.82 - 0.85 - 0.86

0.82 0.15-0.16-0.17 10.01 13.36

8 11038x4730 156.6 1,17 – 1.18-1.19-1.22-1,23

1,17 0.15 - 0.20 - 0.23 14.52 -14.59 19.33 - 19.38 - 19.43

9 11709x4716 165.7 1,22 – 1,30 1,22 0.20 - 0.22 - 0.23 - 0.24

15.37-15.40-15.42 20.41 - 20.45 - 20.49 - 20.54

10 8000x8000 192 1.52-1.51-1.52 1.51 0.27-0.28 17.80-17.81 23.73

11 10799x7274 235.7 1,72 – 1,84 – 1,85

1,72 0.29 - 0.30 - 0.33 - 0.34

21.84-21.85 29.13 - 29.14

12 10000x10000 300 2.24-2.36-2.35 2.24 0.42-0.43-0.44 27.81-27.82 37.07

13 12000x12000 432 3.12-3.39-3.39 3.12 0.62-0.63-0.64 41.95-41.96-41.97 53.66

14 14000x14000 588 4.27 - 4.63 - 4.62

4.27 0.82-0.86-0.87 57.13-57.14 72.68

15 14173x14173 602.6 3.57 - 3.58 - 3.61 - 3.93 -

4.76

3.57 0.57 - 0.75 - 0.86 - 0.87

58.56 94.94

16 15000x15000 675 4.02 - 5.11 - 5.26 - 5.27 -

5.28

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 5.41 - 6.01 - 4.56

4.56 1.07-1.11-1.12 74.69 83.48 - 83.77 - 83.86

18 18000x18000 972 6.76 - 7.61 - 5.75

5.75 1.36-1.40-1.41 94.47 120.14

19 20000x20000 1228.8 7.16 - 8.61 - 9.35

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



Anexo 4: Convolucion con detección de bordes

Nombre de

Imágenes


Tiempos Mejor Tiempo secuencial (segundos)

Tiempo Paralelo con

4 procesadores

(1 Nodo)

Tiempo Paralelo con

8 procesadores

(2 Nodos)

Tiempo Paralelo con

12 procesadores

(3 Nodos)

1 1600x1200 5.8 1.86 - 1.89 - 1.9 1.86 0.26 0.55 0.72

2 1920x1080 6.2 2.02 - 2.04 - 2.05

2.02 0.27 0.6 0.78

3 2008x1384 8.3 2.7 - 2.73 2.7 0.37 0.82 1.04

4 2000x2000 12 3.85 - 3.86 - 3.88

3.85 0.53 1.17 1.49

5 4000x4000 48 15.41 - 15 .57 15.41 2.13 4.67 5.96

6 4940x3554 52.7 17.15 - 17.16 - 17.2

17.15 2.33 5.13 6.52

7 6000x6000 108 34.76 - 34.79 34.76 4.83 10.49 13.36

8 11038x4730 156.6 50.61 - 50.63 - 50.65

50.61 6.95 15.22 19.38

9 11709x4716 165.7 53.49 - 53.51 - 53.52

53.49 7.35 16.09 23.75

10 8000x8000 192 62.24 - 62.47 62.24 8.49 18.65

11 10799x7274 235.7 76.27 - 76.29 -76.3

76.27 10.4 22.89

12 10000x10000 300 97.15 - 98.4 97.15 13.37 29.14

13 12000x12000 432 140.96 - 142.2 140.96 19.28 41.96

14 14000x14000 588 189.04 - 192.31 189.04 26.06 57.12

15 14173x14173 602.6 194.67 - 194.69 194.67 26.64 58.54

16 15000x15000 675 217.53 - 217.55 - 217.56

217.53 29.74 65.58

17 16000x16000 768 247.8 - 250.5 247.8 33.94 74.73

18 18000x18000 972 311.59 - 313.07 311.59 42.75 94.44

19 20000x20000 1228.8 387.77 - 387.90 387.77 52.97 116.66

Tabla 9. Mediciones para Convolucion



Anexo 5: Montaje de Clúster

1-Preparativos

El primer paso para el montaje de Clúster 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 “clúster”, y como nombre de máquina se utilizó la nomenclatura nXX donde las X representan el valor de los últimos dos dígitos de dirección ip asignadas a cada computador para conectarse a la red; además 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 conexión a la red$ping -c n dirección Web ; para comprobar que existe conexión 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 clúster 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 (Intérprete de órdenes segura) nfs (Sistema de archivos de red)

Para instalar estas herramientas se debe abrir una terminal e ingresar como “súper usuario” (root) para poder instalar dichas herramientas como será descrito a continuación:



$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 sesión 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 común, luego se crea la carpeta compartida en el directorio raíz , nombrada mpi; esto se debe hacer en cada nodo del futuro clúster, los pasos anteriormente nombrados serán descritos a continuación:

$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 línea de comandos y se ingresa:



$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 /mpiTerminado esto se procede a modificar el fichero fstab que se ubica en la carpeta etc. y se modifica para que el montaje sea automático que será descrito a continuación:

$sudo gedit /etc/fstab//Se incluye lo siguiente en el archivo: (ip nodo maestro):(Ruta carpeta maestra) (ruta carpeta compartida) nfsy se guarda//$sudo mount -a

Terminado estos pasos, ya se tienen configurados los Nodos Esclavos.



4- Configuración 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 conexión 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 automático y sin el ingreso de contraseña.

5- Compilar y ejecutar código

Para compilar código Mpi c se guarda el archivo de código de fuente en la carpeta compartida y en el nodo maestro se establece como ubicación 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 clúster.



Anexo 6: Formato BMP



Encabezado del archivo

El encabezado del archivo proporciona información acerca del tipo de archivo (mapa de bits) y su tamaño, así como también indica dónde comienza realmente la información 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 tamaño 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 ubicación del comienzo de la

información de la imagen en relación con el comienzo del archivo

Encabezado de información del mapa de bits

El encabezado de información del mapa de bits proporciona información acerca de la imagen, en especial las dimensiones y los colores.

La información del mapa de bits comprende cuatro campos:El tamaño del encabezado de información del mapa de bits en bytes (codificado en 4 bytes). Los siguientes valores hexadecimales son posibles según 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 número de píxeles contados de forma horizontalLa altura de la imagen (en 4 bytes), es decir, el número de píxeles contados de forma verticalEl número de planos (en 2 bytes). Este valor es siempre 1La profundidad del modelo de color (en 2 bytes), es decir, el número de bits usados para codificar el color. Este valor puede ser equivalente a 1, 4, 8, 16, 24 ó 32El método de compresión (en 4 bytes). Este valor es 0 cuando la imagen no está comprimida o 1, 2 ó 3 según el tipo de compresión usado:



1 para la codificación RLE de 8 bits por píxel 2 para la codificación RLE de 4 bits por píxel 3 para la codificación de campo de bits, lo que significa que el color fue codificado

por una máscara triple representada por la paleta.

El tamaño total de la imagen en bytes (en 4 bytes). La resolución horizontal (en 4 bytes), es decir, el número de píxeles por metro contado

de forma horizontal. La resolución vertical (en 4 bytes), es decir, el número de píxeles por metro contado de

forma vertical. El número de colores de la paleta (en 4 bytes). El número de colores importantes de la paleta (en 4 bytes). Este campo puede equivaler

a 0 cuando todos los colores son importantes. Paleta de imágenes

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).

Codificación de imágenes

La codificación de imágenes se realiza escribiendo en forma sucesiva los bits que corresponden a cada píxel, línea por línea, comenzando por el píxel del extremo inferior izquierdo.

Las imágenes de 2 colores usan 1 bit por píxel, lo que significa que un byte permite codificar 8 píxeles

Las imágenes de 16 colores usan 4 bits por píxel, lo que significa que un byte permite codificar 2 píxeles

Las imágenes de 256 colores usan 8 bits por píxel, lo que significa que se necesita un byte para codificar cada píxel

Las imágenes de colores reales usan 24 bits por píxel, lo que significa que se necesitan 3 bytes para codificar cada píxel, respetando la alternancia del orden de los colores para el azul, el verde y el rojo.



Cada línea de la imagen debe comprender un número total de bytes que sea múltiplo de 4; si este esquema no se cumple, la línea se debe completar con todos los 0 necesarios para respetar el criterio.

Anexo 7: Conceptos involucrados en el procesamiento de imágenes

Imagen: es una representación visual, que manifiesta la apariencia visual de un objeto real o imaginario. Aunque el término suele entenderse como sinónimo de representación visual, también se aplica como extensión para otros tipos de percepción, como imágenes auditivas, olfativas, táctiles, sinestésicas, etcétera.

Imagen Digital: La imagen digital es la representación bidimensional de una imagen empleando bits, unidad mínima de información compuesta por dígitos binarios (1 y 0), que se emplea a instancias de la informática y cualquier dispositivo de tipo digital.

Imágenes Bitmap: Las imágenes de mapa de bits están construidas mediante una gran cantidad de cuadraditos, llamados pixel. Cada uno de estos cuadraditos está relleno de un color uniforme, pero la sensación obtenida es el resultado de integrar visualmente, en la retina, las variaciones de color y luminosidad entre píxeles vecinos

Figura 24. Imagen Bitmap

Las imágenes de mapa de bits, también llamadas bitmap, son la alternativa ideal para reproducir objetos sutilmente iluminados y escenas con gran variación tonal. De hecho, es el tipo de imagen utilizado para la fotografía y el cine. Obviamente, la calidad de la imagen dependerá de la cantidad de píxeles utilizados para representarla.Las imágenes 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 píxeles son evidentes y la representación es totalmente irreal. Este efecto, que se conoce con el nombre de pixelado se hace más evidente en las líneas curvas y en las zonas en las que hay cambios bruscos de luminosidad.



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 imágenes 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 dónde y cómo va a mostrarse, con una cantidad de píxeles y una gama de colores adaptados al soporte en el que va a reproducirse. Una vez hecha, las modificaciones comportarán pérdida de calidad

Resolución

Podemos definir la resolución como la capacidad de reproducir fielmente los detalles de una imagen. Utilizaremos esta palabra, lógicamente, al referirnos a la resolución de una imagen digital, pero también, al referirnos a una impresora, un monitor, una cámara o un escáner. Así pues, se trata de un concepto fundamental, que posee distintas acepciones, según el contexto en el que lo utilizamos.

A partir de ahora nos referiremos a la tecnología bitmap, que es la más exigente en lo que concierne a la resolución. Hay que tener presente este concepto en todas las etapas de la vida de la imagen, desde su captura con una cámara digital o un escáner hasta la reproducción en el soporte elegido.

Resolución de una imagen

La resolución de una imagen es la cantidad de píxeles que la componen. Suele medirse en píxeles por pulgada (ppi)1 o píxeles por centímetro (pcm). Cuanto mayor es la resolución de una imagen más calidad tendrá su presentación pero, desgraciadamente, más espacio ocupará en el disco el archivo gráfico que la contiene.Por ejemplo, una imagen con una resolución de 72 ppi, que es muy común en las páginas web, necesitará 5184 píxeles en cada pulgada cuadrada, que es un cuadrado de 2,54 centímetros de lado (ya sé que es una lata tener que manejar las unidades anglosajonas, pero hay que utilizarlas). Una resolución de 72 ppi es adecuada para imágenes que se muestran en el monitor de un ordenador. La nitidez de los detalles es suficiente y la reproducción de las distintas tonalidades es correcta. Sin embargo, podría ser insuficiente para una impresión en papel.



Afortunadamente, muchos de los programas de tratamiento de imágenes nos permiten expresarnos en centímetros y milímetros. Así que, para poner otro ejemplo, supongamos que queremos hacer una imagen con una resolución de 30 pixel por centímetro (30 pcm). Cada centímetro cuadrado necesitará 900 píxeles y, si nuestra imagen es una fotografía de 13 x 18 centímetros, cuya superficie es de 234 cm2, necesitará en total 210600 píxeles. Lógicamente cuanto más alta es la resolución de una imagen, más finamente reproduce los detalles y los cambios sutiles de tonalidad pero, a la vez, más pesado será el archivo.

Profundidad de color

Cada uno de los píxeles de una imagen bitmap está coloreado con un color homogéneo. Así pues, el archivo que contiene los datos de la imagen debe contener la información del color de cada uno de los píxeles. ¿Cuántos bits se emplean para albergar esta información? Eso es lo que se conoce con el término profundidad de color de una imagen.Profundidad de color es el número 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, más colores tendrá la paleta disponible y, por tanto, la representación de la realidad podrá hacerse con más matices, con colores más sutiles.Por ejemplo, si sólo disponemos de 1 bit para describir el color de cada pixel, tan sólo 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 fotografía tiene con una profundidad de 1 bit, que tiene el aspecto de una fotocopia de mala calidad, en cambio la segunda ya está más definida con 8 bit con una calidad tonal más suficiente.



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 imágenes 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 cálculo de los colores disponibles para cada profundidad:


Tabla 10. Profundidad, Color

Profundidad

Colores

1 bit 24 bit 168 bit 25616 bit 6553617 bit 4294967296


Anexo 8: Código Secuencial

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <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; //tamaño 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; //tamaño 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; //tamaño 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, unsigned char r, unsigned char g, unsigned char b, int width){ 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 (*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); }



//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 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 (*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;

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;

elseif(tmp.R + c < 0) tmp.R = 0;

else tmp.R = tmp.R + c; if(tmp.G + c > 255) tmp.G = 255;

elseif(tmp.G + c < 0) tmp.G = 0;

else tmp.G = tmp.G + c; if(tmp.B + c > 255) tmp.B = 255;

elseif(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}, {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 the filter for(x = 0; x < (*im).ih.height; x++) for(y = 0; y < (*im).ih.width; 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 + (*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); 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 counterclock_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");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);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;}



Anexo 9: Código Paralelo

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <time.h>#include "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; //tamaño 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; //tamaño 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; //tamaño 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, unsigned char r, unsigned char g, unsigned char b, int width){ 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 (*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); } //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); 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;

elseif(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 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); //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;






} else {





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_COMM_WORLD);

free(arreglo); }


processed data{






}}

}

void brightImage_Parallel(struct image *im, int c, int size, int rank){ int i,j,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) {







} else {





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;

}


MPI_COMM_WORLD);

free(arreglo); }


processed data{




}}

}

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 alto; int ancho; int st; int 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;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) {





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);




} else {


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);


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);MPI_Send(&arreglo_salida[0], qty*3, MPI_BYTE, 0, SLAVE_TO_MASTER_TAG,

MPI_COMM_WORLD);

free(arreglo_salida); }


processed data{




}}

}

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 counterclock_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;

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 ranksMPI_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();

}

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;}


Date post:	20-Jan-2016
Category:	Documents
Upload:	freddy-aravena
View:	38 times
Download:	0 times

Lab1paralela Version 4

Documents