#include "MainFrame.h"
#include "ui_MainFrame.h"
#include "colossusbase.h"
#include <QHeaderView>
#pragma execution_character_set("utf-8")

QString showVariant(const AlgoParamType type, const QVariant &var) {
	switch (type)
	{
	case LP_INT:
	{
		return QString::number(var.toInt());
		break;
	}
	case LP_BOOLEAN:
	case LP_STRING:
	{
		return var.toString();
		break;
	}
	case LP_DOUBLE:
	{
		return QString::number(var.toDouble());
		break;
	}
	case LP_IMAGE:
	{
		if (!var.isNull())
		{
			QImage img = var.value<QImage>();
			if (!img.isNull())
			{
				return QString("[%1*%2]").arg(img.width()).arg(img.height());
			}
		}
		break;
	}
	case LP_POINTF:
	{
		QPointF pt = var.toPointF();
		QString str = "(%1,%2)"; str = str.arg(pt.x()).arg(pt.y());
		return str;
		break;
	}
	case LP_POINT:
	{
		QPoint pt = var.toPoint();
		QString str = "(%1,%2)"; str = str.arg(pt.x()).arg(pt.y());
		return str;
		break;
	}
	case LP_MAT:
	{
		cv::Mat matResult = var.value<cv::Mat>();
		return QString("[%1*%2]").arg(matResult.cols).arg(matResult.rows);
		break;
	}
	case LP_ROI:
	{
		LP_DETECTOR_ROI_DATA roi = var.value<LP_DETECTOR_ROI_DATA>();

		int nCount = roi.records.size();
		if (nCount > 0)
		{
			for (int i = 0; i < nCount; i++)
			{
				Item_List record = roi.records.at(i);
				int nItemCount = record.size();
				for (int j = 0; j < nItemCount; j++)
				{
					Feature_List item = record.at(j);
					switch (item.first)
					{
					case RECTANGLE:
					case ELLIPSE:
					{
						QString strResult = "(%1,%2,%3,%4)";
						strResult = strResult.arg(item.second.at(0)).arg(item.second.at(1)).arg(item.second.at(2)).arg(item.second.at(3));
						return strResult;
						break;
					}
					case CIRCLE:
					{
						QString strResult = "(%1,%2,%3)";
						strResult = strResult.arg(item.second.at(0)).arg(item.second.at(1)).arg(item.second.at(2));
						return strResult;
						break;
					}
					case POLY:
					{
						break;
					}
					default:
						break;
					}
				}
			}
		}
		break;
	}
	default:
		break;
	}

	return var.toString();
}

CMainFrame::CMainFrame(QWidget *parent)
{
	m_pDE = NULL;
	m_pSolutionMgr = NULL;
	m_pCurrentSolution = NULL;
	m_pCurrentTask = NULL;
	m_pCurrentAlgo = NULL;
	m_pSrcItem = NULL;
	ui = new Ui::MainFrame;
	ui->setupUi(this);
	setContextMenuPolicy(Qt::NoContextMenu);
	setWindowIcon(QIcon(":/img/resource/app.png"));
	connect(ui->treeWidget, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(OnTreeItemClick()));
	ui->treeWidget->setStyleSheet("QTreeWidget::item{height:30px}");

	ui->tableWidget_2->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(ui->tableWidget_2, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(OnParamPopMenu(const QPoint&)));
	connect(ui->tableWidget_2, SIGNAL(cellDoubleClicked(int, int)), this, SLOT(OnRunAlgo()));
	connect(ui->tableWidget_2, SIGNAL(cellClicked(int, int)), this, SLOT(OnInitCurrentAlgoParam()));

	ui->tableWidget->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(ui->tableWidget, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(OnParamListPopMenu(const QPoint&)));
	connect(ui->tableWidget, SIGNAL(cellChanged(int, int)), this, SLOT(OnCellChanged(int, int)));
	connect(ui->tableWidget, SIGNAL(cellClicked(int, int)), this, SLOT(OnCellClicked(int, int)));
//	connect(ui->listWidget, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(OnListItemClick()));
//	connect(ui->listWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(OnListItemDoubleClick()));

//	ui->listWidget->setContextMenuPolicy(Qt::CustomContextMenu);
//	connect(ui->listWidget, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(OnListWidgetPopMenu(const QPoint&)));

	ui->gv_input->setContextMenuPolicy(Qt::CustomContextMenu);
	connect(ui->gv_input, SIGNAL(customContextMenuRequested(const QPoint&)), this, SLOT(OnGvInputWidgetPopMenu(const QPoint&)));


	connect(ui->pushButton_5, SIGNAL(clicked()), this, SLOT(OnClearResult()));
	connect(ui->m_pbLoadImage, SIGNAL(clicked()), this, SLOT(onLoadImage()));
	//connect(ui->menubar, SIGNAL(triggered(QAction *)), this, SLOT(OnMainMenuTrigger(QAction*)));
	connect(ui->m_pbSaveBtn, SIGNAL(clicked()), this, SLOT(OnTrigger()));
	connect(this, SIGNAL(sgShowStatus(QString)), this, SLOT(OnShowStatus(QString)));

	ui->gv_input->setInfoLabel(ui->label_pixel_info);
	connect(ui->gv_input, SIGNAL(imgScaled(QTransform, QPointF)), ui->gv_output, SLOT(scaleImg(QTransform, QPointF)));
	connect(ui->gv_input, SIGNAL(imgMoved(QPointF)), ui->gv_output, SLOT(moveImg(QPointF)));
	connect(ui->gv_output, SIGNAL(imgScaled(QTransform, QPointF)), ui->gv_input, SLOT(scaleImg(QTransform, QPointF)));
	connect(ui->gv_output, SIGNAL(imgMoved(QPointF)), ui->gv_input, SLOT(moveImg(QPointF)));
	connect(ui->gv_output, SIGNAL(pixelSelected(QPoint)), ui->gv_input, SLOT(selectPixel(QPoint)));

	connect(this, SIGNAL(sgShowCameraImage(QImage)), this, SLOT(OnShowCameraImage(QImage)));
	m_plablStatus = new QLabel(this);
	ui->statusBar->addWidget(m_plablStatus);
	_pSaveStatus = ui->label_SaveStatus;

}

CMainFrame::~CMainFrame()
{
	if (m_plablStatus)
	{
		delete m_plablStatus;
		m_plablStatus = NULL;
	}
	if (ui)
	{
		delete ui;
		ui = NULL;
	}
}

bool CMainFrame::OnMainMenuTrigger(QAction* pAction)
{
	if (pAction)
	{
		QString strName = pAction->objectName();
		if ("action_save" == strName)
		{
			if (_pOldTask){
				if (!oldMat.empty())
					_pOldTask->GetTaskInfo()->templateImg = oldMat;
			}
			return false;
		}
	}

	return false;
}

