#include "preprocess.h"


void preprocessor::loadImg()
{
    std::cout << "imread neko img\n";
    for(auto& p : std::filesystem::directory_iterator("/home/simtoon/datasets/unprocessed/neko"))
    {
        cv::Mat img = cv::imread(p.path().string());
        if(!img.empty())
        {
            preprocessor::animeNekoGirls.push_back(img);
        }
    }

    std::cout << "imread non_neko img\n";
    for(auto& p : std::filesystem::directory_iterator("/home/simtoon/datasets/unprocessed/non_neko"))
    {
        cv::Mat img = cv::imread(p.path().string());
        if(!img.empty())
        {
            preprocessor::nonAnimeNekoGirls.push_back(img);
        }
    }
}

void preprocessor::resizeImg(int size)
{
    std::cout << "resizing neko img\n";
    cv::Size sizeObj(size, size); //need to construct an obj of class cv::Size with the int size arg for both width and height
    for(auto& img : preprocessor::animeNekoGirls)
    {
        cv::resize(img, img, sizeObj);
    }

    std::cout << "resizing non_neko img\n";
    for(auto& img : preprocessor::nonAnimeNekoGirls)
    {
        cv::resize(img, img, sizeObj);
    }
}

void preprocessor::normalizeImg()
{
    std::cout << "normalizing neko img\n";
    for(auto& img : preprocessor::animeNekoGirls)
    {
        img /= 255.0;
    }

    std::cout << "normalizing non_neko img\n";
    for(auto& img : preprocessor::nonAnimeNekoGirls)
    {
        img /= 255.0;
    }
}

void preprocessor::convertToGrayscaleImg()
{
    std::cout << "converting to grayscale neko img\n";
    for(auto& img : preprocessor::animeNekoGirls)
    {
        cv::cvtColor(img, img, cv::COLOR_BGR2GRAY);
    }

    std::cout << "converting to grayscale non_neko img\n";
    for(auto& img : preprocessor::nonAnimeNekoGirls)
    {
        cv::cvtColor(img, img, cv::COLOR_BGR2GRAY);
    }
}

void preprocessor::blurImg(int blurType, int kerx, int kery)
{
    if(blurType == 0)
    {
        std::cout << "blurring neko img\n";
        for(auto& img : preprocessor::animeNekoGirls)
        {
            cv::GaussianBlur(img, img, cv::Size(kerx, kery), 0);
        }

        std::cout << "blurring non_neko img\n";
        for(auto& img : preprocessor::nonAnimeNekoGirls)
        {
            cv::GaussianBlur(img, img, cv::Size(kerx, kery), 0);
        }
    }
}

void preprocessor::detectEdgesImg(int algType, int thr1, int thr2)
{
    if(algType == 0)
    {
        std::cout << "applying canny to neko img\n";
        for(auto& img : preprocessor::animeNekoGirls)
        {
            cv::Canny(img, img, thr1, thr2);
        }

        std::cout << "applying canny to non_neko img\n";
        for(auto& img : preprocessor::nonAnimeNekoGirls)
        {
            cv::Canny(img, img, thr1, thr2);
        }
    }
}

