VisionPlus_V3.0/VisionPlusTools/CstSK_Classification/ToolDialog.cpp

#include "ToolDialog.h"
#include <QImage>
#include <QFileInfo>
#include <QFileDialog>
#include <QElapsedTimer>
#include <QGridLayout>

ToolDialogImpl::ToolDialogImpl(QWidget *parent, DllTool* pDllTool)
	: DllToolDialog(parent)
{
	ui.setupUi(this);
	this->setWindowFlags(Qt::Dialog | Qt::WindowMaximizeButtonHint | Qt::WindowCloseButtonHint /*| Qt::WindowStaysOnTopHint*/);


	connect(this, SIGNAL(sigUpdateUI()), this, SLOT(on_UpdateUI()));


	
	// 显示控件初始化
    hwndUnit = new HWndUnit(this);
    Util::ShowUnitInWidget(ui.Image_widget, hwndUnit);
  
    hwndUnit->getHWndCtrl()->useROIController(&roiController);
    connect(&roiController, SIGNAL(ROIChange(const ViewMessage)), this, SLOT(on_ROIChange(const ViewMessage)));


// 	ROIRect1* roi = new ROIRect1();
// 	roi->setTitle("搜索区域");
// 	roiController.setROISign(ROIOperation::Negative);
// 	roiController.setROIShape(roi);
// 	roiController.mouseDownAction(500, 500);



	// Device setting
// 	device = SuaKIT::API::DeviceDescriptor::GetDefaultDevice();
// 	if (device.GetDeviceKind() == SuaKIT::API::DeviceKind::DeviceKind_GPU)
// 	{
// 		size_t free_byte = device.GetFreeGpuMem();
// 
// 		constexpr double MEGABYTE = 1024.0 * 1024.0;
// 		double gpu_free_mb = static_cast<double>(free_byte) / MEGABYTE;
// 
// 		//vWarning() << "use gpu Device" << "GPU free = " << gpu_free_mb << "MB";
// 		if (gpu_free_mb < 100)
// 		{
// 			device = SuaKIT::API::DeviceDescriptor::GetCPUDevice();
// 		}
// 		
// 	}
// 	else
	{
		device = SuaKIT::API::DeviceDescriptor::GetCPUDevice();
	}

	m_pCls = nullptr;

}


ToolDialogImpl::~ToolDialogImpl()
{

	if (m_pCls != nullptr)
	{
		m_pCls->Finalize();
	}
}

cv::Mat HImageToMat(const HalconCpp::HImage& hImg) 
{
	cv::Mat mat;
	int channels = hImg.CountChannels()[0].I();
	HalconCpp::HImage hImage = hImg.ConvertImageType("byte");

	Hlong hW = 0, hH = 0; HString cType;

	if (channels == 1) {
		void* r = hImage.GetImagePointer1(&cType, &hW, &hH);
		mat.create(int(hH), int(hW), CV_8UC1);
		memcpy(mat.data, static_cast<unsigned char*>(r), int(hW * hH));
	}
	else if (channels == 3) {
		void* r = NULL, * g = NULL, * b = NULL;

		hImage.GetImagePointer3(&r, &g, &b, &cType, &hW, &hH);
		mat.create(int(hH), int(hW), CV_8UC3);

		std::vector<cv::Mat> vec(3);
		vec[0].create(int(hH), int(hW), CV_8UC1);
		vec[1].create(int(hH), int(hW), CV_8UC1);
		vec[2].create(int(hH), int(hW), CV_8UC1);

		memcpy(vec[2].data, static_cast<unsigned char*>(r), int(hW * hH));
		memcpy(vec[1].data, static_cast<unsigned char*>(g), int(hW * hH));
		memcpy(vec[0].data, static_cast<unsigned char*>(b), int(hW * hH));
		cv::merge(vec, mat);
	}
	return mat;
}