void CMainFrame::OnTrigger()
{
	QString strObj = sender()->objectName();
	if ("m_pbSaveBtn" == strObj)
	{
		if (_pOldTask){
			if (!oldMat.empty())
				_pOldTask->GetTaskInfo()->templateImg = oldMat;
		}
		if (m_pDE && m_pSolutionMgr->SaveByNames(m_TaskChangeList))
		{
			if (_pSaveStatus)
			{
				_pSaveStatus->setText(QObject::tr("     标定数据保存完成！"));
				QTimer::singleShot(1500, [&](){
					_pSaveStatus->setText(""); 
					update();
				});
				m_TaskChangeList.clear();
				SystemStateInfo::bParamStateFlag = false;
			}
		}
		else
		{
			if (_pSaveStatus)
			{
				_pSaveStatus->setText(QObject::tr("     保存失败！"));
				QTimer::singleShot(2000, [&](){_pSaveStatus->setText(""); });
				update();
			}
		}
	}
}

bool CMainFrame::Initialize(IDetectorEngine* lpDE)
{
	if (!lpDE)
		return false;

	m_pDE = lpDE;
	m_pSolutionMgr = m_pDE->getSolutionMgr();
	if (!m_pSolutionMgr)
		return false;
	return true;
}

bool CMainFrame::InitGraphView()
{
	if (!m_pSolutionMgr)
		return false;

	if (!ui->treeWidget)
		return false;
	_pOldTask = nullptr;
	ui->treeWidget->clear();
	ui->treeWidget->setCurrentItem(NULL);

	ui->tableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
	ui->tableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
	ui->tableWidget->verticalHeader()->setHidden(true);

	ui->tableWidget_2->setSelectionBehavior(QAbstractItemView::SelectRows);
	ui->tableWidget_2->setSelectionMode(QAbstractItemView::SingleSelection);
	ui->tableWidget_2->verticalHeader()->setHidden(true);
	ui->tableWidget_2->setEditTriggers(QAbstractItemView::NoEditTriggers);
	ui->tableWidget_2->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
	ui->tableWidget_2->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
	ui->tableWidget_2->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);

	ui->textEdit->setWordWrapMode(QTextOption::NoWrap);

	{	/*获取所有的solution*/
		QMap<QString, IDetectorSolution*> tmp = m_pSolutionMgr->GetAllSolutions();
		for (QMap<QString, IDetectorSolution*>::iterator it = tmp.begin(); it!= tmp.end(); ++it)
		{
			IDetectorSolution* tmpSolution = *it;
			if (tmpSolution != nullptr)
			{
				PLP_DETECTOR_SOLUTION pSolutionInfo = tmpSolution->GetSolutionInfo();
				QTreeWidgetItem *solutionItem = NULL;
				QString strText = pSolutionInfo->strName;// +tr("(√)");
				solutionItem = new QTreeWidgetItem(ui->treeWidget, QStringList(strText));
				solutionItem->setData(0, Qt::UserRole, tmpSolution->GetID());
				solutionItem->setData(1, Qt::UserRole, SOLUTION);
				solutionItem->setData(2, Qt::UserRole, it.key());

				QMap<QString, IDetectorTask*> mItemMap = tmpSolution->GetAllTasks();
				/*设置template模板在最前面*/
				QMap<QString, IDetectorTask*>::iterator it = mItemMap.find("template");
				if (it != mItemMap.end())
				{
					int nID = (*it)->GetTaskInfo()->nID;
					QString strName = (*it)->GetTaskInfo()->strName;
					QTreeWidgetItem *TaskItem = new QTreeWidgetItem(solutionItem, QStringList(strName));
					TaskItem->setData(0, Qt::UserRole, nID);
					TaskItem->setData(1, Qt::UserRole, Task);
					solutionItem->addChild(TaskItem);
				}

				for (QMap<QString, IDetectorTask*>::iterator its = mItemMap.begin(); its != mItemMap.end(); ++its)
				{	
					int nID = (*its)->GetTaskInfo()->nID;
					QString strName = (*its)->GetTaskInfo()->strName;
					if(strName.contains("template")||strName == "template")
						continue;
					QTreeWidgetItem *TaskItem = new QTreeWidgetItem(solutionItem, QStringList(strName));
					TaskItem->setData(0, Qt::UserRole, nID);
					TaskItem->setData(1, Qt::UserRole, Task);
					solutionItem->addChild(TaskItem);
				}
				ui->treeWidget->expandItem(solutionItem);
				ui->treeWidget->setCurrentItem(solutionItem);
			}
		}
	}
	m_TaskChangeList.clear();
	if (!InitCurrentTask())
		return true;
	return true;
}

bool CMainFrame::InitCurrentTask()
{
	if (!InitCurrentNode())
		return false;

	ui->tableWidget->setRowCount(0);
	ui->tableWidget->clearContents();
	ui->tableWidget_2->setRowCount(0);
	ui->tableWidget_2->clearContents();
	ui->gv_input->clear();
	ui->gv_output->clear();

	ui->textEdit->clear();
	IDetectorTask* ptask = currentTask();
	if (ptask)
	{
		if (_pOldTask==nullptr)
		{
			_pOldTask = ptask;
			oldMat = ptask->GetTaskInfo()->templateImg;
		}
		if (_pOldTask != ptask){
			_pOldTask->GetTaskInfo()->templateImg = oldMat;
			_pOldTask = ptask;
			oldMat = ptask->GetTaskInfo()->templateImg;
		}

		QMap<int, IDetectorAlgorithm*> mAlg = m_pCurrentTask->GetAllAlgorithms();
		int nIndex = 0;
		for (QMap<int, IDetectorAlgorithm*>::iterator it = mAlg.begin();it!=mAlg.end();it++)
		{
			IDetectorAlgorithm* pAlg = *it;
			if (pAlg)
			{
				ui->tableWidget_2->setRowCount(nIndex + 1);
				QTableWidgetItem* pItem = NULL;
				if (m_pCurrentTask->GetRunAlgo() && pAlg->GetID() == m_pCurrentTask->GetRunAlgo()->GetID())
				{
					QString strText = QString::number(pAlg->GetID()) + tr("(√)");
					pItem = new QTableWidgetItem(strText);
					pItem->setData(Qt::UserRole, pAlg->GetID());
					ui->tableWidget_2->setItem(nIndex, 0, pItem);
				}
				else
				{
					pItem = new QTableWidgetItem(QString::number(pAlg->GetID()));
					pItem->setData(Qt::UserRole, pAlg->GetID());
					ui->tableWidget_2->setItem(nIndex, 0, pItem);
				}

				ui->tableWidget_2->setItem(nIndex, 1, new QTableWidgetItem(QObject::tr(pAlg->GetAlgorithmInfo()->strName.toStdString().c_str())));
				ui->tableWidget_2->setItem(nIndex, 2, new QTableWidgetItem(QString::number(pAlg->GetAlgorithmInfo()->nRoiID)));

				if (nIndex == 0)
				{
					ui->tableWidget_2->setCurrentCell(0, QItemSelectionModel::Select);
				}
			}
			nIndex++;
		}

		if (m_pCurrentTask->GetTaskInfo()->templateImg.data == NULL)
		{
			QString strExePath = QCoreApplication::applicationDirPath();
			QString strImagePath = strExePath + LP_DETECTOR_BUSSINESS_IMAGE_DIR;
			QString strImageName = strImagePath + QString::number(m_pCurrentSolution->GetID()) + "_" + QString::number(m_pCurrentTask->GetID()) + ".bmp";
			std::string strPath = strImageName.toLocal8Bit().toStdString();
			m_pCurrentTask->GetTaskInfo()->templateImg = cv::imread(strPath, CV_LOAD_IMAGE_GRAYSCALE);
		}
		ColossusBase::showImage(m_pCurrentTask->GetTaskInfo()->templateImg, ui->gv_input);
	}

	return true;
}

