#include <iostream>
#include <cstdlib>
#include "opencv/highgui.h"
#include <string.h>
#include "opencv/cv.h"
using namespace std;
using namespace cv;

Mat lecturaEscrituraImagen(string nombreImg) {
    Mat img; //Variable donde se colocará la imagen
    string folderName = "Salida"; //Carpeta donde se guardará la imagen
    string folderCreateCommand = "mkdir " + folderName; //comando para crear la carpeta

    //Lectura de imagen
    img = imread(nombreImg);

    //Escritura de imagen
    system(folderCreateCommand.c_str()); //se ejecuta el comando para crear la carpeta Salida
    imwrite(folderName + "/" + nombreImg, img); //se guarda la imagen
    return img;
}

void invertirImagen(Mat img) {
    Mat imgInv = img;

    for (int y = 0; y < img.rows; y++) {
        for (int x = 0; x < img.cols; x++) {
            Vec3b color = imgInv.at<Vec3b>(Point(x, y)); //Creo variable para acceder al pixel(x,y)
            color.val[0] = 255 - color.val[0]; //invierto color
            color.val[1] = 255 - color.val[1]; //invierto color
            color.val[2] = 255 - color.val[2]; //invierto color
            imgInv.at<Vec3b>(Point(x, y)) = color; //asigno el nuevo color a la imagen
        }
    }
    imwrite("Salida/Invert.jpg", imgInv); //Guardo la imagen
}

void espejarImagen(Mat img) {
    Mat imgEsp = img.clone(); //creo una copia de la imagen original(para obtener una variable con las mismas dimensiones)

    for (int y = 0; y < img.rows; y++) {
        for (int x = 0; x < img.cols; x++) {
            Vec3b color = img.at<Vec3b>(Point((img.cols - x), y)); //Creo variable para acceder al pixel(x,y)
            imgEsp.at<Vec3b>(Point(x, y)) = color; //asigno el nuevo color a la imagen

        }
    }
    imwrite("Salida/Espejo.jpg", imgEsp); //Guardo la imagen
}

void calcularHistogramaRGB(Mat img) {
    int b = 0, g = 0, r = 0, total, pB, pG, pR;
    for (int y = 0; y < img.rows; y++) {
        for (int x = 0; x < img.cols; x++) {
            Vec3b color = img.at<Vec3b>(Point(x, y));
            //conteo de niveles de b(azul), g(verde) y r(rojo)
            b += color.val[0];
            g += color.val[1];
            r += color.val[2];
        }
    }
    //obtengo porcentajes que utilizare para obtener un histograma a escala de 1080x1000 pixeles
    total = b + g + r;
    pB = 900.0 * b / total;
    pG = 900.0 * g / total;
    pR = 900.0 * r / total;
    //Creo imagen de 1080x1000 pixeles donde se calculará el histograma
    Mat imgHisto(Size(900, 900), CV_8UC3);
    imgHisto.setTo(Scalar(255,255,255));    //inicializo imagen de color blanco

    for (int y = 0; y < imgHisto.rows; y++) {
        for (int x = 0; x < imgHisto.cols; x++) {
            Vec3b color = imgHisto.at<Vec3b>(Point(x, y));
            if (10 <= x && x < 290) {
                if (y > (900 - pB)) {
                    color.val[0] = 255;
                    color.val[1] = 0;
                    color.val[2] = 0;
                }
                imgHisto.at<Vec3b>(Point(x, y)) = color;
            }
            if (310 <= x && x < 590) {
                if (y > (900 - pG)) {
                    color.val[0] = 0;
                    color.val[1] = 255;
                    color.val[2] = 0;
                }
                imgHisto.at<Vec3b>(Point(x, y)) = color;
            }
            if (610 <= x && x < 890) {
                if (y > (900 - pR)) {
                    color.val[0] = 0;
                    color.val[1] = 0;
                    color.val[2] = 255;
                }
                imgHisto.at<Vec3b>(Point(x, y)) = color;
            }
        }
    }
    putText(imgHisto, "Azul", Point(25,890), FONT_HERSHEY_SIMPLEX, 2, Scalar(0,0,0));
    putText(imgHisto, "Verde", Point(325,890), FONT_HERSHEY_SIMPLEX, 2, Scalar(0,0,0));
    putText(imgHisto, "Rojo", Point(625,890), FONT_HERSHEY_SIMPLEX, 2, Scalar(0,0,0));
    imwrite("Salida/histogramaRGB.jpg", imgHisto);
}