void preprocessor::detectContours()
{
    std::vector<std::vector<cv::Point>> conts;

    std::cout << "applying thresholding and finding contours in neko img\n";
    for(auto& img : preprocessor::animeNekoGirls)
    {
        cv::threshold(img, img, 125, 255, cv::THRESH_BINARY);
        cv::findContours(img, conts, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
        for(size_t i = 0; i < conts.size(); i++)
        {
            cv::drawContours(img, {conts}, i, cv::Scalar(255,0,0), 2);
        }
    }

    std::cout << "applying thresholding and finding contours in non-neko img\n";
    for(auto& img : preprocessor::nonAnimeNekoGirls)
    {
        cv::threshold(img, img, 80, 255, cv::THRESH_BINARY);
        cv::findContours(img, conts, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
        for(size_t i = 0; i < conts.size(); i++)
        {
            cv::drawContours(img, {conts}, i, cv::Scalar(255,0,0), 2);
        }
    }
}

void preprocessor::harrisImg()
{
    std::cout << "applying harris to neko img\n";
    for(auto& img : preprocessor::animeNekoGirls)
    {
        img.convertTo(img, CV_32F);
        cv::cornerHarris(img, img, 2, 1, 0.1);
    }

    std::cout << "applying harris to non_neko img\n";
    for(auto& img : preprocessor::nonAnimeNekoGirls)
    {
        img.convertTo(img, CV_32F);
        cv::cornerHarris(img, img, 2, 5, 0.03);
    }
}

void preprocessor::SIFTimg()
{
    cv::Ptr<cv::SIFT> SIFTdetector = cv::SIFT::create();

    for(auto& img : preprocessor::animeNekoGirls)
    {
        std::vector<cv::KeyPoint> kpoints;
        SIFTdetector->detect(img, kpoints);
        cv::Mat img_kpoints;
    }
}

bool preprocessor::boolDetectHuman()
{
    cv::HOGDescriptor hog;
    hog.setSVMDetector(cv::HOGDescriptor::getDefaultPeopleDetector());
    cv::Mat img = cv::imread("/home/simtoon/img.jpg");

    std::vector<cv::Rect> ppl;
    hog.detectMultiScale(img, ppl);

    for (cv::Rect rect : ppl)
    {
        cv::rectangle(img, rect, cv::Scalar(0, 0, 255), 2);
    }

    if(ppl.empty())
    {
        return false;
    }
    else
    {
        return true;
        cv::imshow("humanzz", img);
        cv::waitKey();  
    }
    return false;
}

void preprocessor::imwriteToDiskImg()
{
    std::cout << "writing pre-processed neko img\n";
    for(size_t i = 0; i < preprocessor::animeNekoGirls.size(); i++)
    {
        //preprocessor::animeNekoGirls[i].convertTo(preprocessor::animeNekoGirls[i], CV_16UC3, 255,255);
        cv::imwrite("/home/simtoon/datasets/processed/neko/" + std::to_string(i) + ".jpeg", preprocessor::animeNekoGirls[i] /** 255*/);
    }

    std::cout << "writing pre-processed non_neko img\n";
    for(size_t i = 0; i < preprocessor::nonAnimeNekoGirls.size(); i++)
    {
        //preprocessor::nonAnimeNekoGirls[i].convertTo(preprocessor::nonAnimeNekoGirls[i], CV_16UC3, 255,255);
        cv::imwrite("/home/simtoon/datasets/processed/non_neko/" + std::to_string(i) + ".jpeg", preprocessor::nonAnimeNekoGirls[i] /** 255*/);
    }
}


int main()
{
    preprocessor Preprocessor;

    Preprocessor.boolDetectHuman();

    Preprocessor.loadImg();
    Preprocessor.resizeImg();
    //Preprocessor.normalizeImg(); fucked up, not calling until a fix is found
    std::cout << "Press any key to proceed to the next step";
    std::cin.ignore();
    Preprocessor.convertToGrayscaleImg();
    Preprocessor.imwriteToDiskImg();
    std::cout << "Press any key to proceed to the next step";
    std::cin.ignore();
    Preprocessor.blurImg(0, 5, 5);
    Preprocessor.imwriteToDiskImg();
    std::cout << "Press any key to proceed to the next step";
    std::cin.ignore();
    //Preprocessor.detectContours();
    //Preprocessor.imwriteToDiskImg();
    //std::cout << "Press any key to proceed to the next step";
    //std::cin.ignore();
    //Preprocessor.detectEdgesImg(0, 200, 350);
    // Preprocessor.harrisImg();
    // Preprocessor.imwriteToDiskImg();
    // std::cout << "Press any key to proceed to the next step";
    // std::cin.ignore();
    //Preprocessor.detectEdgesImg(0, 200, 300);
    //Preprocessor.imwriteToDiskImg();
}