bool CMainFrame::InitCurrentSolution(QTreeWidgetItem* pItem, IDetectorSolution* pSolution)
{
	if (!pSolution || !pItem)
		return false;

	pItem->takeChildren();
	QStringList strKey = pSolution->GetAllTaskNames();
	for (int n = 0; n < strKey.size(); n++)
	{
		IDetectorTask* pTask = pSolution->GetTaskByName(strKey[n]);
		if (pTask)
		{
			PLP_DETECTOR_TASK pTaskInfo = pTask->GetTaskInfo();

			QTreeWidgetItem *TaskItem = new QTreeWidgetItem(pItem, QStringList(pTaskInfo->strName));
			TaskItem->setData(0, Qt::UserRole, pTask->GetID());
			TaskItem->setData(1, Qt::UserRole, Task);

			pItem->addChild(TaskItem);
		}
	}
	return true;
}

bool CMainFrame::OnSetRunSolution()
{
	if (!currentSolution())
		return false;

	if ((NodeType)ui->treeWidget->currentItem()->data(1, Qt::UserRole).toInt() == SOLUTION)
	{
		IDetectorSolution* pRunSolution = m_pSolutionMgr->GetRunSolution();
		if (pRunSolution)
		{
			if (pRunSolution->GetID() == m_pCurrentSolution->GetID())
			{
				QString strName = pRunSolution->GetSolutionName();
				m_pSolutionMgr->SetRunSolution(strName);
				ui->treeWidget->currentItem()->setText(0, m_pCurrentSolution->GetSolutionInfo()->strName);
				return true;
			}
			else
			{
				int nItemCount = ui->treeWidget->topLevelItemCount();
				for (int i = 0; i < nItemCount; i++)
				{
					QTreeWidgetItem* pItem = ui->treeWidget->topLevelItem(i);
					if (pItem->data(0, Qt::UserRole).toString() == pRunSolution->GetSolutionName())
					{
						pItem->setText(0, pRunSolution->GetSolutionInfo()->strName);
						break;
					}
				}

				m_pSolutionMgr->SetRunSolution(m_pCurrentSolution->GetSolutionName());
				QString strText = m_pCurrentSolution->GetSolutionInfo()->strName + tr("(√)");
				ui->treeWidget->currentItem()->setText(0, strText);
				return true;
			}
		}
		else
		{
			m_pSolutionMgr->SetRunSolution(m_pCurrentSolution->GetSolutionName());
			QString strText = m_pCurrentSolution->GetSolutionInfo()->strName + tr("(√)");
			ui->treeWidget->currentItem()->setText(0, strText);
			return true;
		}
	}

	return false;
}

bool CMainFrame::OnBatchLoadImage(bool bReLoad)
{
	if (!currentTask())
		return false;

	QString strDefaultDirPath = m_pCurrentTask->GetTaskInfo()->strDirPath;
	QStringList strFileNamesList = QFileDialog::getOpenFileNames(this, "open file", strDefaultDirPath, "Images (*.bmp *.png *.xpm *.jpg)");
	if (strFileNamesList.size() <= 0)
	{
		return false;
	}

// 	ui->listWidget->clear();
// 	ui->listWidget->setSpacing(12);
// 	ui->listWidget->setMovement(QListView::Static);
// 	ui->listWidget->setViewMode(QListView::IconMode);
// 	ui->listWidget->setWrapping(false);
// 	ui->listWidget->setFlow(QListView::LeftToRight);

// 	for (int i = 0; i < strFileNamesList.size(); i++)
// 	{
// 		QListWidgetItem* item = new QListWidgetItem("Test", ui->listWidget);
// 		item->setData(Qt::UserRole, strFileNamesList.at(i));
// 		item->setText(strFileNamesList.at(i).split("/").last());
// 		ui->listWidget->addItem(item);
// 	}

	QString strFileName = strFileNamesList[0];
	std::string strpath = strFileName.toLocal8Bit().toStdString();//中文路径支持
	//cv::Mat m_img = cv::imread(strpath, CV_LOAD_IMAGE_UNCHANGED);
	m_pCurrentTask->GetTaskInfo()->templateImg = cv::imread(strpath, CV_LOAD_IMAGE_GRAYSCALE);
	oldMat = m_pCurrentTask->GetTaskInfo()->templateImg;
	if (ColossusBase::showImage(m_pCurrentTask->GetTaskInfo()->templateImg, ui->gv_input))
	{
		m_pCurrentTask->GetTaskInfo()->strImageName = strFileName.split("/").last();
	}
	return true;
}

bool CMainFrame::OnCopyFileTitle()
{
//	QListWidgetItem* item = ui->listWidget->currentItem();

// 	if (item)
// 	{
// 		QClipboard *clipboard = QApplication::clipboard();
// 		clipboard->setText(item->text());
// 	}

	return true;
}

void CMainFrame::OnShowCameraImage(QImage img)
{
	m_pCurrentTask->GetTaskInfo()->templateImg = ColossusBase::QImage2cvMat(img).clone();

	if (ColossusBase::showImage(img, ui->gv_input))
	{
		return;
	}
}

void __stdcall ImageEventHandler(void * callBackOwner, QImage& img, int nDeviceID)
{
	CMainFrame* p = (CMainFrame*)(callBackOwner);
	emit p->sgShowCameraImage(img);
}

bool CMainFrame::OnSnapImage()
{
// 	if (!currentTask())
// 		return false;
// 
// 	DeviceType type;
// 	IDetectorCameraDevice* pCamera = (IDetectorCameraDevice*)m_pDeviceMgr->GetDevice(m_pCurrentTask->GetTaskInfo()->nCameraID, type);
// 	if (!pCamera && type != CAMERA)
// 		return false;
// 
// 	pCamera->SnapImage(this, ImageEventHandler);
	return true;
}

bool CMainFrame::InitCurrentNode()
{
	if (!m_pSolutionMgr)
		return false;

	QTreeWidgetItem *currentItem = ui->treeWidget->currentItem();
	if (currentItem)
	{
		if (currentItem->data(1, Qt::UserRole).toInt() == SOLUTION)
		{
			if (m_pCurrentSolution)
				m_pCurrentSolution->ClearUserParamValue();

			QString nSolutionID = currentItem->data(0, Qt::UserRole).toString();
			m_pCurrentSolution = m_pSolutionMgr->GetSolutionByID(nSolutionID);
			if (!m_pCurrentSolution)
				return false;

			m_pCurrentSolution->LoadUserParamValue();
			m_pCurrentTask = NULL;
		}
		else if (currentItem->data(1, Qt::UserRole).toInt() == Task)
		{
			if (currentItem->parent())
			{
				QString nSolutionID = currentItem->parent()->data(2, Qt::UserRole).toString();
				m_pCurrentSolution = m_pSolutionMgr->GetSolutionByID(nSolutionID);
				if (!m_pCurrentSolution)
					return false;

				QString strName = currentItem->data(0,Qt::DisplayRole).toString();
				int nTaskID = currentItem->data(0, Qt::UserRole).toInt();
				m_pCurrentTask = m_pCurrentSolution->GetTaskByName(strName);
				if (!m_pCurrentTask)
					return false;
			}
		}

		return true;
	}

	return true;
}

