mainParalelo.cpp

#include <iostream>
#include <vector>
#include <fstream>
#include <cmath>
#include <chrono>
#include <omp.h>

using namespace std;

// ==========================================================
// CONFIGURACIÓN
// ==========================================================

const int WIDTH = 7680;
const int HEIGHT = 4320;

const int MAX_ITER = 1000;

// ==========================================================
// ESTRUCTURA RGB
// ==========================================================

struct Pixel {
    unsigned char r, g, b;
};

// ==========================================================
// GUARDAR IMAGEN PPM
// ==========================================================

void savePPM(const string& filename,
             const vector<Pixel>& image,
             int width,
             int height) {

    ofstream file(filename, ios::binary);

    file << "P6\n" << width << " "
         << height << "\n255\n";

    for (const auto& pixel : image) {
        file.write(reinterpret_cast<const char*>(&pixel), 3);
    }

    file.close();
}

// ==========================================================
// TAREA A: MANDELBROT PARALELO
// ==========================================================

void generateMandelbrot(vector<Pixel>& image,
                        int width,
                        int height) {

    double xmin = -2.5;
    double xmax = 1.0;
    double ymin = -1.0;
    double ymax = 1.0;

    #pragma omp parallel for schedule(dynamic)

    for (int y = 0; y < height; y++) {

        for (int x = 0; x < width; x++) {

            double cr = xmin +
                (x / (double)width) * (xmax - xmin);

            double ci = ymin +
                (y / (double)height) * (ymax - ymin);

            double zr = 0.0;
            double zi = 0.0;

            int iter = 0;

            while (zr * zr + zi * zi <= 4.0 &&
                   iter < MAX_ITER) {

                double temp =
                    zr * zr - zi * zi + cr;

                zi = 2.0 * zr * zi + ci;
                zr = temp;

                iter++;
            }

            Pixel pixel;

            if (iter == MAX_ITER) {

                pixel = {0, 0, 0};

            } else {

                unsigned char color =
                    (unsigned char)
                    (255.0 * iter / MAX_ITER);

                pixel.r = color;
                pixel.g = 255 - color;
                pixel.b = (color * 2) % 255;
            }

            image[y * width + x] = pixel;
        }
    }
}

// ==========================================================
// TAREA B: FILTRO GAUSSIANO PARALELO
// ==========================================================

void gaussianBlur(const vector<Pixel>& input,
                  vector<Pixel>& output,
                  int width,
                  int height) {

    const int kernelSize = 5;
    const int radius = kernelSize / 2;

    int kernel[5][5] = {
        {1,  4,  6,  4, 1},
        {4, 16, 24, 16, 4},
        {6, 24, 36, 24, 6},
        {4, 16, 24, 16, 4},
        {1,  4,  6,  4, 1}
    };

    int kernelSum = 256;

    #pragma omp parallel for schedule(dynamic)

    for (int y = 0; y < height; y++) {

        for (int x = 0; x < width; x++) {

            int r = 0;
            int g = 0;
            int b = 0;

            for (int ky = -radius;
                 ky <= radius;
                 ky++) {

                for (int kx = -radius;
                     kx <= radius;
                     kx++) {

                    int px =
                        min(max(x + kx, 0),
                        width - 1);

                    int py =
                        min(max(y + ky, 0),
                        height - 1);

                    int weight =
                        kernel[ky + radius]
                              [kx + radius];

                    const Pixel& p =
                        input[py * width + px];

                    r += p.r * weight;
                    g += p.g * weight;
                    b += p.b * weight;
                }
            }

            Pixel result;

            result.r = r / kernelSum;
            result.g = g / kernelSum;
            result.b = b / kernelSum;

            output[y * width + x] = result;
        }
    }
}

// ==========================================================
// MAIN
// ==========================================================

int main() {

    cout << "=== VERSION PARALELA OPENMP ===" << endl;

    cout << "Hilos disponibles: "
         << omp_get_max_threads()
         << endl;

    vector<Pixel> image(WIDTH * HEIGHT);
    vector<Pixel> blurred(WIDTH * HEIGHT);

    // ------------------------------------------------------
    // MANDELBROT
    // ------------------------------------------------------

    auto startA =
        chrono::high_resolution_clock::now();

    cout << "Generando Mandelbrot..."
         << endl;

    generateMandelbrot(image,
                       WIDTH,
                       HEIGHT);

    auto endA =
        chrono::high_resolution_clock::now();

    chrono::duration<double> durationA =
        endA - startA;

    cout << "Tiempo Mandelbrot: "
         << durationA.count()
         << " segundos" << endl;

    savePPM("mandelbrot_parallel.ppm",
            image,
            WIDTH,
            HEIGHT);

    // ------------------------------------------------------
    // FILTRO
    // ------------------------------------------------------

    auto startB =
        chrono::high_resolution_clock::now();

    cout << "Aplicando desenfoque..."
         << endl;

    gaussianBlur(image,
                 blurred,
                 WIDTH,
                 HEIGHT);

    auto endB =
        chrono::high_resolution_clock::now();

    chrono::duration<double> durationB =
        endB - startB;

    cout << "Tiempo Filtro: "
         << durationB.count()
         << " segundos" << endl;

    savePPM("mandelbrot_blur_parallel.ppm",
            blurred,
            WIDTH,
            HEIGHT);

    cout << "Proceso completado."
         << endl;

    return 0;
}