#include "MultiScaleImageCompareModel.h"
#include "ImageCompareModel.h"
//#include "../3rd/cvplot/cvplot.h"


void MultiScaleImageCompareModel::setBaseLevel(const ImageCompareModel* pModel)
{
    ImageCompareModel* p = new ImageCompareModel;
    *p = *pModel;
    p->genMask();
    clear();
    mMultiScaleModels.resize(1);
    mMultiScaleModels[0] = p;
}

void MultiScaleImageCompareModel::genMultiScale()
{
    resetMaxLevel();
    while (getLevel() >= 1)
    {
        ImageCompareModel* pScaledModel = mMultiScaleModels.back()->scale(mScaleStep);
        mMultiScaleModels.push_back(pScaledModel);
        downLevel();
    }
}

const ImageCompareModel* MultiScaleImageCompareModel::getCmpModel(int level)
{
    if (level >= 0 && level < mLevelNum)
    {
        return mMultiScaleModels[level];
    }
    else
    {
        return NULL;
    }
}

void MultiScaleImageCompareModel::clear()
{
    for_each(mMultiScaleModels.begin(), mMultiScaleModels.end(), [&](ImageCompareModel* p)
    {
        delete p;
    });
}

void MultiScaleImageCompareModel::proc(void *pData)
{
    ImageCompareData* pCmpData = (ImageCompareData*)pData;
    MultiScaleImage* pMSImg = pCmpData->getMSI();
    resetMaxLevel();
    float startAngle = pCmpData->getStartAngle();
    float endAngle = pCmpData->getEndAngle();
    float angleRange = (endAngle - startAngle) / 4.0;
    vector<Range> angleRangeVec(1, Range(0, 360));

    ImageCompareModel::RotateData* pRotateData = pCmpData->getRotateData();
    while (getLevel() >= 0)
    {
        const ImageCompareModel* pModel = mMultiScaleModels[getLevel()];
        assert(pModel);
        Mat img = pMSImg->getImg(getLevel());
        assert(!img.empty());


#ifdef DEBUG_VIEW_INTERNAL_MAT
        Mat viewImg = img / 255.0;
        imshow("img", viewImg);
#endif 

        if (angleRangeVec.size() == 1 && angleRangeVec.front().size() >= 360)
        {
            pModel->rotateMatchData(img, pRotateData, 1.0, startAngle, endAngle);
            ImageCompareModel::genCandidateAngleRanges(pRotateData->mDisValVec, 1, angleRangeVec);
            if (angleRangeVec.empty())
            {
                pRotateData->mDisValVec.clear();
                pRotateData->mRImgVec.clear();
                angleRangeVec.resize(1);
                angleRangeVec[0] = Range(0, 360);
            }
        }
        else
        {
            Mat disMat;
            pModel->rotateMatchData(img, pRotateData, angleRangeVec, 1.0, disMat);
            ImageCompareModel::genCandidateAngleRanges(disMat, 1, angleRangeVec, 0.5);
//             pModel->rotateMatchData(img, pRotateData, 1.0, angleRangeVec);
// 
//             double bestAngle = pRotateData->bestAngle();
//             angleRangeVec.clear();
//             Range r;
//             r.start = bestAngle - angleRange;
//             r.end = bestAngle + angleRange;
//             angleRangeVec.push_back(r);
        }


#ifdef DEBUG_VIEW_INTERNAL_MAT
//         Mat viewBestRImg = pRotateData->bestRImg() / 255.0;
//         imshow("bestRImg", viewBestRImg);
#endif 

#ifdef DEBUG_VIEW_PLOT
        {
            stringstream ss;
            ss << "multi_scale_comp_plot" << getLevel();
            CvPlot::clear(ss.str());
            CvPlot::plot<float>(ss.str(), &(pRotateData->mDisValVec[0]),
                pRotateData->mDisValVec.size());
        }
        {
            stringstream ss;
            ss << "multi_scale_comp_plot_0_360_" << getLevel();
            CvPlot::clear(ss.str());
            ImageCompareModel::RotateData testRotateData = *pRotateData;
            pModel->rotateMatchData(img, &testRotateData, 1.0, startAngle, endAngle);
            CvPlot::plot<float>(ss.str(), &(testRotateData.mDisValVec[0]),
                testRotateData.mDisValVec.size());
        }
#endif

        downLevel();
    }
}