bool CMainFrame::OnTreeItemClick()
{
	if (!InitCurrentTask())
		return false;

	return true;
}

bool CMainFrame::OnParamPopMenu(const QPoint& points)
{
	QMenu menu(this);
	QAction *runAction = menu.addAction(QObject::tr("运行"));
	runAction->setObjectName("runAction");
	menu.addSeparator();

// 	QAction *addAlgoAction = menu.addAction(QStringLiteral("添加算法"));
// 	addAlgoAction->setObjectName("addAlgoAction");
// 	menu.addSeparator();

	QAction *selectAlgoAction = menu.addAction(QObject::tr("选择算法"));
	selectAlgoAction->setObjectName("selectAlgoAction");
	QAction *editAction = menu.addAction(QObject::tr("编辑"));
	editAction->setObjectName("editAction");
// 	QAction *deleteAction = menu.addAction(QStringLiteral("删除"));
// 	deleteAction->setObjectName("deleteAction");
// 	menu.addSeparator();

	QAction *setAction = menu.addAction(QObject::tr("输入参数设置"));
	setAction->setObjectName("setAction");
	QAction *outParamAction = menu.addAction(QObject::tr("输出参数设置"));
	outParamAction->setObjectName("outParamAction");

// 	QAction *importParamAciton = menu.addAction(QStringLiteral("导入参数"));
// 	QAction *exportParamAciton = menu.addAction(QStringLiteral("导出参数"));
// 	QAction *importOutParamAciton = menu.addAction(QStringLiteral("导入输出参数"));
// 	QAction *exportOutParamAciton = menu.addAction(QStringLiteral("导出输出参数"));
	QAction *updateRelyOnAlgoAciton = menu.addAction(QObject::tr("更新关联算法参数"));
	updateRelyOnAlgoAciton->setObjectName("updateRelyOnAlgoAciton");


	QAction *selectedAction = menu.exec(QCursor::pos());
	if (!selectedAction)
	{
		menu.clear();
		return false;
	}

	QString strObj = selectedAction->objectName();
	if (strObj == "editAction")
	{
		OnEditAlgo();
	}
	else if (strObj == "deleteAction")
	{
		OnDeleteAlgo();
	}
	else if (strObj == "setAction")
	{
		OnSetAlgo();
	}
	else if (strObj == "outParamAction")
	{
		OnSetOutParam();
	}
	else if (strObj == "addAlgoAction")
	{
	 	OnAddAlgo();
	}
	else if (strObj == "runAction")
	{
		OnRunAlgo();
	}
	else if (strObj == "selectAlgoAction")
	{
		OnSelectAlgo();
	}
	else if (strObj == "importParamAciton")
	{
		OnImportParam();
	}
	else if (strObj == "exportParamAciton")
	{
		OnExportParam();
	}
	else if (strObj == "importOutParamAciton")
	{
		OnImportOutParam();
	}
	else if (strObj == "exportOutParamAciton")
	{
		OnExportOutParam();
	}
	else if (strObj == "updateRelyOnAlgoAciton")
	{
		bool bupdate = OnUpdateRelyOnAlgo();
		if (m_plablStatus){
			if (bupdate)
				m_plablStatus->setText(QObject::tr("更新关联完成"));
			else
				m_plablStatus->setText(QObject::tr("Error，更新关联失败！！！"));
			QTimer::singleShot(1000,[&](){m_plablStatus->setText(""); });
		}
	}

	menu.clear();
	return true;
}

bool CMainFrame::OnAddAlgo()
{
	if (!m_tAlgoDlg.Initialize(m_pDE, m_pCurrentTask))
		return false;
	m_tAlgoDlg.setParent(this);
	m_tAlgoDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
	m_tAlgoDlg.setWindowIcon(QIcon(":/image/leaper"));
	m_tAlgoDlg.setWindowModality(Qt::ApplicationModal);
	m_tAlgoDlg.setAttribute(Qt::WA_ShowModal, true);
	IDetectorAlgorithm* pAlgo = m_tAlgoDlg.ShowAlgoDlg(NULL);
	if (pAlgo)
	{
		int nRowCount = ui->tableWidget_2->rowCount();
		ui->tableWidget_2->setRowCount(nRowCount + 1);
		QTableWidgetItem* pItem = new QTableWidgetItem(QString::number(pAlgo->GetID()));
		pItem->setData(Qt::UserRole, pAlgo->GetID());
		ui->tableWidget_2->setItem(nRowCount, 0, pItem);
		ui->tableWidget_2->setItem(nRowCount, 1, new QTableWidgetItem(QObject::tr(pAlgo->GetAlgorithmInfo()->strName.toStdString().c_str())));
		//ui->tableWidget_2->setItem(nRowCount, 2, new QTableWidgetItem(pAlgo->GetAlgorithmInfo()->strDescription));
		ui->tableWidget_2->setItem(nRowCount, 2, new QTableWidgetItem(QString::number(pAlgo->GetAlgorithmInfo()->nRoiID)));
		ui->tableWidget_2->setCurrentCell(nRowCount, QItemSelectionModel::Select);
		OnInitCurrentAlgoParam();
	}

	return true;
}

bool CMainFrame::OnEditAlgo()
{
	if (!currentTask())
		return false;

	int nRowIndex = ui->tableWidget_2->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
		QTableWidgetItem*item = items.at(0);
		if (item)
		{
			int nCurrentID = item->data(Qt::UserRole).toInt();
			IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
			if (!pAlgo)
				return false;

			if (!m_tAlgoDlg.Initialize(m_pDE, m_pCurrentTask))
				return false;
			m_tAlgoDlg.setParent(this);
			m_tAlgoDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
			m_tAlgoDlg.setWindowIcon(QIcon(":/image/leaper"));
			m_tAlgoDlg.setWindowModality(Qt::ApplicationModal);
			m_tAlgoDlg.setAttribute(Qt::WA_ShowModal, true);
			pAlgo = m_tAlgoDlg.ShowAlgoDlg(pAlgo);
			if (items.size()>1)
				items.at(1)->setText(QObject::tr(pAlgo->GetAlgorithmInfo()->strName.toStdString().c_str()));
			if (items.size()>3)
				items.at(2)->setText(QString::number(pAlgo->GetAlgorithmInfo()->nRoiID));
//			if (items.size()>2)
//			items.at(2)->setText(pAlgo->GetAlgorithmInfo()->strDescription);
//			if (items.size()>3)
//			items.at(3)->setText(QString::number(pAlgo->GetAlgorithmInfo()->nRoiID));

			OnInitCurrentAlgoParam();
			return true;
		}
	}

	return false;
}

