VisionPlus_V3.0/VisionPlusTools/CstAI_Segmentation/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);


	m_pSeg = nullptr;

}


ToolDialogImpl::~ToolDialogImpl()
{

	if (m_pSeg != nullptr)
	{
		DestroySegObj(m_pSeg);
	}
}

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
	{
		hwndUnit->ShowImage(m_Image);

		cv::Mat BaseImg = HImageToMat(m_Image);
		cv::Mat imgMat = BaseImg;
		int ch = BaseImg.channels();
		if ( ch== 1 )
		{
			imgMat = convertTo3Channels(BaseImg);
		}
		
		if (m_pSeg != nullptr && m_pSeg->getStatus() == SegStatus::Seg_Success )
		{

			if (true)
			{
				cv::Mat dstImg;
				dstImg = m_pSeg->Evaluate(imgMat);     //返回缺陷二值图

				// 反色
				dstImg = 200 - dstImg;
				
				cv::Mat mat;
				cv::resize(gray2pseudocolor(dstImg), mat,
					cv::Size(int(imgMat.cols), int(imgMat.rows)),
					0, 0, INTER_AREA);

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

				hwndUnit->ShowImage(img);
			}
			else
			{
				//seg结果集合
				std::vector<SegResult> result;

				//图片裁剪参数,按固定大小裁剪
				CutParam param;
				param.cutType = CutType::Default;
				param.DstH = 256;
				param.DstW = 256;
				param.fillorresize = false;
				param.color = 0;

				//图片裁剪参数,按轮廓裁剪
				/*param.cutType = CutType::Contour;
				param.DstH = 256;
				param.DstW = 256;
				param.fillorresize = false;
				param.color = 0;*/



				m_pSeg->Evaluate(imgMat, result, param);

				for (int j = 0; j < result.size(); j++)
				{
					qWarning() << "X:" << result[j].x << "," << "Y:" << result[j].y << ",Width:" << result[j].w << ",Height:" << result[j].h << ",Class:" << result[j].classes;
				//	string splitPath = temppath + "-" + to_string(j) + ".bmp";
				//	cv::imwrite(splitPath, result[j].resultMask);
				}
			}

			
		

			
			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()
{
	
	QString OpenFile, OpenFilePath;
	OpenFile = QFileDialog::getOpenFileName(this,
		"please choose an modes file",
		"C:\\VisionPlus_V3.0\\AI_Modes\\",
		"Modes Files(*.BHD);;All(*.*)");
	if (!OpenFile.isEmpty())
	{
		try
		{

			int nGPU_ID = 0;
			int nBatchSize = 32;

			QByteArray ba = OpenFile.toLatin1(); // must
			char* modelPath = ba.data();

			int gpuId = 0;
			m_pSeg = CreateSegObjS(modelPath, 256, gpuId);
			if (m_pSeg != nullptr)
			{
				SegStatus status = m_pSeg->getStatus();
				if (status == SegStatus::Seg_Success)
				{
					
				}
			}
			else
			{
				qWarning() << modelPath << "error";
				return;
			}
			

// 		ReadImage(&m_Image,  "C://class_3.bmp");
// 
// 		hwndUnit->ShowImage(m_Image);
// 		hwndUnit->Refresh();

		
		}
		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";
		}


	}
}