whellvalue/src/lpbdesigner/MainFrame.cpp

#include "MainFrame.h"
#include "ui_MainFrame.h"
#include "colossusbase.h"
#include <QHeaderView>
#pragma execution_character_set("utf-8")
typedef QMap<int, PLP_DETECTOR_TASK> TaskMap;
typedef QMap<QString, PLP_DETECTOR_TASK> TaskMapStr;

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->pushButton_8, SIGNAL(clicked()), this, SLOT(OnSnapImage()));

	//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->pushButton_next, SIGNAL(clicked()), this, SLOT(OnNextBtnClick()));

	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;

// 	m_tParamMgrDlg.setParent(this);
// 	m_tParamMgrDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
 	//m_tParamDlg.setParent(parent);
 	//m_tParamDlg.setWindowFlags(Qt::Dialog | Qt::WindowCloseButtonHint);
}

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;
			}
// 			if (m_pDE && m_pDE->SaveTasks(m_TaskChangeList))
// 			{
// 				m_TaskChangeList.clear();
// 				return true;
// 			}

			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_pDE->SaveTasks(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->listWidget->clear();

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

	int nSolutionCount = m_pSolutionMgr->EnumSolution(NULL, 0);
	if (nSolutionCount > 0)
	{
		IDetectorSolution** lppSolution = new IDetectorSolution*[nSolutionCount];
		nSolutionCount = m_pSolutionMgr->EnumSolution(lppSolution, nSolutionCount);
		for (int i = 0; i < nSolutionCount; i++)
		{
			if (lppSolution[i])
			{
				PLP_DETECTOR_SOLUTION pSolutionInfo = lppSolution[i]->GetSolutionInfo();
				QTreeWidgetItem *solutionItem = NULL;

				if (m_pSolutionMgr->GetRunSolution() && m_pSolutionMgr->GetRunSolution()->GetID() == lppSolution[i]->GetID())
				{
					QString strText = pSolutionInfo->strName + tr("(√)");
					solutionItem = new QTreeWidgetItem(ui->treeWidget, QStringList(strText));
				}
				else
				{
					solutionItem = new QTreeWidgetItem(ui->treeWidget, QStringList(pSolutionInfo->strName));
				}

				solutionItem->setData(0, Qt::UserRole, lppSolution[i]->GetID());
				solutionItem->setData(1, Qt::UserRole, SOLUTION);

				QStringList strKeys = lppSolution[i]->GetAllTaskNames();
				QMap<int, TaskMapStr> m_tmpMap;
				for (int n = 0; n < strKeys.size();n++)
				{
					IDetectorTask* pTask = lppSolution[i]->GetTask(strKeys[n]);
					if (pTask)
					{
						PLP_DETECTOR_TASK pTaskInfo = pTask->GetTaskInfo();
						int ID = pTaskInfo->nCameraID;
						int TaskID = pTask->GetID();
						QString strKey = strKeys[n];
						pTaskInfo->nID = TaskID;
						if (m_tmpMap.contains(ID))
						{
							QMap<int, TaskMapStr>::iterator item = m_tmpMap.find(ID);
							(*item)[strKey] = pTaskInfo;
						}
						else
						{
							TaskMapStr Itemtmp;
							Itemtmp[strKey] = pTaskInfo;
							m_tmpMap[ID] = Itemtmp;
						}
					}
				}

				for (QMap<int, TaskMapStr>::iterator its = m_tmpMap.begin(); its != m_tmpMap.end(); ++its)
				{
					int camID = its.key();
					QString strStationName = QString(QObject::tr("工位%1")).arg(camID);
					QTreeWidgetItem *childItem = new QTreeWidgetItem(solutionItem, QStringList(strStationName));
					childItem->setData(0, Qt::UserRole, lppSolution[i]->GetID());
					childItem->setData(1, Qt::UserRole, SOLUTION);
					solutionItem->addChild(childItem);
							
					TaskMapStr tmp = *its;
					int nFirstID = 0;
					QString strFirstName;
					for(TaskMapStr::iterator it = tmp.begin(); it != tmp.end();++it)
					{
						if ((*it)->strName.contains("TEMPLATE"))
						{
							nFirstID = (*it)->nID;
							strFirstName = (*it)->strName;
							break;
						}
					}
					if (nFirstID != 0){
						QTreeWidgetItem *firstTaskItem = new QTreeWidgetItem(childItem, QStringList(strFirstName));
						firstTaskItem->setData(0, Qt::UserRole, nFirstID);
						firstTaskItem->setData(1, Qt::UserRole, Task);
						childItem->addChild(firstTaskItem);
					}


					for (TaskMapStr::iterator itItem = tmp.begin(); itItem != tmp.end(); ++itItem)
					{
						if (nFirstID!=0 &&((*itItem)->strName.contains("TEMPLATE")))
						{
							continue;
						}
						QTreeWidgetItem *TaskItem = new QTreeWidgetItem(childItem, QStringList((*itItem)->strName));
						TaskItem->setData(0, Qt::UserRole, (*itItem)->nID);
						TaskItem->setData(1, Qt::UserRole, Task);
						childItem->addChild(TaskItem);
					}
				}

				if (i == 0)
				{
					ui->treeWidget->setCurrentItem(solutionItem);
				}

				if (m_pSolutionMgr->GetRunSolution() && m_pSolutionMgr->GetRunSolution()->GetID() == lppSolution[i]->GetID())
				{
					ui->treeWidget->setCurrentItem(solutionItem);
					ui->treeWidget->expandItem(solutionItem);
					ui->treeWidget->setCurrentItem(  solutionItem);
				}
			}
		}

		delete[] lppSolution;
	}

	if (!InitCurrentTask())
		return false;
	m_TaskChangeList.clear();
	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->listWidget->clear();
	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;
		}

		int nAlgoCount = m_pCurrentTask->EnumAlgorithm(NULL, 0);
		if (nAlgoCount > 0)
		{
			IDetectorAlgorithm** lppAlgo = new IDetectorAlgorithm*[nAlgoCount];
			nAlgoCount = m_pCurrentTask->EnumAlgorithm(lppAlgo, nAlgoCount);
			for (int i = 0; i < nAlgoCount; i++)
			{
				if (lppAlgo[i])
				{
					ui->tableWidget_2->setRowCount(i + 1);
					QTableWidgetItem* pItem = NULL;
					if (m_pCurrentTask->GetRunAlgo() && lppAlgo[i]->GetID() == m_pCurrentTask->GetRunAlgo()->GetID())
					{
						QString strText = QString::number(lppAlgo[i]->GetID()) + tr("(√)");
						pItem = new QTableWidgetItem(strText);
						pItem->setData(Qt::UserRole, lppAlgo[i]->GetID());
						ui->tableWidget_2->setItem(i, 0, pItem);
					}
					else
					{
						pItem = new QTableWidgetItem(QString::number(lppAlgo[i]->GetID()));
						pItem->setData(Qt::UserRole, lppAlgo[i]->GetID());
						ui->tableWidget_2->setItem(i, 0, pItem);
					}

					ui->tableWidget_2->setItem(i, 1, new QTableWidgetItem(QObject::tr(lppAlgo[i]->GetAlgorithmInfo()->strName.toStdString().c_str())));
					//ui->tableWidget_2->setItem(i, 2, new QTableWidgetItem(lppAlgo[i]->GetAlgorithmInfo()->strDescription));
					ui->tableWidget_2->setItem(i, 2, new QTableWidgetItem(QString::number(lppAlgo[i]->GetAlgorithmInfo()->nRoiID)));

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

			delete[] lppAlgo;
		}

		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->GetTask(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);
		}
	}