bool CMainFrame::OnDeleteAlgo()
{
	if (!currentTask())
		return false;

	int nRowIndex = ui->tableWidget_2->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
		QTableWidgetItem*item = items.at(0);
		if (item)
		{
			int nCurrentID = item->data(Qt::UserRole).toInt();
			IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
			if (!pAlgo)
				return false;

			if (m_pCurrentTask->DeleteAlgorithm(pAlgo->GetID()))
			{
				ui->tableWidget_2->removeRow(nRowIndex);
				OnInitCurrentAlgoParam();
				return true;
			}
		}
	}

	return false;
}


bool CMainFrame::OnSetAlgo()
{
	if (!currentTask())
		return false;

	int nRowIndex = ui->tableWidget_2->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
		QTableWidgetItem*item = items.at(0);
		if (item)
		{
			int nCurrentID = item->data(Qt::UserRole).toInt();
			IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
			if (!pAlgo)
				return false;
			//CDsgAlgorithmParamMgrDlg m_tParamMgrDlg;
			if (!m_tParamMgrDlg.Initialize(m_pDE, m_pCurrentTask, pAlgo,PARAM_IN))
				return false;
			m_tParamMgrDlg.setParent(this);
			m_tParamMgrDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
			m_tParamMgrDlg.setWindowIcon(QIcon(":/image/leaper"));
			m_tParamMgrDlg.setWindowModality(Qt::ApplicationModal);
			m_tParamMgrDlg.setAttribute(Qt::WA_ShowModal, true);
			m_tParamMgrDlg.ShowParamMgrDlg(pAlgo);
			//m_tParamMgrDlg.exec();
		}

	}

	return true;
}

bool CMainFrame::OnSetOutParam()
{
	if (!currentTask())
		return false;

	int nRowIndex = ui->tableWidget_2->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
		QTableWidgetItem*item = items.at(0);
		if (item)
		{
			int nCurrentID = item->data(Qt::UserRole).toInt();
			IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
			if (!pAlgo)
				return false;
			//CDsgAlgorithmParamMgrDlg m_tParamMgrDlg;
			if (!m_tParamMgrDlg.Initialize(m_pDE, m_pCurrentTask, pAlgo,PARAM_OUT))
				return false;

			m_tParamMgrDlg.setParent(this);
			m_tParamMgrDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
			m_tParamMgrDlg.setWindowIcon(QIcon(":/image/leaper"));
			m_tParamMgrDlg.setWindowModality(Qt::ApplicationModal);
			m_tParamMgrDlg.setAttribute(Qt::WA_ShowModal, true);
			m_tParamMgrDlg.ShowParamMgrDlg(pAlgo);
			//m_tParamMgrDlg.exec();
		}
	}

	return true;
}

bool CMainFrame::OnRunAlgo()
{
	if (!currentTask())
		return false;

	int nRowIndex = ui->tableWidget_2->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
		QTableWidgetItem*item = items.at(0);
		if (item)
		{
			int nCurrentID = item->data(Qt::UserRole).toInt();
			IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
			if (!pAlgo)
				return false;
			m_pCurrentTask->GetTaskInfo()->detectImg = m_pCurrentTask->GetTaskInfo()->templateImg;
			//QString strHeader = "";
			//strHeader += "<span style='font-size:15px;color:#ff0000;font-weight:bold;'>";
			//strHeader += pAlgo->GetAlgorithmInfo()->strName;

			//if (pCurrentTask->GetTaskInfo()->strImageName.size() > 0)
			//{
			//	strHeader += "->";
			//	strHeader += pCurrentTask->GetTaskInfo()->strImageName;
			//}
			//strHeader += ":";
			//ui->textEdit->append(strHeader);

			if (pAlgo->Exec())
			{
				QString strResult = "";

				strResult += "<span style='font-size:10px;font-weight:bold;'>";
				strResult += QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
				strResult += " ";
				strResult += "</span>";


				strResult += "<span style='font-size:10px;font-weight:bold;'>";
				strResult += QObject::tr("算法名称:");
				strResult += "</span>";

				strResult += "<span style='font-size:10px;color:#ff0000;'>";
				strResult += QObject::tr(pAlgo->GetAlgorithmInfo()->strName.toStdString().c_str());
				strResult += "</span>";
				strResult += ",";

				if (m_pCurrentTask->GetTaskInfo()->strImageName.size() > 0)
				{
					strResult += "<span style='font-size:10px;font-weight:bold;'>";
					strResult += QObject::tr("图片名称:");
					strResult += "</span>";

					strResult += "<span style='font-size:10px;color:#ff0000;'>";
					strResult += m_pCurrentTask->GetTaskInfo()->strImageName;
					strResult += "</span>";
					strResult += ",";
				}

				QMap<QString, PLP_ALGORITHM_PARAM> mOutParam = pAlgo->GetAllOutParams();
				for (QMap<QString, PLP_ALGORITHM_PARAM>::iterator it = mOutParam.begin();it!=mOutParam.end();it++)
				{
					PLP_ALGORITHM_PARAM pOutParam = *it;
					if (pOutParam)
					{
						strResult += "<span style='font-size:10px;font-weight:bold;'>";
						strResult += pOutParam->strName + ":";
						strResult += "</span>";

						strResult += "<span style='font-size:10px;color:#ff0000;'>";
						switch (pOutParam->type)
						{
						case LP_INT:
						{
							strResult += QString::number(pOutParam->value.toInt());
							break;
						}
						case LP_BOOLEAN:
						{
							strResult += showVariant(pOutParam->type, pOutParam->value);// lppOutParam[i]->value.toString();
							break;
						}
						case LP_STRING:
						{
							strResult += showVariant(pOutParam->type, pOutParam->value); //lppOutParam[i]->value.toString();
							break;
						}
						case LP_DOUBLE:
						{
							strResult += QString::number(pOutParam->value.toDouble());
							break;
						}
						case LP_IMAGE:
						{
							if (!pOutParam->value.isNull())
							{
								QImage img = pOutParam->value.value<QImage>();
								if (!img.isNull())
								{
									ColossusBase::showImage(img, ui->gv_output);
								}

							}

							break;
						}
						case LP_POINTF:
						{
							QPointF pt = pOutParam->value.toPointF();
							QString str = "(%1,%2)"; str = str.arg(pt.x()).arg(pt.y());
							strResult += str;
							break;
						}
						case LP_POINT:
						{
							QPoint pt = pOutParam->value.toPoint();
							QString str = "(%1,%2)"; str = str.arg(pt.x()).arg(pt.y());
							strResult += str;
							break;
						}
						default:
							break;
						}

						strResult += "</span>";
						strResult += ",";
					}

				}

				if (strResult.length() > 0)
				{
					strResult = strResult.left(strResult.length() - 1);
					ui->textEdit->append(strResult);
				}
				
			}
			else
			{
				QString strResult = "";
				strResult += "<span style='font-size:10px;color:#ff0000;'>";
				strResult += QObject::tr("加载算法失败,请检查是否配置相应的算法库");
				strResult += "</span>";
				ui->textEdit->append(strResult);
				return false;
			}
		}
	}
	return true;
}

