添加项目文件。

2023-02-28 14:50:28 +08:00
commit e20fa428dd
187 changed files with 18135 additions and 0 deletions
--- a/NodeEditorPro/examples/halcon/HImageDLSegmentModel.cpp
+++ b/NodeEditorPro/examples/halcon/HImageDLSegmentModel.cpp
@ -0,0 +1,166 @@
+#include "HImageDLSegmentModel.hpp"
+
+#include <QApplication>
+#include <QDir>
+#include <QFileDialog>
+#include <QtCore/QEvent>
+
+#include "HRegionData.hpp"
+#include "DrawShapeView.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "QJsonParser.hpp"
+using namespace HalconCpp;
+
+
+HImageDLSegmentModel::HImageDLSegmentModel()
+{
+	m_hImage = std::make_shared<HImageData>();
+	m_result = std::make_shared<HRegionData>();
+	btn_select_model = new QPushButton(QStringLiteral("选择模型"));
+
+	connect(DrawShapeView::getInst(), SIGNAL(RegionFinished(RegionPixmapData)),
+		this, SLOT(OnNewRegionData(RegionPixmapData)));
+
+	connect(btn_select_model, &QPushButton::clicked, [=]()
+		{
+			dl_path.clear();
+			dl_path =
+				QFileDialog::getOpenFileName(nullptr,
+					tr("Select Dl Model"),
+					QDir::homePath(),
+					tr("File (*.hdl)"));
+			if (dl_path == "")
+			{
+				return;
+			}
+			readDlModel(dl_path);
+		});
+}
+
+bool HImageDLSegmentModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+	try
+	{
+
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	return true;
+}
+
+void HImageDLSegmentModel::OnNewRegionData(ShapeDataStruct _data)
+{
+	//if (!DrawShapeView::getInst()->getDrawFlag())
+	//{
+	//	return;
+	//}
+	RunTask();
+}
+
+unsigned int HImageDLSegmentModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+	case PortType::Out:
+		result = 1;
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HImageDLSegmentModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HImageDLSegmentModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+QJsonObject HImageDLSegmentModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+	result.insert("dl_path", dl_path);
+	return result;
+}
+
+void HImageDLSegmentModel::restore(QJsonObject const& _json)
+{
+	dl_path = _json.value("dl_path").toString();
+}
+
+void HImageDLSegmentModel::readDlModel(QString modelFileName)
+{
+	m_dl_model = new HDlModel();
+	m_dl_model->ReadDlModel(modelFileName.toStdString().c_str());
+	image_dimensions = m_dl_model->GetDlModelParam("image_dimensions");
+	class_ids = m_dl_model->GetDlModelParam("class_ids");
+	m_dl_model->SetDlModelParam("batch_size", 1);
+}
+
+NodeDataType
+HImageDLSegmentModel::dataType(PortType port_type, PortIndex port_index) const
+{
+	if (port_type == PortType::In)
+	{
+		switch (port_index)
+		{
+		case 0:
+			return HImageData().type();
+			break;
+		}
+	}
+	else
+	{
+		switch (port_index)
+		{
+		case 0:
+			return HRegionData().type();
+			break;
+		}
+	}
+	return HImageData().type();
+}
+
+void HImageDLSegmentModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hImageData =
+		std::dynamic_pointer_cast<HImageData>(data);
+	if (hImageData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_hImage->setHImage(*hImageData->hImage());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HImageDLSegmentModel::
+outData(PortIndex)
+{
+	return std::dynamic_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HImageDLSegmentModel.hpp
+++ b/NodeEditorPro/examples/halcon/HImageDLSegmentModel.hpp
@ -0,0 +1,87 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include <QPushButton>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+#include "DrawShapeView.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HImageDLSegmentModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HImageDLSegmentModel();
+	virtual ~HImageDLSegmentModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("语义分割");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("语义分割");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("语义分割");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return btn_select_model; }
+
+	bool
+		resizable() const override { return false; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+	QJsonObject save() const override;
+	void restore(QJsonObject const&) override;
+	void readDlModel(QString modelFileName);
+protected:
+	bool RunTask();
+
+public slots:
+	void OnNewRegionData(ShapeDataStruct _data);
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("图片输入未连接!");
+private:
+	QString dl_path;
+	QPushButton* btn_select_model;
+	HDlModel* m_dl_model;
+	HTuple image_dimensions;
+	HTuple class_ids;
+	HTuple valid_thres = 0.7;
+	std::shared_ptr<HImageData> m_hImage;
+	std::shared_ptr<HRegionData> m_result;
+};
--- a/NodeEditorPro/examples/halcon/HImageData.hpp
+++ b/NodeEditorPro/examples/halcon/HImageData.hpp
@ -0,0 +1,45 @@
+#pragma once
+
+#include <QtGui/QPixmap>
+
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using namespace HalconCpp;
+
+class HImageData :public NodeData
+{
+public:
+	HImageData()
+	{
+		m_himage = HImage();
+	}
+	HImageData(HImage& h_image)
+	{
+		if (h_image.IsInitialized())
+		{
+			m_himage = h_image;
+		}
+	}
+	virtual ~HImageData()
+	{
+
+	}
+	NodeDataType type() const override
+	{
+		return { "HImage","Img" };
+	}
+	HImage* hImage() { return &m_himage; }
+	void setHImage(HImage const& _img)
+	{
+		if (!_img.IsInitialized())
+		{
+			return;
+		}
+		m_himage = _img;
+	}
+private:
+	HImage m_himage;
+};
--- a/NodeEditorPro/examples/halcon/HImageFolderModel.cpp
+++ b/NodeEditorPro/examples/halcon/HImageFolderModel.cpp
@ -0,0 +1,171 @@
+#include "HImageFolderModel.hpp"
+#include <QtCore/QEvent>
+#include <QtCore/QDir>
+#include <QtWidgets/QFileDialog>
+#include <QDebug>
+HImageFolderModel::HImageFolderModel()
+{
+	m_image_view = new HImageViewWidget();
+	m_image_view->resize(200, 200);
+	m_paraWidget = new QWidget();
+	m_paraWidget->resize(200, 250);
+	m_host = new QVBoxLayout();
+	m_h_host = new QHBoxLayout();
+	m_paraWidget->setLayout(m_host);
+	btn_selectFolder = new QPushButton(QStringLiteral("选择目录"));
+	btn_last = new QPushButton(QStringLiteral("上一张"));
+	btn_next = new QPushButton(QStringLiteral("下一张"));
+
+	btn_selectFolder->setFixedHeight(25);
+	btn_last->setFixedHeight(25);
+	btn_next->setFixedHeight(25);
+	m_h_host->addWidget(btn_last);
+	m_h_host->addWidget(btn_next);
+
+	m_host->addWidget(btn_selectFolder);
+	m_host->addLayout(m_h_host);
+	m_host->addWidget(m_image_view);
+	m_host->setSpacing(1);
+	m_h_host->setSpacing(1);
+	m_host->setContentsMargins(0, 0, 0, 0);
+	m_paraWidget->setContentsMargins(1, 1, 1, 1);
+	btn_last->installEventFilter(this);
+	btn_next->installEventFilter(this);
+	btn_selectFolder->installEventFilter(this);
+
+	m_hImageData = std::make_shared<HImageData>();
+}
+
+unsigned int HImageFolderModel::nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 0;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+QJsonObject HImageFolderModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+	result.insert("folderPath", folderPath);
+	result.insert("curIndex", curIndex);
+	return result;
+}
+
+void HImageFolderModel::restore(QJsonObject const& json_values)
+{
+	//NodeDataModel::restore(json_values);
+	folderPath = json_values["folderPath"].toString();
+	curIndex = json_values["curIndex"].toInt(0);
+	loadImageFolder(folderPath, curIndex);
+}
+
+void HImageFolderModel::loadImageFolder(QString path, int index)
+{
+	QDir dir(folderPath);
+	if (folderPath == "" || !dir.exists())
+	{
+		return;
+	}
+	HalconCpp::ListFiles(path.toStdString().c_str(), "files", &fileListStr);
+	TupleRegexpSelect(fileListStr, "\\.(tif|tiff|gif|bmp|jpg|jpeg|jp2|png|pcx|pgm|ppm|pbm|xwd|ima|hobj)$", &imgListStr);
+	imageCounst = imgListStr.Length();
+	if (imageCounst == 0)
+	{
+		return;
+	}
+	if (index >= imageCounst)
+	{
+		index = 0;
+	}
+	curIndex = index;
+	tmpImg.ReadImage(imgListStr[curIndex].ToTuple());
+	m_hImageData->setHImage(tmpImg);
+	m_image_view->showImage(*m_hImageData->hImage());
+}
+
+bool HImageFolderModel::eventFilter(QObject* object, QEvent* event)
+{
+	if (object == btn_selectFolder)
+	{
+		if (event->type() == QEvent::MouseButtonPress)
+		{
+			folderPath = QFileDialog::getExistingDirectory(nullptr,tr("Select Folder"),QDir::homePath());
+			if (folderPath == "")
+			{
+				return false;
+			}
+
+			loadImageFolder(folderPath);
+
+			Q_EMIT dataUpdated(0);
+
+			return true;
+		}
+		else if (event->type() == QEvent::Resize)
+		{
+
+		}
+	}
+	else if (object == btn_last)
+	{
+		if (event->type() == QEvent::MouseButtonPress)
+		{
+			if (curIndex - 1 >= 0)
+			{
+				curIndex--;
+				tmpImg.ReadImage(imgListStr[curIndex].ToTuple());
+				m_hImageData->setHImage(tmpImg);
+				m_image_view->showImage(*m_hImageData->hImage());
+				Q_EMIT dataUpdated(0);
+			}
+			else
+			{
+				curIndex = imageCounst - 1;
+			}
+		}
+	}
+	else if (object == btn_next)
+	{
+		if (event->type() == QEvent::MouseButtonPress)
+		{
+			if (curIndex + 1 < imageCounst)
+			{
+				curIndex++;
+				tmpImg.ReadImage(imgListStr[curIndex].ToTuple());
+				m_hImageData->setHImage(tmpImg);
+				m_image_view->showImage(*m_hImageData->hImage());
+				Q_EMIT dataUpdated(0);
+			}
+			else
+			{
+				curIndex = 0;
+			}
+		}
+	}
+	return false;
+}
+
+NodeDataType
+HImageFolderModel::dataType(PortType, PortIndex) const
+{
+	return HImageData().type();
+}
+std::shared_ptr<NodeData>
+HImageFolderModel::
+outData(PortIndex)
+{
+	return std::dynamic_pointer_cast<HImageData>(m_hImageData);
+}
--- a/NodeEditorPro/examples/halcon/HImageFolderModel.hpp
+++ b/NodeEditorPro/examples/halcon/HImageFolderModel.hpp
@ -0,0 +1,83 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QPushButton>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像输入节点
+ */
+class HImageFolderModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HImageFolderModel();
+	virtual ~HImageFolderModel() {}
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("图像目录输入");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("图像目录输入");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("图像目录输入");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override
+	{ }
+
+	QWidget*
+		embeddedWidget() override { return m_paraWidget; }
+
+	bool
+		resizable() const override { return false; }
+	QJsonObject save() const override;
+	void restore(QJsonObject const&) override;
+	void loadImageFolder(QString path, int index = 0);
+protected:
+	bool eventFilter(QObject* watched, QEvent* event) override;
+private:
+	QString folderPath;
+	std::shared_ptr< HImageData> m_hImageData;
+	QWidget* m_paraWidget;
+	QVBoxLayout* m_host;
+	QHBoxLayout* m_h_host;
+	QPushButton* btn_selectFolder;
+	QPushButton* btn_last;
+	QPushButton* btn_next;
+	HImageViewWidget* m_image_view;
+	HTuple fileListStr;
+	HTuple imgListStr;
+	HImage tmpImg;
+	int curIndex = 0;
+	int imageCounst = 0;
+};
--- a/NodeEditorPro/examples/halcon/HImageLoaderModel.cpp
+++ b/NodeEditorPro/examples/halcon/HImageLoaderModel.cpp
@ -0,0 +1,112 @@
+#include "HImageLoaderModel.hpp"
+#include <QtCore/QEvent>
+#include <QtCore/QDir>
+#include <QtWidgets/QFileDialog>
+
+HImageLoaderModel::HImageLoaderModel()
+{
+	m_image_view = new HImageViewWidget();
+	m_image_view->installEventFilter(this);
+	m_image_view->resize(200, 200);
+	m_hImageData = std::make_shared<HImageData>();
+}
+
+unsigned int HImageLoaderModel::nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 0;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+QJsonObject HImageLoaderModel::save() const
+{
+	QJsonObject modelJson = NodeDataModel::save();
+	if (m_hImageData)
+	{
+		HTuple* R, * G, * B;
+		HTuple width, height;
+		int chanels = m_hImageData->hImage()->CountChannels();
+		m_hImageData->hImage()->GetImageSize(&width, &height);
+		modelJson.insert("width", width.D());
+		modelJson.insert("height", height.D());
+		modelJson.insert("chanels", chanels);
+		modelJson.insert("imageName", imageName);
+	}
+
+	return modelJson;
+}
+
+void HImageLoaderModel::restore(QJsonObject const& p)
+{
+	imageName = p["imageName"].toString();
+	loadImage(imageName);
+}
+
+void HImageLoaderModel::loadImage(QString fileName)
+{
+	if (fileName == "")
+	{
+		return;
+	}
+	HImage tmpImg;
+	tmpImg.ReadImage(fileName.toStdString().c_str());
+	m_hImageData->setHImage(tmpImg);
+	m_image_view->showImage(*m_hImageData->hImage());
+}
+
+bool HImageLoaderModel::eventFilter(QObject* object, QEvent* event)
+{
+	if (object == m_image_view)
+	{
+		if (event->type() == QEvent::MouseButtonPress)
+		{
+			imageName =
+				QFileDialog::getOpenFileName(nullptr,
+					tr("Open Image"),
+					QDir::homePath(),
+					tr("Image Files (*.png *.jpg *.bmp)"));
+			if (imageName == "")
+			{
+				return false;
+			}
+
+			loadImage(imageName);
+
+			Q_EMIT dataUpdated(0);
+
+			return true;
+		}
+		else if (event->type() == QEvent::Resize)
+		{
+
+		}
+	}
+
+	return false;
+}
+
+NodeDataType
+HImageLoaderModel::dataType(PortType, PortIndex) const
+{
+	return HImageData().type();
+}
+
+std::shared_ptr<NodeData>
+HImageLoaderModel::
+outData(PortIndex)
+{
+	return std::dynamic_pointer_cast<HImageData>(m_hImageData);
+}
--- a/NodeEditorPro/examples/halcon/HImageLoaderModel.hpp
+++ b/NodeEditorPro/examples/halcon/HImageLoaderModel.hpp
@ -0,0 +1,70 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像输入节点
+ */
+class HImageLoaderModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HImageLoaderModel();
+	virtual ~HImageLoaderModel() {}
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("图像输入");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("图像输入");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("图像输入");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override
+	{ }
+
+	QWidget*
+		embeddedWidget() override { return m_image_view; }
+
+	bool
+		resizable() const override { return false; }
+	QJsonObject save() const override;
+	void restore(QJsonObject const&) override;
+	void loadImage(QString fileName);
+protected:
+	bool eventFilter(QObject* watched, QEvent* event) override;
+private:
+	QString imageName;
+	std::shared_ptr< HImageData> m_hImageData;
+	HImageViewWidget* m_image_view;
+
+};
--- a/NodeEditorPro/examples/halcon/HImageRGB2GrayModel.cpp
+++ b/NodeEditorPro/examples/halcon/HImageRGB2GrayModel.cpp
@ -0,0 +1,102 @@
+#include "HImageRGB2GrayModel.hpp"
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HImageRGB2GrayModel::HImageRGB2GrayModel()
+{
+	m_hImage = std::make_shared<HImageData>();
+}
+
+bool HImageRGB2GrayModel::RunTask()
+{
+	Q_EMIT computingStarted();
+	PortIndex const outPortIndex = 0;
+	try
+	{
+		HTuple imgChanels = m_hImage->hImage()->CountChannels();
+		if (imgChanels == 3)
+		{
+			HImage tmp_img = m_hImage->hImage()->Rgb3ToGray(*m_hImage->hImage(), *m_hImage->hImage());
+			m_hImage->setHImage(tmp_img);
+			tmp_img.Clear();
+		}
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+	Q_EMIT computingFinished();
+	return true;
+}
+
+unsigned int HImageRGB2GrayModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HImageRGB2GrayModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HImageRGB2GrayModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+NodeDataType
+HImageRGB2GrayModel::dataType(PortType, PortIndex) const
+{
+	return HImageData().type();
+}
+
+void HImageRGB2GrayModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hImageData =
+		std::dynamic_pointer_cast<HImageData>(data);
+	if (hImageData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_hImage->setHImage(*hImageData->hImage());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HImageRGB2GrayModel::
+outData(PortIndex)
+{
+	return std::dynamic_pointer_cast<HImageData>(m_hImage);
+}
--- a/NodeEditorPro/examples/halcon/HImageRGB2GrayModel.hpp
+++ b/NodeEditorPro/examples/halcon/HImageRGB2GrayModel.hpp
@ -0,0 +1,73 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HImageRGB2GrayModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HImageRGB2GrayModel();
+	virtual ~HImageRGB2GrayModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("图像转灰度");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("图像转灰度");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("图像转灰度");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return Q_NULLPTR; }
+
+	bool
+		resizable() const override { return false; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+protected:
+	bool RunTask();
+
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("图片输入未连接!");
+private:
+	std::shared_ptr<HImageData> m_hImage;
+
+};
--- a/NodeEditorPro/examples/halcon/HImageReduceDomainModel.cpp
+++ b/NodeEditorPro/examples/halcon/HImageReduceDomainModel.cpp
@ -0,0 +1,142 @@
+#include "HImageReduceDomainModel.hpp"
+
+#include <QApplication>
+#include <QtCore/QEvent>
+#include "DrawShapeView.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "QJsonParser.hpp"
+using namespace HalconCpp;
+
+
+HImageReduceDomainModel::HImageReduceDomainModel()
+{
+	m_hImage = std::make_shared<HImageData>();
+	m_result = std::make_shared<HImageData>();
+	btn_drawReg = new QPushButton(QStringLiteral("绘制区域"));
+	m_region_data = std::make_shared<ShapeDataStruct>();
+	m_domain.GenEmptyRegion();
+
+	connect(DrawShapeView::getInst(), SIGNAL(RegionComform(ShapeDataStruct)),
+		this, SLOT(OnNewRegionData(ShapeDataStruct)));
+
+	connect(btn_drawReg, &QPushButton::clicked, [=]()
+		{
+			QPixmap tmpPix;
+			HImageViewWidget::HImageToQPixmap(*m_hImage->hImage(), tmpPix);
+			DrawShapeView::getInst()->FitShowImage(tmpPix, *m_region_data);
+		});
+}
+
+bool HImageReduceDomainModel::RunTask()
+{
+	//Q_EMIT computingStarted();
+	PortIndex const outPortIndex = 0;
+	try
+	{
+		if ((int)m_region_data->shapePolygon.size() > 0)
+		{
+			HImage tmpImage;
+			HalconCpp::ReduceDomain(*m_hImage->hImage(), m_domain, &tmpImage);
+			m_result->setHImage(tmpImage);
+		}
+		else
+		{
+			m_result->setHImage(*m_hImage->hImage());
+		}
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+	return true;
+}
+
+void HImageReduceDomainModel::OnNewRegionData(ShapeDataStruct _data)
+{
+	*m_region_data = std::move(_data);
+	m_domain = DrawShapeView::GetHRegionFromData(*m_region_data);
+
+	RunTask();
+}
+
+unsigned int HImageReduceDomainModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HImageReduceDomainModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HImageReduceDomainModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+QJsonObject HImageReduceDomainModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+	result.insert("m_region_data", QJsonConvert::convertToJson(*m_region_data));
+	return result;
+}
+
+void HImageReduceDomainModel::restore(QJsonObject const& _json)
+{
+	QJsonConvert::convertFromJson(_json.value("m_region_data").toObject(), *m_region_data);
+	m_domain = DrawShapeView::GetHRegionFromData(*m_region_data);
+}
+
+NodeDataType
+HImageReduceDomainModel::dataType(PortType, PortIndex) const
+{
+	return HImageData().type();
+}
+
+void HImageReduceDomainModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hImageData =
+		std::dynamic_pointer_cast<HImageData>(data);
+	if (hImageData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_hImage->setHImage(*hImageData->hImage());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HImageReduceDomainModel::
+outData(PortIndex)
+{
+	return std::dynamic_pointer_cast<HImageData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HImageReduceDomainModel.hpp
+++ b/NodeEditorPro/examples/halcon/HImageReduceDomainModel.hpp
@ -0,0 +1,83 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include <QPushButton>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HImageViewWidget.hpp"
+#include "DrawShapeView.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HImageReduceDomainModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HImageReduceDomainModel();
+	virtual ~HImageReduceDomainModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("选区掩膜");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("选区掩膜");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("选区掩膜");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return btn_drawReg; }
+
+	bool
+		resizable() const override { return false; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+	QJsonObject save() const override;
+	void restore(QJsonObject const&) override;
+protected:
+	bool RunTask();
+
+public slots:
+	void OnNewRegionData(ShapeDataStruct _data);
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("图片输入未连接!");
+private:
+	//HWindow* h_window;
+	QPushButton* btn_drawReg;
+	HRegion m_domain;
+	std::shared_ptr<ShapeDataStruct> m_region_data;
+	std::shared_ptr<HImageData> m_hImage;
+	std::shared_ptr<HImageData> m_result;
+};
--- a/NodeEditorPro/examples/halcon/HImageShowModel.cpp
+++ b/NodeEditorPro/examples/halcon/HImageShowModel.cpp
@ -0,0 +1,153 @@
+#include "HImageShowModel.hpp"
+#include <QtCore/QEvent>
+#include <QtCore/QDir>
+#include <QtWidgets/QFileDialog>
+
+HImageShowModel::HImageShowModel()
+{
+	m_image_view = new HImageViewWidget();
+	m_image_view->installEventFilter(this);
+	m_image_view->resize(200, 200);
+	m_hImage = std::make_shared<HImageData>();
+	m_hRegion = std::make_shared<HRegionData>();
+#ifdef SHOWHALCON_OBJ
+	h_window = new HWindow(0, 0, 512, 512, nullptr, "visible", "");
+#endif
+
+}
+
+bool HImageShowModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+
+	try
+	{
+		m_image_view->showImage(*m_hImage->hImage());
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+
+	return true;
+}
+
+unsigned int HImageShowModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 2;
+		break;
+
+	case PortType::Out:
+		result = 2;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HImageShowModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HImageShowModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+bool HImageShowModel::eventFilter(QObject* object, QEvent* event)
+{
+
+	return false;
+}
+
+NodeDataType
+HImageShowModel::dataType(PortType, PortIndex index) const
+{
+	switch (index)
+	{
+	case 0:
+		return HImageData().type();
+		break;
+	case 1:
+		return HRegionData().type();
+		break;
+	}
+	return HImageData().type();
+}
+
+void HImageShowModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	if (data == nullptr)
+	{
+		return;
+	}
+	if (data->type() == m_hImage->type())
+	{
+		auto dataPtr = std::dynamic_pointer_cast<HImageData>(data);
+		if (!dataPtr->hImage()->IsInitialized())
+		{
+			return;
+		}
+		m_hImage->setHImage(*dataPtr->hImage());
+#ifdef SHOWHALCON_OBJ
+		h_window->ClearWindow();
+		h_window->SetPart(HTuple(0), HTuple(0), m_hImage->hImage()->Height(), m_hImage->hImage()->Width());
+		HTuple chanels = m_hImage->hImage()->CountChannels();
+		if (chanels == 1)
+		{
+			h_window->DispImage(*m_hImage->hImage());
+		}
+		else
+		{
+			h_window->DispColor(*m_hImage->hImage());
+		}
+#endif
+	}
+	else if (data->type() == m_hRegion->type())
+	{
+		auto dataPtr = std::dynamic_pointer_cast<HRegionData>(data);
+		if (!dataPtr->hRegion()->IsInitialized())
+		{
+			return;
+		}
+		m_hRegion->setHRegion(*dataPtr->hRegion());
+		m_hRegion->setSize(dataPtr->getSize());
+
+		HImage tmpImg = m_hRegion->hRegion()->RegionToBin(255, 0,
+			m_hRegion->getSize().width(), m_hRegion->getSize().height());
+		m_hImage->setHImage(tmpImg);
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HImageShowModel::
+outData(PortIndex index)
+{
+	switch (index)
+	{
+	case 0:
+		return std::dynamic_pointer_cast<HImageData>(m_hImage);
+		break;
+	case 1:
+		return std::dynamic_pointer_cast<HRegionData>(m_hRegion);
+		break;
+	}
+	return std::dynamic_pointer_cast<HImageData>(m_hImage);
+}
--- a/NodeEditorPro/examples/halcon/HImageShowModel.hpp
+++ b/NodeEditorPro/examples/halcon/HImageShowModel.hpp
@ -0,0 +1,82 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+
+//#define SHOWHALCON_OBJ
+
+/**
+ * \brief halcon 图像输入节点
+ */
+class HImageShowModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HImageShowModel();
+	virtual ~HImageShowModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("图像显示");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("图像显示");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("图像显示");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return m_image_view; }
+
+	bool
+		resizable() const override { return true; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+protected:
+	bool RunTask();
+	bool eventFilter(QObject* watched, QEvent* event) override;
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("图片输入未连接!");
+private:
+#ifdef SHOWHALCON_OBJ
+	HWindow* h_window;
+#endif
+
+	std::shared_ptr<HImageData> m_hImage;
+	std::shared_ptr<HRegionData> m_hRegion;
+	HImageViewWidget* m_image_view;
+};
--- a/NodeEditorPro/examples/halcon/HImageSplitChanelModel.cpp
+++ b/NodeEditorPro/examples/halcon/HImageSplitChanelModel.cpp
@ -0,0 +1,140 @@
+#include "HImageSplitChanelModel.hpp"
+
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HImageSplitChanelModel::HImageSplitChanelModel()
+{
+	m_hImage = std::make_shared<HImageData>();
+}
+
+bool HImageSplitChanelModel::RunTask()
+{
+
+	auto img1 = m_hImage.lock();
+	try
+	{
+		if (img1)
+		{
+			HTuple imgChanels = img1->hImage()->CountChannels();
+			if (imgChanels == 3)
+			{
+				HImage chanR, chanG, chanB;
+				Decompose3(*img1->hImage(), &chanR, &chanG, &chanB);
+				if (m_resultR == nullptr)
+				{
+					m_resultR = std::make_shared<HImageData>(chanR);
+				}
+				if (m_resultG == nullptr)
+				{
+					m_resultG = std::make_shared<HImageData>(chanG);
+				}
+				if (m_resultB == nullptr)
+				{
+					m_resultB = std::make_shared<HImageData>(chanB);
+				}
+				m_resultR->setHImage(chanR);
+				m_resultG->setHImage(chanG);
+				m_resultB->setHImage(chanB);
+			}
+			else if (imgChanels == 1)
+			{
+				m_resultR = std::shared_ptr<HImageData>(m_hImage);
+				m_resultG = std::shared_ptr<HImageData>(m_hImage);
+				m_resultB = std::shared_ptr<HImageData>(m_hImage);
+			}
+			modelValidationState = NodeValidationState::Valid;
+			modelValidationError = QString();
+		}
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+		m_resultR.reset();
+		m_resultG.reset();
+		m_resultB.reset();
+	}
+
+	Q_EMIT dataUpdated((PortIndex)0);
+	Q_EMIT dataUpdated((PortIndex)1);
+	Q_EMIT dataUpdated((PortIndex)2);
+
+	return true;
+}
+
+unsigned int HImageSplitChanelModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 3;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HImageSplitChanelModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HImageSplitChanelModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+NodeDataType
+HImageSplitChanelModel::dataType(PortType, PortIndex) const
+{
+	return HImageData().type();
+}
+
+void HImageSplitChanelModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hImageData =
+		std::dynamic_pointer_cast<HImageData>(data);
+
+	switch (portIndex)
+	{
+	case 0:
+		m_hImage = hImageData;
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HImageSplitChanelModel::
+outData(PortIndex index)
+{
+
+	if (index == 0)
+	{
+		return std::static_pointer_cast<NodeData>(m_resultR);
+	}
+	else if (index == 1)
+	{
+		return std::static_pointer_cast<NodeData>(m_resultG);
+	}
+	else
+	{
+		return std::static_pointer_cast<NodeData>(m_resultB);
+	}
+}
--- a/NodeEditorPro/examples/halcon/HImageSplitChanelModel.hpp
+++ b/NodeEditorPro/examples/halcon/HImageSplitChanelModel.hpp
@ -0,0 +1,75 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HImageSplitChanelModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HImageSplitChanelModel();
+	virtual ~HImageSplitChanelModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("SplitChanel");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("图像通道拆分");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("通道拆分");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return Q_NULLPTR; }
+
+	bool
+		resizable() const override { return true; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+protected:
+	bool RunTask();
+
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("图片输入未连接!");
+private:
+	std::weak_ptr<HImageData> m_hImage;
+	std::shared_ptr<HImageData> m_resultR;
+	std::shared_ptr<HImageData> m_resultG;
+	std::shared_ptr<HImageData> m_resultB;
+};
--- a/NodeEditorPro/examples/halcon/HImageThresholdModel.cpp
+++ b/NodeEditorPro/examples/halcon/HImageThresholdModel.cpp
@ -0,0 +1,204 @@
+#include "HImageThresholdModel.hpp"
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HImageThresholdModel::HImageThresholdModel()
+{
+	m_widget = new QWidget();
+	m_widget->setAttribute(Qt::WA_NoSystemBackground);
+	m_widget->setFixedSize(130, 70);
+	m_minGraySlider = new QSlider(m_widget);
+	m_maxGraySlider = new QSlider(m_widget);
+	m_minGraySlider->setOrientation(Qt::Horizontal);
+	m_maxGraySlider->setOrientation(Qt::Horizontal);
+	m_minGraySlider->resize(120, 25);
+	m_maxGraySlider->resize(120, 25);
+	m_minGraySlider->move(0, 0);
+	m_maxGraySlider->move(0, 35);
+	m_minGraySlider->setMinimum(0);
+	m_minGraySlider->setMaximum(255);
+	m_maxGraySlider->setMinimum(0);
+	m_maxGraySlider->setMaximum(255);
+
+	m_maxGraySlider->setValue(255);
+
+	m_hImage = std::make_shared<HImageData>();
+	m_domain = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+
+	connect(m_minGraySlider, &QSlider::valueChanged, [=]()
+		{
+			RunTask();
+		});
+	connect(m_maxGraySlider, &QSlider::valueChanged, [=]()
+		{
+			RunTask();
+		});
+}
+
+bool HImageThresholdModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+	if (m_hImage->hImage() == nullptr)
+	{
+		return false;
+	}
+	try
+	{
+		if (m_domain->hRegion()->IsInitialized())
+		{
+			m_hImage->hImage()->ReduceDomain(*m_domain->hRegion());
+		}
+		int imgChanels = m_hImage->hImage()->CountChannels();
+		HImage tmp_img;
+		if (imgChanels == 3)
+		{
+			tmp_img = m_hImage->hImage()->Rgb3ToGray(*m_hImage->hImage(), *m_hImage->hImage());
+		}
+		else if (imgChanels == 1)
+		{
+			tmp_img = *m_hImage->hImage();
+		}
+
+		double minVal = m_minGraySlider->value();
+		double maxVal = m_maxGraySlider->value();
+
+		m_result->setHRegion(m_hImage->hImage()->Threshold(minVal, maxVal));
+		m_result->setSize(QSize(m_hImage->hImage()->Width().D(), m_hImage->hImage()->Height().D()));
+		tmp_img.Clear();
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+
+	return true;
+}
+
+bool HImageThresholdModel::eventFilter(QObject* watched, QEvent* event)
+{
+
+	return false;
+}
+
+unsigned int HImageThresholdModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 2;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HImageThresholdModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HImageThresholdModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+QJsonObject HImageThresholdModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+	result.insert("m_minGraySlider", m_minGraySlider->value());
+	result.insert("m_maxGraySlider", m_maxGraySlider->value());
+	return result;
+}
+
+void HImageThresholdModel::restore(QJsonObject const& p)
+{
+	m_minGraySlider->setValue(p["m_minGraySlider"].toInt(0));
+	m_maxGraySlider->setValue(p["m_maxGraySlider"].toInt(255));
+}
+
+NodeDataType
+HImageThresholdModel::dataType(PortType portType, PortIndex portIndex) const
+{
+	if (portType == PortType::In)
+	{
+		switch (portIndex)
+		{
+		case 0:
+			return HImageData().type();
+			break;
+		case 1:
+			return HRegionData().type();
+			break;
+		}
+	}
+	else
+	{
+		switch (portIndex)
+		{
+		case 0:
+			return HRegionData().type();
+			break;
+		}
+	}
+	return HImageData().type();
+}
+
+void HImageThresholdModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	if (portIndex == 0)
+	{
+		auto hImageData =
+			std::dynamic_pointer_cast<HImageData>(data);
+		if (hImageData == nullptr)
+		{
+			return;
+		}
+		m_hImage->setHImage(*hImageData->hImage());
+	}
+	else if (portIndex == 1)
+	{
+		auto hImageData =
+			std::dynamic_pointer_cast<HRegionData>(data);
+		if (hImageData != nullptr)
+		{
+			m_domain->setHRegion(*hImageData->hRegion());
+		}
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HImageThresholdModel::
+outData(PortIndex index)
+{
+	switch (index)
+	{
+	case 0:
+		return std::dynamic_pointer_cast<NodeData>(m_result);
+		break;
+	case 1:
+		break;
+	default:
+		break;
+	}
+	return std::dynamic_pointer_cast<NodeData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HImageThresholdModel.hpp
+++ b/NodeEditorPro/examples/halcon/HImageThresholdModel.hpp
@ -0,0 +1,83 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QSlider>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HImageThresholdModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HImageThresholdModel();
+	virtual ~HImageThresholdModel() = default;
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("二值化节点");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("二值化节点");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("二值化节点");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return m_widget; }
+
+	bool
+		resizable() const override { return true; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+
+	QJsonObject save() const override;
+
+	void restore(QJsonObject const&) override;
+
+protected:
+	bool RunTask();
+	bool eventFilter(QObject* watched, QEvent* event) override;
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("图片输入未连接!");
+private:
+	std::shared_ptr<HImageData> m_hImage;
+	std::shared_ptr<HRegionData> m_domain;
+	std::shared_ptr<HRegionData> m_result;
+	QSlider* m_minGraySlider;
+	QSlider* m_maxGraySlider;
+	QWidget* m_widget;
+};
--- a/NodeEditorPro/examples/halcon/HImageViewWidget.cpp
+++ b/NodeEditorPro/examples/halcon/HImageViewWidget.cpp
@ -0,0 +1,158 @@
+#include "HImageViewWidget.hpp"
+
+HImageViewWidget::HImageViewWidget(QWidget* parent)
+
+{
+	if (parent != Q_NULLPTR)
+	{
+		this->setParent(parent);
+	}
+	this->setStyleSheet("background-color:black;");
+	cur_pixmap = new QPixmap();
+}
+
+void HImageViewWidget::showImage(HImage const& _himg)
+{
+	if (!_himg.IsInitialized())
+	{
+		return;
+	}
+	Hlong width;
+	Hlong height;
+	double zoom_ratio = 1.0;
+	_himg.GetImageSize(&width, &height);
+	if (width > this->width())
+	{
+		zoom_ratio = 1.0 * this->width() / width;
+	}
+	cur_image = _himg.ZoomImageSize(width * zoom_ratio, height * zoom_ratio, "bilinear");
+	HImageToQPixmap(cur_image, *cur_pixmap);
+	this->update();
+}
+
+void HImageViewWidget::HImageToQPixmap(HImage const& _img, QPixmap& tar_pixmap)
+{
+	Hlong w, h; HString hType;
+	Hlong width;
+	Hlong height;
+	QImage tar_img;
+
+	_img.GetImageSize(&width, &height);
+	HTuple type = _img.GetImageType();
+	//获取HImage的通道数
+	HTuple hChannels = _img.CountChannels();
+	if (strcmp(type[0].S(), "byte")) // 如果不是 byte 类型，则失败
+	{
+		return;
+	}
+	QImage::Format format;
+	switch (hChannels[0].I())
+	{
+	case 1:
+		format = QImage::Format_Grayscale8;
+		break;
+	case 3:
+		format = QImage::Format_RGB32;
+		break;
+	default:
+		return;
+	}
+	if (tar_img.width() != width || tar_img.height() != height || tar_img.format() != format)
+	{
+		tar_img = QImage(static_cast<int>(width),
+			static_cast<int>(height),
+			format);
+	}
+	if (hChannels == 1)
+	{
+		//获取HImage的数据指针
+		uchar* pBuf = (uchar*)_img.GetImagePointer1(&hType, &w, &h);
+
+		//创建QImage图片
+		tar_img = QImage(w, h, QImage::Format_Indexed8);
+
+		//memcpy
+		for (int i = 0; i < h; i++, pBuf += w)
+		{
+			uchar* pDest = tar_img.scanLine(i);
+			memcpy(pDest, pBuf, w);
+		}
+
+		//tar_pixmap = QPixmap::fromImage(tar_img);
+	}
+	else if (hChannels == 3)
+	{
+		uchar* R, * G, * B;
+		_img.GetImagePointer3(reinterpret_cast<void**>(&R),
+			reinterpret_cast<void**>(&G),
+			reinterpret_cast<void**>(&B), &hType, &width, &height);
+
+		for (int row = 0; row < height; row++)
+		{
+			QRgb* line = reinterpret_cast<QRgb*>(tar_img.scanLine(row));
+			for (int col = 0; col < width; col++)
+			{
+				line[col] = qRgb(*R++, *G++, *B++);
+			}
+		}
+	}
+	tar_pixmap = QPixmap::fromImage(tar_img);
+}
+
+void HImageViewWidget::QPixmapToHRegion(QPixmap const& _pix, HRegion& tar_reg)
+{
+	HImage tmpImag;
+	QImage tmpQImag = _pix.toImage();
+	bool trans = HImageViewWidget::QImage2HImage(tmpQImag, tmpImag);
+	if (trans)
+	{
+		tar_reg = tmpImag.Threshold(100, 255);
+	}
+	tmpImag.Clear();
+
+}
+
+/**
+ * @brief QImage2HImage 将 Qt QImage 转换为 Halcon 的 HImage
+ * @param from 输入的 QImage
+ * @param to 输出的 HImage ，from 和 to 不共享内存数据。 每次都会为 to 重新分配内存。
+ * @return true 表示转换成功，false 表示转换失败。
+ */
+bool HImageViewWidget::QImage2HImage(QImage& from, HalconCpp::HImage& to)
+{
+	if (from.isNull()) return false;
+
+	int width = from.width(), height = from.height();
+	QImage::Format format = from.format();
+
+	if (format == QImage::Format_RGB32 ||
+		format == QImage::Format_ARGB32 ||
+		format == QImage::Format_ARGB32_Premultiplied)
+	{
+		to.GenImageInterleaved(from.bits(), "rgbx", width, height, 0, "byte", width, height, 0, 0, 8, 0);
+		return true;
+	}
+	else if (format == QImage::Format_RGB888)
+	{
+		to.GenImageInterleaved(from.bits(), "rgb", width, height, 0, "byte", width, height, 0, 0, 8, 0);
+		return true;
+	}
+	else if (format == QImage::Format_Grayscale8 || format == QImage::Format_Indexed8)
+	{
+		to.GenImage1("byte", width, height, from.bits());
+		return true;
+	}
+	return false;
+}
+
+
+void HImageViewWidget::paintEvent(QPaintEvent* event)
+{
+	//QPainter painter(this);
+	if (!cur_pixmap->isNull())
+	{
+		this->setPixmap(cur_pixmap->scaled(this->width(), this->height(), Qt::KeepAspectRatio));
+	}
+	QLabel::paintEvent(event);
+}
+
--- a/NodeEditorPro/examples/halcon/HImageViewWidget.hpp
+++ b/NodeEditorPro/examples/halcon/HImageViewWidget.hpp
@ -0,0 +1,30 @@
+#pragma once
+
+#include <QWidget>
+#include <QLabel>
+#include <QGraphicsView>
+#include <QPixmap>
+#include <QPainter>
+#include "halconcpp/HalconCpp.h"
+using namespace HalconCpp;
+
+class HImageViewWidget
+	:public QLabel
+{
+public:
+	HImageViewWidget(QWidget* parent = Q_NULLPTR);
+	virtual ~HImageViewWidget() {}
+	void showImage(HImage const& _himg);
+public:
+	static void HImageToQPixmap(HImage const& _img, QPixmap& tar_img);
+	static bool QImage2HImage(QImage& from, HImage& to);
+	static void QPixmapToHRegion(QPixmap const& _pix, HRegion& tar_img);
+protected:
+	void paintEvent(QPaintEvent* event) override;
+private:
+	HImage cur_image;
+	QPixmap* cur_pixmap;
+	// 实例化画家对象，this指定的是绘图设备
+	QPainter painter;
+};
+
--- a/NodeEditorPro/examples/halcon/HObjectData.hpp
+++ b/NodeEditorPro/examples/halcon/HObjectData.hpp
@ -0,0 +1,47 @@
+#pragma once
+
+#include <QtGui/QPixmap>
+
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using namespace HalconCpp;
+
+class HObjecData :public NodeData
+{
+public:
+	HObjecData()
+	{
+		m_hObject = HObject();
+	}
+	HObjecData(HObject& _obj)
+	{
+		if (_obj.IsInitialized())
+		{
+			m_hObject = _obj;
+		}
+	}
+	virtual ~HObjecData()
+	{
+
+	}
+	NodeDataType type() const override
+	{
+		return { "HObject","data" };
+	}
+
+	HObject* hObject() { return &m_hObject; }
+
+	void setObject(HObject const& _obj)
+	{
+		if (!_obj.IsInitialized())
+		{
+			return;
+		}
+		m_hObject = _obj;
+	}
+private:
+	HObject m_hObject;
+};
--- a/NodeEditorPro/examples/halcon/HRegionConnectModel.cpp
+++ b/NodeEditorPro/examples/halcon/HRegionConnectModel.cpp
@ -0,0 +1,121 @@
+#include "HRegionConnectModel.hpp"
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HRegionConnectModel::HRegionConnectModel()
+{
+	m_InRegion = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+
+}
+
+bool HRegionConnectModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+	if (m_InRegion->hRegion() == nullptr)
+	{
+		return false;
+	}
+	try
+	{
+		m_result->setHRegion(m_InRegion->hRegion()->Connection());
+
+		m_result->setSize(m_InRegion->getSize());
+
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+
+	return true;
+}
+
+bool HRegionConnectModel::eventFilter(QObject* watched, QEvent* event)
+{
+
+	return false;
+}
+
+unsigned int HRegionConnectModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HRegionConnectModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HRegionConnectModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+NodeDataType
+HRegionConnectModel::dataType(PortType, PortIndex) const
+{
+	return HRegionData().type();
+}
+
+void HRegionConnectModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hRegionData =
+		std::dynamic_pointer_cast<HRegionData>(data);
+	if (hRegionData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_InRegion->setHRegion(*hRegionData->hRegion());
+		m_InRegion->setSize(hRegionData->getSize());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HRegionConnectModel::
+outData(PortIndex index)
+{
+	switch (index)
+	{
+	case 0:
+		return std::dynamic_pointer_cast<HRegionData>(m_result);
+		break;
+	case 1:
+		break;
+	default:
+		break;
+	}
+	return std::dynamic_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HRegionConnectModel.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionConnectModel.hpp
@ -0,0 +1,76 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QSlider>
+#include <QLineEdit>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HRegionConnectModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HRegionConnectModel();
+	virtual ~HRegionConnectModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("非联通区域");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("非联通区域");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("非联通区域");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return nullptr; }
+
+	bool
+		resizable() const override { return false; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+
+protected:
+	bool RunTask();
+	bool eventFilter(QObject* watched, QEvent* event) override;
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("区域输入未连接!");
+private:
+	std::shared_ptr<HRegionData> m_InRegion;
+	std::shared_ptr<HRegionData> m_result;
+};
--- a/NodeEditorPro/examples/halcon/HRegionData.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionData.hpp
@ -0,0 +1,54 @@
+#pragma once
+
+#include <QtGui/QPixmap>
+
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using namespace HalconCpp;
+
+class HRegionData :public NodeData
+{
+public:
+	HRegionData()
+	{
+		m_hRegion = HRegion();
+	}
+	HRegionData(HRegion& _hregion)
+	{
+		if (_hregion.IsInitialized())
+		{
+			m_hRegion = _hregion;
+		}
+	}
+	virtual ~HRegionData()
+	{
+
+	}
+	NodeDataType type() const override
+	{
+		return { "HRegion","Region" };
+	}
+	HRegion* hRegion() { return &m_hRegion; }
+	void setHRegion(HRegion const& _hregion)
+	{
+		if (!_hregion.IsInitialized())
+		{
+			return;
+		}
+		m_hRegion = _hregion;
+	}
+	QSize getSize()
+	{
+		return m_size;
+	}
+	void setSize(QSize const& _size)
+	{
+		m_size = _size;
+	}
+private:
+	HRegion m_hRegion;
+	QSize m_size;
+};
--- a/NodeEditorPro/examples/halcon/HRegionDifferenceModel.cpp
+++ b/NodeEditorPro/examples/halcon/HRegionDifferenceModel.cpp
@ -0,0 +1,153 @@
+#include "HRegionDifferenceModel.hpp"
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HRegionDifferenceModel::HRegionDifferenceModel()
+{
+	m_InRegion = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+	m_InRegionDiv = std::make_shared<HRegionData>();
+
+}
+
+QString HRegionDifferenceModel::portCaption(PortType port, PortIndex port_index) const
+{
+	if (port == PortType::In)
+	{
+		switch (port_index)
+		{
+		case 0:
+			return "Ori";
+			break;
+		case 1:
+			return "Div";
+			break;
+		}
+	}
+	else if (port == PortType::Out)
+	{
+		switch (port_index)
+		{
+		case 0:
+			return "Res";
+			break;
+		}
+	}
+
+	return HRegionDifferenceModel::portCaption(port, port_index);
+}
+
+bool HRegionDifferenceModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+	if (m_InRegion->hRegion() == nullptr)
+	{
+		return false;
+	}
+	try
+	{
+		HalconCpp::Difference(*m_InRegion->hRegion(), *m_InRegionDiv->hRegion(), m_result->hRegion());
+
+		m_result->setSize(m_InRegion->getSize());
+
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+
+	return true;
+}
+
+bool HRegionDifferenceModel::eventFilter(QObject* watched, QEvent* event)
+{
+
+	return false;
+}
+
+unsigned int HRegionDifferenceModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 2;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HRegionDifferenceModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HRegionDifferenceModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+NodeDataType
+HRegionDifferenceModel::dataType(PortType, PortIndex) const
+{
+	return HRegionData().type();
+}
+
+void HRegionDifferenceModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hRegionData =
+		std::dynamic_pointer_cast<HRegionData>(data);
+	if (hRegionData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_InRegion->setHRegion(*hRegionData->hRegion());
+		m_InRegion->setSize(hRegionData->getSize());
+		break;
+	case 1:
+		m_InRegionDiv->setHRegion(*hRegionData->hRegion());
+		m_InRegionDiv->setSize(hRegionData->getSize());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HRegionDifferenceModel::
+outData(PortIndex index)
+{
+	switch (index)
+	{
+	case 0:
+		return std::dynamic_pointer_cast<HRegionData>(m_result);
+		break;
+	case 1:
+		break;
+	default:
+		break;
+	}
+	return std::dynamic_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HRegionDifferenceModel.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionDifferenceModel.hpp
@ -0,0 +1,78 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QSlider>
+#include <QLineEdit>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HRegionDifferenceModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HRegionDifferenceModel();
+	virtual ~HRegionDifferenceModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("相减区域");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("相减区域");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("相减区域");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return nullptr; }
+
+	bool
+		resizable() const override { return false; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+	bool portCaptionVisible(PortType, PortIndex) const override { return true; }
+	QString portCaption(PortType, PortIndex) const override;
+protected:
+	bool RunTask();
+	bool eventFilter(QObject* watched, QEvent* event) override;
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("区域输入未连接!");
+private:
+	std::shared_ptr<HRegionData> m_InRegion;
+	std::shared_ptr<HRegionData> m_InRegionDiv;
+	std::shared_ptr<HRegionData> m_result;
+};
--- a/NodeEditorPro/examples/halcon/HRegionFillUpShapeModel.cpp
+++ b/NodeEditorPro/examples/halcon/HRegionFillUpShapeModel.cpp
@ -0,0 +1,160 @@
+#include "HRegionFillUpShapeModel.hpp"
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HRegionFillUpShapeModel::HRegionFillUpShapeModel()
+{
+	m_hRegion = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+
+	m_widget = new QWidget();
+	m_host = new QVBoxLayout();
+	m_combo_feature = new QComboBox();
+
+	m_minvalEdit = new QLineEdit();
+	m_maxvalEdit = new QLineEdit();
+	m_widget->setContentsMargins(0, 0, 0, 0);
+	m_host->setSpacing(1);
+	m_widget->setLayout(m_host);
+	m_host->addWidget(m_combo_feature);
+	m_host->addWidget(m_minvalEdit);
+	m_host->addWidget(m_maxvalEdit);
+	m_widget->setFixedHeight(90);
+	m_widget->setFixedWidth(100);
+	m_combo_feature->addItem("area");
+	m_combo_feature->addItem("compactness");
+	m_combo_feature->addItem("convexity");
+	m_combo_feature->addItem("anisometry");
+	m_minvalEdit->setText("0.0");
+	m_maxvalEdit->setText("100.0");
+
+	connect(m_minvalEdit, &QLineEdit::textChanged, [=]()
+		{
+			m_minval = m_minvalEdit->text().toDouble();
+			RunTask();
+		});
+	connect(m_maxvalEdit, &QLineEdit::textChanged, [=]()
+		{
+			m_maxval = m_maxvalEdit->text().toDouble();
+			RunTask();
+		});
+	connect(m_combo_feature, &QComboBox::currentTextChanged, [=]()
+		{
+			m_feature = m_combo_feature->currentText();
+			RunTask();
+		});
+}
+
+bool HRegionFillUpShapeModel::RunTask()
+{
+	Q_EMIT computingStarted();
+	PortIndex const outPortIndex = 0;
+	try
+	{
+		HalconCpp::FillUpShape(*m_hRegion->hRegion(), m_result->hRegion(),
+			m_feature.toStdString().c_str(),
+			m_minval,
+			m_maxval);
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+	Q_EMIT computingFinished();
+	return true;
+}
+
+unsigned int HRegionFillUpShapeModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HRegionFillUpShapeModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HRegionFillUpShapeModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+QJsonObject HRegionFillUpShapeModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+
+	result.insert("m_minval", m_minval);
+	result.insert("m_maxval", m_maxval);
+	result.insert("m_feature", m_feature);
+	return result;
+}
+
+void HRegionFillUpShapeModel::restore(QJsonObject const& json_values)
+{
+	NodeDataModel::restore(json_values);
+	m_minval = json_values.value("m_minval").toDouble();
+	m_maxval = json_values.value("m_maxval").toDouble();
+	m_feature = json_values.value("m_feature").toString();
+
+	m_combo_feature->setCurrentText(m_feature);
+	m_minvalEdit->setText(QString::number(m_minval));
+	m_maxvalEdit->setText(QString::number(m_maxval));
+}
+
+NodeDataType
+HRegionFillUpShapeModel::dataType(PortType, PortIndex) const
+{
+	return HRegionData().type();
+}
+
+void HRegionFillUpShapeModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hImageData =
+		std::dynamic_pointer_cast<HRegionData>(data);
+	if (hImageData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_hRegion->setHRegion(*hImageData->hRegion());
+		m_result->setSize(hImageData->getSize());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HRegionFillUpShapeModel::
+outData(PortIndex)
+{
+	return std::static_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HRegionFillUpShapeModel.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionFillUpShapeModel.hpp
@ -0,0 +1,88 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QComboBox>
+#include <QLineEdit>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HRegionFillUpShapeModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HRegionFillUpShapeModel();
+	virtual ~HRegionFillUpShapeModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("填充区域");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("填充区域");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("填充区域");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return m_widget; }
+
+	bool
+		resizable() const override { return false; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+	QJsonObject save() const override;
+
+	void restore(QJsonObject const&) override;
+protected:
+	bool RunTask();
+
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("图片输入未连接!");
+private:
+	QString m_feature;
+	double m_minval = 0.0;
+	double m_maxval = 100.0;
+	std::shared_ptr<HRegionData> m_hRegion;
+	std::shared_ptr<HRegionData> m_result;
+	QWidget* m_widget;
+	QVBoxLayout* m_host;
+	QComboBox* m_combo_feature;
+	QLineEdit* m_minvalEdit;
+	QLineEdit* m_maxvalEdit;
+};
--- a/NodeEditorPro/examples/halcon/HRegionOpenCircleModel.cpp
+++ b/NodeEditorPro/examples/halcon/HRegionOpenCircleModel.cpp
@ -0,0 +1,126 @@
+#include "HRegionOpenCircleModel.hpp"
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HRegionOpenCircleModel::HRegionOpenCircleModel()
+{
+	m_hRegion = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+
+	m_maxvalEdit = new QLineEdit();
+	m_maxvalEdit->setFixedWidth(80);
+	m_maxvalEdit->setText("9.0");
+
+	connect(m_maxvalEdit, &QLineEdit::textChanged, [=]()
+		{
+			m_maxval = m_maxvalEdit->text().toDouble();
+			RunTask();
+		});
+}
+
+bool HRegionOpenCircleModel::RunTask()
+{
+	Q_EMIT computingStarted();
+	PortIndex const outPortIndex = 0;
+	try
+	{
+		HalconCpp::OpeningCircle(
+			*m_hRegion->hRegion(),
+			m_result->hRegion(),
+			m_maxval);
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+	Q_EMIT computingFinished();
+	return true;
+}
+
+unsigned int HRegionOpenCircleModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HRegionOpenCircleModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HRegionOpenCircleModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+QJsonObject HRegionOpenCircleModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+
+	result.insert("m_maxval", m_maxval);
+	return result;
+}
+
+void HRegionOpenCircleModel::restore(QJsonObject const& json_values)
+{
+	NodeDataModel::restore(json_values);
+	m_maxval = json_values.value("m_maxval").toDouble();
+	m_maxvalEdit->setText(QString::number(m_maxval));
+}
+
+NodeDataType
+HRegionOpenCircleModel::dataType(PortType, PortIndex) const
+{
+	return HRegionData().type();
+}
+
+void HRegionOpenCircleModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hImageData =
+		std::dynamic_pointer_cast<HRegionData>(data);
+	if (hImageData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_hRegion->setHRegion(*hImageData->hRegion());
+		m_result->setSize(hImageData->getSize());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HRegionOpenCircleModel::
+outData(PortIndex)
+{
+	return std::static_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HRegionOpenCircleModel.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionOpenCircleModel.hpp
@ -0,0 +1,82 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QLabel>
+#include <QVBoxLayout>
+#include <QHBoxLayout>
+#include <QComboBox>
+#include <QLineEdit>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HRegionOpenCircleModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HRegionOpenCircleModel();
+	virtual ~HRegionOpenCircleModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("开放圆");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("开放圆");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("开放圆");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return m_maxvalEdit; }
+
+	bool
+		resizable() const override { return false; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+	QJsonObject save() const override;
+
+	void restore(QJsonObject const&) override;
+protected:
+	bool RunTask();
+
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("图片输入未连接!");
+private:
+	double m_maxval = 100.0;
+	std::shared_ptr<HRegionData> m_hRegion;
+	std::shared_ptr<HRegionData> m_result;
+	QLineEdit* m_maxvalEdit;
+};
--- a/NodeEditorPro/examples/halcon/HRegionSelectModel.cpp
+++ b/NodeEditorPro/examples/halcon/HRegionSelectModel.cpp
@ -0,0 +1,192 @@
+#include "HRegionSelectModel.hpp"
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HRegionSelectModel::HRegionSelectModel()
+{
+	m_widget = new QWidget();
+	m_widget->setAttribute(Qt::WA_NoSystemBackground);
+	m_widget->setFixedSize(150, 140);
+	m_minValue = new QLineEdit(m_widget);
+	m_maxValue = new QLineEdit(m_widget);
+	combo_feature = new QComboBox(m_widget);
+	combo_operation = new QComboBox(m_widget);
+	m_minValue->resize(120, 25);
+	m_maxValue->resize(120, 25);
+	combo_feature->move(0, 0);
+	combo_operation->move(0, 35);
+	m_minValue->move(0, 70);
+	m_maxValue->move(0, 105);
+
+	m_minValue->setText("0");
+	m_maxValue->setText("99999");
+
+	combo_feature->addItem("area");
+	combo_feature->addItem("row");
+	combo_feature->addItem("column");
+	combo_feature->addItem("width");
+	combo_feature->addItem("height");
+	combo_feature->addItem("circularity");
+	combo_feature->addItem("compactness");
+	combo_feature->addItem("contlength");
+	combo_feature->addItem("convexity");
+	combo_feature->addItem("rectangularity");
+	combo_feature->addItem("inner_width");
+	combo_feature->addItem("inner_height");
+	combo_feature->addItem("roundness");
+
+	combo_operation->addItem("and");
+	combo_operation->addItem("or");
+
+	m_InRegion = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+
+	connect(m_minValue, &QLineEdit::textEdited, [=]()
+		{
+			RunTask();
+		});
+	connect(m_maxValue, &QLineEdit::textEdited, [=]()
+		{
+			RunTask();
+		});
+	connect(combo_feature, &QComboBox::currentTextChanged, [=]()
+		{
+			RunTask();
+		});
+	connect(combo_operation, &QComboBox::currentTextChanged, [=]()
+		{
+			RunTask();
+		});
+}
+
+bool HRegionSelectModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+	if (m_InRegion->hRegion() == nullptr)
+	{
+		return false;
+	}
+	try
+	{
+		minVal = m_minValue->text().toDouble();
+		maxVal = m_maxValue->text().toDouble();
+		m_cur_feature = combo_feature->currentText();
+		m_cur_operation = combo_operation->currentText();
+		m_result->setHRegion(m_InRegion->hRegion()->SelectShape(
+			combo_feature->currentText().toStdString().c_str(),
+			combo_operation->currentText().toStdString().c_str(),
+			minVal, maxVal
+		));
+		m_result->setSize(m_InRegion->getSize());
+
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+
+	return true;
+}
+
+bool HRegionSelectModel::eventFilter(QObject* watched, QEvent* event)
+{
+
+	return false;
+}
+
+unsigned int HRegionSelectModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HRegionSelectModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HRegionSelectModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+QJsonObject HRegionSelectModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+	result.insert("m_minValue", m_minValue->text());
+	result.insert("m_maxValue", m_maxValue->text());
+	return result;
+}
+
+void HRegionSelectModel::restore(QJsonObject const& p)
+{
+	m_minValue->setText(p["m_minValue"].toString("0"));
+	m_maxValue->setText(p["m_maxValue"].toString("99999"));
+}
+
+NodeDataType
+HRegionSelectModel::dataType(PortType, PortIndex) const
+{
+	return HRegionData().type();
+}
+
+void HRegionSelectModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hRegionData =
+		std::dynamic_pointer_cast<HRegionData>(data);
+	if (hRegionData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_InRegion->setHRegion(*hRegionData->hRegion());
+		m_InRegion->setSize(hRegionData->getSize());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HRegionSelectModel::
+outData(PortIndex index)
+{
+	switch (index)
+	{
+	case 0:
+		return std::dynamic_pointer_cast<HRegionData>(m_result);
+		break;
+	case 1:
+		break;
+	default:
+		break;
+	}
+	return std::dynamic_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HRegionSelectModel.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionSelectModel.hpp
@ -0,0 +1,90 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QSlider>
+#include <QComboBox>
+#include <QLineEdit>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HRegionSelectModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HRegionSelectModel();
+	virtual ~HRegionSelectModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("选择区域");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("选择区域");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("选择区域");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return m_widget; }
+
+	bool
+		resizable() const override { return true; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+
+	QJsonObject save() const override;
+
+	void restore(QJsonObject const&) override;
+
+protected:
+	bool RunTask();
+	bool eventFilter(QObject* watched, QEvent* event) override;
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("区域输入未连接!");
+private:
+	std::shared_ptr<HRegionData> m_InRegion;
+	std::shared_ptr<HRegionData> m_result;
+	QComboBox* combo_feature;
+	QComboBox* combo_operation;
+	QLineEdit* m_minValue;
+	QLineEdit* m_maxValue;
+	QWidget* m_widget;
+	QString m_cur_feature;
+	QString m_cur_operation;
+	int minVal;
+	int maxVal;
+};
--- a/NodeEditorPro/examples/halcon/HRegionSelectShapeStdModel.cpp
+++ b/NodeEditorPro/examples/halcon/HRegionSelectShapeStdModel.cpp
@ -0,0 +1,161 @@
+#include "HRegionSelectShapeStdModel.hpp"
+#include <QtCore/QEvent>
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HRegionSelectShapeStdModel::HRegionSelectShapeStdModel()
+{
+	m_widget = new QWidget();
+	m_widget->setAttribute(Qt::WA_NoSystemBackground);
+	m_widget->setFixedSize(120, 80);
+	m_cur_feature = "rectangle1";
+	m_percent = 90;
+	combo_feature = new QComboBox(m_widget);
+	m_percentEdit = new QLineEdit(m_widget);
+	combo_feature->move(0, 10);
+	m_percentEdit->move(0, 60);
+	combo_feature->addItem("max_area");
+	combo_feature->addItem("rectangle1");
+	combo_feature->addItem("rectangle2");
+	m_percentEdit->setText("90.0");
+	m_InRegion = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+
+	connect(combo_feature, &QComboBox::currentTextChanged, [=]()
+		{
+			m_cur_feature = combo_feature->currentText();
+			RunTask();
+		});
+	connect(m_percentEdit, &QLineEdit::textEdited, this, [=]()
+		{
+			m_percent = m_percentEdit->text().toDouble();
+			RunTask();
+		});
+}
+
+bool HRegionSelectShapeStdModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+	if (m_InRegion->hRegion() == nullptr)
+	{
+		return false;
+	}
+	try
+	{
+		HalconCpp::SelectShapeStd(
+			*m_InRegion->hRegion(),
+			m_result->hRegion(),
+			m_cur_feature.toStdString().c_str(),
+			m_percent);
+
+		m_result->setSize(m_InRegion->getSize());
+
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+
+	return true;
+}
+
+bool HRegionSelectShapeStdModel::eventFilter(QObject* watched, QEvent* event)
+{
+
+	return false;
+}
+
+unsigned int HRegionSelectShapeStdModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HRegionSelectShapeStdModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HRegionSelectShapeStdModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+QJsonObject HRegionSelectShapeStdModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+	result.insert("m_cur_feature", combo_feature->currentText());
+	result.insert("m_percent", m_percent);
+	return result;
+}
+
+void HRegionSelectShapeStdModel::restore(QJsonObject const& p)
+{
+	combo_feature->setCurrentText(p["m_cur_feature"].toString("rectangle1"));
+	m_percent = p.value("m_percent").toDouble(90);
+}
+
+NodeDataType
+HRegionSelectShapeStdModel::dataType(PortType, PortIndex) const
+{
+	return HRegionData().type();
+}
+
+void HRegionSelectShapeStdModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hRegionData =
+		std::dynamic_pointer_cast<HRegionData>(data);
+	if (hRegionData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_InRegion->setHRegion(*hRegionData->hRegion());
+		m_InRegion->setSize(hRegionData->getSize());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HRegionSelectShapeStdModel::
+outData(PortIndex index)
+{
+	switch (index)
+	{
+	case 0:
+		return std::dynamic_pointer_cast<HRegionData>(m_result);
+		break;
+	case 1:
+		break;
+	default:
+		break;
+	}
+	return std::dynamic_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HRegionSelectShapeStdModel.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionSelectShapeStdModel.hpp
@ -0,0 +1,86 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QSlider>
+#include <QComboBox>
+#include <QLineEdit>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon shapeTrans节点
+ */
+class HRegionSelectShapeStdModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HRegionSelectShapeStdModel();
+	virtual ~HRegionSelectShapeStdModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("选择形状");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("选择形状");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("选择形状");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return m_widget; }
+
+	bool
+		resizable() const override { return false; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+
+	QJsonObject save() const override;
+
+	void restore(QJsonObject const&) override;
+
+protected:
+	bool RunTask();
+	bool eventFilter(QObject* watched, QEvent* event) override;
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("区域输入未连接!");
+private:
+	std::shared_ptr<HRegionData> m_InRegion;
+	std::shared_ptr<HRegionData> m_result;
+	QLineEdit* m_percentEdit;
+	QComboBox* combo_feature;
+	QWidget* m_widget;
+	QString m_cur_feature;
+	double m_percent;
+};
--- a/NodeEditorPro/examples/halcon/HRegionShapeTransModel.cpp
+++ b/NodeEditorPro/examples/halcon/HRegionShapeTransModel.cpp
@ -0,0 +1,154 @@
+#include "HRegionShapeTransModel.hpp"
+#include <QtCore/QEvent>
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HRegionShapeTransModel::HRegionShapeTransModel()
+{
+	m_widget = new QWidget();
+	m_widget->setAttribute(Qt::WA_NoSystemBackground);
+	m_widget->setFixedSize(150, 50);
+	combo_feature = new QComboBox(m_widget);
+
+	combo_feature->move(0, 10);
+
+	combo_feature->addItem("convex");
+	combo_feature->addItem("ellipse");
+	combo_feature->addItem("outer_circle");
+	combo_feature->addItem("inner_circle");
+	combo_feature->addItem("rectangle1");
+	combo_feature->addItem("rectangle2");
+	combo_feature->addItem("inner_rectangle1");
+	combo_feature->addItem("inner_rectangle2");
+
+	m_InRegion = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+
+	connect(combo_feature, &QComboBox::currentTextChanged, [=]()
+		{
+			RunTask();
+		});
+}
+
+bool HRegionShapeTransModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+	if (m_InRegion->hRegion() == nullptr)
+	{
+		return false;
+	}
+	try
+	{
+		m_cur_feature = combo_feature->currentText();
+		m_result->setHRegion(m_InRegion->hRegion()->ShapeTrans(
+			combo_feature->currentText().toStdString().c_str()
+		));
+		m_result->setSize(m_InRegion->getSize());
+
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+
+	return true;
+}
+
+bool HRegionShapeTransModel::eventFilter(QObject* watched, QEvent* event)
+{
+
+	return false;
+}
+
+unsigned int HRegionShapeTransModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 1;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HRegionShapeTransModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HRegionShapeTransModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+QJsonObject HRegionShapeTransModel::save() const
+{
+	QJsonObject result = NodeDataModel::save();
+	result.insert("m_cur_feature", combo_feature->currentText());
+	return result;
+}
+
+void HRegionShapeTransModel::restore(QJsonObject const& p)
+{
+	combo_feature->setCurrentText(p["m_cur_feature"].toString("rectangle1"));
+}
+
+NodeDataType
+HRegionShapeTransModel::dataType(PortType, PortIndex) const
+{
+	return HRegionData().type();
+}
+
+void HRegionShapeTransModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hRegionData =
+		std::dynamic_pointer_cast<HRegionData>(data);
+	if (hRegionData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_InRegion->setHRegion(*hRegionData->hRegion());
+		m_InRegion->setSize(hRegionData->getSize());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HRegionShapeTransModel::
+outData(PortIndex index)
+{
+	switch (index)
+	{
+	case 0:
+		return std::dynamic_pointer_cast<HRegionData>(m_result);
+		break;
+	case 1:
+		break;
+	default:
+		break;
+	}
+	return std::dynamic_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HRegionShapeTransModel.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionShapeTransModel.hpp
@ -0,0 +1,85 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QSlider>
+#include <QComboBox>
+#include <QLineEdit>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon shapeTrans节点
+ */
+class HRegionShapeTransModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HRegionShapeTransModel();
+	virtual ~HRegionShapeTransModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("仿形变换");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("仿形变换");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("仿形变换");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return m_widget; }
+
+	bool
+		resizable() const override { return true; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+
+	QJsonObject save() const override;
+
+	void restore(QJsonObject const&) override;
+
+protected:
+	bool RunTask();
+	bool eventFilter(QObject* watched, QEvent* event) override;
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("区域输入未连接!");
+private:
+	std::shared_ptr<HRegionData> m_InRegion;
+	std::shared_ptr<HRegionData> m_result;
+	QComboBox* combo_feature;
+	QWidget* m_widget;
+	QString m_cur_feature;
+
+};
--- a/NodeEditorPro/examples/halcon/HRegionUnionModel.cpp
+++ b/NodeEditorPro/examples/halcon/HRegionUnionModel.cpp
@ -0,0 +1,152 @@
+#include "HRegionUnionModel.hpp"
+#include <QtCore/QEvent>
+
+#include "halconcpp/HalconCpp.h"
+
+using namespace HalconCpp;
+
+HRegionUnionModel::HRegionUnionModel()
+{
+	m_InRegion = std::make_shared<HRegionData>();
+	m_result = std::make_shared<HRegionData>();
+
+}
+
+QString HRegionUnionModel::portCaption(PortType port, PortIndex port_index) const
+{
+	if (port == PortType::In)
+	{
+		switch (port_index)
+		{
+		case 0:
+			return "Ori";
+			break;
+		case 1:
+			return "Add";
+			break;
+		}
+	}
+	else if (port == PortType::Out)
+	{
+		switch (port_index)
+		{
+		case 0:
+			return "Res";
+			break;
+		}
+	}
+
+	return NodeDataModel::portCaption(port, port_index);
+}
+
+bool HRegionUnionModel::RunTask()
+{
+	PortIndex const outPortIndex = 0;
+	if (m_InRegion->hRegion() == nullptr)
+	{
+		return false;
+	}
+	try
+	{
+		HalconCpp::Union2(*m_InRegion->hRegion(), *m_InRegionAdd->hRegion(), m_result->hRegion());
+
+		m_result->setSize(m_InRegion->getSize());
+
+		modelValidationState = NodeValidationState::Valid;
+		modelValidationError = QString();
+	}
+	catch (...)
+	{
+		modelValidationState = NodeValidationState::Warning;
+		modelValidationError = QStringLiteral("缺失或运行失败!");
+	}
+
+	Q_EMIT dataUpdated(outPortIndex);
+
+	return true;
+}
+
+bool HRegionUnionModel::eventFilter(QObject* watched, QEvent* event)
+{
+
+	return false;
+}
+
+unsigned int HRegionUnionModel::
+nPorts(PortType portType) const
+{
+	unsigned int result = 1;
+
+	switch (portType)
+	{
+	case PortType::In:
+		result = 2;
+		break;
+
+	case PortType::Out:
+		result = 1;
+
+	default:
+		break;
+	}
+
+	return result;
+}
+
+NodeValidationState HRegionUnionModel::validationState() const
+{
+	return modelValidationState;
+}
+
+QString HRegionUnionModel::validationMessage() const
+{
+	return modelValidationError;
+}
+
+NodeDataType
+HRegionUnionModel::dataType(PortType, PortIndex) const
+{
+	return HRegionData().type();
+}
+
+void HRegionUnionModel::
+setInData(std::shared_ptr<NodeData> data, int portIndex)
+{
+	auto hRegionData =
+		std::dynamic_pointer_cast<HRegionData>(data);
+	if (hRegionData == nullptr)
+	{
+		return;
+	}
+	switch (portIndex)
+	{
+	case 0:
+		m_InRegion->setHRegion(*hRegionData->hRegion());
+		m_InRegion->setSize(hRegionData->getSize());
+		break;
+	case 1:
+		m_InRegionAdd->setHRegion(*hRegionData->hRegion());
+		m_InRegionAdd->setSize(hRegionData->getSize());
+		break;
+	default:
+		break;
+	}
+	RunTask();
+}
+
+std::shared_ptr<NodeData>
+HRegionUnionModel::
+outData(PortIndex index)
+{
+	switch (index)
+	{
+	case 0:
+		return std::dynamic_pointer_cast<HRegionData>(m_result);
+		break;
+	case 1:
+		break;
+	default:
+		break;
+	}
+	return std::dynamic_pointer_cast<HRegionData>(m_result);
+}
--- a/NodeEditorPro/examples/halcon/HRegionUnionModel.hpp
+++ b/NodeEditorPro/examples/halcon/HRegionUnionModel.hpp
@ -0,0 +1,78 @@
+#pragma once
+
+#include <iostream>
+#include <QObject>
+#include <QWidget>
+#include <QSlider>
+#include <QLineEdit>
+#include "DataModelRegistry.hpp"
+#include "NodeDataModel.hpp"
+#include "halconcpp/HalconCpp.h"
+#include "HImageData.hpp"
+#include "HRegionData.hpp"
+#include "HImageViewWidget.hpp"
+
+using QtNodes::PortType;
+using QtNodes::PortIndex;
+using QtNodes::NodeData;
+using QtNodes::NodeDataType;
+using QtNodes::NodeDataModel;
+using QtNodes::NodeValidationState;
+using namespace HalconCpp;
+/**
+ * \brief halcon 图像rgb2gray节点
+ */
+class HRegionUnionModel :public NodeDataModel
+{
+	Q_OBJECT
+public:
+	HRegionUnionModel();
+	virtual ~HRegionUnionModel() {}
+
+public:
+	QString caption() const override
+	{
+		return QStringLiteral("联合区域");
+	}
+	QString name() const override
+	{
+		return QStringLiteral("联合区域");
+	}
+	virtual QString modelName() const
+	{
+		return QStringLiteral("联合区域");
+	}
+	unsigned int
+		nPorts(PortType portType) const override;
+
+	NodeDataType
+		dataType(PortType portType, PortIndex portIndex) const override;
+
+	std::shared_ptr<NodeData>
+		outData(PortIndex port) override;
+
+	void
+		setInData(std::shared_ptr<NodeData>, int) override;
+
+	QWidget*
+		embeddedWidget() override { return nullptr; }
+
+	bool
+		resizable() const override { return true; }
+	NodeValidationState
+		validationState() const override;
+	QString
+		validationMessage() const override;
+	bool portCaptionVisible(PortType, PortIndex) const override { return true; }
+	QString portCaption(PortType, PortIndex) const override;
+protected:
+	bool RunTask();
+	bool eventFilter(QObject* watched, QEvent* event) override;
+public:
+	NodeValidationState modelValidationState = NodeValidationState::Warning;
+	QString modelValidationError = QStringLiteral("区域输入未连接!");
+private:
+	std::shared_ptr<HRegionData> m_InRegion;
+	std::shared_ptr<HRegionData> m_InRegionAdd;
+	std::shared_ptr<HRegionData> m_result;
+};
--- a/NodeEditorPro/examples/halcon/HalconNodes.hpp
+++ b/NodeEditorPro/examples/halcon/HalconNodes.hpp
@ -0,0 +1,19 @@
+#pragma once
+
+//halcon nodes
+#include "halcon/HImageLoaderModel.hpp"
+#include "halcon/HImageFolderModel.hpp"
+#include "halcon/HImageShowModel.hpp"
+#include "halcon/HImageRGB2GrayModel.hpp"
+#include "halcon/HImageThresholdModel.hpp"
+#include "halcon/HImageSplitChanelModel.hpp"
+#include "halcon/HRegionSelectModel.hpp"
+#include "halcon/HRegionConnectModel.hpp"
+#include "halcon/HRegionShapeTransModel.hpp"
+#include "halcon/HImageReduceDomainModel.hpp"
+#include "halcon/HRegionFillUpShapeModel.hpp"
+#include "halcon/HRegionOpenCircleModel.hpp"
+#include "halcon/HRegionUnionModel.hpp"
+#include "halcon/HRegionDifferenceModel.hpp"
+#include "halcon/HRegionSelectShapeStdModel.hpp"
+#include "halcon/HImageDLSegmentModel.hpp"