#include "WheelModel.h"
#include "TempImage.h"
#include "ImageCompareModel.h"
#include "qjsonobject.h"
#pragma execution_character_set("utf-8")
enum TEM_MODEL{
	emTypeModelSuccess = 0,
	emTypeModelWarning,
	emTypeModelError
};
WheelModel::WheelModel()
{
	m_strModelID = QString();
	m_dHeight = 0;      //mm
	m_dDiameter = 0;    //mm
	m_passageway = 0;
	m_nRotate = 0;
	bDetect = false;
	m_nCount = 0;
	m_pChannelInfo = NULL;;
	m_pTempImage = NULL;;
	m_pDetectModel = new ImageCompareModel;
	m_pTempImage = new TempImage;
}


WheelModel::~WheelModel()
{
	if (m_pDetectModel) {
		delete m_pDetectModel;
		m_pDetectModel = NULL;
	}
	if (m_pTempImage) {
		delete m_pTempImage;
		m_pTempImage = NULL;
	}
	if (m_pChannelInfo) {
		delete m_pChannelInfo;
		m_pChannelInfo = NULL;
	}
}

void WheelModel::clearCount()
{
	m_nCount = 0;
}

void WheelModel::increCount(int n /*= 1*/)
{
	m_nCount += n;
}
int WheelModel::getCount() const
{
	return m_nCount;
}
bool WheelModel::initTmpImage(const QString&strBase)
{
	if (!m_pTempImage) {
		m_pTempImage = new TempImage;
	}
	m_pTempImage->init(strBase, m_strModelID);
	return true;
}

bool WheelModel::initComModel(const QString&strBase)
{
	if (!m_pDetectModel) {
		m_pDetectModel = new ImageCompareModel;
	}
	QString str = strBase + "template\\" + m_strModelID + "\\model.yml";
	std::string strs = str.toLocal8Bit().toStdString();
	bool bFlags = m_pDetectModel->readFromFile(strs/*str.toLatin1().data()*/);
	if (!bFlags) {
 		m_pDetectModel->train(m_pTempImage->getImgVector());
		bFlags = m_pDetectModel->save2file(strs/*string((const char *)str.toLocal8Bit())*/);
	}
	return bFlags;
}

void WheelModel::readJson(QJsonObject *pJson)
{
	if (!pJson) {
		return;
	}
	QJsonObject obj = pJson->value(m_strModelID).toObject();
	if (!obj.empty()) {
		m_passageway = obj.value("channel").toInt();
		bDetect = obj.value("detect").toBool();
		m_bAddTrain = obj.value("addTrain").toBool(true);
	}
}

void WheelModel::saveJson(class QJsonObject *pJson)
{
	if (!pJson) {
		return;
	}
	QJsonObject obj;
	obj.insert("channel", m_passageway);
	obj.insert("detect", bDetect);
	obj.insert("addTrain", m_bAddTrain);
	pJson->insert(m_strModelID, obj);
}

double WheelModel::getDiameter() const
{
	return m_dDiameter;
}

void WheelModel::setDiameter(double dValue)
{
	m_dDiameter = dValue;
}

int WheelModel::getChannel() const
{
	return m_passageway;
}

void WheelModel::setChannel(int nValue)
{
	m_passageway = nValue;
}

double WheelModel::getThickness() const
{
	return m_dHeight;
}

void WheelModel::setThickness(double dValue)
{
	m_dHeight = dValue;
}

bool WheelModel::getDetectState() const
{
	return bDetect;
}

void WheelModel::setDetectState(bool bValue)
{
	bDetect = bValue;
}

void WheelModel::setRepeatNum(int nValue)
{
	m_nRotate = nValue;
	if (m_pDetectModel)
	{
		m_pDetectModel->setRepeatNum(nValue);
	}
}

int WheelModel::getRepeatNum() const
{
	return m_pDetectModel->getRepeatNum();
	//return m_nRotate;
}

ICompareModel * WheelModel::getImageComModel() const
{
// 	if (!m_pDetectModel)
// 	{
// 		m_pDetectModel = new ImageCompareModel;
// 	}
	return m_pDetectModel;
}

void WheelModel::setImageComModel(ICompareModel *p)
{
	m_pDetectModel = p;
}

TempImage * WheelModel::getTempImage() const
{
	return m_pTempImage;
}

QString WheelModel::getModelID() const
{
	return m_strModelID;
}

void WheelModel::setModelID(QString id)
{
	m_strModelID = id;
}

void WheelModel::setPicPath(QString str)
{
	m_strPath = str;
}

QString WheelModel::getPicPath() const
{
	return m_strPath;
}

int WheelModel::getImageModel() const
{
	if (m_pDetectModel->getBaseImg().data == NULL){
		return emTypeModelWarning;
	}
	else{
		if (m_pDetectModel->getFalseSampleMinDis() >= m_pDetectModel->getDisMax()){
			return emTypeModelSuccess;
		}
		else{
			return emTypeModelError;
		}	
	}
}

bool WheelModel::reloadTmpImage(const QString& strBase)
{
	if (!m_pTempImage) {
		m_pTempImage = new TempImage;
	}
	m_pTempImage->reload(strBase, m_strModelID);
	return true;
}

int WheelModel::getImgCount() const
{
	if (m_pTempImage != NULL)
		return m_pTempImage->getImgCount();
	else
		return 0;
}