bool CMainFrame::OnSelectAlgo()
{
	if (!currentTask())
		return false;

	int nRowIndex = ui->tableWidget_2->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
		QTableWidgetItem* item = items.at(0);
		if (item)
		{
			int nCurrentID = item->data(Qt::UserRole).toInt();
			IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
			if (!pAlgo)
				return false;

			IDetectorAlgorithm* pRunAlgo = m_pCurrentTask->GetRunAlgo();
			if (pRunAlgo)
			{
				if (pRunAlgo->GetID() == pAlgo->GetID())
				{
					m_pCurrentTask->SetRunAlgo(LP_DETECTOR_INVALID_ID);
					item->setText(QString::number(pAlgo->GetID()));
					return true;
				}
				else
				{
					int nCount = ui->tableWidget_2->rowCount();
					for (int i = 0; i < nCount; i++)
					{
						QTableWidgetItem* pIDItem = ui->tableWidget_2->item(i, 0);
						if (pIDItem->data(Qt::UserRole).toInt() == pRunAlgo->GetID())
						{
							pIDItem->setText(QString::number(pRunAlgo->GetID()));
							break;
						}
					}

					m_pCurrentTask->SetRunAlgo(pAlgo->GetID());
					QString strText = QString::number(pAlgo->GetID()) + tr("(√)");
					item->setText(strText);
					return true;
				}
			}
			else
			{
				m_pCurrentTask->SetRunAlgo(pAlgo->GetID());
				QString strText = QString::number(pAlgo->GetID()) + tr("(√)");
				item->setText(strText);
				return true;
			}

		}

	}

	return true;
}

bool CMainFrame::OnListWidgetPopMenu(const QPoint&)
{
	QMenu menu;
	QAction *batchLoadImgAction = menu.addAction(QObject::tr("加载标定图片"));
	//QAction *copyTitleAction = menu.addAction(QStringLiteral("复制图片名称"));
	//QAction *deleteAction = menu.addAction(QStringLiteral("删除"));

	QAction *selectedAction = menu.exec(QCursor::pos());
	if (!selectedAction)
	{
		menu.clear();
		return false;
	} 
	if (selectedAction == batchLoadImgAction)
	{
		OnBatchLoadImage();
	}
	menu.clear();
	return true;
}

bool CMainFrame::OnGvInputWidgetPopMenu(const QPoint&)
{
	if (!m_pCurrentTask || m_pCurrentTask->GetTaskInfo()->templateImg.empty())
	{
		return true;
	}

	QMenu menu;
	QAction *saveImgAction = menu.addAction(QObject::tr("设置当前为标定图"));
	QAction *selectedAction = menu.exec(QCursor::pos());
	if (!selectedAction)
	{
		menu.clear();
		return false;
	}

	if (selectedAction == saveImgAction)
	{
		if (_pOldTask){
			oldMat = _pOldTask->GetTaskInfo()->templateImg;
		}
		QString strName = m_pCurrentTask->GetTaskInfo()->strName;
		if (!m_TaskChangeList.contains(strName))
		{
			m_TaskChangeList.append(strName);
		}
// 		QString fileName = QFileDialog::getSaveFileName(this, tr("save image"), qApp->applicationDirPath(), tr("Image (*.bmp)"));
// 
// 		if (!fileName.isNull())
// 		{
// 			std::string strpath = fileName.toLocal8Bit().toStdString();
// 			if (!cv::imwrite(strpath, m_pCurrentTask->GetTaskInfo()->img))
// 				return false;
// 		}
	}


	menu.clear();
	return true;
}

bool CMainFrame::OnListItemDoubleClick()
{
	return OnRunAlgo();
}

bool CMainFrame::OnListItemClick()
{
// 	if (m_pCurrentTask)
// 	{
// 		QListWidgetItem* item = ui->listWidget->currentItem();
// 
// 		if (item)
// 		{
// 			QString strFilePath = item->data(Qt::UserRole).toString();
// 			std::string strpath = strFilePath.toLocal8Bit().toStdString();
// 			m_pCurrentTask->GetTaskInfo()->templateImg = cv::imread(strpath, 0);
// 
// 			if (ColossusBase::showImage(m_pCurrentTask->GetTaskInfo()->templateImg, ui->gv_input))
// 			{
// 				m_pCurrentTask->GetTaskInfo()->strImageName = strFilePath.split("/").last();
// 			}
// 		}
// 
// 		return true;
// 	}
	return false;
}

void CMainFrame::OnClearResult()
{
	ui->textEdit->clear();
}


bool CMainFrame::OnInitCurrentAlgoParam()
{
	
	if (!ui->tableWidget)
		return false;

	ui->tableWidget->setRowCount(0);
	ui->tableWidget->clearContents();

	//ui->tableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
	ui->tableWidget->setSelectionBehavior(QAbstractItemView::SelectItems);
	ui->tableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
	ui->tableWidget->verticalHeader()->setHidden(true);
	ui->tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);

	ui->tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);

	if (!m_pCurrentTask)
		return false;

	int nRowIndex = ui->tableWidget_2->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
		QTableWidgetItem*item = items.at(0);
		if (item)
		{
			int nCurrentID = item->data(Qt::UserRole).toInt();
			m_pCurrentAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
			if (!m_pCurrentAlgo)
				return false;

 			if (!m_tParamDlg.Initialize(m_pDE, m_pCurrentTask, m_pCurrentAlgo, PARAM_IN))
 				return false;

			QMap<QString, PLP_ALGORITHM_PARAM> mParam = m_pCurrentAlgo->GetAllParams();
			int nIndex = 0;
			for (QMap<QString, PLP_ALGORITHM_PARAM>::iterator its = mParam.begin(); its != mParam.end(); ++its){

				ui->tableWidget->setRowCount(nIndex + 1);
 				ui->tableWidget->setItem(nIndex, 0, new QTableWidgetItem(QString::number(nIndex + 1)));
 				ui->tableWidget->setItem(nIndex, 1, new QTableWidgetItem((*its)->strName));
 				ui->tableWidget->setItem(nIndex, 2, new QTableWidgetItem(GetParamTypeStr((*its)->type)));
 				ui->tableWidget->setItem(nIndex, 3, new QTableWidgetItem(showVariant((*its)->type, (*its)->value)));
 				//ui->tableWidget->setItem(nIndex, 4, new QTableWidgetItem((*its)->strDescription));
				nIndex++;
			}
		}
	}

	return true;
}