void calcularHistogramaGray(Mat img) {
    //Creo imagen de 1080x1000 pixeles donde se calculará el histograma
    Mat imgHisto(Size(900, 900), CV_8UC3);
    imgHisto.setTo(Scalar(255,255,255));    //inicializo el histograma de color blanco
    unsigned char colorGrayScale;
    int white = 0, gray = 0, black = 0, total, pW, pG, pB;

    for (int y = 0; y < img.rows; y++) {
        for (int x = 0; x < img.cols; x++) {
            Vec3b color = img.at<Vec3b>(Point(x, y));
            //se utiliza el metodo basado en luminosidad para convertir a escala de grises
            //se asigna los siguientes pesos: Rojo:0.21, Verde:0.72, Azul:0.07
            colorGrayScale = (0.07 * color.val[0])+(0.72 * color.val[1])+(0.21 * color.val[2]);
            if (0 <= colorGrayScale && colorGrayScale < 80)
                black += colorGrayScale;
            if (80 <= colorGrayScale && colorGrayScale < 180)
                gray += colorGrayScale;
            if (180 <= colorGrayScale && colorGrayScale < 255)
                white += colorGrayScale;
        }
    }
    //obtengo porcentajes que utilizare para obtener un histograma a escala de 1080x1000 pixeles
    total = white + black + gray;
    pW = 900.0 * white / total;
    pB = 900.0 * black / total;
    pG = 900.0 * gray / total;

    for (int y = 0; y < imgHisto.rows; y++) {
        for (int x = 0; x < imgHisto.cols; x++) {
            Vec3b color = imgHisto.at<Vec3b>(Point(x, y));
            if (10 <= x && x < 290) {
                if (y > (900 - pW)) {
                    color.val[0] = 0;
                    color.val[1] = 0;
                    color.val[2] = 0;
                }
                imgHisto.at<Vec3b>(Point(x, y)) = color;
            }
            if (310 <= x && x < 590) {
                if (y > (900 - pG)) {
                    color.val[0] = 0;
                    color.val[1] = 0;
                    color.val[2] = 0;
                }
                imgHisto.at<Vec3b>(Point(x, y)) = color;
            }
            if (610 <= x && x < 890) {
                if (y > (900 - pB)) {
                    color.val[0] = 0;
                    color.val[1] = 0;
                    color.val[2] = 0;
                }
                imgHisto.at<Vec3b>(Point(x, y)) = color;
            }
        }
    }
    putText(imgHisto, "Blanco", Point(25,890), FONT_HERSHEY_SIMPLEX, 2, Scalar(255,255,255));
    putText(imgHisto, "Gris", Point(325,890), FONT_HERSHEY_SIMPLEX, 2, Scalar(255,255,255));
    putText(imgHisto, "Negro", Point(625,890), FONT_HERSHEY_SIMPLEX, 2, Scalar(255,255,255));
    imwrite("Salida/histogramaGray.jpg", imgHisto);
}

void calcularHistograma(Mat img, string colorHisto) {
    if (colorHisto == "RGB")
        calcularHistogramaRGB(img);
    else
        calcularHistogramaGray(img);
}

void caracterizarImagenes() {

}

void convertirRGBaGray(Mat img) {
    for (int y = 0; y < img.rows; y++) {
        for (int x = 0; x < img.cols; x++) {
            Vec3b color = img.at<Vec3b>(Point(x, y));
            //se utiliza el metodo basado en luminosidad para convertir a escala de grises
            //se asigna los siguientes pesos: Rojo:0.21, Verde:0.72, Azul:0.07
            color.val[0] = (0.07 * color.val[0])+(0.72 * color.val[1])+(0.21 * color.val[2]);
            color.val[1] = (0.07 * color.val[0])+(0.72 * color.val[1])+(0.21 * color.val[2]);
            color.val[2] = (0.07 * color.val[0])+(0.72 * color.val[1])+(0.21 * color.val[2]);
            img.at<Vec3b>(Point(x, y)) = color;
        }
    }
    imshow("Gray", img);
    waitKey(0);
}

int main() {
    string nombreImg = "My Picture.jpg";
    Mat img;
    img = lecturaEscrituraImagen(nombreImg);

    //convertirRGBaGray(img);
    invertirImagen(img);
    espejarImagen(img);

    string colorHisto = "RGB";
    calcularHistograma(img, colorHisto);
    calcularHistograma(img, "Grayscale");


    return 0;
}