HalconCpp::HImage MatToHImage(cv::Mat& cv_img)
{
	HalconCpp::HObject H_img;

	if (cv_img.channels() == 1)
	{
		int height = cv_img.rows, width = cv_img.cols;
		int size = height * width;
		uchar* temp = new uchar[size];

		memcpy(temp, cv_img.data, size);
		HalconCpp::GenImage1(&H_img, "byte", width, height, (Hlong)(temp));

		delete[] temp;
	}
	else if (cv_img.channels() == 3)
	{
		int height = cv_img.rows, width = cv_img.cols;
		int size = height * width;
		uchar* B = new uchar[size];
		uchar* G = new uchar[size];
		uchar* R = new uchar[size];

		for (int i = 0; i < height; i++)
		{
			uchar* p = cv_img.ptr<uchar>(i);
			for (int j = 0; j < width; j++)
			{
				B[i * width + j] = p[3 * j];
				G[i * width + j] = p[3 * j + 1];
				R[i * width + j] = p[3 * j + 2];
			}
		}
		HalconCpp::GenImage3(&H_img, "byte", width, height, (Hlong)(R), (Hlong)(G), (Hlong)(B));

		delete[] R;
		delete[] G;
		delete[] B;
	}
	return H_img;
}




HalconCpp::HImage Mat2HImage(cv::Mat arg)
{
	cv::Mat argMat;
	HalconCpp::HImage dstImg;

	argMat = arg.clone();

	void* p = nullptr;
	Hlong wd = argMat.cols;
	Hlong ht = argMat.rows;
	int cvType = argMat.type();
	int countChannels = argMat.channels();
	HalconCpp::HString hType;

	if (!argMat.isContinuous()) {
		return HalconCpp::HImage();
	}

	if (cvType == CV_8UC3) {
		hType = "byte";
		std::vector< cv::Mat> channels;
		cv::split(argMat, channels);
		uchar* pr, * pg, * pb;
		pr = channels.at(2).ptr<uchar>(0);
		pg = channels.at(1).ptr<uchar>(0);
		pb = channels.at(0).ptr<uchar>(0);
		dstImg.GenImage3(hType, wd, ht, pr, pg, pb);
	}
	else if (cvType == CV_8UC1) {
		hType = "byte";
		void* p = argMat.ptr<uchar>(0);
		dstImg.GenImage1(hType, wd, ht, p);
	}
	else if (cvType == CV_32FC1) {
		hType = "real";
		void* p = argMat.ptr<float>(0);
		dstImg.GenImage1(hType, wd, ht, p);
	}
	else if (cvType == CV_16U) {
		hType = "uint2";
		void* p = argMat.ptr<float>(0);
		dstImg.GenImage1(hType, wd, ht, p);
	}

	return dstImg;
}


cv::Mat HImage2Mat(HalconCpp::HImage arg)
{
	HalconCpp::HImage argImg;

	argImg = arg.Clone();

	void* p = nullptr;
	Hlong wd, ht;
	HalconCpp::HString hType;

	int channels = argImg.CountChannels();
	p = argImg.GetImagePointer1(&hType, &wd, &ht);
	QString type = hType.Text();

	if (channels == 3 && type == "byte") 
	{
		cv::Mat newImage;
		Hlong temp_wd, temp_ht;
		HalconCpp::HString temp_type;
		std::vector<cv::Mat> channels_BGR;
		auto&& r = argImg.AccessChannel(1);
		auto&& g = argImg.AccessChannel(2);
		auto&& b = argImg.AccessChannel(3);
		void* pCvr = r.GetImagePointer1(&temp_type, &temp_wd, &temp_ht);
		void* pCvg = g.GetImagePointer1(&temp_type, &temp_wd, &temp_ht);
		void* pCvb = b.GetImagePointer1(&temp_type, &temp_wd, &temp_ht);
		channels_BGR.push_back(cv::Mat(ht, wd, CV_8UC1, pCvb));
		channels_BGR.push_back(cv::Mat(ht, wd, CV_8UC1, pCvg));
		channels_BGR.push_back(cv::Mat(ht, wd, CV_8UC1, pCvr));
		cv::merge(channels_BGR, newImage);
		return newImage;
	}
	else if (type == "byte") {
		return cv::Mat(ht, wd, CV_8UC1, p);
	}
	else if (type == "real") {
		return cv::Mat(ht, wd, CV_32FC1, p);
	}
	else if (type == "uint2") {
		return cv::Mat(ht, wd, CV_16U, p);
	}
	else {
		return cv::Mat();
	}
}

