main.cpp

#include <iostream>
#include <vector>
#include <fstream>
#include <cmath>
#include <chrono>

using namespace std;

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

const int WIDTH = 7680;   // 8K UHD
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: GENERAR MANDELBROT
// ==========================================================

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;

    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 PESADO
// ==========================================================

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

    // Kernel Gaussiano 5x5
    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;

    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 << "Resolucion: " << WIDTH << "x" << HEIGHT << endl;

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

    // ------------------------------------------------------
    // TAREA A
    // ------------------------------------------------------

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

    cout << "Generando fractal 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.ppm", image, WIDTH, HEIGHT);

    // ------------------------------------------------------
    // TAREA B
    // ------------------------------------------------------

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

    cout << "Aplicando filtro Gaussiano..." << 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.ppm", blurred, WIDTH, HEIGHT);

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

    return 0;
}