bool CMainFrame::OnParamListPopMenu(const QPoint&)
{
	QMenu menu;
// 	QAction *addParamAction = menu.addAction(QStringLiteral("添加"));
// 	addParamAction->setObjectName("addParamAction");
	QAction *editParamAction = menu.addAction(QObject::tr("编辑"));
	editParamAction->setObjectName("editParamAction");
// 	QAction *deleteParamAction = menu.addAction(QStringLiteral("删除"));
// 	deleteParamAction->setObjectName("deleteParamAction");

	QAction *selectedAction = menu.exec(QCursor::pos());

	if (!selectedAction)
	{
		menu.clear();
		return false;
	}
	QString strObj = selectedAction->objectName();

	//if (selectedAction == addParamAction)
	if (strObj == "addParamAction")
	{
		OnAddParam();
	}
	//else if (selectedAction == editParamAction)
	else if (strObj == "editParamAction")
	{
		OnEditParam();
	}
	//else if (selectedAction == deleteParamAction)
	else if (strObj == "deleteParamAction")
	{
		OnDeleteParam();
	}

	menu.clear();
	return true;
}

bool CMainFrame::OnAddParam()
{
	if (!currentAlgorithm())
		return false;

	if (!m_tParamDlg.InitGraphView())
		return false;
	m_tParamDlg.setParent(this);
	m_tParamDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
	m_tParamDlg.setWindowIcon(QIcon(":/image/leaper"));
	m_tParamDlg.setWindowModality(Qt::ApplicationModal);
	m_tParamDlg.setAttribute(Qt::WA_ShowModal, true);
	PLP_ALGORITHM_PARAM pParam = m_tParamDlg.ShowParamDlg(NULL);
	if (pParam)
	{
		int nRowCount = ui->tableWidget->rowCount();

		ui->tableWidget->setRowCount(nRowCount + 1);
		ui->tableWidget->setItem(nRowCount, 0, new QTableWidgetItem(QString::number(pParam->nID)));
		ui->tableWidget->setItem(nRowCount, 1, new QTableWidgetItem(pParam->strName));
		ui->tableWidget->setItem(nRowCount, 2, new QTableWidgetItem(GetParamTypeStr(pParam->type)));
		ui->tableWidget->setItem(nRowCount, 3, new QTableWidgetItem(showVariant(pParam->type, pParam->value)));

		ui->tableWidget->setItem(nRowCount, 4, new QTableWidgetItem(pParam->strDescription));

		return true;
	}

	return false;
}

bool CMainFrame::OnDeleteParam()
{
	if (!currentAlgorithm())
		return false;

	int nRowIndex = ui->tableWidget->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget->selectedItems();
		QTableWidgetItem*item = items.at(0);
		if (item)
		{
			int nCurrentID = item->text().toInt();
			m_pCurrentAlgo->DeleteParam(nCurrentID);

			ui->tableWidget->removeRow(nRowIndex);
			return true;
		}
	}

	return false;
}

bool CMainFrame::OnEditParam()
{
	if (!currentAlgorithm())
		return false;

	int nRowIndex = ui->tableWidget->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items;//= ui->tableWidget->selectedItems();
		for (int i = 0; i < ui->tableWidget->colorCount(); i++)
		{
			items.push_back(ui->tableWidget->item(nRowIndex, i));
		}
		
		QTableWidgetItem*item = items.at(1);
		if (item)
		{
			if (_pOldTask){
				if (!oldMat.empty())
					_pOldTask->GetTaskInfo()->templateImg = oldMat;
			}
			//int nCurrentID = item->text().toInt();
			QString strParaName = item->text();
			AlgoParamType type;
			PLP_ALGORITHM_PARAM pParam = NULL;
			pParam = m_pCurrentAlgo->GetParamByName(strParaName);
			//pParam = m_pCurrentAlgo->GetParam(nCurrentID);

			if (pParam)
			{
 				if (!m_tParamDlg.InitGraphView())
 					return false;

//				m_tParamDlg.show();
				m_tParamDlg.setParent(this);
				m_tParamDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
				m_tParamDlg.setWindowIcon(QIcon(":/image/leaper"));
				m_tParamDlg.setWindowModality(Qt::ApplicationModal);
				m_tParamDlg.setAttribute(Qt::WA_ShowModal, true);
				m_tParamDlg.ShowParamDlg(pParam);
// 				items.at(1)->setText(pParam->strName);
// 				items.at(2)->setText(GetParamTypeStr(pParam->type));
// 				items.at(3)->setText(showVariant(pParam->type,pParam->value));
				//items.at(4)->setText(pParam->strDescription);
				QString st = _pOldTask->GetTaskInfo()->strName;
				if (!m_TaskChangeList.contains(st))
				{
					m_TaskChangeList.append(st);
				}
				return true;
			}
		}

	}
	return false;
}

bool CMainFrame::OnImportParam()
{
	QString strFileName = QFileDialog::getOpenFileName(this, "open file", "", "File (*.json)");
	if (strFileName.length() > 0)
	{
		int nRowIndex = ui->tableWidget_2->currentRow();
		if (nRowIndex != -1)
		{
			QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
			QTableWidgetItem*item = items.at(0);
			if (item)
			{
				int nCurrentID = item->data(Qt::UserRole).toInt();
				IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
				if (!pAlgo)
					return false;

				QFile file(strFileName);
				QByteArray byteArray;

				if (!file.open(QIODevice::ReadOnly))
				{
					return false;
				}

				byteArray = file.readAll();

				if (byteArray.size() == 0)
					return true;

				QJsonParseError parse_error;
				QJsonDocument document = QJsonDocument::fromJson(byteArray, &parse_error);
				if (parse_error.error == QJsonParseError::NoError)
				{
					if (!document.isEmpty() && !document.isNull())
					{
						if (document.isArray())
						{
							QJsonArray paramArray = document.array();

							pAlgo->ImportParam(paramArray);

							return true;
						}
					}
				}
			}
		}
	}
	return true;
}

bool CMainFrame::OnExportParam()
{
	QString fileName = QFileDialog::getSaveFileName(this,"Open Param","","Param File (*.json)");

	if (!fileName.isNull())
	{
		int nRowIndex = ui->tableWidget_2->currentRow();
		if (nRowIndex != -1)
		{
			QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
			QTableWidgetItem*item = items.at(0);
			if (item)
			{
				int nCurrentID = item->data(Qt::UserRole).toInt();
				IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
				if (!pAlgo)
					return false;

				QByteArray byteArray;
				byteArray = pAlgo->ExportParam();

				QFile file(fileName);
				if (file.open(QFile::WriteOnly))
				{
					file.write(byteArray);
					return true;
				}
			}
		}
	}

	return true;
}

bool CMainFrame::OnImportOutParam()
{
	QString strFileName = QFileDialog::getOpenFileName(this, "open file", "", "File (*.json)");
	if (strFileName.length() > 0)
	{
		int nRowIndex = ui->tableWidget_2->currentRow();
		if (nRowIndex != -1)
		{
			QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
			QTableWidgetItem*item = items.at(0);
			if (item)
			{
				int nCurrentID = item->data(Qt::UserRole).toInt();
				IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
				if (!pAlgo)
					return false;

				QFile file(strFileName);
				QByteArray byteArray;

				if (!file.open(QIODevice::ReadOnly))
				{
					return false;
				}

				byteArray = file.readAll();

				if (byteArray.size() == 0)
					return true;

				QJsonParseError parse_error;
				QJsonDocument document = QJsonDocument::fromJson(byteArray, &parse_error);
				if (parse_error.error == QJsonParseError::NoError)
				{
					if (!document.isEmpty() && !document.isNull())
					{
						if (document.isArray())
						{
							QJsonArray paramArray = document.array();

							pAlgo->ImportOutParam(paramArray);

							return true;
						}
					}
				}
			}
		}
	}
	return true;
}