// 伪彩
cv::Mat gray2pseudocolor(const cv::Mat& scaledGray)
{
	cv::Mat outputPseudocolor(scaledGray.size(), CV_8UC3);
	unsigned char grayValue;
	for (int y = 0; y < scaledGray.rows; y++)
		for (int x = 0; x < scaledGray.cols; x++)
		{
			//获取灰度值
			grayValue = scaledGray.at<uchar>(y, x);
			cv::Vec3b& pixel = outputPseudocolor.at<cv::Vec3b>(y, x);
			//给mat的RGB三通道赋值  orange  255 127 0
			pixel[0] = abs(255 - grayValue);
			pixel[1] = abs(127 - grayValue);
			pixel[2] = abs(0 - grayValue);
		}

	return outputPseudocolor;
}

Mat convertTo3Channels(const Mat& binImg)
{
	Mat three_channel = Mat::zeros(binImg.rows, binImg.cols, CV_8UC3);
	std::vector<Mat> channels;
	for (int i = 0; i < 3; i++)
	{
		channels.push_back(binImg);
	}
	merge(channels, three_channel);
	return three_channel;
}

VPEnum::RETURN_VALUE ToolDialogImpl::Execute()
{
	
	try
	{
		using namespace SuaKIT::API;
// 		if (m_Image.IsInitialized() && false)
// 		{
// 			QByteArray byteArray;
// 			Hlong size;
// 			char* data = (char*)m_Image.SerializeObject().GetSerializedItemPtr(&size);
// 			byteArray.resize(size);
// 			memcpy(byteArray.data(), data, size);
// 		}
		
		SuaKIT::API::Rect roi(0, 0, 480, 480);//optional

		cv::Mat BaseImg = HImageToMat(m_Image);
		cv::Mat imgMat = BaseImg;
		int ch = BaseImg.channels();
		if ( ch== 1 )
		{
			imgMat = convertTo3Channels(BaseImg);
		}
		
		int x = imgMat.step;
		int y = imgMat.channels();

		ImageData curImg(imgMat.data, imgMat.step, imgMat.cols, imgMat.rows, imgMat.channels()/*, true, roi*/);
		Status status = curImg.GetStatus();
		if (status == Status::SUCCESS)
		{

			SuaKIT_Int64 resultClass;
			FloatArray resultProbMapArray;
			float resultUncertainty;   // 结果不确定性能
			ImageData debugProbMap;
			status = m_pCls -> Evaluate(curImg, resultClass, resultProbMapArray, resultUncertainty, debugProbMap);
			if (status == Status::SUCCESS)
			{
				float* fptr = resultProbMapArray.GetDataPtr();
				HTuple Msg = HTuple();
				Msg[0] = "Class Name: " + (HTuple)m_pCls->GetClassLabelName(resultClass);
				Msg[1] = "Class Index: " + (HTuple)(int)resultClass;
				Msg[2] = "Class Score: " + (HTuple)fptr[resultClass];
				Msg[3] = "Uncertainty: " + (HTuple)resultUncertainty;

				cv::Mat debugMat(debugProbMap.GetWidth(), debugProbMap.GetHeight(), CV_8U);
				memcpy(debugMat.data, debugProbMap.GetDataPtr(), debugProbMap.GetHeight() * debugProbMap.GetWidth() * 1);

				cv::Mat mat;
				cv::resize(gray2pseudocolor(debugMat), mat,
					cv::Size(int(imgMat.cols), int(imgMat.rows)),
					0, 0, INTER_AREA);

				/// 执行线性融合
				float alpha = 0.5;
				float beta = (1.0 - alpha);
				cv::addWeighted(imgMat, beta, mat, alpha, 0.0, mat);

				HImage img = Mat2HImage(mat);

				hwndUnit->ShowImage(img);
				hwndUnit->ShowMsg(Msg);
			}
			else
			{
				hwndUnit->ShowImage(m_Image);
				hwndUnit->ShowMsg("Error");
			}
	
			hwndUnit->Refresh();

		}
	}
	catch (...)
	{
		qWarning() << "Execute() Error";
	}

	emit sigUpdateUI();
	return VPEnum::RETURN_VALUE::Success;
}

