#include "rawimage.h"
#include <QDebug>
#include <opencv2/highgui.hpp>

RawImage::ImgType CV2Type(int cvtype)
{
    switch (cvtype)
    {
    case CV_8U:
        return RawImage::UINT8;
    case CV_16U:
        return RawImage::UINT16;
    case CV_32F:
        return RawImage::FLOAT32;
    case CV_8UC3:
        return RawImage::UINT8C3;
    case CV_16UC3:
        return RawImage::UINT16C3;
    case CV_32FC3:
        return RawImage::FLOAT32C3;
    default:
        return RawImage::UNKNOWN;
    }
}

int Type2CV(RawImage::ImgType type)
{
    switch (type)
    {
    case RawImage::UINT8:
        return CV_8U;
    case RawImage::UINT16:
        return CV_16U;
    case RawImage::FLOAT32:
        return CV_32F;
    case RawImage::UINT8C3:
        return CV_8UC3;
    case RawImage::UINT16C3:
        return CV_16UC3;
    case RawImage::FLOAT32C3:
        return CV_32FC3;
    case RawImage::UNKNOWN:
        return CV_8S;
    default:
        return CV_8U;
    }
}

RawImage::RawImage()
{
}

RawImage::RawImage(int w, int h, ImgType type)
{
    m_img.create(h, w, Type2CV(type));
}

RawImage::RawImage(const RawImage &d)
{
    d.m_img.copyTo(m_img);
}

bool RawImage::imageStats(double *mean, double *stdDev, double *median, double *min, double *max) const
{
    cv::Scalar meanS, stdDevS;

    qDebug() << m_img.type();
    cv::meanStdDev(m_img, meanS, stdDevS);
    if(min && max)cv::minMaxIdx(m_img, min, max);

    int histSize = 256;
    if(m_img.type() == CV_16U || m_img.type() == CV_32F)histSize = 65536;
    float range[] = {0, (float)histSize};
    const float *ranges[] = {range};
    cv::Mat hist;
    cv::calcHist(&m_img, 1, nullptr, cv::Mat(), hist, 1, &histSize, ranges);

    if(mean)*mean = meanS[0];
    if(stdDev)*stdDev = stdDevS[0];
    size_t halfImageSize = size()/2;
    if(median)
    {
        size_t medianSum = 0;
        for(int i=0; i < histSize; i++)
        {
            medianSum += hist.at<float>(0, i);
            if(medianSum >= halfImageSize)
            {
                *median = i;
                break;
            }
        }
    }

    return true;
}

void RawImage::rect(int &x, int &y, int w, int h, std::vector<double> &r) const
{
    r.resize(w*h);
    x -= w/2;
    y -= h/2;
    if(x<0)x = 0;
    if(y<0)y = 0;
    if(x+w >= m_img.cols)x = m_img.cols-w;
    if(y+h >= m_img.rows)y = m_img.rows-h;
    cv::Mat roiImg(m_img, cv::Rect(x, y, w, h));
    cv::Mat doubleMat;
    roiImg.convertTo(doubleMat, CV_64F);
    r = std::vector<double>(doubleMat.begin<double>(), doubleMat.end<double>());
}

int RawImage::findPeaks(double background, double distance, std::vector<Peak> &peaks) const
{
    std::vector<std::vector<cv::Point>> contours;

    cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(distance, distance));

    cv::Mat mask, dilate, locMax, result;
    cv::dilate(m_img, dilate, kernel);
    cv::compare(m_img, dilate, locMax, cv::CMP_GE);
    cv::compare(m_img, cv::Scalar(background), mask, cv::CMP_GT);
    cv::bitwise_and(locMax, mask, result);

    cv::findContours(result, contours, cv::noArray(), cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
    peaks.reserve(contours.size());
    for(auto contour : contours)
    {
        peaks.push_back(Peak(1, contour[0].x, contour[0].y));
    }

    return peaks.size();
}

RawImage* RawImage::medianFilter() const
{
    RawImage *ret = new RawImage();
    cv::medianBlur(m_img, ret->m_img, 3);
    return ret;
}

void RawImage::quarter()
{

}

uint32_t RawImage::width() const
{
    return m_img.cols;
}

uint32_t RawImage::height() const
{
    return m_img.rows;
}

uint32_t RawImage::size() const
{
    return width()*height();
}

RawImage::ImgType RawImage::type() const
{
    switch(m_img.type())
    {
    case CV_8U:
        return UINT8;
    case CV_16U:
        return UINT16;
    case CV_32F:
        return FLOAT32;
    default:
        return UNKNOWN;
    }
}

void* RawImage::data()
{
    return m_img.ptr();
}

const void *RawImage::data() const
{
    return m_img.ptr();
}