// 	int nTaskCount = pSolution->EnumTask(NULL, 0);
// 	if (nTaskCount > 0)
// 	{
// 		IDetectorTask** lppTask = new IDetectorTask*[nTaskCount];
// 		nTaskCount = pSolution->EnumTask(lppTask, nTaskCount);
// 		for (int i = 0; i < nTaskCount; i++)
// 		{
// 			if (lppTask[i])
// 			{
// 				PLP_DETECTOR_TASK pTaskInfo = lppTask[i]->GetTaskInfo();
// 
// 				QTreeWidgetItem *TaskItem = new QTreeWidgetItem(pItem, QStringList(pTaskInfo->strName));
// 				TaskItem->setData(0, Qt::UserRole, lppTask[i]->GetID());
// 				TaskItem->setData(1, Qt::UserRole, Task);
// 
// 				pItem->addChild(TaskItem);
// 			}
// 		}
// 
// 		delete[] lppTask;
// 	}
	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())
			{
				m_pSolutionMgr->SetRunSolution(LP_DETECTOR_INVALID_ID);
				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).toInt() == pRunSolution->GetID())
					{
						pItem->setText(0, pRunSolution->GetSolutionInfo()->strName);
						break;
					}
				}

				m_pSolutionMgr->SetRunSolution(m_pCurrentSolution->GetID());
				QString strText = m_pCurrentSolution->GetSolutionInfo()->strName + tr("(√)");
				ui->treeWidget->currentItem()->setText(0, strText);
				return true;
			}
		}
		else
		{
			m_pSolutionMgr->SetRunSolution(m_pCurrentSolution->GetID());
			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);
