Esta sección explica detalladamente cómo se diseñó la solución, cuáles son las entradas y salidas de cada componente, y las condiciones de operación para ejecutar el experimento completo.

---

1. Fase de Preparación (Usuario/GUI)

   • El usuario abre la interfaz (interfaz.py) y selecciona:
     • Carpeta de entrada (images/).
     • Número de procesos MPI a usar (por ejemplo, 4, 8, 12).
     • Tamaño de kernel para desenfoque (impar entre 55 y 155).
   • La GUI verifica que todos los campos sean válidos.

2. Invocación del Ejecutable en C

   • Una vez que el usuario hace clic en “Procesar” en la GUI, main.py (o interfaz.py) lanza un comando similar a:

     mpirun -np <num_procesos> ./procesar_imagenes <kernel_blur>
     

   • Antes de lanzar el MPI, se comprueba que:
     • El ejecutable procesar_imagenes (generado a partir de main.c) exista y tenga permisos de ejecución.
     • La carpeta results/ exista o se cree vacía.

3. Procesamiento en C (MPI + OpenMP)

   • Proceso maestro (rank 0):

     1. Lee kernel_blur de argv[1].
     2. Abre images/ y genera archivos_global[] con todas las rutas de archivos .bmp.
     3. Difunde (MPI_Bcast) el kernel, el total de imágenes (total_global) y el arreglo archivos_global.
     4. Inicia temporizador con MPI_Wtime().
     5. En paralelo (OpenMP), ejecuta:
        • Sección A: Mientras haya imágenes sin blur, aplica procesar_blur(...) localmente en rank 0.
        • Sección B:
          • Reparte tareas ligeras a ayudantes (ranks ≥ 1), enviándoles una Tarea (TAREA_LIGERA o TAREA_BLUR) según disponibilidad de índices.
          • Cuando un ayudante ya no encuentre más imágenes ligeras, recibe petición de blur y le envía una ruta, hasta que se acaben las imágenes.
          • Marca TAG_FIN para indicar al rank que ya no hay más trabajo.
     6. Una vez todos los ayudantes completaron su trabajo, recopila sus métricas (Resultados rcv) y calcula totales (bytes leídos, bytes escritos, imágenes procesadas).
     7. Detiene el temporizador, calcula MIPS y MB/s, y escribe results.txt.
     8. Finaliza con MPI_Finalize().

   • Procesos ayudantes (rank ≥ 1):

     1. Entran a un bucle recibiendo Tareas del maestro:
        • Si la tarea es TAREA_LIGERA: llaman a procesar_filtros_ligeros(...) (internamente usan OpenMP para 5 filtros ligeros).
        • Si la tarea es TAREA_BLUR: llaman a procesar_blur(...) (OpenMP para blur).
        • Si la tarea es tipo == -1 (fin), salen del bucle y envían sus métricas (Resultados local) al maestro.
     2. Salen de MPI_Finalize() y terminan.

4. Presentación de Resultados (GUI / Python)

   • Tras completarse el mpirun, main.py lee el archivo results.txt generado por C y despliega métricas al usuario.
   • La GUI (interfaz.py) puede opcionalmente mostrar miniaturas de las imágenes generadas en results/ o simplemente listar los nombres de archivo.

---

• Entradas

  1. kernel_blur (argumento de línea de comandos): entero impar entre 55 y 155.
  2. Carpeta images/ con archivos .bmp.

• Salidas

  1. Carpeta results/, con subficheros por cada imagen original:
     • <base>_grayscale.bmp
     • <base>_mirrorh.bmp
     • <base>_mirrorv.bmp
     • <base>_gray_mirrorh.bmp
     • <base>_gray_mirrorv.bmp
     • <base>_blur_<kernel>.bmp
  2. Archivo results.txt con métricas globales:
     • Tiempo total (segundos)
     • Total de imágenes generadas
     • Bytes leídos / escritos
     • MIPS estimado
     • Velocidad (MB/s y GB/s)

• Entradas
  1. Selección de carpeta de imágenes (GUI).
  2. Parámetros de ejecución (número de procesos MPI, tamaño de kernel).
• Salidas
  1. Ejecución de mpirun con el ejecutable en C (no directa, sino por subprocess).
  2. Lectura de results.txt y despliegue en GUI (por ejemplo, en un QTextEdit o lista).
  3. Opcional: vista de miniaturas de las imágenes procesadas (implementable extendiendo la GUI).

---

1. Requisitos Previos

   • Linux con GCC, OpenMP y MPI instalados:

     sudo apt-get install build-essential libopenmpi-dev openmpi-bin
     

   • Python 3.x con PyQt5 (o Flask, según versión de interfaz.py):

     pip install pyqt5
     

   • Carpetas creadas:
     • images/ (con archivos .bmp)
     • results/ (vacía, para guardar salidas)

2. Compilación (C)

• Esto genera el ejecutable procesar_imagenes en la raíz del proyecto.

3. Ejecución Completa

4. Ejecutar la GUI:

   cd python/
   python main.py
   

   (La interfaz pedirá la carpeta images/, número de procesos y kernel).

5. Al presionar “Procesar”, la GUI (o main.py) lanza algo como:

   mpirun -np <n> ../procesar_imagenes <kernel>
   

6. Esperar a que termine ., revisar results/ y results.txt.

7. En la GUI, hacer clic en “Ver Resultados” o similar para leer y mostrar el contenido de results.txt.

8. Escalabilidad y Validación

• Probar con distintos tamaños de clúster:
  • mpirun -np 4 ./procesar_imagenes 101
  • mpirun -np 8 ./procesar_imagenes 101
  • Comparar tiempos en results.txt.
• Verificar que las imágenes resultantes realmente contengan los filtros correspondientes (abrir algunas con cualquier visor BMP).

---