void ToolDialogImpl::on_ROIChange(const ViewMessage& sign)
{
	switch (sign)
	{
	case ViewMessage::MovingROI:
	{
		ROI* roi = roiController.getActiveROI();
		hv_roiDate = roi->getROIData();
		try
		{
			GenRectangle1(&m_objROI, hv_roiDate[0], hv_roiDate[1], hv_roiDate[2], hv_roiDate[3]);
		}
		catch (...)
		{	
		}
	}
	case ViewMessage::UpdateROI:
	case ViewMessage::CreatedROI:
	{
		roiController.defineModelROI();
		ROI* roi = roiController.getActiveROI();
		hv_roiDate = roi->getROIData();
		try
		{
			GenRectangle1(&m_objROI, hv_roiDate[0], hv_roiDate[1], hv_roiDate[2], hv_roiDate[3]);
		}
		catch (...)
		{
		}
	}
	break;
	default:
		break;
	}
}



/// <summary>
/// 
/// </summary>
/// <param name="bRun"></param>
void ToolDialogImpl::Running(bool bRun)
{

}



/// <summary>
/// 
/// </summary>
/// <param name="ar"></param>
/// <param name="bIsOut"></param>
/// <returns></returns>
bool ToolDialogImpl::Serialized(QDataStream& ar, bool bIsOut)
{
	int paranum;//参数数量
	if (bIsOut)//保存参数流程
	{ 
		paranum = 3;
		ar << paranum;//先保存参数数量

		ar << (int)1 << hv_roiDate;
		ar << (int)2 << roiController;
		ar << (int)3 << m_objROI;
	
	}
	else//加载参数流程，参数加载顺序一定要跟保存顺序一致
	{ 
		int nSize1 = 0;

		int para;
		ar >> paranum;//读取参数数量
		for (int i = 0; i < paranum; i++)
		{
			ar >> para;
			switch (para)
			{
			case 1:			  ar >> hv_roiDate;										break;
			case 2:			  ar >> roiController;									break;
			case 3:			  ar >> m_objROI;										break;

			default:
			{
				qWarning() << "Serialized(In) Error" ;
				return false;
			}
			break;
			}
		}

	}
	return true;
}






void ToolDialogImpl::on_UpdateUI()
{
	
}



/// <summary>
/// 确定
/// </summary>
void ToolDialogImpl::on_btnOK_clicked()
{
      this->hide();
}


/// <summary>
/// 取消按钮
/// </summary>
void ToolDialogImpl::on_btnCancel_clicked()
{
	// 将本工具的恢复到打开工具之前的状态
	RecoverData();
}


/// <summary>
/// 测试按钮
/// </summary>
void ToolDialogImpl::on_btnExecute_clicked()
{
	QElapsedTimer toolTimer;
	toolTimer.start();
	// 发送事件
	ToolEvent* pToolEvent = new ToolEvent(m_strPouName, m_strInstanceName, TOOL_EVENT_TYPE::TOOL_TRIGGER);
	QCoreApplication::sendEvent(m_pEventTarget, pToolEvent);

	// 统计返回值
	VPEnum::RETURN_VALUE ret = pToolEvent->ret;
	double nExecTime = toolTimer.elapsed();
	QString str;
	str = QString("耗时： %1 ms").arg(nExecTime, 0, 'G', 5);
	ui.label_time->setText(str);

	str = QString("状态： %1 ").arg(QMetaEnum::fromType<VPEnum::RETURN_VALUE>().key((short)ret));
	ui.label_state->setText(str);

	delete pToolEvent;
}