//	ui->listWidget->setIconSize(QSize(75, 75));

	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();

			int nSolutionID = currentItem->data(0, Qt::UserRole).toInt();
			m_pCurrentSolution = m_pSolutionMgr->GetSolution(nSolutionID);
			if (!m_pCurrentSolution)
				return false;

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

				int nTaskID = currentItem->data(0, Qt::UserRole).toInt();
				m_pCurrentTask = m_pCurrentSolution->GetTask(nTaskID);
				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;

	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()
{
	//return false;
	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;

			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.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.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())
			{
				int nCount = pAlgo->EnumOutParam(NULL, 0);
				if (nCount > 0)
				{
					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 += ",";
					}

					LP_ALGORITHM_PARAM** lppOutParam = new PLP_ALGORITHM_PARAM[nCount];
					nCount = pAlgo->EnumOutParam(lppOutParam, nCount);
					for (int i = 0; i < nCount; i++)
					{

						if (lppOutParam[i])
						{
							strResult += "<span style='font-size:10px;font-weight:bold;'>";
							strResult += lppOutParam[i]->strName + ":";
							strResult += "</span>";

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

								}

								break;
							}
							case LP_POINTF:
							{
								QPointF pt = lppOutParam[i]->value.toPointF();
								QString str = "(%1,%2)"; str = str.arg(pt.x()).arg(pt.y());
								strResult += str;
								break;
							}
							case LP_POINT:
							{
								QPoint pt = lppOutParam[i]->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);
					}
					delete[] lppOutParam;
				}

			}
			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 == deleteAction)
// 	{
// 		if (ui->listWidget->currentItem())
// 		{
// 			ui->listWidget->removeItemWidget(ui->listWidget->currentItem());
// 			delete ui->listWidget->currentItem();
// 		}
// 	}
// 	else 
	if (selectedAction == batchLoadImgAction)
	{
		OnBatchLoadImage();
	}
// 	else if (selectedAction == copyTitleAction)
// 	{
// 		OnCopyFileTitle();
// 	}


	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;

			int nCount = m_pCurrentAlgo->EnumParam(NULL, 0);

			if (nCount > 0)
			{
				LP_ALGORITHM_PARAM** lppParam = new LP_ALGORITHM_PARAM*[nCount];
				nCount = m_pCurrentAlgo->EnumParam(lppParam, nCount);

				QMap<int, LP_ALGORITHM_PARAM*> m_map;
				for (int i = 0; i < nCount; i++){
					if (lppParam[i]){
						m_map[lppParam[i]->nID] = lppParam[i];
					}
				}
				int nIndex = 0;
				for (QMap<int, LP_ALGORITHM_PARAM*>::iterator its = m_map.begin(); its != m_map.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++;
				}
			

// 				for (int i = 0; i < nCount; i++)
// 				{
// 					if (lppParam[i])
// 					{
// 						ui->tableWidget->setRowCount(i + 1);
// 						ui->tableWidget->setItem(i, 0, new QTableWidgetItem(QString::number(lppParam[i]->nID)));
// 						ui->tableWidget->setItem(i, 1, new QTableWidgetItem(lppParam[i]->strName));
// 						ui->tableWidget->setItem(i, 2, new QTableWidgetItem(GetParamTypeStr(lppParam[i]->type)));
// 						ui->tableWidget->setItem(i, 3, new QTableWidgetItem(showVariant(lppParam[i]->type, lppParam[i]->value)));
// 						ui->tableWidget->setItem(i, 4, new QTableWidgetItem(lppParam[i]->strDescription));
// 					}
// 				}
				delete[] lppParam;
			}
		}
	}

	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;

	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.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()->GetID());
	}
	//OnManualTrigger();
	QMainWindow::closeEvent(event);
}