bool CMainFrame::OnExportOutParam()
{
	QString fileName = QFileDialog::getSaveFileName(this, "Open Param", "", tr("Param File (*.json)"));

	if (!fileName.isNull())
	{
		int nRowIndex = ui->tableWidget_2->currentRow();
		if (nRowIndex != -1)
		{
			QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
			QTableWidgetItem*item = items.at(0);
			if (item)
			{
				int nCurrentID = item->data(Qt::UserRole).toInt();
				IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
				if (!pAlgo)
					return false;

				QByteArray byteArray;
				byteArray = pAlgo->ExportOutParam();

				QFile file(fileName);
				if (file.open(QFile::WriteOnly))
				{
					file.write(byteArray);
					return true;
				}
			}
		}
	}

	return true;
}

bool CMainFrame::OnUpdateRelyOnAlgo()
{
	int nRowIndex = ui->tableWidget_2->currentRow();
	if (nRowIndex != -1)
	{
		QList<QTableWidgetItem*>items = ui->tableWidget_2->selectedItems();
		QTableWidgetItem*item = items.at(0);
		if (item)
		{
			int nCurrentID = item->data(Qt::UserRole).toInt();
			IDetectorAlgorithm* pAlgo = m_pCurrentTask->GetAlgorithm(nCurrentID);
			if (!pAlgo)
				return false;
			QString strName = m_pCurrentTask->GetTaskInfo()->strName;

			QList<int> rltList = pAlgo->UpdateRelyOnAlgo();
			
			if (rltList.size() <= 0)
				return false;
			if (!m_TaskChangeList.contains(strName))
			{
				m_TaskChangeList.append(strName);
			}
			return true;
		}
	}

	return false;
}

QString CMainFrame::GetParamTypeStr(AlgoParamType type)
{
	QString strType;
	return AlgoParamName[type];

	switch (type)
	{
	case LP_INT:
	{
		strType = "INT";
		break;
	}
	case LP_BOOLEAN:
	{
		strType = "BOOLEAN";
		break;
	}
	case LP_STRING:
	{
		strType = "STRING";
		break;
	}
	case LP_DOUBLE:
	{
		strType = "DOUBLE";
		break;
	}
	case LP_IMAGE:
	{
		strType = "IMAGE";
		break;
	}
	default:
		break;
	}

	return strType;
}

void CMainFrame::OnCellChanged(int row, int column)
{
	QString str = sender()->objectName();
	int a = 1;
}

bool CMainFrame::OnNextBtnClick()
{
// 	int index = ui->listWidget->currentRow();
// 	int maxindex = ui->listWidget->count()-1;
// 
// 	if (index < maxindex)
// 	{
// 		ui->listWidget->setCurrentRow(index + 1);
// 		OnListItemClick();
// 	}

	return OnRunAlgo();
}

void CMainFrame::OnCellClicked(int row, int column)
{
	return;
	QTableWidgetItem *pWidget = ui->tableWidget->item(row, column);

	if (2 == column)
	{
		QComboBox *pCombox = new QComboBox(ui->tableWidget);

		for (int i = 0; i < LP_MAX_ALGO_PARAM_NUM; i++)
		{
			pCombox->insertItem(i, AlgoParamName[i]);
		}
		pCombox->setEditable(false);

		ui->tableWidget->setCellWidget(row, column, pCombox);
		connect(pCombox, SIGNAL(currentIndexChanged(int)), this, SLOT(OnComboxSelect(int)));
	}
	else if (3 == column)
	{
		
	}
}

IDetectorSolution * CMainFrame::currentSolution()
{
	if (!m_pCurrentSolution) {
		//emit sgShowStatus("current solution not exist");
		return NULL;
	}
	//emit sgShowStatus("current solution exist");
	return m_pCurrentSolution;
}

IDetectorTask * CMainFrame::currentTask()
{
	if (!m_pCurrentTask) {
		//emit sgShowStatus("current task not exist");
		return NULL;
	}
	//emit sgShowStatus("current task exist");
	return m_pCurrentTask;
}

IDetectorAlgorithm * CMainFrame::currentAlgorithm()
{
	if (!m_pCurrentAlgo) {
		//emit sgShowStatus("current algo not exist");
		return NULL;
	}
	//emit sgShowStatus("current algo exist");
	return m_pCurrentAlgo;
}

void CMainFrame::OnShowStatus(QString strMess)
{
	QStatusBar *p = statusBar();
	p->showMessage(strMess);
}

QString CMainFrame::genInfo()
{
	//<! solution xx:, task xx:, algo: xx;
	QString strMess = "";
	return true;
}

void CMainFrame::closeEvent(QCloseEvent *event)
{
	return QMainWindow::closeEvent(event);;
	if (_pOldTask){
		if (!oldMat.empty())
			_pOldTask->GetTaskInfo()->templateImg = oldMat;
	}
	if (SystemStateInfo::bParamStateFlag)
	{
		QMessageBox msgBox(QMessageBox::Warning, QObject::tr("提示"), QObject::tr("配置已修改过，是否保存相关参数到文件中？"), 0, this);
		msgBox.addButton(QObject::tr("是"), QMessageBox::AcceptRole);
		msgBox.addButton(QObject::tr("否"), QMessageBox::RejectRole);
		if (msgBox.exec() == QMessageBox::AcceptRole)
		{
			//m_pDE->Save();
		}
		SystemStateInfo::bParamStateFlag = false;
	}
	if (m_pSolutionMgr && m_pSolutionMgr->GetRunSolution()) {
		m_pSolutionMgr->SetRunSolution(m_pSolutionMgr->GetRunSolution()->GetSolutionName());
	}
	//OnManualTrigger();
	QMainWindow::closeEvent(event);
}

Q_SLOT void CMainFrame::onLoadImage()
{
	if (!currentTask())
		return ;

	QString strDefaultDirPath = m_pCurrentTask->GetTaskInfo()->strDirPath;
	QStringList strFileNamesList = QFileDialog::getOpenFileNames(this, "open file", strDefaultDirPath, "Images (*.bmp *.png *.xpm *.jpg)");
	if (strFileNamesList.size() <= 0)
	{
		return ;
	}

	QString strFileName = strFileNamesList[0];
	std::string strpath = strFileName.toLocal8Bit().toStdString();//中文路径支持
	m_pCurrentTask->GetTaskInfo()->templateImg = cv::imread(strpath, CV_LOAD_IMAGE_GRAYSCALE);
	oldMat = m_pCurrentTask->GetTaskInfo()->templateImg;
	if (ColossusBase::showImage(m_pCurrentTask->GetTaskInfo()->templateImg, ui->gv_input))
	{
		m_pCurrentTask->GetTaskInfo()->strImageName = strFileName.split("/").last();
	}
}