void ToolDialogImpl::on_btnLoadMode_clicked()
{
	using namespace SuaKIT::API;

	QString OpenFile, OpenFilePath;
	OpenFile = QFileDialog::getOpenFileName(this,
		"please choose an modes file",
		"C:\\VisionPlus_V3.0\\SK_Modes\\",
		"Modes Files(*.net);;All(*.*)");
	if (!OpenFile.isEmpty())
	{
		try
		{
		


		// 定义网络输入大小。此网络大小和输入图像大小应相同
		int networkH = 512;
		int networkW = 512;
		int networkC = 3;

		int batchSize = 8;	// user can choose the batch size among 1 <= batchSize <= maxBatchSize. 用户可以在1<=batchSize<=MaxBatchSide中选择批量大小。

		SuaKIT::API::InputDataType inputDataType = SuaKIT::API::InputDataType::SINGLE;
		SuaKIT_UInt64 multiImgCount = 1;


		SuaKIT_UInt64 maxNetSize = SuaKIT::API::ClassificationEvaluator::GetMaxNetworkSize(OpenFile.toStdWString().c_str() , device);
		if (networkH * networkW > maxNetSize) {
			vWarning() << "The network size is greater than the maximum size." ;
			vWarning() << SuaKIT::API::UnitFunction::GetErrorMessage() ;
			return;
		}


		SuaKIT_UInt64 maxBatchSize = SuaKIT::API::ClassificationEvaluator::GetMaxBatchSize(OpenFile.toStdWString().c_str(), device, networkH, networkW, networkC);
		if (batchSize > maxBatchSize) {
			vWarning() << "The batchSize size is greater than the maximum size." ;
			return;
		}

		


		// ClassificationEvaluator cls(networkPath.c_str(), device, networkH, networkW, networkC, batchSize, inputDataType, multiImgCount);
		m_pCls = new SuaKIT::API::ClassificationEvaluator(OpenFile.toStdWString().c_str(), device, networkH, networkW, networkC, batchSize);

		SuaKIT::API::Status status = m_pCls -> GetStatus();
		if (status != SuaKIT::API::Status::SUCCESS) {
			qWarning() << "ClassificationEvaluator Initialize Error : " << status ;
			qWarning() << UnitFunction::GetErrorMessage() ;

			return;
		}


		// 便利所有的类别
		size_t numClass = m_pCls ->GetClassTotalNum();
		for (int i = 0; i < numClass; ++i)
		{
			qWarning() << "Class name "<<  m_pCls-> GetClassLabelName(i) ;
		}

		ReadImage(&m_Image,  "C://0.png");

		hwndUnit->ShowImage(m_Image);
		hwndUnit->Refresh();

		qWarning() << "ok";


		}
		catch (...)
		{
			qWarning() << "Error";
		}

	}
}



void ToolDialogImpl::on_btnReadImg_clicked()
{

	QString OpenFile, OpenFilePath;
	OpenFile = QFileDialog::getOpenFileName(this,
		"please choose an image file",
		"C:\\VisionPlus_V3.0\\DemoImage\\",
		"Image Files(*.jpg *.png *.bmp *.pgm *.pbm);;All(*.*)");
	if (!OpenFile.isEmpty())
	{
		try
		{
			ReadImage(&m_Image, OpenFile.toStdString().c_str());

			m_QImage.load(OpenFile);
			hwndUnit->ShowImage(m_Image);

			hwndUnit->Refresh();
		}
		catch (...)
		{
			qWarning() << "Error";
		}


	}
}