original version

.qmake.stash

@@ -0,0 +1,23 @@
+QMAKE_CXX.QT_COMPILER_STDCXX = 199711L
+QMAKE_CXX.QMAKE_MSC_VER = 1933
+QMAKE_CXX.QMAKE_MSC_FULL_VER = 193331629
+QMAKE_CXX.COMPILER_MACROS = \
+    QT_COMPILER_STDCXX \
+    QMAKE_MSC_VER \
+    QMAKE_MSC_FULL_VER
+QMAKE_CXX.INCDIRS = \
+    E:\\VS2022\\VC\\Tools\\MSVC\\14.33.31629\\include \
+    E:\\VS2022\\VC\\Tools\\MSVC\\14.33.31629\\ATLMFC\\include \
+    E:\\VS2022\\VC\\Auxiliary\\VS\\include \
+    "C:\\Program Files (x86)\\Windows Kits\\10\\include\\10.0.20348.0\\ucrt" \
+    "C:\\Program Files (x86)\\Windows Kits\\10\\\\include\\10.0.20348.0\\\\um" \
+    "C:\\Program Files (x86)\\Windows Kits\\10\\\\include\\10.0.20348.0\\\\shared" \
+    "C:\\Program Files (x86)\\Windows Kits\\10\\\\include\\10.0.20348.0\\\\winrt" \
+    "C:\\Program Files (x86)\\Windows Kits\\10\\\\include\\10.0.20348.0\\\\cppwinrt" \
+    "C:\\Program Files (x86)\\Windows Kits\\NETFXSDK\\4.8\\include\\um"
+QMAKE_CXX.LIBDIRS = \
+    E:\\VS2022\\VC\\Tools\\MSVC\\14.33.31629\\ATLMFC\\lib\\x64 \
+    E:\\VS2022\\VC\\Tools\\MSVC\\14.33.31629\\lib\\x64 \
+    "C:\\Program Files (x86)\\Windows Kits\\NETFXSDK\\4.8\\lib\\um\\x64" \
+    "C:\\Program Files (x86)\\Windows Kits\\10\\lib\\10.0.20348.0\\ucrt\\x64" \
+    "C:\\Program Files (x86)\\Windows Kits\\10\\\\lib\\10.0.20348.0\\\\um\\x64"

3rdparty/CvxCamera/include/cvx_camera_global.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#if defined(CVXCAMERAX64_EXPORTS)
+#define CVX_EXPORT __declspec(dllexport)
+#else
+#define CVX_EXPORT __declspec(dllimport)
+#endif

3rdparty/CvxCamera/include/cvxcamera.h

@@ -0,0 +1,128 @@
+#pragma once
+#include "cvx_camera_global.h"
+#include <stdint.h>
+#include  <string>
+#include <vector>
+
+#ifdef USE_OPENCV
+#include "opencv2/opencv.hpp"
+#endif // USE_OPENCV
+
+#ifdef USE_HALCON
+#include <HalconCpp.h>
+#endif // USE_HALCON
+
+namespace cv
+{
+    class Mat;
+}
+namespace HalconCpp
+{
+    class HObject;
+}
+
+enum E_CameraType
+{
+    TYPE_HK = 0,
+    TYPE_DAHENG = 1,
+    TYPE_BASLER,
+    TYPE_SIMULATE
+};
+
+
+class CVX_EXPORT CvxCamera
+{
+public:
+    virtual ~CvxCamera(){}
+    enum E_PIXEL_TYPE
+    {
+        PIXEL_TYPE_GVSP_MONO8,
+        PIXEL_TYPE_GVSP_RGB8
+
+    };
+    enum E_TRIGGER_MODE
+    {
+        TRIGGER_MODE_OFF = 0,
+        TRIGGER_MODE_ON,
+    };
+    enum E_TRIGGER_SOURCE
+    {
+        TRIGGER_SOURCE_SOFT = 0,
+        TRIGGER_SOURCE_LINE0,
+        TRIGGER_SOURCE_LINE2,
+        TRIGGER_SOURCE_LINE3,
+        TRIGGER_SOURCE_Anyway,
+    };
+
+    static std::shared_ptr<CvxCamera> createInstance(E_CameraType type);
+
+
+    virtual int64_t enumDevicesSN(std::vector<std::string>& sn) = 0;
+    virtual int64_t openCamera(const char* camSN) = 0;
+    virtual int64_t setInitParameters() = 0;
+    virtual std::string   getCameraSN() = 0;
+    virtual int64_t getCameraImageSize(int64_t &size) = 0;
+    virtual int64_t   getCameraImageWidth(int64_t& width) = 0;
+    virtual int64_t   getCameraImageHeigth(int64_t& height) = 0;
+#ifdef USE_OPENCV
+    virtual int64_t getOneImage(cv::Mat& img) = 0;
+    virtual int64_t takeSingleImage(cv::Mat& img) = 0;//软触发并取一次图
+#endif
+#ifdef USE_HALCON
+    virtual int64_t getOneImage(HalconCpp::HObject& img) = 0;
+    virtual int64_t takeSingleImage(HalconCpp::HObject& img) = 0;//软触发并取一次图
+#endif // USE_HALCON
+
+    virtual int64_t closeCamera() = 0 ;
+    virtual int64_t reConnectCamera() = 0;
+    virtual int64_t clearCameraBuf() = 0;
+    virtual int64_t startGrabbing() = 0;
+    virtual int64_t stopGrabbing() = 0;
+    virtual int64_t softTriggerOnce() = 0;//软触发一次
+    virtual int64_t setPixelType(E_PIXEL_TYPE type) = 0; //设置图像格式
+    virtual int64_t setTriggerMode(E_TRIGGER_MODE mode) = 0; //设置触发模式
+    virtual int64_t setTriggerSource(E_TRIGGER_SOURCE source) = 0; //设置触发源
+    virtual float   getExposureTime() = 0;//获取设备当前曝光时间
+    virtual int64_t setExposureTime(float expTime) = 0;//设置曝光
+    virtual int64_t setTriggerDelay(int delay) = 0; //设置触发延时
+    virtual int64_t setGain(float gainValue) = 0; //设置增益
+    virtual float getGain() = 0;//获取增益
+
+    enum 
+    {
+        IMAGESIZE_DEFAULT_WIDTH = 2590,
+        IMAGESIZE_DEFAULT_HEIGHT = 1944,
+    };
+    enum {
+        SUCCESS = 0,
+        ACTION_FAILED_UNDO = -100001,
+        GAMERA_UNKOWN_CONTROLLER = -98000,
+        GAMERA_FAILED_NODEVICE,
+        GAMERA_FAILED_ALLOCATE,
+        GAMERA_FAILED_OVERCONNECT,
+        GAMERA_FAILED_TOCONNECT,
+        GAMERA_FAILED_UNCONNECTED,
+        GAMERA_FAILED_SETEXPOSURE,
+        GAMERA_FAILED_INACTION,
+        GAMERA_FAILED_TIMEOUTEXEC,
+        GAMERA_FAILED_NOIMAGEACC,
+        GAMERA_FAILED_IMAGEBUFLEN,
+        GAMERA_FAILED_STDEXCEPTION,
+        GAMERA_FAILED_UNKNOWNEXCEPTION,
+        GAMERA_FAILED_GETIMAGE,
+        ERROR_UNDEFINE
+    };
+
+
+protected:
+    CvxCamera(){}
+};
+
+
+
+
+
+
+
+
+

3rdparty/CvxCamera/include/defs.h

@@ -0,0 +1,51 @@
+#pragma once
+#include <stdio.h>
+#include "log.h"
+#ifdef _WIN32
+#define filename(x) strrchr(x,'\\')?strrchr(x,'\\')+1:x
+#else
+#if __GNUC__ >= 4
+#define filename(x) strrchr(x,'/')?strrchr(x,'/')+1:x
+#endif
+#endif
+
+//
+//
+//#define CREATE_LOG_HEAD \
+//char acLogStr[1024*4] = {0};\
+//int  iHeadLength = sprintf_s(acLogStr, 1024*4, "[%s:%d] %s:   ", filename(__FILE__), __LINE__, __FUNCTION__);\
+//
+//#define  LOG_TRACE(...) \
+//{\
+//    CREATE_LOG_HEAD\
+//    snprintf(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+//    printf("[TRACE] %s", acLogStr);\
+//}
+//
+//#define  LOG_DEBUG(...) \
+//{\
+//    CREATE_LOG_HEAD\
+//    sprintf_s(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+//    printf("[DEBUG] %s", acLogStr);\
+//}
+//
+//#define  LOG_INFO(...) \
+//{\
+//    CREATE_LOG_HEAD\
+//    snprintf(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+//    printf("[INFO] %s", acLogStr);\
+//}
+//
+//#define  LOG_WARN(...) \
+//{\
+//    CREATE_LOG_HEAD\
+//    snprintf(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+//    printf("[WARN] %s", acLogStr);\
+//}
+//
+//#define  LOG_ERROR(...) \
+//{\
+//    CREATE_LOG_HEAD\
+//    snprintf(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+//    printf("[ERROR] %s", acLogStr);\
+//}

3rdparty/ImgProcessAlg/include/FeatureMatching.h

@@ -0,0 +1,54 @@
+/*****************************************************************************
+*                                                                            *
+*  @file     FeatureMatching.h                                               *
+*  @brief    »ùÓÚorbµÄÌØÕ÷µãÆ¥Åä												 *
+*  Details.                                                                  *
+*                                                                            *
+*  @author   X P                                                             *
+*  @version  1.0.0.0                                                         *
+*  @date     2023-03-28                                                      *
+*  @license  GNU General Public License (GPL)                                *
+*                                                                            *
+*****************************************************************************/
+
+#ifndef _FEATURE_MATCHING_H_
+#define _FEATURE_MATCHING_H_
+
+#include <opencv2/opencv.hpp>
+#include <xfeatures2d.hpp>
+#include <qpoint.h>
+#include "ImgProcessGlobal.h"
+
+using namespace std;
+
+class CVX_PROCESS_EXPORT FeatureMatching
+{
+
+public:
+	FeatureMatching();
+	~FeatureMatching();
+	void ExtractDescriptors(const cv::Mat spread, int id);
+	void Matching(cv::Mat& homMat2d, float thresh = 30.f);
+	void AffineImage(cv::Mat &out);
+	void AffinePoint(const QPoint& pointOri, QPoint& pointDst);
+	static void AffinePoint(const cv::Mat& homMat2d,const QPoint& pointOri, QPoint& pointDst);
+private:
+	
+	int features_;
+	float scale_factory_;
+	int pyramid_levels_;
+	cv::Ptr<cv::ORB> orb_;
+	//cv::Ptr<cv::xfeatures2d::SURF> orb_;
+	typedef vector<cv::KeyPoint> KeyPoints;
+	cv::Mat spreads_[2];
+
+	cv::Mat homMat2d;
+	KeyPoints keypoints_[2];
+	cv::Mat descriptors_[2];
+};
+
+#endif
+
+
+
+

3rdparty/ImgProcessAlg/include/ImgProcessAlg.h

@@ -0,0 +1,72 @@
+#pragma once
+#include "ImgProcessGlobal.h"
+#include "FeatureMatching.h"
+
+
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+
+enum IBorderType {
+	IBORDER_CLAMP = (1 << 0),
+	IBORDER_MIRROR = (1 << 1),
+	IBORDER_REPEAT = (1 << 2),
+	IBORDER_CONSTANT = (1 << 3)
+};
+
+namespace IBorder 
+{
+	template<typename T>
+	T value(T value, T len, IBorderType type)
+	{
+		switch (type) {
+		case IBORDER_CLAMP: if (value < 0)
+			return 0;
+			if (value >= len)
+				return len - 1;
+			return value;
+		case IBORDER_MIRROR:
+			if (value < 0)
+				return -((value + 1) % len);
+			if (value >= len)
+				return len - 1 - value % len;
+			return value;
+		case IBORDER_REPEAT:
+			if (value < 0)
+				return len - 1 + ((value + 1) % len);
+			if (value >= len)
+				return value % len;
+			return value;
+		case IBORDER_CONSTANT:
+		default:
+			if (value < 0 || value >= len) return -1;
+		}
+		return -1;
+	}
+}
+
+static float g_gauss3_data[] = { 0.25f, 0.5f, 0.25f };
+static float g_gauss5_data[] = { 1.0f / 17.0f, 4.0f / 17.0f, 7.0f / 17.0f, 4.0f / 17.0f, 1.0f / 17.0f };
+static float g_gauss7_data[] = { 1.0f / 226.0f, 12.0f / 226.0f, 55.0f / 226.0f, 90.0f / 226.0f, 55.0f / 226.0f, 12.0f / 226.0f, 1.0f / 226.0f };
+static float g_derivate7_data[] = { -1.0f,-1.0f,-1.0f, 0.f, 1.0f,1.0f ,1.0f };
+static float g_derivate21_data[] = { -1.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f,-1.0f, 0.f, 1.0f,1.0f ,1.0f, 1.0f,1.0f ,1.0f, 1.0f,1.0f ,1.0f,1.0f };
+static float g_mean3_data[] = { 1.0f / 3.0f, 1.0f / 3.0f, 1.0f / 3.0f };
+static float g_mean5_data[] = { 1.0f / 5.0f, 1.0f / 5.0f, 1.0f / 5.0f, 1.0f / 5.0f, 1.0f / 5.0f };
+static float g_mean7_data[] = { 1.0f / 7.0f, 1.0f / 7.0f, 1.0f / 7.0f, 1.0f / 7.0f, 1.0f / 7.0f, 1.0f / 7.0f, 1.0f / 7.0f };
+static float g_mean11_data[] = { 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f, 1.0f / 11.0f };
+
+void CVX_PROCESS_EXPORT mulValue1f(float* dst, float const* src, const float value, const size_t n);
+
+
+void CVX_PROCESS_EXPORT convolveHorizontal1f(float* dst, const float* src, const size_t width, float const* weights, const size_t wn, IBorderType btype);
+
+float CVX_PROCESS_EXPORT ncc(const float* src1, const float* src2, const size_t n);
+
+cv::Mat CVX_PROCESS_EXPORT plotSignals1D(std::vector<float> projArray, int plotImageHeight = -1);
+
+//¼ÆËãͼÏñµÄÇåÎú¶È
+float CVX_PROCESS_EXPORT calImgSharpness(cv::Mat Pic, cv::Rect roi);
+
+int CVX_PROCESS_EXPORT calRoiInfo(const cv::Mat& m, int& idxL, int& idxR, int& idyT, int& idyB, float rectExpandWidthFactor = 0.05, int sampleStep = 40, int gradientThresh = 50);

3rdparty/ImgProcessAlg/include/ImgProcessGlobal.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#if defined(IMG_PROCESS_EXPORTS)
+#define CVX_PROCESS_EXPORT __declspec(dllexport)
+#else
+#define CVX_PROCESS_EXPORT __declspec(dllimport)
+#endif

3rdparty/include22/BarcodeAlgDllApi.h

@@ -0,0 +1,69 @@
+/*****************************************************************************
+模块名      : FmmAlg
+文件名      : FmmAlgDllApi.h
+相关文件    :
+文件实现功能:
+作者        : XP
+版本        : 1.0.0
+-----------------------------------------------------------------------------
+修改记录:
+
+******************************************************************************/
+#pragma once
+#ifdef DLL_EXPORTS
+#define EXPORT_API __declspec(dllexport)
+#else
+#define EXPORT_API __declspec(dllimport)
+#endif
+
+
+#ifndef EXPORT_API_C
+	#define EXPORT_API_C extern "C" EXPORT_API
+#endif // !EXPORT_API_C
+
+
+#ifndef IN
+#define IN
+#endif
+#ifndef OUT
+#define OUT
+#endif
+#ifndef INOUT
+#define INOUT
+#endif
+
+namespace HalconCpp
+{
+	class HObject;
+	class HTuple;
+}
+
+struct AlgInfo
+{
+	const char* version;		//	版本号
+	const char* name;			//	算法名称	
+	const char* lastUpdated;	//	更新日期
+	const char* updateDescribe;	//	最新修改记录
+};
+
+
+//获取算法信息
+EXPORT_API_C int getAlgInfo(OUT AlgInfo& algInfo);
+
+
+
+/// <summary>
+/// 读取配置文件，（最先运行）
+/// </summary>
+/// <param name="xmlPath">xml路径</param>
+/// <returns>函数运行成功为0</returns>
+EXPORT_API int loadConfigParams(IN const char* xmlPath);
+
+/// <summary>
+/// 处理函数
+/// </summary>
+/// <param name="image">输入图像</param>
+/// <param name="outXlds">输出xld信息</param>
+/// <param name="barcodes">读取的barcodes</param>
+/// <returns></returns>
+EXPORT_API void  process(IN const  HalconCpp::HObject& ho_Image, OUT HalconCpp::HObject& ho_outXlds, OUT HalconCpp::HTuple& hv_barcodes, OUT HalconCpp::HTuple hv_flag);

3rdparty/include22/CameraGrabber.h

@@ -0,0 +1,333 @@
+#ifndef _MV_CAMERA_GRABBER_H_
+#define _MV_CAMERA_GRABBER_H_
+
+#include "CameraDefine.h"
+#include "CameraStatus.h"
+
+
+/// @ingroup GRABBER_CREATE
+/// \~chinese
+/// \brief 弹出相机列表让用户选择要打开的相机
+/// \param [out] Grabber 返回新创建的采集器
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \note 本函数内部使用了 @link CameraInit @endlink 打开相机，因此可以使用 @link CameraGrabber_GetCameraHandle @endlink 获取相机句柄，进而使用其他SDK API来操作相机。
+/// \~english
+/// \brief Pop-up camera list allows the user to select the camera to open
+/// \param [out] Grabber returns newly created grabber
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \note This function uses @link CameraInit @endlink internally to open the camera, so you can use @link CameraGrabber_GetCameraHandle @endlink to get the camera handle and use other SDK APIs to operate the camera.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_CreateFromDevicePage(
+	void** Grabber
+	);
+
+/// @ingroup GRABBER_CREATE
+/// \~chinese
+/// \brief 使用相机列表索引创建Grabber
+/// \param [out] Grabber 返回新创建的采集器
+/// \param [in] Index 相机索引
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \note 本函数内部使用了 @link CameraInit @endlink 打开相机，因此可以使用 @link CameraGrabber_GetCameraHandle @endlink 获取相机句柄，进而使用其他SDK API来操作相机。
+/// \~english
+/// \brief Creating a Grabber Using a Camera List Index
+/// \param [out] Grabber returns newly created grabber
+/// \param [in] Index Camera index
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \note This function uses @link CameraInit @endlink internally to open the camera, so you can use @link CameraGrabber_GetCameraHandle @endlink to get the camera handle and use other SDK APIs to operate the camera.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_CreateByIndex(
+	void** Grabber,
+	int Index
+	);
+
+/// @ingroup GRABBER_CREATE
+/// \~chinese
+/// \brief 使用相机名称创建Grabber
+/// \param [out] Grabber 返回新创建的采集器
+/// \param [in] Name 相机名称。@link #tSdkCameraDevInfo.acFriendlyName @endlink
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \note 本函数内部使用了 @link CameraInit @endlink 打开相机，因此可以使用 @link CameraGrabber_GetCameraHandle @endlink 获取相机句柄，进而使用其他SDK API来操作相机。
+/// \~english
+/// \brief Create a Grabber with a Camera Name
+/// \param [out] Grabber returns newly created grabber
+/// \param [in] Name Camera name.@link #tSdkCameraDevInfo.acFriendlyName @endlink
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \note This function uses @link CameraInit @endlink internally to open the camera, so you can use @link CameraGrabber_GetCameraHandle @endlink to get the camera handle and use other SDK APIs to operate the camera.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_CreateByName(
+	void** Grabber,
+	char* Name
+	);
+
+/// @ingroup GRABBER_CREATE
+/// \~chinese
+/// \brief 从设备信息创建Grabber
+/// \param [out] Grabber 返回新创建的采集器
+/// \param [in] pDevInfo 设备信息。@link #CameraEnumerateDevice @endlink
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \note 本函数内部使用了 @link CameraInit @endlink 打开相机，因此可以使用 @link CameraGrabber_GetCameraHandle @endlink 获取相机句柄，进而使用其他SDK API来操作相机。
+/// \~english
+/// \brief Create Grabber from device info
+/// \param [out] Grabber returns newly created grabber
+/// \param [in] pDevInfo device information. @link #CameraEnumerateDevice @endlink
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \note This function uses @link CameraInit @endlink internally to open the camera, so you can use @link CameraGrabber_GetCameraHandle @endlink to get the camera handle and use other SDK APIs to operate the camera.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_Create(
+	void** Grabber,
+	tSdkCameraDevInfo* pDevInfo
+	);
+
+/// @ingroup GRABBER_DESTROY
+/// \~chinese
+/// \brief 销毁Grabber
+/// \param [in] Grabber 采集器
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Destroy Grabber
+/// \param [in] Grabber
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_Destroy(
+	void* Grabber
+	);
+
+/// @ingroup GRABBER_CTRL
+/// \~chinese
+/// \brief 设置预览视频的显示窗口
+/// \param [in] Grabber 采集器
+/// \param [in] hWnd 显示窗口的窗口句柄
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Set the preview video display window
+/// \param [in] Grabber
+/// \param [in] hWnd window handle of the display window
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SetHWnd(
+	void* Grabber,
+	HWND hWnd
+	);
+
+/// @ingroup GRABBER_CTRL
+/// \~chinese
+/// \brief 设置Grabber取图时使用的优先级
+/// \param [in] Grabber 采集器
+/// \param [in] Priority 取图优先级 详见：@link #emCameraGetImagePriority @endlink
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Sets the priority used by Grabber when fetching graphs
+/// \param [in] Grabber
+/// \param [in] Priority GetImageBuffer priority, For details see: @link #emCameraGetImagePriority @endlink
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SetPriority(
+	void* Grabber,
+	UINT Priority
+	);
+
+/// @ingroup GRABBER_CTRL
+/// \~chinese
+/// \brief 开始采集
+/// \param [in] Grabber 采集器
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \note Grabber必须进入采集状态，采集回调、抓图等功能才能正常运作
+/// \~english
+/// \brief Start Grabber
+/// \param [in] Grabber
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \note Grabber must enter the acquisition state, grab callbacks, snapshot and other functions in order to function properly
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_StartLive(
+	void* Grabber
+	);
+
+/// @ingroup GRABBER_CTRL
+/// \~chinese
+/// \brief 停止采集
+/// \param [in] Grabber 采集器
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \warning 本函数内部会等待所有回调函数结束后才返回调用者,并且在等待时会派发windows消息。
+/// \~english
+/// \brief Stop Grabber
+/// \param [in] Grabber
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \warning This function will wait for all callbacks to end before returning to the caller,And it will dispatch windows messages while waiting.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_StopLive(
+	void* Grabber
+	);
+
+/// @ingroup GRABBER_SNAPSHOT
+/// \~chinese
+/// \brief 同步抓图
+/// \param [in] Grabber 采集器
+/// \param [out] Image 返回抓取到的图像 \note 需要调用@link #CameraImage_Destroy @endlink释放
+/// \param [in] TimeOut 超时时间（毫秒）
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Synchronized snapshot
+/// \param [in] Grabber
+/// \param [out] Image Returns Captured Image \note Need to Call @link #CameraImage_Destroy @endlink Release
+/// \param [in] TimeOut Timeout (milliseconds)
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SaveImage(
+	void* Grabber,
+	void** Image,
+	DWORD TimeOut
+	);
+
+/// @ingroup GRABBER_SNAPSHOT
+/// \~chinese
+/// \brief 提交一个异步的抓图请求，提交成功后待抓图完成会回调用户设置的完成函数
+/// \param [in] Grabber 采集器
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \see CameraGrabber_SetSaveImageCompleteCallback
+/// \~english
+/// \brief Submit an asynchronous snapshot request, complete the user's completion function after the completion of the submission.
+/// \param [in] Grabber
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \see CameraGrabber_SetSaveImageCompleteCallback
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SaveImageAsync(
+	void* Grabber
+	);
+
+/// @ingroup GRABBER_SNAPSHOT
+/// \~chinese
+/// \brief 提交一个异步的抓图请求，提交成功后待抓图完成会回调用户设置的完成函数
+/// \param [in] Grabber 采集器
+/// \param [in] UserData 用户数据，可使用 @link CameraImage_GetUserData @endlink 从Image获取此值
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \see CameraGrabber_SetSaveImageCompleteCallback
+/// \~english
+/// \brief Submit an asynchronous snapshot request, complete the user's completion function after the completion of the submission.
+/// \param [in] Grabber
+/// \param [in] UserData user data, which can be obtained from Image using @link CameraImage_GetUserData @endlink
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \see CameraGrabber_SetSaveImageCompleteCallback
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SaveImageAsyncEx(
+	void* Grabber,
+	void* UserData
+	);
+
+/// @ingroup GRABBER_SNAPSHOT
+/// \~chinese
+/// \brief 设置异步方式抓图的完成函数
+/// \param [in] Grabber 采集器
+/// \param [in] Callback 当异步抓图任务完成时被调用
+/// \param [in] Context 当Callback被调用时，作为参数传入Callback
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \see CameraGrabber_SaveImageAsync CameraGrabber_SaveImageAsyncEx
+/// \~english
+/// \brief Set the completion function of asynchronous mode snapshot
+/// \param [in] Grabber
+/// \param [in] Callback Callback is called when the asynchronous snapshot task completes
+/// \param [in] Context Passed as a parameter when the Callback is invoked
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+/// \see CameraGrabber_SaveImageAsync CameraGrabber_SaveImageAsyncEx
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SetSaveImageCompleteCallback(
+	void* Grabber,
+	pfnCameraGrabberSaveImageComplete Callback,
+	void* Context
+	);
+
+/// @ingroup GRABBER_CB
+/// \~chinese
+/// \brief 设置帧监听函数
+/// \param [in] Grabber 采集器
+/// \param [in] Listener 监听函数
+/// \param [in] Context 当Listener被调用时，作为参数传入Listener
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Set frame listening function
+/// \param [in] Grabber
+/// \param [in] Listener listener function
+/// \param [in] Context Passed as a parameter when the Listener is invoked
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SetFrameListener(
+	void* Grabber,
+	pfnCameraGrabberFrameListener Listener,
+	void* Context
+	);
+
+/// @ingroup GRABBER_CB
+/// \~chinese
+/// \brief 设置RAW数据回调函数
+/// \param [in] Grabber 采集器
+/// \param [in] Callback Raw回调函数
+/// \param [in] Context 当Callback被调用时，作为参数传入Callback
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Set RAW data callback function
+/// \param [in] Grabber
+/// \param [in] Callback Raw data callback function
+/// \param [in] Context Passed as a parameter when the Callback is invoked
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SetRawCallback(
+	void* Grabber,
+	pfnCameraGrabberFrameCallback Callback,
+	void* Context
+	);
+
+/// @ingroup GRABBER_CB
+/// \~chinese
+/// \brief 设置RGB回调函数
+/// \param [in] Grabber 采集器
+/// \param [in] Callback RGB回调函数
+/// \param [in] Context 当Callback被调用时，作为参数传入Callback
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Set RGB callback function
+/// \param [in] Grabber
+/// \param [in] Callback RGB data callback function
+/// \param [in] Context Passed as a parameter when the Callback is invoked
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_SetRGBCallback(
+	void* Grabber,
+	pfnCameraGrabberFrameCallback Callback,
+	void* Context
+	);
+
+/// @ingroup GRABBER_CTRL
+/// \~chinese
+/// \brief 获取相机句柄
+/// \param [in] Grabber 采集器
+/// \param [out] hCamera 返回的相机句柄
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Get camera handle
+/// \param [in] Grabber
+/// \param [out] hCamera returned camera handle
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_GetCameraHandle(
+	void* Grabber,
+	CameraHandle *hCamera
+	);
+
+/// @ingroup GRABBER_CTRL
+/// \~chinese
+/// \brief 获取帧统计信息
+/// \param [in] Grabber 采集器
+/// \param [out] stat 返回的统计信息
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Get frame statistics
+/// \param [in] Grabber
+/// \param [out] stat returned statistics
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_GetStat(
+	void* Grabber,
+	tSdkGrabberStat *stat
+	);
+
+/// @ingroup GRABBER_CTRL
+/// \~chinese
+/// \brief 获取相机DevInfo
+/// \param [in] Grabber 采集器
+/// \param [out] DevInfo 返回的相机DevInfo
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Get Camera DevInfo
+/// \param [in] Grabber
+/// \param [out] DevInfo Returns Camera DevInfo
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraGrabber_GetCameraDevInfo(
+	void* Grabber,
+	tSdkCameraDevInfo *DevInfo
+	);
+
+
+
+
+#endif // _MV_CAMERA_GRABBER_H_

3rdparty/include22/CameraImage.h

@@ -0,0 +1,380 @@
+#ifndef _MV_CAMERA_IMAGE_H_
+#define _MV_CAMERA_IMAGE_H_
+
+#include "CameraDefine.h"
+#include "CameraStatus.h"
+
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 创建一个新的Image
+/// \param [out] Image 新创建的图片
+/// \param [in] pFrameBuffer 帧数据
+/// \param [in] pFrameHead 帧头
+/// \param [in] bCopy TRUE: 复制出一份新的帧数据   FALSE: 不复制，直接使用pFrameBuffer指向的缓冲区
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Create a new Image
+/// \param [out] Image Newly Created Image
+/// \param [in] pFrameBuffer frame data
+/// \param [in] pFrameHead Frame Header
+/// \param [in] bCopy TRUE: Copy a new frame data FALSE: Do not copy, directly use the buffer pointed to by pFrameBuffer
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_Create(
+	void** Image,
+	BYTE *pFrameBuffer, 
+	tSdkFrameHead* pFrameHead,
+	BOOL bCopy
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 创建一个空的Image
+/// \param [out] Image 新创建的图片
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Create an empty Image
+/// \param [out] Image Newly Created Image
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_CreateEmpty(
+	void** Image
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 销毁Image
+/// \param [in] Image
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Destroy Image
+/// \param [in] Image
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_Destroy(
+	void* Image
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 从Image获取帧数据和帧头
+/// \param [in] Image
+/// \param [out] DataBuffer 帧数据
+/// \param [out] Head 帧头
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Get frame data and frame header from Image
+/// \param [in] Image
+/// \param [out] DataBuffer Frame Data
+/// \param [out] Head header
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_GetData(
+	void* Image,
+	BYTE** DataBuffer,
+	tSdkFrameHead** Head
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 获取Image的用户自定义数据
+/// \param [in] Image
+/// \param [out] UserData 返回用户自定义数据
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Get User's Custom Data of Image
+/// \param [in] Image
+/// \param [out] UserData returns user-defined data
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_GetUserData(
+	void* Image,
+	void** UserData
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 设置Image的用户自定义数据
+/// \param [in] Image
+/// \param [in] UserData 用户自定义数据
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Set user-defined data for Image
+/// \param [in] Image
+/// \param [in] UserData User-defined data
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_SetUserData(
+	void* Image,
+	void* UserData
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 判断一个Image是否为空
+/// \param [in] Image
+/// \param [out] IsEmpty 为空返回:TRUE(1)  否则返回:FALSE(0)
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Determine if an Image is empty
+/// \param [in] Image
+/// \param [out] IsEmpty Empty Returns: TRUE(1) Otherwise returns: FALSE(0)
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_IsEmpty(
+	void* Image,
+	BOOL* IsEmpty
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 绘制Image到指定窗口
+/// \param [in] Image
+/// \param [in] hWnd 目的窗口
+/// \param [in] Algorithm 缩放算法  0：快速但质量稍差  1：速度慢但质量好
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Draw Image to the specified window
+/// \param [in] Image
+/// \param [in] hWnd destination window
+/// \param [in] Algorithm scaling algorithm 0:fast but slightly worse quality  1:slower but better quality
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_Draw(
+	void* Image,
+	HWND hWnd,
+	int Algorithm
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 拉升绘制Image到指定窗口
+/// \param [in] Image
+/// \param [in] hWnd 目的窗口
+/// \param [in] Algorithm 缩放算法  0：快速但质量稍差  1：速度慢但质量好
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Pull up drawing Image to the specified window
+/// \param [in] Image
+/// \param [in] hWnd destination window
+/// \param [in] Algorithm scaling algorithm 0:fast but slightly worse quality  1:slower but better quality
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_DrawFit(
+	void* Image,
+	HWND hWnd,
+	int Algorithm
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 绘制Image到指定DC
+/// \param [in] Image
+/// \param [in] hDC 目的DC
+/// \param [in] Algorithm 缩放算法  0：快速但质量稍差  1：速度慢但质量好
+/// \param [in] xDst 目标矩形的左上角X坐标
+/// \param [in] yDst 目标矩形的左上角Y坐标
+/// \param [in] cxDst 目标矩形的宽度
+/// \param [in] cyDst 目标矩形的高度
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Draw Image to specified DC
+/// \param [in] Image
+/// \param [in] hDC destination DC
+/// \param [in] Algorithm scaling algorithm 0:fast but slightly worse quality   1:slower but better quality
+/// \param [in] xDst The X coordinate of the upper left corner of the target rectangle
+/// \param [in] yDst The Y coordinate of the upper left corner of the target rectangle
+/// \param [in] cxDst Width of target rectangle
+/// \param [in] cyDst Height of target rectangle
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_DrawToDC(
+	void* Image,
+	HDC hDC,
+	int Algorithm,
+	int xDst,
+	int yDst,
+	int cxDst,
+	int cyDst
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 拉升绘制Image到指定DC
+/// \param [in] Image
+/// \param [in] hDC 目的DC
+/// \param [in] Algorithm 缩放算法  0：快速但质量稍差  1：速度慢但质量好
+/// \param [in] xDst 目标矩形的左上角X坐标
+/// \param [in] yDst 目标矩形的左上角Y坐标
+/// \param [in] cxDst 目标矩形的宽度
+/// \param [in] cyDst 目标矩形的高度
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Pull up drawing Image to specified DC
+/// \param [in] Image
+/// \param [in] hDC destination DC
+/// \param [in] Algorithm scaling algorithm 0:fast but slightly worse quality   1:slower but better quality
+/// \param [in] xDst The X coordinate of the upper left corner of the target rectangle
+/// \param [in] yDst The Y coordinate of the upper left corner of the target rectangle
+/// \param [in] cxDst Width of target rectangle
+/// \param [in] cyDst Height of target rectangle
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_DrawToDCFit(
+	void* Image,
+	HDC hDC,
+	int Algorithm,
+	int xDst,
+	int yDst,
+	int cxDst,
+	int cyDst
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 绘制Image到指定窗口（不缩放）
+/// \param [in] Image
+/// \param [in] hWnd 目的窗口
+/// \param [in] xDst 目标矩形的左上角X坐标
+/// \param [in] yDst 目标矩形的左上角Y坐标
+/// \param [in] cxDst 目标矩形的宽度
+/// \param [in] cyDst 目标矩形的高度
+/// \param [in] xSrc 图像矩形的左上角X坐标
+/// \param [in] ySrc 图像矩形的左上角Y坐标
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Draw Image to specified window (without scaling)
+/// \param [in] Image
+/// \param [in] hWnd destination window
+/// \param [in] xDst The X coordinate of the upper left corner of the target rectangle
+/// \param [in] yDst The Y coordinate of the upper left corner of the target rectangle
+/// \param [in] cxDst Width of target rectangle
+/// \param [in] cyDst Height of target rectangle
+/// \param [in] xSrc X coordinate of the upper left corner of the image rectangle
+/// \param [in] ySrc Y coordinate of the upper left corner of the image rectangle
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_BitBlt(
+	void* Image,
+	HWND hWnd,
+	int xDst,
+	int yDst,
+	int cxDst,
+	int cyDst,
+	int xSrc,
+	int ySrc
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 绘制Image到指定DC（不缩放）
+/// \param [in] Image
+/// \param [in] hDC 目的DC
+/// \param [in] xDst 目标矩形的左上角X坐标
+/// \param [in] yDst 目标矩形的左上角Y坐标
+/// \param [in] cxDst 目标矩形的宽度
+/// \param [in] cyDst 目标矩形的高度
+/// \param [in] xSrc 图像矩形的左上角X坐标
+/// \param [in] ySrc 图像矩形的左上角Y坐标
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Draw Image to specified DC (without scaling)
+/// \param [in] Image
+/// \param [in] hDC destination DC
+/// \param [in] xDst The X coordinate of the upper left corner of the target rectangle
+/// \param [in] yDst The Y coordinate of the upper left corner of the target rectangle
+/// \param [in] cxDst Width of target rectangle
+/// \param [in] cyDst Height of target rectangle
+/// \param [in] xSrc X coordinate of the upper left corner of the image rectangle
+/// \param [in] ySrc Y coordinate of the upper left corner of the image rectangle
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_BitBltToDC(
+	void* Image,
+	HDC hDC,
+	int xDst,
+	int yDst,
+	int cxDst,
+	int cyDst,
+	int xSrc,
+	int ySrc
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 以bmp格式保存Image
+/// \param [in] Image
+/// \param [in] FileName 文件名
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Save Image as bmp
+/// \param [in] Image
+/// \param [in] FileName file name
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_SaveAsBmp(
+	void* Image,
+	char const* FileName
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 以jpg格式保存Image
+/// \param [in] Image
+/// \param [in] FileName 文件名
+/// \param [in] Quality 保存质量(1-100)，100为质量最佳但文件也最大
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Save Image as jpg
+/// \param [in] Image
+/// \param [in] FileName file name
+/// \param [in] Quality save quality (1-100), 100 is the best quality but the file is also the largest
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_SaveAsJpeg(
+	void* Image,
+	char const* FileName,
+	BYTE  Quality
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 以png格式保存Image
+/// \param [in] Image
+/// \param [in] FileName 文件名
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Save Image as png
+/// \param [in] Image
+/// \param [in] FileName file name
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_SaveAsPng(
+	void* Image,
+	char const* FileName
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 以raw格式保存Image
+/// \param [in] Image
+/// \param [in] FileName 文件名
+/// \param [in] Format 0: 8Bit Raw     1: 16Bit Raw
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Save Image as raw
+/// \param [in] Image
+/// \param [in] FileName file name
+/// \param [in] Format 0: 8Bit Raw     1: 16Bit Raw
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_SaveAsRaw(
+	void* Image,
+	char const* FileName,
+	int Format
+	);
+
+/// @ingroup MV_IMAGE
+/// \~chinese
+/// \brief 从Image创建一个IPicture
+/// \param [in] Image
+/// \param [out] NewPic 新创建的IPicture
+/// \return 成功返回 CAMERA_STATUS_SUCCESS(0)。否则返回非0值的错误码, 请参考 CameraStatus.h 中错误码的定义。
+/// \~english
+/// \brief Create an IPicture from an Image
+/// \param [in] Image
+/// \param [out] NewPic Newly created IPicture
+/// \return Returns CAMERA_STATUS_SUCCESS(0) successfully. Otherwise, it returns a non-zero error code. Please refer to the definition of the error code in CameraStatus.h.
+MVSDK_API CameraSdkStatus __stdcall CameraImage_IPicture(
+	void* Image,
+	IPicture** NewPic
+	);
+
+
+
+
+#endif // _MV_CAMERA_IMAGE_H_

3rdparty/include22/CameraStatus.h

@@ -0,0 +1,118 @@
+#ifndef __CAMERA_STATUS_DEF__
+#define __CAMERA_STATUS_DEF__
+
+/// @ingroup MV_TYPEDEF
+/// \~chinese SDK错误码
+/// \~english SDK error code
+typedef int CameraSdkStatus;
+
+
+/*常用的宏*/
+#define SDK_SUCCESS(_FUC_)              (_FUC_ == CAMERA_STATUS_SUCCESS)
+
+#define SDK_UNSUCCESS(_FUC_)            (_FUC_ != CAMERA_STATUS_SUCCESS)
+
+#define SDK_UNSUCCESS_RETURN(_FUC_,RET) if((RET = _FUC_) != CAMERA_STATUS_SUCCESS)\
+                                        {\
+                                            return RET;\
+                                        }
+
+#define SDK_UNSUCCESS_BREAK(_FUC_)      if(_FUC_ != CAMERA_STATUS_SUCCESS)\
+                                        {\
+                                            break;\
+                                        }
+
+
+/// @ingroup MV_MACRO_TYPE 
+/// @{
+/* 常用错误  */
+
+#define CAMERA_STATUS_SUCCESS                    0   ///< \~chinese 操作成功 \~english Successful
+#define CAMERA_STATUS_FAILED                    -1   ///< \~chinese 操作失败 \~english operation failed
+#define CAMERA_STATUS_INTERNAL_ERROR            -2   ///< \~chinese 内部错误 \~english internal error
+#define CAMERA_STATUS_UNKNOW                    -3   ///< \~chinese 未知错误 \~english unknown error
+#define CAMERA_STATUS_NOT_SUPPORTED             -4   ///< \~chinese 不支持该功能 \~english Does not support this feature
+#define CAMERA_STATUS_NOT_INITIALIZED           -5   ///< \~chinese 初始化未完成 \~english Incomplete initialization
+#define CAMERA_STATUS_PARAMETER_INVALID         -6   ///< \~chinese 参数无效 \~english Invalid argument
+#define CAMERA_STATUS_PARAMETER_OUT_OF_BOUND    -7   ///< \~chinese 参数越界 \~english Out of bounds of parameters
+#define CAMERA_STATUS_UNENABLED                 -8   ///< \~chinese 未使能 \~english Not enabled
+#define CAMERA_STATUS_USER_CANCEL               -9   ///< \~chinese 用户手动取消了，比如roi面板点击取消，返回 \~english The user manually canceled, such as roi panel click cancel, return
+#define CAMERA_STATUS_PATH_NOT_FOUND            -10  ///< \~chinese 注册表中没有找到对应的路径 \~english The corresponding path was not found in the registry
+#define CAMERA_STATUS_SIZE_DISMATCH             -11  ///< \~chinese 获得图像数据长度和定义的尺寸不匹配 \~english The length of the obtained image data does not match the defined size
+#define CAMERA_STATUS_TIME_OUT                  -12  ///< \~chinese 超时错误 \~english Timeout error
+#define CAMERA_STATUS_IO_ERROR                  -13  ///< \~chinese 硬件IO错误 \~english Hardware IO error
+#define CAMERA_STATUS_COMM_ERROR                -14  ///< \~chinese 通讯错误 \~english Communication error
+#define CAMERA_STATUS_BUS_ERROR                 -15  ///< \~chinese 总线错误 \~english Bus error
+#define CAMERA_STATUS_NO_DEVICE_FOUND           -16  ///< \~chinese 没有发现设备 \~english No device found
+#define CAMERA_STATUS_NO_LOGIC_DEVICE_FOUND     -17  ///< \~chinese 未找到逻辑设备 \~english Logical device not found
+#define CAMERA_STATUS_DEVICE_IS_OPENED          -18  ///< \~chinese 设备已经打开 \~english The device is already open
+#define CAMERA_STATUS_DEVICE_IS_CLOSED          -19  ///< \~chinese 设备已经关闭 \~english Device is off
+#define CAMERA_STATUS_DEVICE_VEDIO_CLOSED       -20  ///< \~chinese 没有打开设备视频，调用录像相关的函数时，如果相机视频没有打开，则回返回该错误。 \~english Without opening the device video, when the video-related function is called, if the camera video is not open, the error is returned back.
+#define CAMERA_STATUS_NO_MEMORY                 -21  ///< \~chinese 没有足够系统内存 \~english Not enough system memory
+#define CAMERA_STATUS_FILE_CREATE_FAILED        -22  ///< \~chinese 创建文件失败 \~english Failed to create file
+#define CAMERA_STATUS_FILE_INVALID              -23  ///< \~chinese 文件格式无效 \~english Invalid file format
+#define CAMERA_STATUS_WRITE_PROTECTED           -24  ///< \~chinese 写保护，不可写 \~english Write protection, not write
+#define CAMERA_STATUS_GRAB_FAILED               -25  ///< \~chinese 数据采集失败 \~english Data collection failed
+#define CAMERA_STATUS_LOST_DATA                 -26  ///< \~chinese 数据丢失，不完整 \~english Loss of data, incomplete
+#define CAMERA_STATUS_EOF_ERROR                 -27  ///< \~chinese 未接收到帧结束符 \~english No frame terminator received
+#define CAMERA_STATUS_BUSY                      -28  ///< \~chinese 正忙(上一次操作还在进行中)，此次操作不能进行 \~english Busy (last operation is still in progress), this operation cannot be performed
+#define CAMERA_STATUS_WAIT                      -29  ///< \~chinese 需要等待(进行操作的条件不成立)，可以再次尝试 \~english Need to wait (condition of operation is not established), can try again
+#define CAMERA_STATUS_IN_PROCESS                -30  ///< \~chinese 正在进行，已经被操作过 \~english Ongoing, has been operated
+#define CAMERA_STATUS_IIC_ERROR                 -31  ///< \~chinese IIC传输错误 \~english IIC transmission error
+#define CAMERA_STATUS_SPI_ERROR                 -32  ///< \~chinese SPI传输错误 \~english SPI transmission error
+#define CAMERA_STATUS_USB_CONTROL_ERROR         -33  ///< \~chinese USB控制传输错误 \~english USB control transmission error
+#define CAMERA_STATUS_USB_BULK_ERROR            -34  ///< \~chinese USB BULK传输错误 \~english USB BULK transmission error
+#define CAMERA_STATUS_SOCKET_INIT_ERROR         -35  ///< \~chinese 网络传输套件初始化失败 \~english Network Transport Suite Initialization Failed
+#define CAMERA_STATUS_GIGE_FILTER_INIT_ERROR    -36  ///< \~chinese 网络相机内核过滤驱动初始化失败，请检查是否正确安装了驱动，或者重新安装。 \~english The webcam kernel filter driver failed to initialize. Please check if the driver is installed correctly or reinstall it.
+#define CAMERA_STATUS_NET_SEND_ERROR            -37  ///< \~chinese 网络数据发送错误 \~english Network data sending error
+#define CAMERA_STATUS_DEVICE_LOST               -38  ///< \~chinese 与网络相机失去连接，心跳检测超时 \~english Lost connection with webcam, heartbeat timeout
+#define CAMERA_STATUS_DATA_RECV_LESS            -39  ///< \~chinese 接收到的字节数比请求的少  \~english Received fewer bytes than requested
+#define CAMERA_STATUS_FUNCTION_LOAD_FAILED      -40  ///< \~chinese 从文件中加载程序失败 \~english Failed to load program from file
+#define CAMERA_STATUS_CRITICAL_FILE_LOST        -41  ///< \~chinese 程序运行所必须的文件丢失。 \~english The file necessary to run the program is missing.
+#define CAMERA_STATUS_SENSOR_ID_DISMATCH        -42  ///< \~chinese 固件和程序不匹配，原因是下载了错误的固件。 \~english The firmware and program do not match because the wrong firmware was downloaded.
+#define CAMERA_STATUS_OUT_OF_RANGE              -43  ///< \~chinese 参数超出有效范围。 \~english The parameter is out of valid range.
+#define CAMERA_STATUS_REGISTRY_ERROR            -44  ///< \~chinese 安装程序注册错误。请重新安装程序，或者运行安装目录Setup/Installer.exe \~english Setup registration error. Please reinstall the program, or run the installation directory Setup/Installer.exe
+#define CAMERA_STATUS_ACCESS_DENY               -45  ///< \~chinese 禁止访问。指定相机已经被其他程序占用时，再申请访问该相机，会返回该状态。(一个相机不能被多个程序同时访问) \~english No Access. When the specified camera has been occupied by another program, it will return to this state if you request to access the camera. (A camera cannot be accessed simultaneously by multiple programs)
+#define CAMERA_STATUS_CAMERA_NEED_RESET         -46  ///< \~chinese 表示相机需要复位后才能正常使用，此时请让相机断电重启，或者重启操作系统后，便可正常使用。 \~english It means that the camera needs to be reset before it can be used normally. At this time, please make the camera power off and restart, or restart the operating system, then it can be used normally.
+#define CAMERA_STATUS_ISP_MOUDLE_NOT_INITIALIZED -47 ///< \~chinese ISP模块未初始化 \~english ISP module is not initialized
+#define CAMERA_STATUS_ISP_DATA_CRC_ERROR        -48  ///< \~chinese 数据校验错误 \~english Data check error
+#define CAMERA_STATUS_MV_TEST_FAILED            -49  ///< \~chinese 数据测试失败 \~english Data test failed
+#define CAMERA_STATUS_INTERNAL_ERR1             -50	 ///< \~chinese 内部错误1 \~english Internal error 1
+#define CAMERA_STATUS_U3V_NO_CONTROL_EP			-51	 ///< \~chinese U3V控制端点未找到 \~english U3V control endpoint not found
+#define CAMERA_STATUS_U3V_CONTROL_ERROR			-52	 ///< \~chinese U3V控制通讯错误 \~english U3V control communication error
+#define CAMERA_STATUS_INVALID_FRIENDLY_NAME		-53	 ///< \~chinese 无效的设备名，名字里不能包含以下字符(\/:*?"<>|") \~english Invalid device name, the name cannot contain the following characters (\/:*?"<>|")
+#define CAMERA_STATUS_FORMAT_ERROR				-54	 ///< \~chinese 格式错误 \~english Format error
+#define CAMERA_STATUS_PCIE_OPEN_ERROR			-55  ///< \~chinese PCIE设备打开失败 \~english PCIE device open failed
+#define CAMERA_STATUS_PCIE_COMM_ERROR			-56  ///< \~chinese PCIE设备通讯失败 \~english PCIE device communication failed
+#define CAMERA_STATUS_PCIE_DDR_ERROR			-57  ///< \~chinese PCIE DDR错误 \~english PCIE DDR error
+
+
+
+//和AIA制定的标准相同
+/*#define CAMERA_AIA_SUCCESS                        0x0000 */
+#define CAMERA_AIA_PACKET_RESEND                          0x0100 ///< \~chinese 该帧需要重传 \~english The frame needs to be retransmitted
+#define CAMERA_AIA_NOT_IMPLEMENTED                        0x8001 ///< \~chinese 设备不支持的命令 \~english Device does not support commands
+#define CAMERA_AIA_INVALID_PARAMETER                      0x8002 ///< \~chinese 命令参数非法 \~english Illegal command parameters
+#define CAMERA_AIA_INVALID_ADDRESS                        0x8003 ///< \~chinese 不可访问的地址 \~english Inaccessible address
+#define CAMERA_AIA_WRITE_PROTECT                          0x8004 ///< \~chinese 访问的对象不可写 \~english The accessed object cannot be written
+#define CAMERA_AIA_BAD_ALIGNMENT                          0x8005 ///< \~chinese 访问的地址没有按照要求对齐 \~english Visited address is not aligned as required
+#define CAMERA_AIA_ACCESS_DENIED                          0x8006 ///< \~chinese 没有访问权限 \~english No access
+#define CAMERA_AIA_BUSY                                   0x8007 ///< \~chinese 命令正在处理中 \~english Command is processing
+#define CAMERA_AIA_DEPRECATED                             0x8008 ///< \~chinese 0x8008-0x0800B  0x800F  该指令已经废弃 \~english 0x8008-0x0800B 0x800F This instruction has been deprecated
+#define CAMERA_AIA_PACKET_UNAVAILABLE                     0x800C ///< \~chinese 包无效 \~english Invalid package
+#define CAMERA_AIA_DATA_OVERRUN                           0x800D ///< \~chinese 数据溢出，通常是收到的数据比需要的多 \~english Data overflow, usually more data than needed
+#define CAMERA_AIA_INVALID_HEADER                         0x800E ///< \~chinese 数据包头部中某些区域与协议不匹配 \~english Some areas in the packet header do not match the protocol
+#define CAMERA_AIA_PACKET_NOT_YET_AVAILABLE               0x8010 ///< \~chinese 图像分包数据还未准备好，多用于触发模式，应用程序访问超时 \~english Image packet data is not ready yet. It is mostly used in trigger mode. Application access timeout
+#define CAMERA_AIA_PACKET_AND_PREV_REMOVED_FROM_MEMORY    0x8011 ///< \~chinese 需要访问的分包已经不存在。多用于重传时数据已经不在缓冲区中 \~english Subcontracts that require access no longer exist. Mostly used for data retransmission is not in the buffer
+#define CAMERA_AIA_PACKET_REMOVED_FROM_MEMORY             0x8012 ///< \~chinese CAMERA_AIA_PACKET_AND_PREV_REMOVED_FROM_MEMORY \~english CAMERA_AIA_PACKET_AND_PREV_REMOVED_FROM_MEMORY
+#define CAMERA_AIA_NO_REF_TIME                            0x0813 ///< \~chinese 没有参考时钟源。多用于时间同步的命令执行时 \~english There is no reference clock source. When used for time synchronization commands
+#define CAMERA_AIA_PACKET_TEMPORARILY_UNAVAILABLE         0x0814 ///< \~chinese 由于信道带宽问题，当前分包暂时不可用，需稍后进行访问 \~english Due to channel bandwidth issues, the current subcontracting is temporarily unavailable and needs to be accessed later
+#define CAMERA_AIA_OVERFLOW                               0x0815 ///< \~chinese 设备端数据溢出，通常是队列已满 \~english Data overflow on the device, usually the queue is full
+#define CAMERA_AIA_ACTION_LATE                            0x0816 ///< \~chinese 命令执行已经超过有效的指定时间 \~english Command execution has exceeded valid specified time
+#define CAMERA_AIA_ERROR                                  0x8FFF ///< \~chinese 错误 \~english error
+
+/// @} end of MV_MACRO_TYPE
+
+                                        
+
+#endif

3rdparty/include22/SenseCameraDll/defs.h

@@ -0,0 +1,50 @@
+#pragma once
+#include <stdio.h>
+#ifdef _WIN32
+#define filename(x) strrchr(x,'\\')?strrchr(x,'\\')+1:x
+#else
+#if __GNUC__ >= 4
+#define filename(x) strrchr(x,'/')?strrchr(x,'/')+1:x
+#endif
+#endif
+
+
+
+#define CREATE_LOG_HEAD \
+char acLogStr[1024*4] = {0};\
+int  iHeadLength = sprintf_s(acLogStr, 1024*4, "[%s:%d] %s:   ", filename(__FILE__), __LINE__, __FUNCTION__);\
+
+#define  LOG_TRACE(...) \
+{\
+    CREATE_LOG_HEAD\
+    snprintf(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+    printf("[TRACE] %s", acLogStr);\
+}
+
+#define  LOG_DEBUG(...) \
+{\
+    CREATE_LOG_HEAD\
+    sprintf_s(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+    printf("[DEBUG] %s", acLogStr);\
+}
+
+#define  LOG_INFO(...) \
+{\
+    CREATE_LOG_HEAD\
+    snprintf(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+    printf("[INFO] %s", acLogStr);\
+}
+
+#define  LOG_WARN(...) \
+{\
+    CREATE_LOG_HEAD\
+    snprintf(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+    printf("[WARN] %s", acLogStr);\
+}
+
+#define  LOG_ERROR(...) \
+{\
+    CREATE_LOG_HEAD\
+    snprintf(acLogStr+iHeadLength, sizeof(acLogStr)-iHeadLength, __VA_ARGS__);\
+    printf("[ERROR] %s", acLogStr);\
+}

3rdparty/include22/SenseCameraDll/mv_camera.h

@@ -0,0 +1,146 @@
+/************************************************************************/
+/* 以C++接口为基础，对常用函数进行二次封装，方便用户使用                */
+/************************************************************************/
+
+#ifndef _MV_CAMERA_H_
+#define _MV_CAMERA_H_
+
+#include "MvCameraControl.h"
+#include <string.h>
+
+#ifndef MV_NULL
+#define MV_NULL    0
+#endif
+
+class CMvCamera
+{
+public:
+    CMvCamera();
+    ~CMvCamera();
+
+    // ch:获取SDK版本号 | en:Get SDK Version
+    static int GetSDKVersion();
+
+    // ch:枚举设备 | en:Enumerate Device
+    static int EnumDevices(unsigned int nTLayerType, MV_CC_DEVICE_INFO_LIST* pstDevList);
+
+    // ch:判断设备是否可达 | en:Is the device accessible
+    static bool IsDeviceAccessible(MV_CC_DEVICE_INFO* pstDevInfo, unsigned int nAccessMode);
+
+    // ch:打开设备 | en:Open Device
+    int Open(MV_CC_DEVICE_INFO* pstDeviceInfo);
+
+    // ch:关闭设备 | en:Close Device
+    int Close();
+
+    // ch:判断相机是否处于连接状态 | en:Is The Device Connected
+    bool IsDeviceConnected();
+
+    // ch:注册图像数据回调 | en:Register Image Data CallBack
+    int RegisterImageCallBack(void(__stdcall* cbOutput)(unsigned char * pData, MV_FRAME_OUT_INFO_EX* pFrameInfo, void* pUser), void* pUser);
+
+    // ch:开启抓图 | en:Start Grabbing
+    int StartGrabbing();
+
+    // ch:停止抓图 | en:Stop Grabbing
+    int StopGrabbing();
+
+    // ch:主动获取一帧图像数据 | en:Get one frame initiatively
+    int GetImageBuffer(MV_FRAME_OUT* pFrame, int nMsec);
+
+    // ch:释放图像缓存 | en:Free image buffer
+    int FreeImageBuffer(MV_FRAME_OUT* pFrame);
+
+    // ch:显示一帧图像 | en:Display one frame image
+    int DisplayOneFrame(MV_DISPLAY_FRAME_INFO* pDisplayInfo);
+
+    // ch:设置SDK内部图像缓存节点个数 | en:Set the number of the internal image cache nodes in SDK
+    int SetImageNodeNum(unsigned int nNum);
+
+    // ch:获取设备信息 | en:Get device information
+    int GetDeviceInfo(MV_CC_DEVICE_INFO* pstDevInfo);
+
+    // ch:获取GEV相机的统计信息 | en:Get detect info of GEV camera
+    int GetGevAllMatchInfo(MV_MATCH_INFO_NET_DETECT* pMatchInfoNetDetect);
+
+    // ch:获取U3V相机的统计信息 | en:Get detect info of U3V camera
+    int GetU3VAllMatchInfo(MV_MATCH_INFO_USB_DETECT* pMatchInfoUSBDetect);
+
+#pragma region 一些详细控制参数设置
+
+
+#pragma endregion
+
+
+    // ch:获取和设置Int型参数，如 Width和Height，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
+    // en:Get Int type parameters, such as Width and Height, for details please refer to MvCameraNode.xlsx file under SDK installation directory
+    int GetIntValue(IN const char* strKey, OUT MVCC_INTVALUE_EX *pIntValue);
+    int SetIntValue(IN const char* strKey, IN int64_t nValue);
+
+    // ch:获取和设置Enum型参数，如 PixelFormat，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
+    // en:Get Enum type parameters, such as PixelFormat, for details please refer to MvCameraNode.xlsx file under SDK installation directory
+    int GetEnumValue(IN const char* strKey, OUT MVCC_ENUMVALUE *pEnumValue);
+    int SetEnumValue(IN const char* strKey, IN unsigned int nValue);
+    int SetEnumValueByString(IN const char* strKey, IN const char* sValue);
+
+    // ch:获取和设置Float型参数，如 ExposureTime和Gain，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
+    // en:Get Float type parameters, such as ExposureTime and Gain, for details please refer to MvCameraNode.xlsx file under SDK installation directory
+    int GetFloatValue(IN const char* strKey, OUT MVCC_FLOATVALUE *pFloatValue);
+    int SetFloatValue(IN const char* strKey, IN float fValue);
+
+    // ch:获取和设置Bool型参数，如 ReverseX，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
+    // en:Get Bool type parameters, such as ReverseX, for details please refer to MvCameraNode.xlsx file under SDK installation directory
+    int GetBoolValue(IN const char* strKey, OUT bool *pbValue);
+    int SetBoolValue(IN const char* strKey, IN bool bValue);
+
+    // ch:获取和设置String型参数，如 DeviceUserID，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件UserSetSave
+    // en:Get String type parameters, such as DeviceUserID, for details please refer to MvCameraNode.xlsx file under SDK installation directory
+    int GetStringValue(IN const char* strKey, MVCC_STRINGVALUE *pStringValue);
+    int SetStringValue(IN const char* strKey, IN const char * strValue);
+
+    // ch:执行一次Command型命令，如 UserSetSave，详细内容参考SDK安装目录下的 MvCameraNode.xlsx 文件
+    // en:Execute Command once, such as UserSetSave, for details please refer to MvCameraNode.xlsx file under SDK installation directory
+    int CommandExecute(IN const char* strKey);
+
+    // ch:探测网络最佳包大小(只对GigE相机有效) | en:Detection network optimal package size(It only works for the GigE camera)
+    int GetOptimalPacketSize(unsigned int* pOptimalPacketSize);
+
+    // ch:注册消息异常回调 | en:Register Message Exception CallBack
+    int RegisterExceptionCallBack(void(__stdcall* cbException)(unsigned int nMsgType, void* pUser), void* pUser);
+
+    // ch:注册单个事件回调 | en:Register Event CallBack
+    int RegisterEventCallBack(const char* pEventName, void(__stdcall* cbEvent)(MV_EVENT_OUT_INFO * pEventInfo, void* pUser), void* pUser);
+
+    // ch:强制IP | en:Force IP
+    int ForceIp(unsigned int nIP, unsigned int nSubNetMask, unsigned int nDefaultGateWay);
+
+    // ch:配置IP方式 | en:IP configuration method
+    int SetIpConfig(unsigned int nType);
+
+    // ch:设置网络传输模式 | en:Set Net Transfer Mode
+    int SetNetTransMode(unsigned int nType);
+
+    // ch:像素格式转换 | en:Pixel format conversion
+    int ConvertPixelType(MV_CC_PIXEL_CONVERT_PARAM* pstCvtParam);
+
+    // ch:保存图片 | en:save image
+    int SaveImage(MV_SAVE_IMAGE_PARAM_EX* pstParam);
+    int SaveImageToFile(MV_SAVE_IMG_TO_FILE_PARAM* pstSaveFileParam);
+
+private:
+
+    void*               m_hDevHandle;
+	MV_CC_DEVICE_INFO	m_stDeviceInfo;
+
+};
+
+#endif//_MV_CAMERA_H_
+
+
+////	//设置Enum型参数-相机图像格式
+//	//注意点1：相机图像格式设置时，只有在MV_CC_Startgrab接口调用前才能设置,取流过程中，不能修改图像格式
+//nRet = MV_CC_SetEnumValue(handle, "PixelFormat", PixelType_Gvsp_Mono12);
+//if (MV_OK != nRet)
+//{
+//    printf("error: Set PixelFormat fail [%x]\n", nRet);
+//}

3rdparty/include22/SenseCameraDll/mv_camera_imp.h.h

@@ -0,0 +1 @@
+#pragma once

3rdparty/include22/SenseCameraDll/sense_camera_adapter.h

@@ -0,0 +1,95 @@
+#pragma once
+#include "sense_camera_global.h"
+#include <stdint.h>
+#include  <string>
+#include <vector>
+
+#ifdef USE_OPENCV
+#include "opencv2/opencv.hpp"
+#endif // USE_OPENCV
+
+#ifdef USE_HALCON
+#include <HalconCpp.h>
+#endif // USE_HALCON
+
+namespace cv
+{
+    class Mat;
+}
+namespace HalconCpp
+{
+    class HObject;
+}
+
+
+class SENSE_EXPORT CameraAdapter
+{
+public:
+
+    enum class E_TRIGGER_MODE
+    {
+        TRIGGER_MODE_ON = 0,
+        TRIGGER_MODE_OFF,
+    };
+    enum class E_TRIGGER_SOURCE
+    {
+        TRIGGER_SOURCE_SOFT = 0,
+        TRIGGER_SOURCE_LINE0,
+        TRIGGER_SOURCE_LINE2,
+        TRIGGER_SOURCE_LINE3,
+    };
+    virtual int64_t openCamera(const char* camSN) = 0;
+    virtual int64_t setInitParameters() = 0;
+#ifdef USE_OPENCV
+    virtual int64_t getOneImage(cv::Mat& img) = 0;
+    virtual int64_t takeSingleImage(cv::Mat& img) = 0;//软触发并取一次图
+#endif
+#ifdef USE_HALCON
+    virtual int64_t getOneImage(HalconCpp::HObject& img) = 0;
+    virtual int64_t takeSingleImage(HalconCpp::HObject& img) = 0;//软触发并取一次图
+#endif // USE_HALCON
+
+    virtual int64_t closeCamera() = 0 ;
+    virtual int64_t reConnectCamera() = 0;
+    virtual void    clearCameraBuf() = 0;
+    virtual int64_t startGrabbing() = 0;
+    virtual int64_t stopGrabbing() = 0;
+    virtual int64_t softTriggerOnce() = 0;//软触发一次
+    virtual double  getExposureTime() = 0; ////获取设备当前曝光时间
+    virtual void    setTriggerMode(E_TRIGGER_MODE mode) = 0; //设置设备曝光时间
+    virtual void    setTriggerSource(E_TRIGGER_SOURCE source) = 0; //设置触发源
+    enum 
+    {
+        IMAGESIZE_DEFAULT_WIDTH = 2590,
+        IMAGESIZE_DEFAULT_HEIGHT = 1944,
+    };
+    enum {
+        SUCCESS = 0,
+        ACTION_FAILED_UNDO = -100001,
+        GAMERA_UNKOWN_CONTROLLER = -98000,
+        GAMERA_FAILED_NODEVICE,
+        GAMERA_FAILED_ALLOCATE,
+        GAMERA_FAILED_OVERCONNECT,
+        GAMERA_FAILED_TOCONNECT,
+        GAMERA_FAILED_UNCONNECTED,
+        GAMERA_FAILED_SETEXPOSURE,
+        GAMERA_FAILED_INACTION,
+        GAMERA_FAILED_TIMEOUTEXEC,
+        GAMERA_FAILED_NOIMAGEACC,
+        GAMERA_FAILED_IMAGEBUFLEN,
+        GAMERA_FAILED_STDEXCEPTION,
+        GAMERA_FAILED_UNKNOWNEXCEPTION,
+        GAMERA_FAILED_GETIMAGE,
+        ERROR_UNDEFINE
+    };
+
+};
+
+
+
+
+
+
+
+
+

3rdparty/include22/SenseCameraDll/sense_camera_global.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#if defined(SENSECAMERAX64_EXPORTS)
+#define SENSE_EXPORT __declspec(dllexport)
+#else
+#define SENSE_EXPORT __declspec(dllimport)
+#endif

3rdparty/include22/SenseCameraDll/sense_ctrl_frame_grabber.h

@@ -0,0 +1,57 @@
+#pragma once
+#include "sense_camera_global.h"
+#include "sense_camera_adapter.h"
+#include <memory>
+
+
+class SENSE_EXPORT CtrlFrameGrabber
+{
+
+public:
+    enum E_CameraType
+    {
+        TYPE_HK = 0,
+        TYPE_DAHENG = 1,
+        TYPE_BASLER,
+        TYPE_SIMULATE
+    };
+    enum 
+    {
+        CAM_MAXNUM = 9,
+    };
+    //单例函数指针获取
+    static CtrlFrameGrabber* getInstance();
+    static void releaseInstance();
+    static long enumDevicesSN(std::vector<std::string>& vecCamSn, CtrlFrameGrabber::E_CameraType type);
+    long connectCam(long index, std::string& sn, long type);
+    long reConnectCam(long index);
+    long disconnectCam(long index);
+    long disconnectALL();
+    long getType(long index);
+#ifdef USE_OPENCV
+    long getOneImage(long index, cv::Mat& img);
+    long takeSingleImage(long index, cv::Mat& img);
+#endif
+#ifdef USE_HALCON
+    long getOneImage(long index, HalconCpp::HObject& img);
+    long takeSingleImage(long index, HalconCpp::HObject& img);//软触发并取一次图
+#endif // USE_HALCON
+
+
+
+    void clearCameraBuf(long index);
+    long startGrabbing(long index);
+    long stopGrabbing(long index);
+    long softTriggerOnce(long index);
+    void setTriggerMode(long index,CameraAdapter::E_TRIGGER_MODE mode); //设置设备曝光时间
+    void setTriggerSource(long index, CameraAdapter::E_TRIGGER_SOURCE source);
+private:
+    explicit CtrlFrameGrabber();
+    ~CtrlFrameGrabber();
+private:
+    static CtrlFrameGrabber*    m_handle;
+    CameraAdapter*              m_pCamAr[CtrlFrameGrabber::CAM_MAXNUM];//ProSYS::CAM_MAXNUM
+    long                        m_pTypeAr[CtrlFrameGrabber::CAM_MAXNUM];//ProSYS::CAM_MAXNUM
+
+
+};

3rdparty/include22/SenseCameraDll/sense_gx_camera_imp.h

@@ -0,0 +1,50 @@
+#pragma once
+#include "sense_camera_adapter.h"
+#include "GalaxyIncludes.h"
+#include <atomic>
+//大恒相机
+
+class CameraDahengImp : public CameraAdapter
+{
+public:
+	CameraDahengImp();
+	~CameraDahengImp();
+	int64_t enumDevicesSN(std::vector<std::string>& sn);
+	virtual int64_t setInitParameters();
+	virtual int64_t openCamera(const char* strDeviceSN);
+
+#ifdef USE_OPENCV
+	virtual int64_t getOneImage(cv::Mat& img);
+	virtual int64_t takeSingleImage(cv::Mat& img);
+#endif // USE_OPENCV
+
+#ifdef USE_HALCON
+	virtual int64_t getOneImage(HalconCpp::HObject& img);
+	virtual int64_t takeSingleImage(HalconCpp::HObject& img);//软触发并取一次图
+#endif // USE_HALCON
+
+
+	virtual int64_t softTriggerOnce();	//软触发一次
+	virtual int64_t closeCamera();
+	virtual int64_t reConnectCamera();
+	virtual void	clearCameraBuf();
+	virtual int64_t startGrabbing();
+	virtual int64_t stopGrabbing();
+	virtual double	getExposureTime();
+	virtual void	setTriggerMode(E_TRIGGER_MODE mode);
+	virtual void	setTriggerSource(E_TRIGGER_SOURCE source);
+private:
+	std::atomic_bool			bIsStreamOpen= false;			///< 设备流是否已打开标识
+	std::atomic_bool			bIsDeviceOpen = false;          ///< 设备是否已打开标识
+	std::atomic_bool			m_bIsColor = false;				///< 是否支持彩色
+	std::atomic_bool            m_bStartGrabbing = false;       ///< 设备采集标识
+	CImageDataPointer           m_objImageDataPtr;              ///< GetImage获取的图像
+	CGXDevicePointer            m_objDevicePtr;                 ///< 设备句柄
+	CGXStreamPointer            m_objStreamPtr;                 ///< 设备流对象
+	CGXFeatureControlPointer    m_objFeatureControlPtr;         ///< 属性控制器
+	CGXFeatureControlPointer    m_objStreamFeatureControlPtr;   ///< 流层控制器对象
+	GX_VALID_BIT_LIST			_getBestValudBit(GX_PIXEL_FORMAT_ENTRY emPixelFormatEntry);
+	void						_isSupportColor();
+	///判断PixelFormat是否为8位
+	bool						_isPixelFormat8(GX_PIXEL_FORMAT_ENTRY emPixelFormatEntry);
+};

3rdparty/include22/SenseCameraDll/sense_mvs_camera_imp.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "sense_camera_adapter.h"
+#include "mv_camera.h"
+#include <atomic>
+//大恒相机
+
+class CameraHaiKangImp : public CameraAdapter
+{
+public:
+	CameraHaiKangImp();
+	~CameraHaiKangImp();
+	int64_t			enumDevicesSN(std::vector<std::string>& sn);
+	virtual int64_t setInitParameters();
+	virtual int64_t openCamera(const char* strDeviceSN);
+#ifdef USE_OPENCV
+	virtual int64_t getOneImage(cv::Mat& img);
+	virtual int64_t takeSingleImage(cv::Mat& img);
+#endif // USE_OPENCV
+
+#ifdef USE_HALCON
+	virtual int64_t getOneImage(HalconCpp::HObject& img);
+	virtual int64_t takeSingleImage(HalconCpp::HObject& img);//软触发并取一次图
+#endif // USE_HALCON
+
+
+
+	virtual int64_t softTriggerOnce();	//软触发一次
+	virtual int64_t closeCamera();
+	virtual int64_t reConnectCamera();
+	virtual void	clearCameraBuf();
+	virtual int64_t startGrabbing();
+	virtual int64_t stopGrabbing();
+	virtual void	setTriggerMode(E_TRIGGER_MODE mode);
+	virtual void	setTriggerSource(E_TRIGGER_SOURCE source);
+	virtual double  getExposureTime();
+private:
+	std::atomic_bool			bIsDeviceOpen = false;          ///< 设备是否已打开标识
+	std::atomic_bool			m_bIsColor = false;				///< 是否支持彩色
+	std::atomic_bool            m_bStartGrabbing = false;       ///< 设备采集标识
+	std::string                 m_mSNstr = "";					///< 相机SN
+	CMvCamera					m_pcMyCamera;					// ch:CMyCamera封装了常用接口 | en:CMyCamera packed commonly used interface
+	
+};

3rdparty/include22/SenseCameraDll/sense_simulate_camera_imp.h

@@ -0,0 +1,59 @@
+#pragma once
+#include "sense_camera_adapter.h"
+
+class CameraSimulateImp : public CameraAdapter
+{
+public:
+    explicit CameraSimulateImp();
+    ~CameraSimulateImp();
+
+    virtual int64_t openCamera();
+
+    virtual int64_t openCamera(const char* camSN);
+
+    virtual int64_t closeCamera();
+
+    virtual int64_t setInitParameters();
+
+    virtual std::string   getCameraSN();
+
+    virtual int64_t getCameraImageSize();
+
+    virtual int64_t getCameraImageWidth();
+
+    virtual int64_t getCameraImageHeigth();
+
+    virtual int64_t setExposureTime(int64_t tvalue);
+
+    virtual double  getExposureTime();
+
+    virtual int64_t shotOneFrame();
+
+#ifdef USE_OPENCV
+    virtual int64_t getOneImage(cv::Mat& img);
+    virtual int64_t takeSingleImage(cv::Mat& img);
+#endif // USE_OPENCV
+
+#ifdef USE_HALCON
+    virtual int64_t getOneImage(HalconCpp::HObject& img);
+    virtual int64_t takeSingleImage(HalconCpp::HObject& img);//Èí´¥·¢²¢È¡Ò»´Îͼ
+#endif // USE_HALCON
+
+    virtual int64_t setRetryTimes(uint32_t tvalue);
+    virtual int64_t doshotOneExec();
+	virtual int64_t reConnectCamera();
+    virtual int64_t waitshotOneDone();
+    virtual int64_t startGrabbing();
+    virtual int64_t stopGrabbing();
+    virtual int64_t softTriggerOnce();
+    virtual int64_t getImageOneFrame(unsigned char* pbuf, int64_t buflen, int64_t& iwidth, int64_t& iheight, int64_t& isizebytes,int32_t queuebuf = 1);
+    virtual void  setTriggerMode(E_TRIGGER_MODE mode);
+    virtual void  setTriggerSource(E_TRIGGER_SOURCE source);
+	virtual void  clearCameraBuf();
+private:
+    std::string                 _mCamSN;
+    uint32_t                    _mMaxRetry;
+    int64_t                     _mExpTime;
+
+};
+

3rdparty/include22/halcon/HBase.h

@@ -0,0 +1,365 @@
+/*****************************************************************************
+ * HBase.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: Basic definitions for HALCON, HALCON/C, HALCON/C++
+ *              and other language interfaces
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HBASE_H
+#define HBASE_H
+
+#include <stdlib.h> /* NULL */
+#include "HIntDef.h"
+
+typedef   void*   VOIDP;
+
+/*****************************************************************************/
+/* Parameter passing (Control parameters)                                    */
+/*****************************************************************************/
+#define UNDEF_PAR        0       /* Parameter type: no defined type          */
+#define LONG_PAR         1       /* Parameter type: long                     */
+#define FLOAT_PAR        2       /* Parameter type: float                    */
+#define STRING_PAR       4       /* Parameter type: string                   */
+#define HANDLE_PAR       16      /* Parameter type: handle (arbitrary data)  */
+#define INT_PAR          LONG_PAR    /* Parameter type: int                  */
+#define DOUBLE_PAR       FLOAT_PAR   /* Parameter type: double               */
+#define MIXED_PAR        8           /* Parameter type: Hcpar                */
+#define MAX_TUPLE_TYPE   HANDLE_PAR  /* maximum type number                  */
+/* Possible parameter types for a single element: */
+#define ANY_ELEM         (LONG_PAR|FLOAT_PAR|STRING_PAR|HANDLE_PAR)
+/* Possible parameter types for a tuple: */
+#define ANY_TUPLE        (ANY_ELEM|MIXED_PAR)
+/*                       32          reserved */
+#define POINTER_PAR      64        /* Parameter type: pointer to any type    */
+#define TUPLE_PAR        128       /* Parameter type: pointer to tuple       */
+#define MAX_PAR          HANDLE_PAR
+
+
+/*****************************************************************************/
+/* Constants and basic types                                                 */
+/*****************************************************************************/
+#define MAX_TUPLE_LENGTH 1000000   /* max. length of a tuple                 */
+#define MAX_STRING       1024      /* max. length of a string                */
+
+typedef UINT4            Herror;   /* Type function values (error messages)  */
+
+typedef  long *Hkey;               /* primary key in DB (for iconic objects) */
+#define  UNDEF_KEY   (Hkey)(0)     /* Undefined iconic object                */
+
+
+/*****************************************************************************/
+/* Structures for passing parameters between language interface and core     */
+/*****************************************************************************/
+#ifndef HC_NO_STRUCT_MEMBER_ALIGNMENT
+/* sets the struct member alignment to avoid problems if
+ * the settings of the user differ to those of the HALCON
+ * version. (8 is the default alignment, generally) */
+# pragma pack(push,8)
+#endif
+
+
+/*****************************************************************************/
+/* HALCON procedure (operator) handle                                        */
+/*****************************************************************************/
+/* This data structure contains all informations about an instance of an     */
+/* HALCON operator or an HALCON thread derived from an HALCON operator       */
+/* instance. The contained information describes the processing context of   */
+/* HALCON operators (e.g. parameter values, debugging information, etc.).    */
+/*****************************************************************************/
+typedef void *Hproc_handle;
+
+
+/*****************************************************************************/
+/* Structures, Functions and Defines for Handles                             */
+/*****************************************************************************/
+
+struct HStreamBufferT;
+struct HhandleListT;
+
+/****************************************************************************/
+/** HSignalTypeEnum: List of signals that can be sent to handles
+ ****************************************************************************
+ * This enum defines a set of signals that can be sent to the
+ * signalling callback of handles.  Note that the callback functions must
+ * ignore any signal that they do not understand.
+ ****************************************************************************/
+typedef enum {
+  eSignalNone = 0,   /**< No signal */
+  eSignalStartAbort, /**< Initiate abort: stop running, abort mutexes etc. */
+  eSignalAbort,      /**< Finalize abort, wait for resources to finish */
+  eSignalRestore,    /**< After abortion is complete, restore mutexes etc. */
+} HSignalTypeEnum;
+
+typedef Herror (*HHandleSerializeFunc)(Hproc_handle, struct HStreamBufferT *,
+                                       void *);
+typedef Herror (*HHandleDeserializeFunc)(Hproc_handle, struct HStreamBufferT *,
+                                         void **);
+typedef Herror (*HHandleDestructorFunc)(Hproc_handle, void *);
+typedef Herror (*HHandleSignalFunc)(HSignalTypeEnum signal, void *);
+
+/****************************************************************************/
+/** HHandleInfo holds handle type information.
+ ****************************************************************************
+ * This structure exists once per handle type (usually per sem_type).
+ * It contains basic, static, constant information about that type.
+ * Most notably, it contains pointers to the functions that operate on the
+ * handles (clear, serialize, deserialize and signal).
+ *
+ * Handles (instances) of types where the cb_signal callback is not NULL are
+ * stored in a list that allows calling the signal callback for each of them.
+ *
+ * All serialized items must have a unique header, usually a string, that
+ * identifies them. 'header' contains a pointer to that header, allowing
+ * other functions to identify a serialized item based on its header.
+ * If no (de)serialization function is set, header must be NULL.
+ *
+ * \ingroup data_structures_handles
+ ****************************************************************************/
+typedef struct H_HANDLE_TYPE {
+  INT4_8                 type_id;        /**< Type ID */
+  const char *           sem_type;       /**< sem_type of the handle */
+  HHandleSerializeFunc   cb_serialize;   /**< Serialize this handle type */
+  HHandleDeserializeFunc cb_deserialize; /**< Deserialize this handle type */
+  const char *           header;         /**< Serialization header */
+  HHandleDestructorFunc  cb_clear;       /**< Clear this handle type */
+  HHandleSignalFunc      cb_signal;      /**< Signal (for semaphores etc.) */
+  struct HhandleListT *  list;           /**< List of handles, or NULL */
+} HHandleInfo;
+
+
+/****************************************************************************/
+/** HANDLE_INFO_INITIALIZER: Convenience macro for initializing HHandleInfo
+ ****************************************************************************/
+#  define HANDLE_INFO_INITIALIZER(TYPE_ID, SEM_TYPE, FUN_SERIALIZE,           \
+                                  FUN_DESERIALIZE, HEADER_STRING, FUN_CLEAR,  \
+                                  FUN_SIGNAL, LIST)                           \
+    {                                                                         \
+      (INT4_8)(TYPE_ID), (SEM_TYPE), (HHandleSerializeFunc)(FUN_SERIALIZE),   \
+          (HHandleDeserializeFunc)(FUN_DESERIALIZE), HEADER_STRING,           \
+          (HHandleDestructorFunc)(FUN_CLEAR),                                 \
+          (HHandleSignalFunc)(FUN_SIGNAL), (LIST)                             \
+    }
+
+/****************************************************************************/
+/** HANDLE_INFO_INITIALIZER_NOSER: Convenience macro for init. HHandleInfo
+ ****************************************************************************
+ * Use this macro for handles that cannot be (de)serialized.
+ ****************************************************************************/
+#  define HANDLE_INFO_INITIALIZER_NOSER(TYPE_ID, SEM_TYPE, FUN_CLEAR,         \
+                                        FUN_SIGNAL, LIST)                     \
+    {                                                                         \
+      (INT4_8)(TYPE_ID), (SEM_TYPE), (HHandleSerializeFunc)NULL,              \
+          (HHandleDeserializeFunc)NULL, (const char *)NULL,                   \
+          (HHandleDestructorFunc)(FUN_CLEAR),                                 \
+          (HHandleSignalFunc)(FUN_SIGNAL), (LIST)                             \
+    }
+
+typedef struct HhandleT *Hphandle;
+
+typedef union
+{
+  INT4_8   l;             /* 4/8 byte integer                       (input)  */
+  double   d;             /* 8 byte real                            (input)  */
+  char     *s;            /* pointer to strings                     (input)  */
+  double   f;             /* 8 byte real (legacy 11.0)              (input)  */
+  Hphandle h;             /* Pointer to handle                      (input)  */
+} Hpar;                   /* parameter passing for the C interface           */
+
+typedef union
+{
+  INT4_8  *l;             /* 4/8 byte integer                       (output) */
+  double  *d;             /* 8 byte real,                           (output) */
+  char    *s;             /* pointer to strings                     (output) */
+  void   *p;              /* pointer to var. of any type (e.g. tuple)(output)*/
+  double  *f;             /* 8 byte real, (legacy 11.0)             (output) */
+} Hvar;                   /* parameter passing for the C interface           */
+
+typedef struct
+{
+  Hpar   par;             /* values                                          */
+  HINT   type;            /* type flag                                       */
+} Hcpar;                  /* parameter passing for the C interface           */
+
+typedef struct
+{
+  Hvar   var;             /* values                                          */
+  HINT   type;            /* type flag                                       */
+} Hcvar;                  /* parameter passing for the C interface           */
+
+typedef union {
+  INT4_8   *l;
+  double   *d;
+  char     **s;
+  Hcpar    *cpar;
+  Hphandle *h;
+} Hcelem; /* pure type array */
+
+
+typedef struct HCTUPLE
+{
+  Hpar  val;
+  HINT  type;
+  /*
+   * Add manual padding here so that a Hcpar can be mapped to a Hctuple exactly,
+   * including the padding compilers insert at the end of data structures to
+   * align the entire structure to the largest alignment of any structure
+   * member. Note that on 32 bit Linux for Intel, Hcpar is aligned to 4 bytes,
+   * so no manual padding is necessary on that architecture (only).
+   */
+#if !(defined(__linux__) && defined(__i386__))
+  char   pad[sizeof(Hcpar)-sizeof(Hpar)-sizeof(HINT)];
+#endif
+  INT4_8 num;                   /* number of set array elements */
+  INT4_8 capacity;              /* allocated array length */
+  HINT  free;                   /* free array elem when destroying tuple? */
+  Hcelem elem;                  /* the actual array */
+} Hctuple;
+#define HCTUPLE_INITIALIZER {{0},UNDEF_PAR,{0},0,0,0,{NULL}}
+
+typedef struct
+{
+  Hcvar   *variables;     /* variables (of application) to write back values */
+  Hcpar   *element;       /* tuple element(s)                                */
+  INT4_8  num_el;         /* number of used elements                         */
+  INT4_8  length;         /* total length of array (incl. unused elements)   */
+} Hcvtuple;               /* for passing control parameter variables from    */
+                          /* the language to the core interface              */
+#ifndef HC_NO_STRUCT_MEMBER_ALIGNMENT
+# pragma pack(pop)
+#endif
+
+/*****************************************************************************/
+/* Bool constants                                                            */
+/*****************************************************************************/
+#ifdef TRUE
+#undef TRUE
+#endif
+#define TRUE             true
+
+#ifdef FALSE
+#undef FALSE
+#endif
+#define FALSE            false
+
+
+/*****************************************************************************/
+/* Pixel types of HALCON images                                              */
+/*****************************************************************************/
+#define UNDEF_IMAGE   (HINT)0
+#define BYTE_IMAGE    (HINT)(1<<0)
+#define INT4_IMAGE    (HINT)(1<<1)
+#define LONG_IMAGE    INT4_IMAGE
+#define FLOAT_IMAGE   (HINT)(1<<2)
+#define DIR_IMAGE     (HINT)(1<<3)
+#define CYCLIC_IMAGE  (HINT)(1<<4)
+#define INT1_IMAGE    (HINT)(1<<5)
+/* (1<<6) omitted so far -> use it for next new image type */
+#define COMPLEX_IMAGE (HINT)(1<<7)
+/* (1<<8) omitted so far -> use it for next new image type */
+#define INT2_IMAGE    (HINT)(1<<9)
+#define UINT2_IMAGE   (HINT)(1<<10)
+#define VF_IMAGE      (HINT)(1<<11)
+#define INT8_IMAGE    (HINT)(1<<12)
+
+/*****************************************************************************/
+/* Type of HALCON vector field images                                        */
+/*****************************************************************************/
+#define VF_ABSOLUTE   (INT4)0
+#define VF_RELATIVE   (INT4)(1<<0)
+
+
+/*****************************************************************************/
+/* data types for handling pthreads (POSIX threads) and mutex variables      */
+/*****************************************************************************/
+typedef void*          H_pthread_t;            /* pthread handle             */
+typedef void*          H_pthread_mutex_t;      /* pthread mutex data type    */
+typedef void*          H_pthread_cond_t;       /* pthread condition variable */
+typedef void*          H_pthread_barrier_t;    /* pthread barrier variable */
+
+
+/*****************************************************************************/
+/* signature of the callback functions for drawing objects                   */
+/*****************************************************************************/
+
+#ifndef _WIN32
+#define __stdcall
+#endif
+typedef Herror (__stdcall *HDrawObjectCallback)(Hphandle DrawHandle,
+                                                Hphandle WindowHandle,
+                                                char* type);
+
+/*****************************************************************************/
+/* signature of the callback functions for buffer window content updates     */
+/*****************************************************************************/
+typedef Herror (__stdcall *HUpdateContentCallback)(void *context);
+
+/*****************************************************************************/
+/* signature of the callback function for license recheck failure callbacks  */
+/*****************************************************************************/
+typedef void (__stdcall *HLicenseRecheckFailedCallback)(void *context,
+                                                        Herror error);
+
+/* A define for the restrict qualifier */
+#if !defined(H_RESTRICT)
+# if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+   /* Compiler is in C99 mode and should know about the restrict qualifier */
+#  define H_RESTRICT restrict
+# else
+#  if (defined(_WIN32) && defined(_MSC_VER) && _MSC_VER >= 1400) || defined(__INTEL_COMPILER)
+    /* Intel Compilers and grown-up Microsoft Compilers always know a __restrict */
+#   define H_RESTRICT __restrict
+#  elif (defined(__linux) || defined(__APPLE__)) && defined(__GNUC__)
+    /* Gcc knows about __restrict__ since at least gcc 3.0 */
+#   define H_RESTRICT __restrict__
+#  elif defined(__TI_COMPILER_VERSION__)
+    /* TI's cgtools know about restrict. */
+#   define H_RESTRICT restrict
+#  else
+#   define H_RESTRICT
+#  endif
+# endif /* __STDC_VERSION__ */
+#endif /* H_RESTRICT */
+
+
+/* A define for the inline qualifier */
+#if !defined(H_INLINE)
+#ifdef __cplusplus
+#define H_INLINE inline
+#else
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+/* compiler is in C99 mode and should know about the inline qualifier */
+#  define H_INLINE inline
+#else
+#if defined(_WIN32) || defined(__alpha) || defined(__sgi)
+#  define H_INLINE __inline
+#else
+#if defined(__linux) || defined(__APPLE__)
+#  define H_INLINE __inline__
+#else
+#if defined(__sun)
+#  define H_INLINE inline
+#else
+#  define H_INLINE
+#endif
+#endif
+#endif
+#endif /* __STDC_VERSION__ */
+#endif /* #ifdef __cplusplus .. else */
+#endif /* H_INLINE */
+
+/* A define to force functions to be inlined */
+#if defined(_WIN32)
+#define H_FORCEINLINE __forceinline
+#elif (defined(__linux) || defined(__APPLE__)) && defined(__GNUC__)
+#define H_FORCEINLINE H_INLINE __attribute__((always_inline))
+#else
+#define H_FORCEINLINE H_INLINE
+#endif
+
+#endif /* ifndef HBASE_H */

3rdparty/include22/halcon/HConst.h

@@ -0,0 +1,199 @@
+/*****************************************************************************
+ * HConst.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: Definition of constants
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HCONST_H
+#define HCONST_H
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*             General constants for the HALCON library                      */
+/*****************************************************************************/
+/*****************************************************************************/
+
+
+/* Data Base */
+#define H_UNDEFINED  UNDEF_KEY /* Ctype.h, CORE*.c do not change */
+
+
+/*****************************************************************************/
+/* Max. values for the library                                               */
+/*****************************************************************************/
+#if !defined(HC_LARGE_IMAGES)
+#define LD_MAX_FORMAT             15
+#else
+#define LD_MAX_FORMAT             30
+#endif
+#define MAX_FORMAT                (1<<LD_MAX_FORMAT)
+
+#define RL_LENGTH                 1       /* Only for typedef                */
+#define DEF_RL_LENGTH             50000   /* initial value for CurrentRL     */
+#define OBJ_PER_PROC              5000    /* Typical # of objects per param. */
+#define FILE_TRANS_SIZE           1024*16 /* max. # of byte per read call    */
+#define MAX_FILES                 20      /* max. # of open files            */
+#define MAX_EDGE_LENGTH1          101     /* max. filter size                */
+#define MAX_CLUSTER               1024    /* LearnNDim,ClassNDim             */
+#define MAX_CONVOL                50000   /* IPConvol.c (> 10000!)           */
+#define MAX_IMAGE_DIR             (16*MAX_STRING) /* length of the image dir */
+#define MAX_GRAPHIC_COLOR         64/* max. number of graphics colors in LUT */
+#define MAX_COLOR_NAME_LENGTH     40 /* max. length of a color name          */
+
+
+/*****************************************************************************/
+/* Environment variables of HALCON                                           */
+/*****************************************************************************/
+#define HALCONROOT                "HALCONROOT"       /* Environment variable */
+#define HALCONIMAGES              "HALCONIMAGES"     /* Environment variable */
+#define HALCONHELP                "HALCONHELP"       /* Environment variable */
+#define HALCONSPY                 "HALCONSPY"        /* Environment variable */
+#define HALCONEXTENSIONS          "HALCONEXTENSIONS" /* Environment variable */
+#define HALCONEXAMPLES            "HALCONEXAMPLES"   /* Environment variable */
+
+
+/*****************************************************************************/
+/* Core Interface and operator implementation                                */
+/*****************************************************************************/
+#define MAX_INP_OBJ_PAR           9       /* max # input object parameters   */
+#define MAX_OUTP_OBJ_PAR          9       /* max # output object parameters  */
+#define MAX_INP_CTRL_PAR          20      /* max # inpput control parameters */
+#define MAX_OUTP_CTRL_PAR         20      /* max # output control parameters */
+#define MAX_CHAPTER                2      /* max # chapters / operator       */
+#define MAX_CHAPTER_PROC         300      /* max # operators / chapter       */
+
+#define MAX_KEY_NAME              5       /* old */
+#define KEY_NAME_LENGTH           20      /* old */
+#define MAX_BUFFER                10      /* old */
+
+/* Shortcut for object access */
+#define REGION                    0       /* object component: region        */
+#define CHORD                     0       /* object component: region (old)  */
+#define IMAGE1                    1       /* object component: 1st image     */
+#define IMAGE2                    2       /* object component: 2nd image     */
+#define IMAGE3                    3       /* object component: 3rd image     */
+#define IMAGE4                    4       /* object component: 4th image     */
+#define IMAGE5                    5       /* object component: 5th image     */
+#define IMAGE6                    6       /* object component: 6th image     */
+#define IMAGE7                    7       /* object component: 7th image     */
+#define IMAGE8                    8       /* object component: 8th image     */
+
+
+#define REGION_ID                 1
+#define IMAGE_ID                  2
+#define OBJECT_ID                 3
+#define TUPLE_ID                  4
+#define XLD_CONTOUR_ID            5
+#define XLD_POLYGON_ID            6
+#define XLD_PARALLEL_ID           7
+#define XLD_MOD_PARALLEL_ID       8
+#define XLD_EXT_PARALLEL_ID       9
+#define MIN_XLD_ID                XLD_CONTOUR_ID
+#define MAX_XLD_ID                XLD_EXT_PARALLEL_ID
+#define STD_FREE                  HFree
+
+/*****************************************************************************/
+/* File extensions                                                           */
+/*****************************************************************************/
+
+#define TRAINF_EXT                "trf"   /* OCR training file               */
+#define OCR_EXT                   "fnt"   /* OCR                             */
+#define OCR_BOX_EXT               "obc"   /* OCR box classifier              */
+#define OCR_MLP_EXT               "omc"   /* OCR MLP classifier              */
+#define OCR_SVM_EXT               "osc"   /* OCR SVM classifier              */
+#define OCR_KNN_EXT               "onc"   /* OCR kNN classifier              */
+#define OCR_KNN_EXT_LEGACY        "okc"   /* OCR kNN classifier (legacy)     */
+#define OCR_CNN_EXT               "occ"   /* OCR CNN classifier              */
+#define OCV_EXT                   "ocv"   /* OCV                             */
+#define PS_EXTENSION              "ps"    /* Postscript                      */
+#define TIFF_EXTENSION            "tiff"  /* TIFF                            */
+#define EXP_EXTENSION             "exp"   /* Extension image description     */
+#define IMAGE_EXTENSION           "ima"   /* Extension HALCON image          */
+#define REGION_EXTENSION          "reg"   /* Extension region file           */
+#define FILTER_EXTENSION          "fil"   /* Extension convol filters        */
+#define LUT_EXTENSION             "lut"   /* Extension LUT                   */
+#define GREYSE_EXT                "gse"   /* Extension gray struct element   */
+#define BMP_EXTENSION             "bmp"   /* Extension Windows-BMP           */
+#define DEEP_LEARNING_EXTENSION   "hdl"   /* Extension deep networks         */
+#define DEEP_OCR_EXT                "hdo"   /* Extension ocr deep networks     */
+
+
+
+
+/*****************************************************************************/
+/* Mathematical constants                                                    */
+/*****************************************************************************/
+
+#ifndef PI
+#ifdef  M_PI
+#define PI               M_PI
+#else
+#define PI               3.14159265358979323846
+#endif
+#endif
+#ifndef PI_2
+#define PI_2             (PI / 2.0)
+#endif
+#ifndef PI_4
+#define PI_4             (PI / 4.0)
+#endif
+
+
+/*****************************************************************************/
+/* Thread handling                                                           */
+/*****************************************************************************/
+
+#define GLOBAL_ID             NULL         /* 'global' operator handle       */
+#define DEFAULT_AGENTS_NR     4            /* default # for agents           */
+
+/* controlling the access to global/local context variables (see HInstance.c)*/
+#define GV_WRITE_INFO         0            /* Flag: write global context var.*/
+#define GV_READ_INFO          1            /* Flag: read global context var. */
+#define GV_INIT_INFO          2            /* Flag: init. global context var.*/
+#define GV_GET_ADRESS         3            /* Flag: get address of var.      */
+#define GV_REALLOC_A          4            /* Flag: realloc an array         */
+#define GV_LOCK               5            /* Flag: lock a mutex variable    */
+#define GV_UNLOCK             6            /* Flag: unlock a mutex variable  */
+#define GV_BOR_INFO           7            /* Flag: bitwise OR with variable */
+#define GV_BAND_INFO          8            /* Flag: bitwise AND with variable*/
+#define GV_WRITE_REF          9            /* Flag: write in reference var.; */
+                                    /* (forces changes in reference version) */
+#define GV_READ_REF          10            /* Flag: read from reference var. */
+
+/*****************************************************************************/
+/* H_SYS_INFO_READ_ONLY                                                      */
+/*****************************************************************************/
+
+#define CLOCK_MODE_PROCESSOR_TIME      0  /* clock mode */
+#define CLOCK_MODE_ELAPSED_TIME        1
+#define CLOCK_MODE_PERFORMANCE_COUNTER 2
+#define CLOCK_MODE_MULTIMEDIA_TIMER    3
+#define CLOCK_MODE_PROCESS_TIME        4
+#define OCR_TRAINFILE_VERSION1_0       1  /* file version when writing OCR */
+#define OCR_TRAINFILE_VERSION2_0       2  /* trainf */
+#define OCR_TRAINFILE_VERSION3_0       3  /* trainf + UINT2 images */
+#define H_ENCODING_NATIVE              1  /* local8bit character encoding    */
+#define H_ENCODING_UTF8                2  /* UTF-8 character encoding        */
+#define H_ENCODING_HLIB                3  /* encoding that is used by hlib   */
+#define H_ENCODING_ASCII               4  /* promise that a passed string is
+                                           * pure ASCII                      */
+#define H_ENCODING_SYSTEM              5  /* promise that a passed string is
+                                           * in system encoding: which is the
+                                           * locale under Linux, utf8 on Mac,
+                                           * and for Windows not needed      */
+#define H_ENCODING_AUTO                6  /* generic mode for detecting the
+                                           * encoding automatically */
+#define H_ENCODING_LATIN1              7  /* promise that a passed string is
+                                             pure latin-1 */
+#define TIMER_MODE_ELAPSED_TIME        0
+#define TIMER_MODE_MULTIMEDIA_TIMER    1
+#define TIMER_MODE_PERFORMANCE_COUNTER 2
+
+
+#endif

3rdparty/include22/halcon/HCtype.h

@@ -0,0 +1,214 @@
+/*****************************************************************************
+ * HCtype.h
+ *****************************************************************************
+ *
+ * Project:      HALCON/libhalcon
+ * Description:  (Global) data structures defining the processing context
+ *               for HALCON operator instances and HALCON operator threads
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *               www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HCTYPE_H
+#define HCTYPE_H
+
+#include "HErrorDef.h" /* -> H_MSG_OK */
+#include "IPType.h" /* -> HBOOL */
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+#ifndef HC_NO_STRUCT_MEMBER_ALIGNMENT 
+/* sets the struct member alignment to avoid problems if 
+ * the settings of the user differ to those of the HALCON
+ * version. (8 is the default alignment, generally) */
+# pragma pack(push,8) 
+#endif
+
+/*---------------------------------------------------------------------------
+ * aop_split_t defines CORE-AOP levels 
+ *---------------------------------------------------------------------------*/
+typedef enum {split_tuple=0, split_channel, split_domain, split_num} 
+  aop_split_t;
+
+
+/*---------------------------------------------------------------------------*/
+/* ATTENTION! Increase H_OPERATOR_INFO_VERSION/DERIVATE whenever you change
+ *            or add operator info identifyers
+ *            The version number is composed as follows:
+ *            Version#32 := [Major#8 Minor#8 OptionalInfo16]
+ *            whereas major#8 denotes a 1 byte coded mojor version number,
+ *            Minor#8 denotes a 1 byte coded minor version number,
+ *            OptionalInfo16 denotes a 16 bit coded bitfield of optional coded
+ *            operator information 
+ *---------------------------------------------------------------------------*/
+#define H_OPERATOR_INFO_VERSION  0x0400  /* 4.0 */
+
+#ifndef HC_NO_COMPUTE_DEVICES
+# define HOI_COMPUTE_DEVICES (1<<0)  /* Bit0: information for compute device
+                                      * support available */
+#else
+# define HOI_COMPUTE_DEVICES 0
+#endif
+
+#define H_OPERATOR_INFO_DERIVATE ( (H_OPERATOR_INFO_VERSION<<16) |  \
+                                   HOI_COMPUTE_DEVICES)
+
+/* HALCON operator info identifyers: */
+#define HOIID_NumInpObjPar        0
+#define HOIID_NumOutpObjPar       1
+#define HOIID_NumInpCtrlPar       2
+#define HOIID_NumOutpCtrlPar      3
+#define HOIID_LogicalName         4
+#define HOIID_PhysicalName        5
+#define HOIID_ParameterName       6
+#define HOIID_ParameterType       7   /* [2] */
+#define HOIID_process_excl_local  8 
+#define HOIID_parallelization     9
+#define HOIID_splitIOPmask       10   /*[split_num]*/
+#define HOIID_tupleIOPmask       11   /*[split_num]*/
+#define HOIID_splitIOPref        12   /*[split_num]*/
+#define HOIID_RegionPost         13
+#define HOIID_ParameterCosts     14   /*[MAX_INP_CTRL_PAR]*/
+#define HOIID_ParameterPost      15   /*[MAX_OUTP_CTRL_PAR]*/
+#define HOIID_aopCost            16
+#define HOIID_numCost            17
+#define HOIID_parallelMinCosts   18
+#define HOIID_parallelRegionsplit 19
+#define HOIID_HelpIndex          20
+#define HOIID_InfoLength         21
+#define HOIID_Class              22   /*[MAX_CHAPTER]*/
+#define HOIID_ClassName          23   /*[MAX_CHAPTER]*/
+#define HOIID_package_id         24
+
+/* --- compute devices: */
+#define HOIID_compute_device     25
+#define HOIID_cd_supported_image_kinds 26
+#define HOIID_cd_supported_values 27
+#define HOIID_cd_supported_values_num 28
+
+#define HOIID_procedure          50
+#define HOIID_module             51
+
+
+/*---------------------------------------------------------------------------
+ * HXPkgOpenId initializes extension package structures and checks 
+ * compatibility.
+ *---------------------------------------------------------------------------*/
+extern HLibExport Herror HXPkgOpenId( INT4 xpkg_id, UINT4 halcon_version, 
+                                      UINT4 opinfo_version,
+                                      HINT op_num, HINT *osid);
+
+/*---------------------------------------------------------------------------
+ * HXPkgSetOpInfo sets operator information of a specific extension package 
+ * operator.
+ *---------------------------------------------------------------------------*/
+extern HLibExport Herror HXPkgSetOpInfo( INT4 xpkg_id, INT4 op_id, 
+                                         INT4 oi_id, ...);
+
+
+/*---------------------------------------------------------------------------*/
+/* H_OPERATOR_PARAMETERS - data structure that contains the operator
+ * parameters passed to the language interface. This information is only valid
+ * for the processing time of the associated instance/HALCON thread.
+ * All read/write accesses to the information are done exclusively
+ * (thus different HALCON threads of the same instance differ in the
+ * content of this structure).
+ *---------------------------------------------------------------------------*/
+typedef struct 
+{
+  /*-------------------------------- operator parameters --------------------*/
+  /*______________________________________________input object parameters:___*/
+  Hkey    *InpObjList[MAX_INP_OBJ_PAR+1]; /* for every input object par      *
+                                           * an array of object keys         */
+  Hkey    InpObjSingle[MAX_INP_OBJ_PAR+1]; /* used, when the array of obj 
+                                            * keys has size 1                */
+  INT4_8  InpObjNum[MAX_INP_OBJ_PAR+1];  /* number of objects per input obj. *
+                                          * parameter; index: 1..inp_obj     */
+  INT1    freeIOP[MAX_INP_OBJ_PAR+1];
+  
+  /*_____________________________________________input control parameters:___*/
+  Hctuple **InpCtrlList;  /* used to access inp. ctrl handles */
+  Hctuple *InpCtrlStack[MAX_INP_CTRL_PAR];/* stores interf./Single references*/
+  Hctuple InpCtrlNested[MAX_INP_CTRL_PAR]; /* holds tuple trunks, eg for pure
+                                            * type input ctrls(single values)*/
+  HBOOL   ctrl_inherited;   /* true, if all ctrl. values are inherited from 
+                             * a father instance (only important for 
+                             * correctly freeing the InpCtrlList).           */
+  
+#if 0
+  Hctuple *InpCtrlList;     /* for handling inp. ctrl. values;               */
+  Hctuple *InpCtrlNested;   /* for storing inp. ctrl. values; 
+                             * one Hctuple element per parameter             */
+  INT1    *freeICP;         /* inp ctrl values were copied or passed 
+                             * by reference                                  */
+  HBOOL   ctrl_inherited;   /* true, if all ctrl. values are inherited from 
+                             * a father instance (only important for 
+                             * correctly freeing the InpCtrlList).
+                             *                                               */
+#endif
+  /*_____________________________________________output object parameters:___*/
+  Hkey    *OutpObjList[MAX_OUTP_OBJ_PAR+1];/* for every output object par.   *
+                                            * an array of objects keys       */
+  INT4_8  OutpObjNum[MAX_OUTP_OBJ_PAR+1];  /* number of objects per output   *
+                                            * object par.; index: 1..        */
+  INT4_8  OutpObjLen[MAX_OUTP_OBJ_PAR+1];  /* length of OutpObjList per      *
+                                            * output object par.; index: 1.. */
+  /*____________________________________________output control parameters:___*/
+  Hctuple **OutpCtrlList;      /* used to access outp. ctrl parameters   */
+  Hctuple *OutpCtrlStack[MAX_OUTP_CTRL_PAR]; /* stores interface/Nested ref. */
+  Hctuple OutpCtrlNested[MAX_OUTP_CTRL_PAR]; /* holds tuple trunks for output
+                                              * ctrl values (eg, pure type 
+                                              * operators)   */
+  UINT4    freeOCP; /* bitcoded free flag: 8*sizof(freeOCP)>=MAX_OUTP_CTRL_PAR*/
+
+} H_OPERATOR_PARAMETERS;
+
+
+/*---------------------------------------------------------------------------*/
+/* H_OPERATOR_SHARED - data structure that is shared among internal threads.
+ *---------------------------------------------------------------------------*/
+typedef struct
+{
+  INT4 run_state;
+} H_OPERATOR_SHARED;
+
+typedef enum
+{
+  ph_ready        = 0,
+  ph_running      = H_MSG_OK,
+  ph_break        = H_ERR_BREAK,
+  ph_hen_canceled = H_ERR_HEN_CANCEL,
+  ph_canceled     = H_ERR_CANCEL
+} HRunState;
+
+typedef struct HLISTEL
+{ /* placeholder for internal double linked list element type */
+  struct HLISTEL* prev;
+  struct HLISTEL* next;
+} H_LIST_EL;
+
+
+typedef struct HALCON_OPERATOR_HANDLE
+{
+  H_LIST_EL list_el; /*list_el must be defined in the first place*/
+  void*     generator;
+  INT4      proc_index;         /* Index of HALCON operator        */
+  H_OPERATOR_PARAMETERS* param; /* operator parameters (thread-specific) */
+  H_OPERATOR_SHARED*     shared_data; /*shared operator data*/
+} H_OPHANDLE;
+typedef H_OPHANDLE* Hophandle_;
+
+#ifndef HC_NO_STRUCT_MEMBER_ALIGNMENT 
+#pragma pack(pop)
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

3rdparty/include22/halcon/HDeclSpec.h

@@ -0,0 +1,61 @@
+/*****************************************************************************
+ * HDeclSpec.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: Windows DLL specifications
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HALCON_DECL_SPEC_H
+#define HALCON_DECL_SPEC_H
+
+/* HALCON library. If _HLibStatic is defined, HALCON is a static library. */
+#if defined(_HLibStatic)
+#  define HLibExport
+#elif defined(_WIN32) && !defined(_NODLL)
+#  if defined(_HLibDLL)
+#    define HLibExport __declspec(dllexport)
+#  else
+#    define HLibExport __declspec(dllimport)
+#  endif
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+#  define HLibExport __attribute__((visibility("default")))
+#else
+#  define HLibExport
+#endif
+
+/*
+ * HALCON language interfaces. If _LIntExport is defined, the language
+ * interfaces are static libraries.
+ */
+#if defined(_LIntStatic)
+#  define LIntExport
+#elif defined(_WIN32) && !defined(_NODLL)
+#  if defined(_LIntDLL)
+#    define LIntExport __declspec(dllexport)
+#  else
+#    define LIntExport __declspec(dllimport)
+#  endif
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+#  define LIntExport __attribute__((visibility("default")))
+#else
+#  define LIntExport
+#endif
+
+/* Extension packages. These are always shared libraries / DLLs */
+#if defined(_WIN32)
+#  define HUserExport __declspec(dllexport)
+#  define HUserImport __declspec(dllimport)
+#elif defined(__GNUC__) && (__GNUC__ >= 4)
+#  define HUserExport __attribute__((visibility("default")))
+#  define HUserImport
+#else
+#  define HUserExport
+#  define HUserImport
+#endif
+
+#endif

3rdparty/include22/halcon/HExtern.h

@@ -0,0 +1,118 @@
+/*****************************************************************************
+ * HExtern.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: External variables and some global procedures for
+ *              language interfaces
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HEXTERN_H
+#define HEXTERN_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* global variables for image processing                                     */
+                                                /* procedures description    */
+extern HLibExport HINT         HDoLowError;     /* error messages of HALCON  */
+extern HLibExport INT4         HLowErrorAction[4]; /* action for HALCON low  */
+                                                   /* level error messages   */
+extern HLibExport HINT         HDoLicenseError; /* license msgs of HALCON    */
+extern HLibExport HINT         HUseSpinLock;    /* sync initialization of
+                                                 * Parallel HALCON           */
+extern HLibExport HINT         HStartUpThreadPool;  /* start thread pool
+                                                     * initially? */
+extern HLibExport HINT         HShutdownThreadPool; /* shutdown thread pool
+                                                     * on termination? */
+extern HLibExport HINT         HShuttingDown; /* currently terminating and
+                                               * unloading HALCON Library? */
+
+/* Convenience function accessors as some development environments */
+/* do not directly support importing variables from C DLLs.        */
+
+extern HLibExport void __stdcall HSetDoLicenseError(HINT value);
+extern HLibExport void __stdcall HSetUseSpinLock(HINT value);
+extern HLibExport void __stdcall HSetStartUpThreadPool(HINT value);
+extern HLibExport void __stdcall HSetShutdownThreadPool(HINT value);
+
+extern HLibExport HINT __stdcall HGetDoLicenseError(void);
+extern HLibExport HINT __stdcall HGetUseSpinLock(void);
+extern HLibExport HINT __stdcall HGetStartUpThreadPool(void);
+extern HLibExport HINT __stdcall HGetShutdownThreadPool(void);
+extern HLibExport HINT __stdcall HGetShuttingDown(void);
+
+/* remark: the structure above contains global HALCON system variables       */
+/* which are (in the normal case) exclusively accessible via a valid         */
+/* procedure handle and by using specific functions of the HALCON-Lib        */
+/* source code file HInstance.c; those functions contain synchronization     */
+/* mechanisms to guarantee a correct access to the variables even in case of */
+/* a parallel/multithreaded/reentrant HALCON version.                        */
+/* Nevertheless the structure is propagated here so that it also can be used */
+/* directly, but this should be done VERY CAREFULLY!! At the moment it is    */
+/* only used directly within HDevelop, which means no problem, because       */
+/* HDevelop works strictly sequentially, i.e. it calls all HALCON            */
+/* operators one after another;                                              */
+
+/* Functions to tell HALCON library the interface from which it gets accessed.
+ * This enables the library to adapt its default behaviour.                  */
+extern HLibExport void __stdcall HSetHDevelopInt(HINT AccessByHDevelop);
+extern HLibExport HINT __stdcall HGetHDevelopInt(void);
+extern HLibExport void __stdcall HSetCOMInt(HINT AccessByCOM);
+extern HLibExport HINT __stdcall HGetCOMInt(void);
+
+/* Function to tell HALCON library about the console */
+#ifdef WIN32
+extern HLibExport void __stdcall HSetConsole(HINT ProcessId);
+#endif
+
+/* Function to register a license recheck failure callback. */
+extern HLibExport void __stdcall
+HSetLicenseRecheckFailedCallback(HLicenseRecheckFailedCallback callback,
+                                 void *context);
+
+/* FinalizeHALCONLibrary prepares HALCON for finalization. It should be called
+ * right before unloading the HALCON Library.
+ * Return Value: H_ERR_FINI_USR_THREAD if there are still user threads running
+ * that were using HALCON functionality. No resources are freed in this case.
+ */
+extern HLibExport HINT __stdcall FinalizeHALCONLibrary(void);
+
+/* Callback interface for operators to signal their progress and current
+ * status.  External applications can register to receive such updates using
+ * set_system('add_progress_callback', CallbackFunction).
+ *
+ * The registered callback is called by selected operators to signal their
+ * progress and supply an update in text form. The parameters of the callback
+ * are:
+ * - id: Operating system specific thread identifier. Note that with Automatic
+ *       Operator Parallelization (AOP), the callback can be called from a
+ *       different thread than the one used to call the operator. The id is
+ *       thread independent and unique for the current operator call.
+ *       It is the result of GetCurrentThreadId() (Windows) or pthread_self
+ *       (UNIX) of the main thread used to call the operator.
+ * - operator_name: Name of the operator that is executing
+ * - progress: >=0: the current progress of the operator between 0 and 1.
+ *                  Note that the progress is only an approximation.
+ *             -1: No progress available (only a message)
+ *             -2: the operator has finished execution. The application should
+ *                 clean up any resources allocated for the operator.
+ *                 Note that this call is done only for operators that
+ *                 previously sent a progress update.
+ * - message: If not NULL, a message about the operator's progress in english.
+ */
+typedef void(__stdcall *HProgressBarCallback)(Hlong       id,
+                                              const char *operator_name,
+                                              double      progress,
+                                              const char *message);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

3rdparty/include22/halcon/HIntDef.h

@@ -0,0 +1,191 @@
+/*****************************************************************************
+ * HIntDef.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: Definition of HALCON data types
+ *              These definitions can be controlled by the compiler
+ *              The size of the data type is always in byte _not_ in bits
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HINTDEF_H
+#define HINTDEF_H
+
+#ifndef __midl
+#  include <float.h>  /* FLT_MAX, DBL_MAX, ... */
+#  include <limits.h> /* LONG_MAX, INT_MAX, ... */
+#  include <stdlib.h> /* RAND_MAX */
+#endif
+
+#include "hclib/hclib_types.h"    /* C99 standard integer types    */
+
+typedef int HINT;           /* Signed integer. HALCON assumes at least
+                               4 bytes */
+typedef unsigned int HUINT; /* Unsigned integer. HALCON assumes at least
+                               4 bytes */
+#define HUINT_MIN 0
+
+#ifndef _DOUBLE8
+typedef double DOUBLE8;
+#else
+typdef _DOUBLE8 DOUBLE8;
+#endif
+
+#ifdef __vxworks
+#  include <types/vxTypesBase.h>
+#  ifndef DBL_MAX
+#    define DBL_MAX _ARCH_DBL_MAX
+#  endif
+#  ifndef DBL_MIN
+#    define DBL_MIN _ARCH_DBL_MIN
+#  endif
+#  ifndef FLT_MAX
+#    define FLT_MAX _ARCH_FLT_MAX
+#  endif
+#  ifndef FLT_MIN
+#    define FLT_MIN _ARCH_FLT_MIN
+#  endif
+#endif
+
+/* float and double epsilons: These are the differences between 1 and
+   the smallest floating point number of type float/double that is
+   greater than 1. As we assume IEEE 754 floating point arithmetic,
+   the following values are used. */
+#ifndef FLT_EPSILON
+#  define FLT_EPSILON 1.19209290e-07F
+#endif
+
+#ifndef DBL_EPSILON
+#  define DBL_EPSILON 2.2204460492503131e-16
+#endif
+
+#ifndef RAND_MAX
+#  define RAND_MAX MAXINT
+#endif
+
+typedef int8_t INT1; /* signed integer, 1 byte */
+#define INT1_MIN INT8_MIN
+#define INT1_MAX INT8_MAX
+
+typedef uint8_t UINT1; /* unsigned integer, 1 byte */
+#define UINT1_MIN 0
+#define UINT1_MAX UINT8_MAX
+
+typedef int16_t INT2; /* signed integer, 2 bytes */
+#define INT2_MIN INT16_MIN
+#define INT2_MAX INT16_MAX
+
+typedef uint16_t UINT2; /* unsigned integer, 2 bytes */
+#define UINT2_MIN 0
+#define UINT2_MAX UINT16_MAX
+
+typedef int32_t INT4; /* signed integer, 4 bytes */
+#define INT4_MIN INT32_MIN
+#define INT4_MAX INT32_MAX
+
+typedef uint32_t UINT4; /* unsigned integer, 4 bytes */
+#define UINT4_MIN 0
+#define UINT4_MAX UINT32_MAX
+
+/*
+ * Defining HINT4_8 and UINT4_8 to be 64 bits on 64 bit systems and 32 bits on
+ * 32 bit systems is a bit tricky. The obvious solution would be to use
+ * intptr_t and uintptr_t, but this causes problems on platforms where
+ * 'intptr_t' is ultimately derived from 'int'. Our C++ language interface has
+ * overloaded functions with variants taking both 'int' and 'Hlong' parameters,
+ * which is only allowed if 'int' and 'Hlong' are distinct types. Since typedef
+ * does not create distinct types in C++, we must make sure 'Hlong' is
+ * ultimately derived from a different type. The 'long' type nicely fits our
+ * requirements, as it is 64 bits on all our supported platforms except for 64
+ * bit Windows, and 32 bits on all 32 bit platforms (except for TI C6X DSPs
+ * using COFF object format - which is obsolete - where it is 40 bits).
+ */
+#if defined(_WIN64)
+typedef __int64 HINT4_8;
+typedef __int64 INT4_8;
+#  define INT4_8_FORMAT "I64"
+#  define INT4_8_MIN _I64_MIN
+#  define INT4_8_MAX _I64_MAX
+
+typedef unsigned __int64 UINT4_8;
+#  define UINT4_8_MIN 0UL
+#  define UINT4_8_MAX _UI64_MAX
+#  define UINT4_8_FORMAT INT4_8_FORMAT
+
+#else
+typedef long    HINT4_8;
+typedef long    INT4_8;
+#  define INT4_8_MIN LONG_MIN
+#  define INT4_8_MAX LONG_MAX
+#  define INT4_8_FORMAT "l"
+
+typedef unsigned long UINT4_8;
+#  define UINT4_8_MIN 0UL
+#  define UINT4_8_MAX ULONG_MAX
+#  define UINT4_8_FORMAT INT4_8_FORMAT
+#endif
+
+/* Hlong/Hulong is the same as INT4_8/UINT4_8 */
+typedef INT4_8 Hlong;
+#define HLONG_MIN INT4_8_MIN
+#define HLONG_MAX INT4_8_MAX
+#define HLONG_FORMAT INT4_8_FORMAT
+#define LONG_FORMAT INT4_8_FORMAT /* deprecated, use HLONG_FORMAT     */
+
+typedef UINT4_8 Hulong;
+#define HULONG_MIN UINT4_8_MIN
+#define HULONG_MAX UINT4_8_MAX
+
+typedef int64_t HINT8; /* signed integer, 8 bytes */
+#define HINT8_MIN INT64_MIN
+#define HINT8_MAX INT64_MAX
+#if defined(_WIN32)
+#  define HINT8_FORMAT "I64"
+#else
+#  define HINT8_FORMAT "ll"
+#endif
+
+typedef uint64_t HUINT8; /* unsigned integer, 8 bytes */
+#define HUINT8_MIN 0U
+#define HUINT8_MAX UINT64_MAX
+
+#if !defined(HC_LARGE_IMAGES)
+#  define HIMGCOOR_MIN INT2_MIN
+#  define HIMGCOOR_MAX INT2_MAX
+#  define HITEMCNT_MIN INT4_MIN
+#  define HITEMCNT_MAX INT4_MAX
+#  define HSUBCOOR_MIN FLT_MIN
+#  define HSUBCOOR_MAX FLT_MAX
+#  define HSUBCOOR_EPS FLT_EPSILON
+#  define HSUBATTR_MIN FLT_MIN
+#  define HSUBATTR_MAX FLT_MAX
+#else
+#  define HIMGCOOR_MIN INT4_MIN
+#  define HIMGCOOR_MAX INT4_MAX
+#  define HITEMCNT_MIN INT4_8_MIN
+#  define HITEMCNT_MAX INT4_8_MAX
+#  define HSUBCOOR_MIN DBL_MIN
+#  define HSUBCOOR_MAX DBL_MAX
+#  define HSUBCOOR_EPS DBL_EPSILON
+#  define HSUBATTR_MIN DBL_MIN
+#  define HSUBATTR_MAX DBL_MAX
+#endif
+
+/*
+ * Define the largest double that can be safely casted to INT4_8 without
+ * turning negative.
+ */
+#if INT4_8_MAX == INT4_MAX
+#  define INT_4_8_MAXDOUBLE (double)INT4_MAX
+#else
+#  define INT_4_8_MAXDOUBLE (double)(HINT8_MAX - 1023)
+#endif
+
+/* At least an address must fit into MACHINE_WORD */
+typedef intptr_t MACHINE_WORD;
+
+#endif /* !HINTDEF_H */

3rdparty/include22/halcon/HInterfaceC.h

@@ -0,0 +1,79 @@
+/*****************************************************************************
+ * HInterfaceC.h
+ *****************************************************************************
+ *
+ * Project:      HALCON/HLib
+ * Description:  Prototypes for HALCON/C interface
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HINTERFACE_C_H
+#define HINTERFACE_C_H
+
+/*===========================================================================*/
+/*                             Defines                                      */
+/*===========================================================================*/
+
+
+/*===========================================================================*/
+/*                             Prototypes                                    */
+/*===========================================================================*/
+extern LIntExport Herror HcErrorHandling(Hproc_handle ph, Herror err);
+
+extern LIntExport Herror HcException(HINT op_id, Herror err);
+
+extern LIntExport Herror HcPreCall(HINT proc_index, Hproc_handle* ph);
+
+extern LIntExport Herror HcCall(Hproc_handle ph);
+
+extern LIntExport Herror HcPostCall(Hproc_handle ph, Herror err);
+
+extern LIntExport Herror HcStoreIO(Hproc_handle ph, HINT par,
+                                   Hobject inObjVar);
+
+extern LIntExport Herror HcStoreICL(Hproc_handle ph, HINT par, Hlong value);
+
+extern LIntExport Herror HcStoreICD(Hproc_handle ph, HINT par, double value);
+
+extern LIntExport Herror HcStoreICS(Hproc_handle ph, HINT par,
+                                    char const* value);
+extern LIntExport Herror HcStoreICSEnc(Hproc_handle ph, HINT par,
+                                       char const* value);
+
+extern LIntExport Herror HcStoreICT(Hproc_handle ph, HINT par,
+                                    Htuple const* value);
+extern LIntExport Herror HcStoreICTEnc(Hproc_handle ph, HINT par,
+                                       Htuple const* value);
+
+
+extern LIntExport void HcInitOC(Hproc_handle ph, HINT par);
+extern LIntExport void HcInitOCD(Hproc_handle ph, HINT par);
+extern LIntExport void HcInitOCL(Hproc_handle ph, HINT par);
+extern LIntExport void HcInitOCS(Hproc_handle ph, HINT par);
+extern LIntExport void HcInitOCT(Hproc_handle ph, HINT par, Hctuple* ctuple);
+
+extern LIntExport Herror HcStoreOO(Hproc_handle ph, HINT par,
+                                   Hobject* outObjVar, Herror err);
+
+extern LIntExport Herror HcStoreOCL(Hproc_handle ph, HINT par,
+                                    Hlong* outCtrlVar, Herror err);
+
+extern LIntExport Herror HcStoreOCD(Hproc_handle ph, HINT par,
+                                    double* outCtrlVar, Herror err);
+
+extern LIntExport Herror HcStoreOCS(Hproc_handle ph, HINT par,
+                                    char* outCtrlVar, Herror err);
+
+extern LIntExport Herror HcStoreOCSEnc(Hproc_handle ph, HINT par,
+                                       char* outCtrlVar, Herror err);
+
+extern LIntExport Herror HcStoreOCT(Hproc_handle ph, HINT par,
+                                    Htuple* outCtrlVar, Herror err);
+
+extern LIntExport Herror HcStoreOCTEnc(Hproc_handle ph, HINT par,
+                                       Htuple* outCtrlVar, Herror err);
+
+#endif

3rdparty/include22/halcon/HParallel.h

@@ -0,0 +1,218 @@
+/*****************************************************************************
+ * HParallel.h
+ *****************************************************************************
+ *
+ * Project:      HALCON/HLib
+ * Description:  Basic constants for controlling the automatic 
+ *               parallelization of HALCON operators and 
+ *               programs (operator sequences)
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HCPAR_H
+#define HCPAR_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* --- Defines -------------------------------------------------- */
+# if defined(_POSIX_THREADS)
+#  define H_POSIX_THREADS
+# elif defined(_WIN32)
+#  define H_WIN32_THREADS
+# endif
+/* else: no synchronization and threads used */
+
+
+# if !defined (H_PARALLEL) || \
+     !(defined(H_WIN32_THREADS)||defined(H_POSIX_THREADS)) 
+  /* Sequential HALCON or no synchronization specified */
+#  define H_NO_SPIN_LOCK
+#  if defined H_TSD
+#    undef H_TSD  /* no thread specific data */
+#  endif
+# else
+#  define H_TSD /* use thread specific data */
+# endif
+
+
+
+/*===========================================================================*/
+/*                                Constants                                  */
+/*===========================================================================*/
+/* -------- (knowledge default values and control weights) ----------------- */
+
+/* constants for describing how to process an operator:                      */
+#define HAG_PAR_INDEPENDENT   0            /* completely independent of other
+                                            * operators, i.e., can run with
+                                            * exclusive operators in parallel*/
+#define HAG_PAR_NO_RESTRICT   1<<0         /* no restriction                 */
+#define HAG_PAR_LOCAL         1<<1         /* force local processing         */
+                                           /* by main thread/process         */
+#define HAG_PAR_MUTUAL        1<<2         /* force processing under mutual  */
+                                           /* exclusion, i.e. the same       */
+                                           /* operator may only run once at  */
+                                           /* a time                         */
+#define HAG_PAR_EXCLUSIVE     1<<3         /* force exclusive processing,    */
+                                           /* i.e. no other operator may run */
+                                           /* while this operator works      */
+
+
+/* default control values:                                                   */
+#define HAG_KW_CHORD_NUM      1            /* minimal num. of chords for par.*/
+#define HAG_KW_MIN_COSTS      16300        /* minimal costs for which to par.*/
+#define HAG_KW_PAR_COSTS      308          /* weight of ctrl. par. costs     */
+#define HAG_KW_CPU_RATING     10           /* threshold for assigning a cpu  */
+
+
+/* -------- (postprocessing of control parameters) ------------------------- */
+#define HAG_PAR_NOCT          1            /* no need of ctrl. par. postproc.*/
+                                           /* =>adopt par. of 1. H. thread   */
+#define HAG_PAR_TUCT_ADD      2            /* add ctrl. par.s ;       tuple  */
+#define HAG_PAR_CHCT_ADD      4            /* add ctrl. par.s ;       channel*/
+                                           /* (must be 2*HAG_PAR_TUCT_ADD)   */
+#define HAG_PAR_RECT_ADD      8            /* add ctrl. par.s ;       res.de.*/
+                                           /* (must be 4*HAG_PAR_TUCT_ADD)   */
+#define HAG_PAR_TUCT_MIN      16           /* minimum of ctrl. par.s; tuple  */
+#define HAG_PAR_CHCT_MIN      32           /* minimum of ctrl. par.s; channel*/
+#define HAG_PAR_RECT_MIN      64           /* minimum of ctrl. par.s; res.de.*/
+#define HAG_PAR_TUCT_MAX      128          /* maximum of ctrl. par.s; tuple  */
+#define HAG_PAR_CHCT_MAX      256          /* maximum of ctrl. par.s; channel*/
+#define HAG_PAR_RECT_MAX      512          /* maximum of ctrl. par.s; res.de.*/
+#define HAG_PAR_TUCT_CON      1024         /* concatenate ctrl. par.s;tuple  */
+#define HAG_PAR_CHCT_CON      2048         /* concatenate ctrl. par.s;channel*/
+#define HAG_PAR_RECT_CON      4096         /* concatenate ctrl. par.s;res.de.*/
+                                           /* ATTENTION: the difference in   */
+                                           /* the codes for tuples/channels/ */
+                                           /* resources must always show the */
+                                           /* above scheme of *2 and *4!     */
+                                           /* Because this is used in the    */
+                                           /* HAgent-source code; e.g.:      */
+                                           /* HAG_PAR_CHCT_MIN is assumed to */
+                                           /* be HAG_PAR_TUCT_MIN*2          */
+#define HAG_PAR_TUCT          1170         /* postprocess ctrl. par.; tuple  */
+/* remark: this is a shortcut for: HAG_PAR_TUCT_ADD | HAG_PAR_TUCT_MIN |     */
+/*                                 HAG_PAR_TUCT_MAX | HAG_PAR_TUCT_CON       */
+#define HAG_PAR_CHCT          2340         /* postprocess ctrl. par.; channel*/
+                                           /* (must be 2*HAG_PAR_TUCT)       */
+#define HAG_PAR_RECT          4680         /* postprocess ctrl. par.; res.de.*/
+                                           /* (must be 4*HAG_PAR_TUCT)       */
+
+/* -------- (postprocessing of domains/region components of output objects)  */
+#define HAG_PAR_REG_NONE      0            /* no post processing             */
+#define HAG_PAR_REG_CONSI     (1<<0)       /* concatenation of (disjuntive)  */
+                                           /* result regions for single      */
+                                           /* input iconic parameter         */
+#define HAG_PAR_REG_CONMU     (1<<1)       /* concatenation of (disjuntive)  */
+                                           /* result regions for multiple    */
+                                           /* input iconic parameters        */
+#define HAG_PAR_REG_CONMAN    (1<<2)       /* manual concatenation of        */
+                                           /* result regions for multiple    */
+                                           /* input iconic parameters        */
+                                           /* Use HAG_PAR_REG_CONMAN if your */
+                                           /* the output region is variable, */
+                                           /* and not dependent on the input */
+                                           /* iconic parameters              */
+
+/* -------- (task-/operator-/thread-parallelization; chances and states) --- */
+/* -------- (and postprocessing of control parameters) --------------------- */
+/* The following constants symbolize different methods of parallelization.   */
+/* Their values are built up according to the following rules:               */
+/*     Bit  0   signals multithreading ability (see HAG_PAR_MT)              */
+/*     Bits 1-6 signal which method of parallelization can be used:          */
+#define HAG_PAR_SEQ           0            /* all operators are called       */
+                                           /* sequentially => no need of     */
+                                           /* synchronization; no automatic  */
+                                           /* parallelization                */
+#define HAG_PAR_MT            (1<<0)       /* "multithreading" context;      */
+                                           /* operators may called in        */
+                                           /* parallel use synchronization   */
+                                           /* mechanisms for reentrancy,     */
+                                           /* but don't use automatic par.   */
+#define HAG_PAR_FORCE         (1<<1)       /* force parallelization if 
+                                            * supported */
+#define HAG_PAR_NONE          (1<<2)       /* no parallelization 'lucrative' */
+                                           /* is set explicitely, if the 
+                                            * hardware/operator training 
+                                            * showed that the processing does 
+                                            * not speed up by parallelization*/
+#define HAG_PAR_TUPL          (1<<5)       /* tuple parallelization possible */
+#define HAG_PAR_CHNL          (1<<6)       /* channel paralleli. is possible */
+#define HAG_PAR_RESC          (1<<7)       /* resource decomposition possible*/
+#define HAG_PAR_REIF          (1<<8)       /* res. dec. at image filtering   */
+#define HAG_PAR_PART          (1<<9)    /* partial automatic parallelization: 
+                                         * an operator is parallelized 
+                                         * manually within the hlib */
+#define HAG_PAR_PAIF          (1<<10)   /* internal domain parallelization */
+
+
+/* constants for describing the overall processing context:                  */
+#define HAG_PAR_SPLIT_NONE    0
+#define HAG_PAR_SPLIT_DOMAIN  (HAG_PAR_RESC|HAG_PAR_REIF)
+  /* ^domain parallelization */
+#define HAG_PAR_INTERFACE     (HAG_PAR_TUPL|HAG_PAR_CHNL|HAG_PAR_REIF)
+  /* ^parallelization by interface */
+#define HAG_PAR_INTERNAL      (HAG_PAR_PART|HAG_PAR_PAIF)
+  /* ^manual, internal parallelization */
+#define HAG_PAR_ALL       (HAG_PAR_TUPL|HAG_PAR_CHNL|HAG_PAR_RESC|HAG_PAR_REIF|HAG_PAR_PART|HAG_PAR_PAIF)
+
+/* remark: all following "TRUE" values (!=0) mean in any case that HALCON    */
+/* works in a parallel manner and needs synchronization mechanisms           */
+#define HAG_PAR_TUPL_MT      ( HAG_PAR_TUPL | HAG_PAR_MT)
+#define HAG_PAR_CHNL_MT      ( HAG_PAR_CHNL | HAG_PAR_MT)
+#define HAG_PAR_RESC_MT      ( HAG_PAR_RESC | HAG_PAR_MT)
+#define HAG_PAR_REIF_MT      ( HAG_PAR_REIF | HAG_PAR_MT)
+#define HAG_PAR_DOM_MT       ( HAG_PAR_REIF_MT | HAG_PAR_RESC_MT)
+#define HAG_PAR_PART_MT      ( HAG_PAR_PART | HAG_PAR_MT)
+#define HAG_PAR_PAIF_MT      ( HAG_PAR_PAIF | HAG_PAR_MT)
+
+#define HAG_PAR_DPAR_MT      ( HAG_PAR_TUPL_MT|HAG_PAR_CHNL_MT|\
+                               HAG_PAR_RESC_MT|HAG_PAR_REIF_MT|\
+                               HAG_PAR_PART_MT|HAG_PAR_PAIF_MT)
+                                           /* "multithreading" context (see  */
+                                           /* above) AND use automatic       */
+                                           /* data parallelization for       */
+                                           /* processing operators (default) */
+
+                                          /* tuple & channel p. & res. dec. */
+/*     Bits 8-23 currently not used                                          */
+/* #define                    128           *                                */
+/* #define                    256           *                                */
+/* #define                    512           *                                */
+/* #define                    1024          *                                */
+/* #define                    2048          *                                */
+/* #define                    4096          *                                */
+/* #define                    8192          *                                */
+/* #define                    16384         *                                */
+/* #define                    32768         *                                */
+/* #define                    65536         *                                */
+/* #define                    131072        *                                */
+/* #define                    262144        *                                */
+/* #define                    524288        *                                */
+/* #define                    1048576       *                                */
+/* #define                    2097152       *                                */
+/* #define                    4194304       *                                */
+/*     Bits 24-31 signal which parallelization steps have already been       */
+/*     done for the actual task/operator/thread:                             */
+#define HAG_PAR_TUPLED        (1<<24)      /* tuple parallelized             */
+#define HAG_PAR_CHNLED        (1<<25)      /* channel parallelized           */
+#define HAG_PAR_RESCED        (1<<26)      /* resources already decomposed   */
+#define HAG_PAR_REIFED        (1<<27)      /* res. decom. at image filtering */
+
+/*--------------------    Compute Device constants      ---------------------*/
+#define  COMPUTE_DEVICE_NONE    0
+#define  COMPUTE_DEVICE_OpenCL  1
+
+/* H_OPERATOR_INFO.compute_device bit field defines */
+#define  COMPUTE_DEVICE_BIT_NONE     0
+#define  COMPUTE_DEVICE_BIT_OpenCL   (1<<(COMPUTE_DEVICE_OpenCL))
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

3rdparty/include22/halcon/HVersNum.h

@@ -0,0 +1,93 @@
+/*****************************************************************************
+ * HVersNum.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: Current version of the HALCON library
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HLIB_MAJOR_NUM
+# define HLIB_MAJOR_NUM         20
+#endif
+
+#ifndef HLIB_MINOR_NUM
+# define HLIB_MINOR_NUM         11
+#endif
+
+#ifndef HLIB_REVISION_NUM
+# define HLIB_REVISION_NUM       0
+#endif
+
+#ifndef HLIB_BUILD_NUM
+# define HLIB_BUILD_NUM          0
+#endif
+
+
+#ifndef HLIB_PRODUCT_VERSION
+/* major_number.minor_number.maintenance_number.build_number */
+# define HLIB_PRODUCT_VERSION   HVERSNUM_STR(HLIB_MAJOR_NUM) "."        \
+  HVERSNUM_STR(HLIB_MINOR_NUM) "." HVERSNUM_STR(HLIB_REVISION_NUM)      \
+    "." HVERSNUM_STR(HLIB_BUILD_NUM)
+#endif
+
+#ifndef HLIB_FILE_VERSION
+# define HLIB_FILE_VERSION  HLIB_PRODUCT_VERSION
+#endif
+
+#if HLIB_REVISION_NUM == 0
+# define HC_PROGRESS_EDITION
+# define HALCON_PRODUCT_NAME "HALCON Progress Edition"
+#else
+# define HALCON_PRODUCT_NAME "HALCON Steady Edition"
+#endif
+
+/* --- Derived version numbers (with according helper macros) --- */
+#ifndef HVERSNUM_STR
+# define HVERSNUM_STR(S) HVERSNUM_STRX(S)
+# define HVERSNUM_STRX(S) #S
+#endif
+
+#ifndef HVERSNUM_GLUE
+# define HVERSNUM_GLUE(A,B)  HVERSNUM_GLUEX(A,B)
+# define HVERSNUM_GLUEX(A,B) A ## B
+#endif
+
+#ifndef HLIB_VERSION
+# define HLIB_VERSION       HVERSNUM_STR(HLIB_MAJOR_NUM) "." HVERSNUM_STR(HLIB_MINOR_NUM)
+#endif
+
+#ifndef HLIB_HEX_VERSION
+# define HLIB_HEX_VERSION    (((HLIB_MAJOR_NUM)<<8) + ((HLIB_MINOR_NUM)<<0))
+#endif
+
+#ifndef HLIB_VERSION_NUM
+/* deprecated: */
+# define HLIB_VERSION_NUM        HVERSNUM_GLUE(HLIB_MAJOR_NUM,HVERSNUM_GLUE(.,HLIB_MINOR_NUM))
+#endif
+
+
+#ifndef HLIB_REVISION
+# if HLIB_REVISION_NUM > 0
+#  define HLIB_REVISION         HVERSNUM_STR(HLIB_REVISION_NUM)
+# else
+
+#  define HLIB_REVISION         ""
+# endif
+#endif
+
+
+#ifndef HALCON_VERSION
+# define HALCON_VERSION(major,minor,revision)   \
+  HALCON_VERSIONX(major,minor,revision)
+# define HALCON_VERSIONX(major,minor,revision)  \
+  (((major)<<16) + ((minor)<<8) + (revision))
+#endif
+
+#ifndef HALCON_VERSION_CODE
+# define HALCON_VERSION_CODE  HALCON_VERSION(HLIB_MAJOR_NUM,HLIB_MINOR_NUM,\
+                                             HLIB_REVISION_NUM)
+#endif

3rdparty/include22/halcon/Halcon.h

@@ -0,0 +1,40 @@
+/*****************************************************************************
+ * Halcon.h
+ *****************************************************************************
+ *
+ * Project:      HALCON/HLib
+ * Description:  Includes all header files for HALCON library
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef HALCON_H
+#define HALCON_H
+
+/* needed system includes */
+#include <math.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "HVersNum.h"
+#include "HIntDef.h"
+#include "HDeclSpec.h"
+#include "HErrorDef.h"
+#include "HConst.h"
+#include "HBase.h"
+#include "IPType.h"
+#include "HParallel.h"
+#include "hlib/HAlloc.h"
+#include "HMacro.h"
+#include "HExtern.h"
+#include "hlib/HBaseGP.h"
+#include "hlib/IOSpy.h"
+#include "hlib/HInstance.h"
+#include "hlib/DBNew.h"
+#include "hlib/CORE1.h"
+#include "hlib/HXLD.h"
+#include "hlib/HError.h"
+#endif

3rdparty/include22/halcon/HalconC.h

@@ -0,0 +1,27 @@
+/*****************************************************************************
+ * HalconC.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: Defines, types, and declarations for HALCON/C
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ ****************************************************************************/
+
+#ifndef HALCON_C_H
+#define HALCON_C_H
+
+
+#include "HalconCDefs.h"
+#include "HInterfaceC.h"
+#include "halconc/Hvector.h"  /* HALCON/C vector implementation */
+
+/*
+ * generated prototypes for all HALCON operators
+ *--------------------------------------------------------------------------*/
+#include "HProto.h"
+
+
+#endif

3rdparty/include22/halcon/HalconCDefs.h

@@ -0,0 +1,544 @@
+/*****************************************************************************
+ * HalconCDefs.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: Defines, types, and declarations for HALCON/C
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ ****************************************************************************/
+
+#ifndef HALCON_C_DEFS_H
+#define HALCON_C_DEFS_H
+
+#include "HParallel.h"
+#include "HIntDef.h"
+#include "HDeclSpec.h"
+#include "HErrorDef.h"
+#include "HConst.h"
+#include "HBase.h"
+#include "IPType.h"
+#include "HMacro.h"
+#include "HExtern.h"
+
+#include <string.h>
+
+#define     UNDEF_TYPE  (-1)  /* Type after deleting a tuple               */
+                              /* instead of STRING_PAR, INT_PAR, etc       */
+
+/*
+ * Data of type Hobject is a pointer into the HALCON object data base.
+ * Thus it has to be treated as a magic number and must not be changed
+ * by the user.
+ */
+typedef Hkey     Hobject;      /* Pointer to HALCON iconic data            */
+
+
+/*
+ * The data structure Htuple is used to pass control data to the
+ * HALCON operators and get various kinds to non iconic data back
+ * to the application.
+ * Creating, access and deletion must only be done with the
+ * supplied procedures. For global, static initialization, the
+ * HTUPLE_INITIALIZER  macro is provided.
+ */
+typedef Hctuple Htuple;
+#define HTUPLE_INITIALIZER HCTUPLE_INITIALIZER
+
+
+/*
+ * Constants
+ */
+#ifdef HC_LEGACY_PAR
+#define _                 (Hlong*)0      /* anonyme Variable               */
+#define _i                (Hlong*)0      /* anonyme Variable (long)        */
+#define _d                (double*)0     /* anonyme Variable (double)      */
+#define _s                (char*)0       /* anonyme Variable (string)      */
+#define _t                (Htuple*)0     /* anonyme Variable (Tupel)       */
+#endif
+
+#define HALCONC_HNULL     ((Hphandle)0)  /* undefined handle               */
+
+#define NO_OBJECTS        (Hobject)(1)   /* leere Objektliste          */
+#define EMPTY_REGION      (Hobject)(2)   /* Objekt mit leerer Region   */
+#if 0
+#define FULL_REGION       (Hobject)(3)   /* Objekt mit maximaler Region*/
+#endif
+
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+LIntExport void SetHcInterfaceStringEncodingIsUtf8(int is_utf8);
+LIntExport int  IsHcInterfaceStringEncodingUtf8();
+
+
+LIntExport void* CMalloc(size_t size, const char* file, INT4_8 line);
+LIntExport void  CFree(void* mem, const char* file, INT4_8 line);
+
+/* HALCON/C interface utility functions */
+
+LIntExport void  Mcreate_tuple(Htuple* t, Hlong l, char const* file, int line);
+LIntExport void  Mcreate_tuple_type(Htuple* t, Hlong l, int type,
+                                    char const* file, int line);
+LIntExport void  Mcopy_tuple(Htuple const* input, Htuple* output,
+                             char const* file, int line);
+LIntExport void  Mattach_tuple(Htuple* H_RESTRICT src, Htuple* H_RESTRICT dest,
+                               char const* file, int line);
+LIntExport void  Mresize_tuple(Htuple* input, Hlong LEN, char const* file,
+                               int line);
+LIntExport void  Mdestroy_tuple(Htuple* t, char const* file, int line);
+LIntExport Hlong Mlength_tuple(Htuple const* t, char const* file, int line);
+LIntExport void  Mset_i(Htuple* t, Hlong v, Hlong i, char const* file,
+                        int line);
+LIntExport void  Mset_d(Htuple* t, double v, Hlong i, char const* file,
+                        int line);
+LIntExport void  Mset_s(Htuple* t, char const* v, Hlong i, const char* file,
+                        int line);
+LIntExport void  Mset_s_from_utf8(Htuple* t, char const* v, Hlong i,
+                                  const char* file, int line);
+LIntExport void  Mset_s_from_local8bit(Htuple* t, char const* v, Hlong i,
+                                       const char* file, int line);
+#ifdef _WIN32
+LIntExport void  Mset_s_from_wcs(Htuple* t, wchar_t const* v, Hlong i,
+                                 const char* file, int line);
+#endif
+LIntExport void  Mset_s_len(Htuple* t, Hlong len, Hlong i, char const* file,
+                            int line);
+
+LIntExport void  Mset_h(Htuple* t, Hphandle v, Hlong i, const char* file,
+                        int line);
+LIntExport Hlong  Mget_i(Htuple const* t, Hlong i, char const* file, int line);
+LIntExport double Mget_d(Htuple const* t, Hlong i, char const* file, int line);
+LIntExport char const* Mget_s(Htuple const* t, Hlong i, char const* file,
+                              int line);
+
+LIntExport Hlong Mget_s_to_utf8(char* dest, Hlong dest_size, Htuple const* t,
+                                Hlong i, char const* file, int line);
+LIntExport Hlong Mget_s_to_local8bit(char* dest, Hlong dest_size,
+                                     Htuple const* t, Hlong i,
+                                     char const* file, int line);
+#ifdef _WIN32
+LIntExport Hlong Mget_s_to_wcs(wchar_t* dest, Hlong dest_size, Htuple const* t,
+                               Hlong i, char const* file, int line);
+#endif
+
+LIntExport Hphandle Mget_h(Htuple const* t, Hlong i, char const* file,
+                           int line);
+LIntExport int Mget_type(Htuple const* t, Hlong i, char const* file, int line);
+
+/* functions combining (re)creation and one value setting */
+LIntExport void Mcreate_tuple_i(Htuple* t, Hlong value, char const* file,
+                                int line);
+LIntExport void Mcreate_tuple_d(Htuple* t, double value, char const* file,
+                                int line);
+LIntExport void Mcreate_tuple_s(Htuple* t, char const* value, char const* file,
+                                int line);
+LIntExport void Mcreate_tuple_s_from_utf8(Htuple* t, char const* value,
+                                          char const* file, int line);
+LIntExport void Mcreate_tuple_s_from_local8bit(Htuple* t, char const* value,
+                                               char const* file, int line);
+#ifdef _WIN32
+LIntExport void Mcreate_tuple_s_from_wcs(Htuple* t, wchar_t const* value,
+                                         char const* file, int line);
+#endif
+LIntExport void Mcreate_tuple_h(Htuple* t, Hphandle value, char const* file,
+                                int line);
+LIntExport void Mreuse_tuple_i(Htuple* t, Hlong value, char const* file,
+                               int line);
+LIntExport void Mreuse_tuple_d(Htuple* t, double value, char const* file,
+                               int line);
+LIntExport void Mreuse_tuple_s(Htuple* t, char const* value, char const* file,
+                               int line);
+LIntExport void Mreuse_tuple_s_from_utf8(Htuple* t, char const* value,
+                                         char const* file, int line);
+LIntExport void Mreuse_tuple_s_from_local8bit(Htuple* t, char const* value,
+                                              char const* file, int line);
+#ifdef _WIN32
+LIntExport void Mreuse_tuple_s_from_wcs(Htuple* t, wchar_t const* value,
+                                        char const* file, int line);
+#endif
+LIntExport void Mreuse_tuple_h(Htuple* t, Hphandle value, char const* file,
+                               int line);
+
+
+LIntExport void F_create_tuple_type(Htuple* H_RESTRICT htuple, Hlong len,
+                                    HINT type);
+LIntExport void F_create_tuple(Htuple* H_RESTRICT htuple, Hlong l);
+LIntExport void F_copy_tuple(Htuple const* H_RESTRICT in,
+                             Htuple* H_RESTRICT out);
+LIntExport void F_attach_tuple(Htuple* H_RESTRICT src,
+                               Htuple* H_RESTRICT dest);
+LIntExport void F_resize_tuple(Htuple* H_RESTRICT htuple, Hlong LEN);
+LIntExport void F_destroy_tuple(Htuple* H_RESTRICT htuple);
+LIntExport void F_set_i(Htuple* H_RESTRICT t, Hlong value, Hlong idx);
+LIntExport void F_set_d(Htuple* H_RESTRICT t, double value, Hlong idx);
+LIntExport void F_set_s(Htuple* H_RESTRICT t, char const* H_RESTRICT val,
+                        Hlong idx);
+LIntExport void F_set_s_from_utf8(Htuple* H_RESTRICT t,
+                                  char const* H_RESTRICT val, Hlong idx);
+LIntExport void F_set_s_from_local8bit(Htuple* H_RESTRICT t,
+                                       char const* H_RESTRICT val, Hlong idx);
+#ifdef _WIN32
+LIntExport void F_set_s_from_wcs(Htuple* H_RESTRICT t,
+                                 wchar_t const* H_RESTRICT val, Hlong idx);
+#endif
+LIntExport void F_set_h(Htuple* H_RESTRICT t, Hphandle val, Hlong idx);
+
+LIntExport void F_init_i(Htuple* H_RESTRICT t, Hlong value, Hlong idx);
+LIntExport void F_init_d(Htuple* H_RESTRICT t, double value, Hlong idx);
+LIntExport void F_init_s(Htuple* H_RESTRICT t, char const* H_RESTRICT value,
+                         Hlong idx);
+LIntExport void F_init_s_from_utf8(Htuple* H_RESTRICT t,
+                                   char const* H_RESTRICT value, Hlong idx);
+LIntExport void F_init_s_from_local8bit(Htuple* H_RESTRICT t,
+                                        char const* H_RESTRICT value,
+                                        Hlong                  idx);
+#ifdef _WIN32
+LIntExport void F_init_s_from_wcs(Htuple* H_RESTRICT t,
+                                  wchar_t const* H_RESTRICT value, Hlong idx);
+#endif
+LIntExport void F_init_s_len(Htuple* H_RESTRICT t, Hlong len, Hlong idx);
+LIntExport void F_init_h(Htuple* H_RESTRICT t, Hphandle value, Hlong idx);
+
+LIntExport Hlong       F_get_i(Htuple const* H_RESTRICT t, Hlong idx);
+LIntExport double      F_get_d(Htuple const* H_RESTRICT t, Hlong idx);
+LIntExport char const* F_get_s(Htuple const* H_RESTRICT t, Hlong idx);
+LIntExport Hlong F_get_s_to_utf8(char* dest, Hlong dest_size,
+                                 Htuple const* H_RESTRICT t, Hlong i);
+LIntExport Hlong F_get_s_to_local8bit(char* dest, Hlong dest_size,
+                                      Htuple const* H_RESTRICT t, Hlong i);
+#ifdef _WIN32
+LIntExport Hlong F_get_s_to_wcs(wchar_t* dest, Hlong dest_size,
+                                Htuple const* H_RESTRICT t, Hlong i);
+#endif
+LIntExport Hphandle F_get_h(Htuple const* H_RESTRICT t, Hlong idx);
+
+
+/* functions combining (re)creation and one value setting */
+LIntExport void F_create_tuple_i(Htuple* H_RESTRICT t, Hlong val);
+LIntExport void F_create_tuple_d(Htuple* H_RESTRICT t, double val);
+LIntExport void F_create_tuple_s(Htuple* H_RESTRICT t, char const* val);
+LIntExport void F_create_tuple_s_from_utf8(Htuple* H_RESTRICT t,
+                                           char const*        val);
+LIntExport void F_create_tuple_s_from_local8bit(Htuple* H_RESTRICT t,
+                                                char const*        val);
+#ifdef _WIN32
+LIntExport void F_create_tuple_s_from_wcs(Htuple* H_RESTRICT t,
+                                          wchar_t const*     val);
+#endif
+LIntExport void F_create_tuple_h(Htuple* H_RESTRICT t, Hphandle val);
+
+LIntExport void F_reuse_tuple_i(Htuple* H_RESTRICT t, Hlong val);
+LIntExport void F_reuse_tuple_d(Htuple* H_RESTRICT t, double val);
+LIntExport void F_reuse_tuple_s(Htuple* H_RESTRICT t,
+                                char const* H_RESTRICT val);
+LIntExport void F_reuse_tuple_s_from_utf8(Htuple* H_RESTRICT t,
+                                          char const* H_RESTRICT val);
+LIntExport void F_reuse_tuple_s_from_local8bit(Htuple* H_RESTRICT t,
+                                               char const* H_RESTRICT val);
+#ifdef _WIN32
+LIntExport void F_reuse_tuple_s_from_wcs(Htuple* H_RESTRICT t,
+                                         wchar_t const* H_RESTRICT val);
+#endif
+LIntExport void F_reuse_tuple_h(Htuple* H_RESTRICT t, Hphandle val);
+
+
+/* new generic HALCON operator call style:
+ * - the operator is called by an id that is returned by get_operator_id;
+ *    attention: this id may differ for different HALCON versions
+ * - the tuple arrays are passed directly to the call -> this method is
+ *   thread safe
+ *---------------------------------------------------------------------------*/
+LIntExport int    get_operator_id(char const* name);
+LIntExport Herror T_call_halcon_by_id(int id, Hobject const in_objs[],
+                                      Hobject      out_objs[],
+                                      Htuple const in_ctrls[],
+                                      Htuple       out_ctrls[]);
+
+/* old generic HALCON operator call style (legacy)
+ * the parameters are set befor calling T_call_halcon with set_*_[t|o]par
+ * this approach is not thread safe without additional synchronisation
+ *---------------------------------------------------------------------------*/
+LIntExport void   set_in_tpar(Htuple* t, int i);
+LIntExport void   set_out_tpar(Htuple* t, int i);
+LIntExport void   set_in_opar(Hobject o, int i);
+LIntExport void   set_out_opar(Hobject* o, int i);
+LIntExport Herror T_call_halcon(const char* n);
+
+/* obsolete method, kept inside for compatibility reasons, returns always 0
+ *---------------------------------------------------------------------------*/
+LIntExport Hlong num_tuple(void);
+
+/*
+ * The following functions can be used to emulate the behavior of
+ * HDevelop graphics windows for HALCON graphics windows. They are primarily
+ * intended for usage in C programs exported from HDevelop programs containing
+ * HDevelop window operators (e.g. dev_set_window, dev_open_window,
+ * dev_close_window...). On multithreaded systems, every thread has its own
+ * graphics windows stack.
+ *---------------------------------------------------------------------------*/
+LIntExport void hdev_window_stack_push(const Htuple win_handle);
+LIntExport void hdev_window_stack_pop(Htuple* win_handle);
+LIntExport void hdev_window_stack_get_active(Htuple* win_handle);
+LIntExport void hdev_window_stack_set_active(const Htuple win_handle);
+LIntExport int  hdev_window_stack_is_open(void);
+LIntExport void hdev_window_stack_close_all(void);
+
+/*
+ * The following functions are kept for downward compatibility only.
+ * DO NOT USE !!!
+ * Use the hdev_window_stack_... functions instead !
+ *---------------------------------------------------------------------------*/
+LIntExport void  window_stack_push(Hlong win_handle);
+LIntExport Hlong window_stack_pop(void);
+LIntExport Hlong window_stack_get_active(void);
+LIntExport void  window_stack_set_active(Hlong win_handle);
+LIntExport int   window_stack_is_open(void);
+LIntExport void  window_stack_close_all(void);
+
+/* Used in C programs exported from HDevelop */
+LIntExport Herror replace_elements(Htuple* htuple, Htuple* index,
+                                   Htuple const* replace_val);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#if !defined(H_NO_INLINE) && !defined(H_INLINE)
+#  define H_NO_INLINE
+#endif
+
+
+/*
+ * Short versions for the tuple operators
+ */
+#ifndef HC_HIDE_SHORT_VERSIONS
+    #define CT(TUP,LEN)              create_tuple(TUP,LEN)
+    #define CPT(TUP,Out)             copy_tuple(TUP,Out)
+    #define RT(TUP,LEN)              resize_tuple(TUP,LEN)
+    #define DT(TUP)                  destroy_tuple(TUP)
+    #define LT(TUP)                  length_tuple(TUP)
+    #define SS(TUP,VAL,IDX)          set_s(TUP,VAL,IDX)
+    #define SS_U8(TUP,VAL,IDX)       set_s_from_utf8(TUP,VAL,IDX)
+    #define SS_LOC(TUP,VAL,IDX)      set_s_from_local8bit(TUP,VAL,IDX)
+    #ifdef _WIN32
+    #define SS_W(TUP,VAL,IDX)        set_s_from_wcs(TUP,VAL,IDX)
+    #endif
+    #define SI(TUP,VAL,IDX)          set_i(TUP,VAL,IDX)
+    #define SD(TUP,VAL,IDX)          set_d(TUP,VAL,IDX)
+    #define SH(TUP,VAL,IDX)          set_h(TUP,VAL,IDX)
+    #define GS(TUP,IDX)              get_s(TUP,IDX)
+    #define GS_U8(BUF,SIZE,TUP,IDX)  get_s_to_utf8(BUF,SIZE,TUP,IDX)
+    #define GS_LOC(BUF,SIZE,TUP,IDX) get_s_to_local8bit(BUF,SIZE,TUP,IDX)
+    #ifdef _WIN32
+    #define GS_W(BUF,SIZE,TUP,IDX)   get_s_to_wcs(BUF,SIZE,TUP,IDX)
+    #endif
+    #define GI(TUP,IDX)              get_i(TUP,IDX)
+    #define GD(TUP,IDX)              get_d(TUP,IDX)
+    #define GH(TUP,IDX)              get_h(TUP,IDX)
+    #define GT(TUP,IDX)              get_type(TUP,IDX)
+
+    #define TC(PROC_NAME)            T_call_halcon(PROC_NAME)
+    #define IT(TUP,NUM)              set_in_tpar(&(TUP),NUM)
+    #define OT(TUP,NUM)              set_out_tpar(TUP,NUM)
+    #define IO(OBJ,NUM)              set_in_opar(OBJ,NUM)
+    #define OO(OBJ,NUM)              set_out_opar(OBJ,NUM)
+#endif
+
+#ifdef HC_FAST /* Compiler option for tested programs */
+
+
+#  define C_TUPLE_IDX_TYPE(PCTUPLE, IDX)                                      \
+    ((MIXED_PAR != (PCTUPLE)->type)                                           \
+         ? (PCTUPLE)->type                                                    \
+         : (IDX < (PCTUPLE)->num) ? (PCTUPLE)->elem.cpar[IDX].type            \
+                                  : UNDEF_PAR)
+
+#  define length_tuple(TUP) ((TUP).num)
+#  define get_type(TUP, IDX) (C_TUPLE_IDX_TYPE(&(TUP), IDX))
+
+#  define create_tuple(TUP, LEN) F_create_tuple(TUP, LEN)
+#  define create_tuple_type(TUP, LEN, TYP) F_create_tuple_type(TUP, LEN, TYP)
+#  define destroy_tuple(TUP) F_destroy_tuple(&(TUP))
+#  define copy_tuple(TUP_I, TUP_O) F_copy_tuple(&(TUP_I), TUP_O)
+#  define attach_tuple(TUP_S, TUP_D) F_attach_tuple(&(TUP_S), TUP_D)
+#  define resize_tuple(TUP, LEN) F_resize_tuple(TUP, LEN)
+
+#  define create_tuple_i(TUP, VAL) F_create_tuple_i(TUP, VAL)
+#  define create_tuple_d(TUP, VAL) F_create_tuple_d(TUP, VAL)
+#  define create_tuple_s(TUP, VAL) F_create_tuple_s(TUP, VAL)
+#  define create_tuple_s_from_utf8(TUP, VAL)                                  \
+    F_create_tuple_s_from_utf8(TUP, VAL)
+#  define create_tuple_s_from_local8bit(TUP, VAL)                             \
+    F_create_tuple_s_from_local8bit(TUP, VAL)
+#  ifdef _WIN32
+#    define create_tuple_s_from_wcs(TUP, VAL)                                 \
+      F_create_tuple_s_from_wcs(TUP, VAL)
+#  endif
+#  define create_tuple_h(TUP, VAL) F_create_tuple_h(TUP, VAL)
+
+#  define reuse_tuple_i(TUP, VAL) F_reuse_tuple_i(TUP, VAL)
+#  define reuse_tuple_d(TUP, VAL) F_reuse_tuple_d(TUP, VAL)
+#  define reuse_tuple_s(TUP, VAL) F_reuse_tuple_s(TUP, VAL)
+#  define reuse_tuple_s_from_utf8(TUP, VAL) F_reuse_tuple_s_from_utf8(TUP, VAL)
+#  define reuse_tuple_s_from_local8bit(TUP, VAL)                              \
+    F_reuse_tuple_s_from_local8bit(TUP, VAL)
+#  ifdef _WIN32
+#    define reuse_tuple_s_from_wcs(TUP, VAL) F_reuse_tuple_s_from_wcs(TUP, VAL)
+#  endif
+#  define reuse_tuple_h(TUP, VAL) F_reuse_tuple_h(TUP, VAL)
+
+#  define init_i(TUP, VAL, IDX) F_init_i(&(TUP), VAL, IDX)
+#  define init_d(TUP, VAL, IDX) F_init_d(&(TUP), VAL, IDX)
+#  define init_s(TUP, VAL, IDX) F_init_s(&(TUP), VAL, IDX)
+#  define init_s_len(TUP, LEN, IDX) F_init_s_len(&(TUP), LEN, IDX)
+#  define init_s_from_utf8(TUP, VAL, IDX) F_init_s_from_utf8(&(TUP), VAL, IDX)
+#  define init_s_from_local8bit(TUP, VAL, IDX)                                \
+    F_init_s_from_local8bit(&(TUP), VAL, IDX)
+#  ifdef _WIN32
+#    define init_s_from_wcs(TUP, VAL, IDX) F_init_s_from_wcs(&(TUP), VAL, IDX)
+#  endif
+#  define init_h(TUP, VAL, IDX) F_init_h(&(TUP), VAL, IDX)
+
+#  define at_i(TUP, IDX)                                                      \
+    ((LONG_PAR == (TUP).type) ? (TUP).elem.l[IDX]                             \
+                              : (TUP).elem.cpar[IDX].par.l /*MIXED_PAR*/)
+#  define at_d(TUP, IDX)                                                      \
+    ((DOUBLE_PAR == (TUP).type) ? (TUP).elem.f[IDX]                           \
+                                : (TUP).elem.cpar[IDX].par.f /*MIXED_PAR*/)
+#  define at_s(TUP, IDX)                                                      \
+    ((char const*const)((STRING_PAR == (TUP).type)                            \
+                                ? (TUP).elem.s[IDX]                           \
+                                : (TUP).elem.cpar[IDX].par.s /*MIXED_PAR*/)
+#  define at_h(TUP, IDX)                                                      \
+    ((char const*const)((HANDLE_PAR == (TUP).type)                            \
+                                ? (TUP).elem.h[IDX]                           \
+                                : (TUP).elem.cpar[IDX].par.h /*MIXED_PAR*/)
+
+
+#  define set_i(TUP, VAL, IDX) F_set_i(&(TUP), VAL, IDX)
+#  define set_d(TUP, VAL, IDX) F_set_d(&(TUP), VAL, IDX)
+#  define set_s(TUP, VAL, IDX) F_set_s(&(TUP), VAL, IDX)
+#  define set_s_from_utf8(TUP, VAL, IDX) F_set_s_from_utf8(&(TUP), VAL, IDX)
+#  define set_s_from_local8bit(TUP, VAL, IDX)                                 \
+    F_set_s_from_local8bit(&(TUP), VAL, IDX)
+#  ifdef _WIN32
+#    define set_s_from_wcs(TUP, VAL, IDX) F_set_s_from_wcs(&(TUP), VAL, IDX)
+#  endif
+#  define set_h(TUP, VAL, IDX) F_set_h(&(TUP), VAL, IDX)
+
+#  define get_i(TUP, IDX) F_get_i(&(TUP), IDX)
+#  define get_d(TUP, IDX) F_get_d(&(TUP), IDX)
+#  define get_s(TUP, IDX) F_get_s(&(TUP), IDX)
+#  define get_s_to_utf8(BUF, SIZE, TUP, IDX)                                  \
+    F_get_s_to_utf8(BUF, SIZE, &(TUP), IDX)
+#  define get_s_to_local8bit(BUF, SIZE, TUP, IDX)                             \
+    F_get_s_to_local8bit(BUF, SIZE, &(TUP), IDX)
+#  ifdef _WIN32
+#    define get_s_to_wcs(BUF, SIZE, TUP, IDX)                                 \
+      F_get_to_wcs(BUF, SIZE, &(TUP), IDX)
+#  endif
+#  define get_h(TUP, IDX) F_get_h(&(TUP), IDX)
+
+
+#else /* := #ifndef HC_FAST -> paranoiac version */
+
+
+#  define create_tuple(TUP, LEN) Mcreate_tuple(TUP, LEN, __FILE__, __LINE__)
+#  define create_tuple_type(TUP, LEN, TYP)                                    \
+    Mcreate_tuple_type(TUP, LEN, TYP, __FILE__, __LINE__)
+#  define destroy_tuple(TUP) Mdestroy_tuple(&(TUP), __FILE__, __LINE__)
+#  define copy_tuple(TUP_I, TUP_O)                                            \
+    Mcopy_tuple(&(TUP_I), TUP_O, __FILE__, __LINE__)
+#  define attach_tuple(TUP_S, TUP_D)                                          \
+    Mattach_tuple(&(TUP_S), TUP_D, __FILE__, __LINE__)
+#  define resize_tuple(TUP, LEN) Mresize_tuple(TUP, LEN, __FILE__, __LINE__)
+
+#  define length_tuple(TUP) Mlength_tuple(&(TUP), __FILE__, __LINE__)
+#  define get_type(TUP, IDX) Mget_type(&(TUP), IDX, __FILE__, __LINE__)
+
+#  define init_i(TUP, VAL, IDX) Mset_i(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  define init_d(TUP, VAL, IDX) Mset_d(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  define init_s(TUP, VAL, IDX) Mset_s(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  define init_s_len(TUP, LEN, IDX)                                           \
+    Mset_s_len(&(TUP), LEN, IDX, __FILE__, __LINE__)
+#  define init_s_from_utf8(TUP, VAL, IDX)                                     \
+    Minit_s_from_utf8(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  define init_s_from_local8bit(TUP, VAL, IDX)                                \
+    Minit_s_from_local8bit(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  ifdef _WIN32
+#    define init_s_from_wcs(TUP, VAL, IDX)                                    \
+      Minit_s_from_wcs(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  endif
+#  define init_h(TUP, VAL, IDX) Mset_h(&(TUP), VAL, IDX, __FILE__, __LINE__)
+
+#  define set_i(TUP, VAL, IDX) Mset_i(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  define set_d(TUP, VAL, IDX) Mset_d(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  define set_s(TUP, VAL, IDX) Mset_s(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  define set_s_from_utf8(TUP, VAL, IDX)                                      \
+    Mset_s_from_utf8(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  define set_s_from_local8bit(TUP, VAL, IDX)                                 \
+    Mset_s_from_local8bit(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  ifdef _WIN32
+#    define set_s_from_wcs(TUP, VAL, IDX)                                     \
+      Mset_s_from_wcs(&(TUP), VAL, IDX, __FILE__, __LINE__)
+#  endif
+#  define set_h(TUP, VAL, IDX) Mset_h(&(TUP), VAL, IDX, __FILE__, __LINE__)
+
+#  define get_i(TUP, IDX) Mget_i(&(TUP), IDX, __FILE__, __LINE__)
+#  define get_d(TUP, IDX) Mget_d(&(TUP), IDX, __FILE__, __LINE__)
+#  define get_s(TUP, IDX) Mget_s(&(TUP), IDX, __FILE__, __LINE__)
+#  define get_h(TUP, IDX) Mget_h(&(TUP), IDX, __FILE__, __LINE__)
+#  define get_s_to_utf8(BUF, SIZE, TUP, IDX)                                  \
+    Mget_s_to_utf8(BUF, SIZE, &(TUP), IDX, __FILE__, __LINE__)
+#  define get_s_to_local8bit(BUF, SIZE, TUP, IDX)                             \
+    Mget_s_to_local8bit(BUF, SIZE, &(TUP), IDX, __FILE__, __LINE__)
+#  ifdef _WIN32
+#    define get_s_to_wcs(BUF, SIZE, TUP, IDX)                                 \
+      Mget_s_to_wcs(BUF, SIZE, &(TUP), IDX, __FILE__, __LINE__)
+#  endif
+
+#  define at_i(TUP, IDX) Mget_i(&(TUP), IDX, __FILE__, __LINE__)
+#  define at_d(TUP, IDX) Mget_d(&(TUP), IDX, __FILE__, __LINE__)
+#  define at_s(TUP, IDX) Mget_s(&(TUP), IDX, __FILE__, __LINE__)
+#  define at_h(TUP, IDX) Mget_h(&(TUP), IDX, __FILE__, __LINE__)
+
+#  define create_tuple_i(TUP, VAL)                                            \
+    Mcreate_tuple_i(TUP, VAL, __FILE__, __LINE__)
+#  define create_tuple_d(TUP, VAL)                                            \
+    Mcreate_tuple_d(TUP, VAL, __FILE__, __LINE__)
+#  define create_tuple_s(TUP, VAL)                                            \
+    Mcreate_tuple_s(TUP, VAL, __FILE__, __LINE__)
+#  define create_tuple_h(TUP, VAL)                                            \
+    Mcreate_tuple_h(TUP, VAL, __FILE__, __LINE__)
+#  define create_tuple_s_from_utf8(TUP, VAL)                                  \
+    Mcreate_tuple_s_from_utf8(TUP, VAL, __FILE__, __LINE__)
+#  define create_tuple_s_from_local8bit(TUP, VAL)                             \
+    Mcreate_tuple_s_from_local8bit(TUP, VAL, __FILE__, __LINE__)
+#  ifdef _WIN32
+#    define create_tuple_s_from_wcs(TUP, VAL)                                 \
+      Mcreate_tuple_s_from_wcs(TUP, VAL, __FILE__, __LINE__)
+#  endif
+
+#  define reuse_tuple_i(TUP, VAL) Mreuse_tuple_i(TUP, VAL, __FILE__, __LINE__)
+#  define reuse_tuple_d(TUP, VAL) Mreuse_tuple_d(TUP, VAL, __FILE__, __LINE__)
+#  define reuse_tuple_s(TUP, VAL) Mreuse_tuple_s(TUP, VAL, __FILE__, __LINE__)
+#  define reuse_tuple_h(TUP, VAL) Mreuse_tuple_h(TUP, VAL, __FILE__, __LINE__)
+#  define reuse_tuple_s_from_utf8(TUP, VAL)                                   \
+    Mreuse_tuple_s_from_utf8(TUP, VAL, __FILE__, __LINE__)
+#  define reuse_tuple_s_from_local8bit(TUP, VAL)                              \
+    Mreuse_tuple_s_from_local8bit(TUP, VAL, __FILE__, __LINE__)
+#  ifdef _WIN32
+#    define reuse_tuple_s_from_wcs(TUP, VAL)                                  \
+      Mreuse_tuple_s_from_wcs(TUP, VAL, __FILE__, __LINE__)
+#  endif
+
+
+#endif  /* ifdef HC_FAST .. else */
+
+
+#endif

3rdparty/include22/halcon/IPType.h

@@ -0,0 +1,530 @@
+/*****************************************************************************
+ * IPType.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/libhalcon
+ * Description: Types for image processing and language interfaces
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************/
+
+#ifndef IPTYPE_H
+#define IPTYPE_H
+
+#ifndef HC_NO_STRUCT_MEMBER_ALIGNMENT 
+/* sets the struct member alignment to avoid problems if 
+ * the settings of the user differ to those of the HALCON
+ * version. (8 is the default alignment, generally) */
+# pragma pack(push,8) 
+#endif
+
+typedef  bool  HBOOL;                  /* TRUE (1) or FALSE (0) */
+typedef  UINT1 HBYTE;                  /* unsigned Byte */
+
+
+#if !defined(HC_LARGE_IMAGES)
+typedef INT4 HIMGDIM;   /* Image dimension, e.g., width and height */
+typedef INT2 HIMGCOOR;  /* Image coordinates, e.g, row and column */
+typedef INT4 HLINCOOR;  /* Linearized image coordinates */
+typedef INT4 HIMGCNT;   /* Number of pixels, e.g., area or buffer size */
+typedef INT4 HITEMCNT;  /* Number of elements, e.g., contours or runlengths */
+typedef float HSUBCOOR; /* Sub-pixel precise coordinates */
+typedef float HSUBATTR; /* Sub-pixel precise attributes of contours */
+#else
+typedef INT4 HIMGDIM;
+typedef INT4 HIMGCOOR;
+typedef INT4_8 HLINCOOR;
+typedef INT4_8 HIMGCNT;
+typedef INT4_8 HITEMCNT;
+typedef double HSUBCOOR;
+typedef double HSUBATTR;
+#endif
+
+
+/****************************************************************************/
+/*  Types for images                                                        */
+/****************************************************************************/
+
+typedef void* (*HImageAllocProc)(size_t size);
+typedef void  (*HImageFreeProc)(void *mem);
+
+typedef struct {
+  float re;                  /* real part                                   */
+  float im;                  /* imaginary part                              */
+} HComplexPixel;
+
+typedef struct {
+  INT2 *p;                   /* pointer to gray vales                       */
+  INT1 num_bits;             /* number of used bits                         */
+} HInt2Pixel;
+
+typedef struct {
+  UINT2 *p;                  /* pointer to gray vales                       */
+  INT1  num_bits;            /* number of used bits                         */
+} HUInt2Pixel;
+
+typedef struct {
+  float *row;                /* row direction                               */
+  float *col;                /* column direction                            */
+  INT4  kind;                /* VF_ABSOLUTE or VF_RELATIVE                  */
+} HVFPixel;
+
+typedef union {
+  HBYTE         *b;         /* 0..255 (BYTE_IMAGE)                          */
+  HBYTE         *z;         /* 0..255 mod 256 (CYCLIC_IMAGE)                */
+  HBYTE         *d;         /* orientation 0..180 (DIR_IMAGE)               */
+  INT1          *i;         /* -127..126 (INT1_IMAGE)                       */
+  INT4          *l;         /* 4 byte integer (LONG_IMAGE)                  */
+  HINT8         *i8;        /* 8 byte integer (INT8_IMAGE)                  */
+  float         *f;         /* 4 byte real (FLOAT_IMAGE)                    */
+  HVFPixel      vf;         /* vector field (VF_IMAGE)                      */
+  HComplexPixel *c;         /* complex image (COMPLEX_IMAGE)                */
+  HInt2Pixel    s;          /* 2 bytes with sign (INT2_IMAGE)               */
+  HUInt2Pixel   u;          /* 2 bytes without sign (UINT2_IMAGE)           */
+} HPixelImage;
+
+typedef struct {
+  HINT        kind;         /* pixel type                                   */
+  HPixelImage pixel;        /* pixel data                                   */
+  HIMGDIM     width;        /* image width                                  */
+  HIMGDIM     height;       /* image height                                 */
+  HImageFreeProc free_proc; /* function for deallocating image data         */
+  HBOOL       free;         /* free image data when deleting image          */
+  /* time of creation of image                                              */
+  UINT2       msec;         /* milliseconds 0..999                          */
+  UINT1       sec;          /* seconds 0..59                                */
+  UINT1       min;          /* minutes 0.59                                 */
+  UINT1       hour;         /* 0..23                                        */
+  UINT1       day;          /* 1..31                                        */
+  UINT2       yday;         /* 1..366                                       */
+  UINT1       mon;          /* 1..12                                        */
+  UINT2       year;         /* 19xx                                         */
+} Himage;
+
+/* Information file for HALCON image file format (.exp)                     */
+typedef struct {
+  INT4 width;               /* width of image                               */
+  INT4 kind;                /* Pixel type                                   */
+  INT4 height;              /* height of image                              */
+  char info[1000-4];        /* for further use                              */
+} Himage_exp;
+    
+/* Information header for HALCON image file format                          */
+typedef struct {
+  INT4 version_number;      /* version number of the ima file format       */
+  INT4 num_images;           /* number of images in file                    */
+  HBOOL is_msb_first;        /* is most significant bit first (byte order)  */
+} Himage_hobj_file_header;
+
+/* Information header for HALCON image file format  - for each image        */
+typedef struct {
+  INT4 width;               /* width of image                               */
+  INT4 height;              /* height of image                              */
+  INT4 num_channels;        /* channels in image                            */
+} Himage_hobj_image_header;
+
+
+typedef HBYTE *Hbits;       /* Binary image                                 */
+
+
+/****************************************************************************/
+/*                       Regionen                                           */
+/****************************************************************************/
+
+
+/* Index range for coordinates of run length regions                        */
+#define MAX_COORD (MAX_FORMAT-1)
+#define MIN_COORD (-MAX_COORD)
+
+/* Data type for a single run of a region encoded with runlength encoding   */
+typedef struct {
+  HIMGCOOR l;               /* line number (row) of run                     */
+  HIMGCOOR cb;              /* column index of beginning of run             */
+  HIMGCOOR ce;              /* column index of ending of run                */
+} Hrun;
+
+/* vertical run */
+typedef struct {
+  HIMGCOOR c;               /* column index of run                          */
+  HIMGCOOR lb;              /* row index of beginning of run                */
+  HIMGCOOR le;              /* row index of ending of run                   */
+} Hvrun;
+
+#define SHAPE_RECTANGLE1     (UINT1)1
+#define SHAPE_RECTANGLE2     (UINT1)2
+#define SHAPE_CIRCLE         (UINT1)3
+#define SHAPE_ELLIPSE        (UINT1)4
+
+/* Bit-array to check if a feature of a region was calculated               */
+typedef struct {
+  unsigned int shape               : 1;
+  unsigned int is_convex           : 1;
+  unsigned int is_filled           : 1;
+  unsigned int is_connected4       : 1;
+  unsigned int is_connected8       : 1;
+  unsigned int is_thin             : 1;
+  unsigned int circularity         : 1;
+  unsigned int compactness         : 1;
+  unsigned int contlength          : 1;
+  unsigned int convexity           : 1;
+  unsigned int phi                 : 1;
+  unsigned int elliptic_axis       : 1;   /* ra, rb                         */
+  unsigned int elliptic_shape      : 1;   /* ra_, rb_                       */
+  unsigned int excentricity        : 1;   /* anisometry,bulkiness,str_faktor*/
+  unsigned int moments             : 1;   /* m11, m20, m02, ia, ib          */
+  unsigned int center_area         : 1;   /* row, col, area                 */
+  unsigned int smallest_rectangle1 : 1;   /* row1,col1,row2,col2            */
+  unsigned int smallest_rectangle2 : 1;   /* row_rect, col_rect, phi_rect,  */
+                                          /* length1, length2               */
+  unsigned int smallest_circle     : 1;   /* row_circle, col_circle, radius */
+  unsigned int min_max_chord       : 1;   /* longest/shortest run           */
+  unsigned int min_max_chord_gap   : 1;   /* longest/shortest run (holes)   */
+  unsigned int rectangularity      : 1;
+} HFeatureFlags;
+
+
+/* Shape feature caching inside the region structure                        */
+typedef struct {
+  union {
+    HFeatureFlags single;
+    long          all;      /* if possible use 64 bits!                     */
+  }               def;
+  UINT1    shape;           /* SHAPE_*                                      */
+  HBOOL    is_convex;
+  HBOOL    is_filled;
+  HBOOL    is_connected4;
+  HBOOL    is_connected8;
+  HBOOL    is_thin;         /* one pixel thin                               */
+  double   circularity;
+  double   compactness;
+  double   contlength;
+  double   convexity;
+  double   phi;
+  double   ra, rb;          /* elliptic_axis                                */
+  double   ra_, rb_;        /* elliptic_shape                               */
+  double   anisometry, bulkiness, structure_factor;
+  double   m11, m20, m02, ia, ib;
+  double   row, col;
+  HIMGCNT  area;
+  HIMGCOOR row1, col1, row2, col2;
+  double   row_rect, col_rect, phi_rect, length1, length2;
+  double   row_circle, col_circle, radius;
+  HIMGCOOR min_chord, max_chord;
+  HIMGCOOR min_chord_gap, max_chord_gap;
+  double rectangularity;
+} HRegFeature;
+
+
+typedef struct {
+  HBOOL       is_compl;     /* region is complement                         */
+  HITEMCNT    num;          /* number of runs                               */
+  HITEMCNT    num_max;      /* maximum number of runs                       */
+  HRegFeature feature;      /* already processed features                   */
+  Hrun        *rl;          /* pointer on array of run lengths              */
+} Hrlregion;
+
+
+/* vertical runlength encoding */
+typedef struct {
+  HBOOL       is_compl;     /* region is complement                         */
+  HITEMCNT    num;          /* number of runs                               */
+  HITEMCNT    num_max;      /* maximum number of runs                       */
+  HRegFeature feature;      /* already processed features                   */
+  Hvrun       *rc;          /* array of runs                                */
+} Hvrlregion;
+
+/* Data structure for fast single pixel access for Hrlregion regions        */
+typedef struct {
+  HIMGCOOR min, max;        /* Min/Max row index                            */
+  Hrun     *rl;             /* pointer to runs of the region                */
+  HITEMCNT *first;          /* array of index values (row begin)            */
+  HITEMCNT *last;           /* array of index values (row end)              */
+  HBOOL    *no_row;         /* is there this row available?                 */
+} Hrlaccess;
+
+/* Data structure for a multichannel image                                  */
+typedef struct {
+  Himage    *channels;      /* Channels of the multichannel image           */
+  Hrlregion *region;        /* Domain of the multichannel image             */
+  HINT      num_channels;   /* Number of channels of the multichannel image */
+} HMultiChannelImage;
+
+
+/****************************************
+ *
+ ****************************************/
+/* simple contour with long coordinates and variable allocation length */
+typedef struct {
+  HIMGCOOR *row;                    /* row values                           */
+  HIMGCOOR *col;                    /* columns values                       */
+  HITEMCNT num;                     /* length of contour (number of points) */
+  HITEMCNT max_num;                 /* allocated points of contour          */
+} Hcontvar;
+
+/* simple contour with float coordinates and variable allocation length */
+typedef struct {
+  HSUBCOOR *row;                    /* row values                           */
+  HSUBCOOR *col;                    /* columns values                       */
+  HITEMCNT num;                     /* length of contour (number of points) */
+  HITEMCNT max_num;                 /* allocated points of contour          */
+} Hfcontvar;
+
+/* Countour as chain code                                                   */
+typedef struct {
+  HIMGCOOR l, c;                 /* Start point (row,column)                */
+  HBYTE    *cc;                  /* array of chain code                     */
+  HITEMCNT num;                  /* length of contour (number of points)    */
+} Hchain_code;
+
+
+/* line (start and end point)                                               */
+typedef struct {
+  HSUBCOOR row1, col1;      /* Start point                                  */
+  HSUBCOOR row2, col2;      /* End point                                    */
+} Hline;
+
+/* Array of lines                                                           */
+typedef struct {
+  HITEMCNT num;
+  Hline    *line;
+} Hlines;
+
+
+
+/****************************************************************************/
+/*                       Distribution                                       */
+/****************************************************************************/
+
+#define HISTO_LEN   256
+typedef HIMGCNT Hhisto_abs[HISTO_LEN];
+typedef double Hhisto_rel[HISTO_LEN];
+
+
+#define MAX_DISTR   (2*256+1)
+#define NULL_DISTR  256
+
+
+
+/****************************************************************************/
+/*              Misc. image processing                                      */
+/****************************************************************************/
+
+/* Convolution (Convol and FFT)                                             */
+typedef struct {
+  INT4  f;
+  INT4  *gk;
+  INT4  num_max;
+} Hconv_mask_s;
+
+/* 2 dimensional convolution masks                                          */
+typedef struct {
+  HIMGCOOR min_row,max_row;
+  HIMGCOOR min_col,max_col;
+  INT4     norm;
+  INT4     num;
+  HIMGCOOR row[MAX_CONVOL];
+  HIMGCOOR col[MAX_CONVOL];
+  HLINCOOR koor[MAX_CONVOL];
+  INT4     m[MAX_CONVOL];
+} Hconv_mask_2;
+
+/* 1 dimensional convolution masks                                          */
+typedef struct {
+  HIMGCOOR min_col, max_col;
+  INT4     norm;
+  INT4     num;
+  HIMGCOOR col[MAX_CONVOL];
+  INT4     m[MAX_CONVOL];
+} Hconv_mask_1;
+
+
+/* Color (name plus RGB values)                                             */
+typedef struct {
+  HBYTE red;
+  HBYTE green;
+  HBYTE blue;
+  char  name[MAX_COLOR_NAME_LENGTH];
+} Hcolor;
+
+
+
+/****************************************************************************/
+/*                  Extended Line Description (XLD)                         */
+/****************************************************************************/
+
+/****************************************************************************/
+/* XLD-Object Contour                                                       */
+/****************************************************************************/
+
+typedef enum cont_class {
+  cont_unknown,     /* unknown                                              */
+  cont_no_junc,     /* neither start nor end point points are junctions     */
+  cont_start_junc,  /* start point is a junction                            */
+  cont_end_junc,    /* end point is a junction                              */
+  cont_both_junc,   /* both start and end point are junctions               */
+  cont_closed       /* closed contour                                       */
+} Hcont_class;
+
+typedef struct cont_attrib {
+  char     *name;   /* name of the attribute                                */
+  HSUBATTR *val;    /* value of the attribute (per point)                   */
+} Hcont_attrib;
+
+typedef struct cont_global_attrib {
+  char     *name;   /* name of the global attribute                         */
+  HSUBATTR val;     /* value of the attribute (per contour)                 */
+} Hcont_global_attrib;
+
+typedef struct cont_type {
+  HITEMCNT            num;        /* number of points along the contour     */
+  HSUBCOOR            *row;       /* points / row indices (y coordinates)   */
+  HSUBCOOR            *col;       /* points / column indices (x coord.)     */
+  Hcont_class         cont_class; /* contour class                          */
+  INT4                num_attrib; /* number of additional attributes        */
+  Hcont_attrib        *attribs;   /* additional attributes (for each point) */
+  INT4                num_global; /* number of additional global attributes */
+  Hcont_global_attrib *global;    /* additional attributes (per contour)    */
+  INT4                h;          /* auxiliary (temporary)                  */
+} Hcont;
+
+
+/****************************************************************************/
+/* XLD-Objects: polygons                                                    */
+/****************************************************************************/
+
+typedef struct lin_seg_type {
+  HSUBCOOR row, col; /* control points of the polygon                       */
+  HSUBATTR length;   /* length of the line from the cur. to the next point  */
+  HSUBATTR phi;      /* orientation (rad) of this line                      */
+  Hkey  ref;         /* data base key of the underlying contour             */
+  HITEMCNT  first;   /* index of the first point of the underlying contour  */
+  HITEMCNT  last;    /* index of the last contour point                     */
+} Hline_seg;
+
+typedef struct poly_type {
+  HITEMCNT  num_line;  /* number of lines                                   */
+  HITEMCNT  len_line;  /* maximum number of lines (size of the array lines) */
+  Hline_seg *lines;    /* control points of the polygon                     */
+} Hpoly;
+
+
+/****************************************************************************/
+/* XLD-Objects: parallels                                                   */
+/****************************************************************************/
+
+typedef struct para_poly_type {
+  Hkey     poly1;    /* Pointer to 1st polygon of the relation (P1)         */
+  Hkey     poly2;    /* Pointer to 2nd polygon of the relation (P2)         */
+  HITEMCNT first1;   /* Index of the start line segm. of the parallel in P1 */
+  HITEMCNT last1;    /* Index of the end line segment of the parallel in P1 */
+  HITEMCNT first2;   /* Index of the start line segm. of the parallel in P2 */
+  HITEMCNT last2;    /* Index of the end line segment of the parallel in P2 */
+  double   quality;  /* Measure of the degree of parallelism of the polygons*/
+} Hpara_poly;
+
+
+/****************************************************************************/
+/* XLD-Objects parallel object borders                                      */
+/****************************************************************************/
+
+typedef struct mod_para_type {
+  Hkey     poly1;    /* Pointer to 1st polygon of the relation (P1)         */
+  Hkey     poly2;    /* Pointer to 2nd polygon of the relation (P2)         */
+  HITEMCNT first1;   /* Index of the start line segm. of the parallel in P1 */
+  HITEMCNT last1;    /* Index of the end line segment of the parallel in P1 */
+  HITEMCNT first2;   /* Index of the start line segm. of the parallel in P2 */
+  HITEMCNT last2;    /* Index of the end line segment of the parallel in P2 */
+  HSUBATTR first1_dist; /* Half distance of the first line of P1 to P2      */
+  HSUBATTR last1_dist;  /* Half distance of the last line of P1 to P2       */
+  HSUBATTR first2_dist; /* Half distance of the first line of P2 to P1      */
+  HSUBATTR last2_dist;  /* Half distance of the last line of P2 to P1       */
+  INT2  dir1;        /* Position of P1 relative to P2:                      */
+                     /*   dir1 = 1: P2 is to the right of P1                */
+                     /*   dir1 = -1: P2 is to the left of P1                */
+  INT2  dir2;        /* Position of P2 relative to P1:                      */
+                     /*   dir2 = 1: P1 is to the right of P2                */
+                     /*   dir2 = -1: P1 is to the left of P2                */
+} Hmod_para;
+
+/****************************************************************************/
+/* XLD-Objects Extended object borders                                      */
+/****************************************************************************/
+
+typedef struct ext_para_type {
+  Hkey     poly1;    /* Pointer to 1st polygon of the relation (P1)         */
+  Hkey     poly2;    /* Pointer to 2nd polygon of the relation (P2)         */
+  HITEMCNT first1;   /* Index of the start line segm. of the parallel in P1 */
+  HITEMCNT last1;    /* Index of the end line segment of the parallel in P1 */
+  HITEMCNT first2;   /* Index of the start line segm. of the parallel in P2 */
+  HITEMCNT last2;    /* Index of the end line segment of the parallel in P2 */
+} Hext_para;
+
+
+/****************************************************************************/
+/* Homogeneous coordiantes: Hhom_mat_[23]d / Hproj_mat_[23]d                */
+/****************************************************************************/
+typedef double Hhom_mat_2d[2][3];
+typedef double (*H_RESTRICT pHhom_mat_2d)[3]; /* pointer type variant of Hhom_mat_2d   */
+typedef double (*puHhom_mat_2d)[3]; /* unrestricted pointer type variant of Hhom_mat_2d   */
+typedef double Hhom_mat_3d[3][4];
+typedef double (*H_RESTRICT pHhom_mat_3d)[4]; /* pointer type variant of Hhom_mat_3d   */
+typedef double (*puHhom_mat_3d)[4]; /* unrestricted pointer type variant of Hhom_mat_3d   */
+typedef double Hproj_mat_2d[3][3];
+typedef double (*H_RESTRICT pHproj_mat_2d)[3]; /* pointer type variant of Hproj_mat_2d */
+typedef double (*puHproj_mat_2d)[3];         /* unrestricted pointer type variant of Hproj_mat_2d */
+typedef double Hproj_mat_3d[4][4];
+typedef double (*H_RESTRICT pHproj_mat_3d)[4]; /* pointer type variant of Hproj_mat_3d */
+typedef double (*puHproj_mat_3d)[4];         /* unrestricted pointer type variant of Hproj_mat_3d */
+
+
+
+/****************************************************************************/
+/* 1D-Functions                                                             */
+/****************************************************************************/
+
+typedef struct {
+  INT4  num;          /* Number of elements in x and y                      */
+  float *x;           /* Array of the x-values of the function (always set) */
+  float *y;           /* Array of the y-values of the function              */
+  float xmin;         /* Minimum x value (always set)                       */
+  float xmax;         /* Maximum x value (always set)                       */
+  float xdist;        /* Distance of x-values if they are equidistant       */
+  HBOOL is_equidist;  /* Are the x-values equidistant?                      */
+} Hfunction_1d;
+
+
+
+
+/****************************************************************************/
+/*  Parameter passing (inside library and for language interfaces)          */
+/****************************************************************************/
+
+typedef union {
+  INT4_8 *l;                /* 4-8 Byte integer                             */
+  double *f;                /* 8 Byte real                                  */
+  char   *s;                /* Pointer to string                            */
+} DPHpar;                   /* For HALCON/C                                 */
+
+
+typedef union {
+  INT4_8  l;                /* 4-8 Byte integer                             */
+  double  f;                /* 8 Byte real                                  */
+  char    *s;               /* Pointer to string                            */
+} DVHpar;                   /* For HALCON/C                                 */
+
+
+/****************************************************************************/
+/*  Type for callback function for HALCON low level error messages          */
+/****************************************************************************/
+
+#ifndef _WIN32
+#define __stdcall
+#endif
+typedef void  (__stdcall *HLowLevelErrorCallbackProc)(const char *err);
+
+#ifndef HC_NO_STRUCT_MEMBER_ALIGNMENT 
+# pragma pack(pop) /* unset struct member alignment */
+#endif
+#endif

3rdparty/include22/halcon/com/HalconCOM.h

@@ -0,0 +1,236 @@
+/*****************************************************************************
+ * HalconCOM.h
+ ***************************************************************************** 
+ *
+ * Project:     HALCON/COM
+ * Description: Defines, types, and declarations for HALCON/COM,
+ *              required for building COM extension packages
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *               www.mvtec.com 
+ * 
+ *****************************************************************************/
+
+#ifndef HALCON_COM_H
+#define HALCON_COM_H
+
+#include <windows.h>
+#include "HIntDef.h"
+#include "HBase.h"
+#include "HDeclSpec.h"
+#include "HConst.h"
+#include "IPType.h"
+#include "HCtype.h"
+
+/* FindText, CreateMutex, CreateEvent, and DeleteFile are also functions of
+ * the Windows API. They are defines on FindTextW, CreateMutexW, CreateEventW,
+ * and DelteFileW if UNICODE is defined, otherwise they are defines on
+ * FindTextA, CreateMutexA, CreateMutexA, and DeleteFileA.
+ * These defines are undefined here. If you want to use the corresponding
+ * Windows API calls, you must use FindTextA, FindTextW, CreateMutexA,
+ * CreateMutexW, CreateEventA, CreateEventW, DeleteFileA, or DeleteFileW
+ * directly. */
+#undef FindText
+#undef CreateMutex
+#undef CreateEvent
+#undef DeleteFile
+
+/* Error codes */
+
+#define HALCONX_ERR_BASE (0x80040000UL + 2048UL)
+#define HALCONX_COMINT_ERR_BASE (0x80040000UL + 1024UL)
+
+#define HXC_WRONG_INTERFACE (HALCONX_COMINT_ERR_BASE + 1UL)
+#define HXC_CANT_ACCESS_HANDLE (HALCONX_COMINT_ERR_BASE + 2UL)
+#define HXC_SRC_OBJECT_NOT_INITIALIZED (HALCONX_COMINT_ERR_BASE + 3UL)
+#define HXC_TUPLE_CONVERSION_ERROR (HALCONX_COMINT_ERR_BASE + 4UL)
+#define HXC_NULL_POINTER (HALCONX_COMINT_ERR_BASE + 5UL)
+
+#ifndef HALCON_C_H
+
+typedef Hkey     Hobject;     /* ID of iconic HALCON objects    */
+
+typedef struct                /* Tuple representation           */
+{
+  Hcpar   *tuple;
+  INT_PTR length;
+} Htuple;
+
+#define UNDEF_TYPE  (-1)      /* Uninitialized tuple type       */
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/* Prototypes of interface functions */
+
+extern LIntExport char *HMessage_COMInt(Herror message) ;
+
+extern LIntExport Herror 
+HcomPreCall(INT proc_index, Hproc_handle *proc_handle);
+
+extern LIntExport Herror 
+HcomCall(Hproc_handle proc_handle);
+
+extern LIntExport Herror 
+HcomPostCall(Hproc_handle proc_handle,Herror err);
+
+extern LIntExport Herror 
+HcomStoreIO(Hproc_handle proc_handle,INT par,Hobject inObjVar);
+
+extern LIntExport Herror 
+HcomStoreICL(Hproc_handle proc_handle,INT par,Hlong value);
+
+extern LIntExport Herror 
+HcomStoreICD(Hproc_handle proc_handle,INT par,double value);
+
+extern LIntExport Herror 
+HcomStoreICT(Hproc_handle proc_handle,INT par,Htuple value);
+
+extern LIntExport Herror 
+HcomStoreICTOOL(Hproc_handle proc_handle, INT par, Htuple value);
+
+extern LIntExport Herror 
+HcomStoreOO(Hproc_handle proc_handle,INT par,Hobject *outObjVar,Herror err);
+
+extern LIntExport Herror 
+HcomStoreOCL(Hproc_handle proc_handle,INT par, Hlong *outCtrlVar,Herror err);
+
+extern LIntExport Herror 
+HcomStoreOCD(Hproc_handle proc_handle,INT par,double *outCtrlVar,Herror err);
+
+extern LIntExport Herror 
+HcomStoreOCT(Hproc_handle proc_handle,INT par,Htuple *outCtrlVar,Herror err);
+
+extern LIntExport Herror 
+HcomStoreOCTOOL(Hproc_handle proc_handle, INT par, Htuple *outCtrlVar, 
+                Herror err);
+
+/* Higher level signatures based on COM types */
+
+extern LIntExport Herror 
+HcomStoreIOHandleAccess(Hproc_handle proc_handle, INT par, 
+                        CComQIPtr<IHandleAccess, &IID_IHandleAccess> piha);
+
+extern LIntExport Herror 
+HcomStoreOOHandleAccess(Hproc_handle proc_handle, INT par, 
+                       CComQIPtr<IHandleAccess, &IID_IHandleAccess> piha,
+                       Herror errorStatus);
+
+extern LIntExport Herror 
+HcomStoreITOOLHandleAccess(Hproc_handle proc_handle, INT par, 
+                           CComQIPtr<IHandleAccess, &IID_IHandleAccess> piha);
+
+extern LIntExport Herror 
+HcomStoreOTOOLHandleAccess(Hproc_handle proc_handle, INT par,
+                           CComQIPtr<IHandleAccess, &IID_IHandleAccess> piha,
+                           Herror errorStatus);
+
+extern LIntExport Herror 
+HcomStoreICV(Hproc_handle proc_handle, INT par, VARIANT value);
+
+extern LIntExport Herror 
+HcomStoreOCV(Hproc_handle proc_handle, INT par, VARIANT *value, Herror err);
+
+extern LIntExport Herror 
+HcomStoreICBSTR(Hproc_handle proc_handle, INT par, BSTR value);
+
+extern LIntExport Herror 
+HcomStoreOCBSTR(Hproc_handle proc_handle, INT par, BSTR *value, Herror err);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+/* Conversions between tuples and COM data types */
+
+#define VARCONVERT varconvert
+#define TUPLECONVERT tupleconvert
+
+extern LIntExport 
+void varconvert(Htuple *dest, const INT_PTR arg, const char *par_name);
+
+extern LIntExport 
+void varconvert(Htuple *dest, const double arg, const char *par_name);
+
+extern LIntExport 
+void varconvert(Htuple *dest, const BSTR arg, const char *par_name);
+
+extern LIntExport 
+void varconvert(Hctuple *dest, const BSTR arg, const char *par_name);
+
+extern LIntExport 
+void varconvert(Htuple *dest, const VARIANT &arg, const char *par_name);
+
+extern LIntExport 
+void varconvert(Hctuple *dest, const VARIANT &arg, const char *par_name);
+
+extern LIntExport 
+void tupleconvert(Htuple &val, INT_PTR *lVal, char *par_name);
+
+extern LIntExport 
+void tupleconvert(Htuple &val, VARIANT_BOOL *bVal, char *par_name);
+
+extern LIntExport 
+void tupleconvert(Htuple &val, double *dVal, char *par_name);
+
+extern LIntExport 
+void tupleconvert(Htuple &val, BSTR *bstrVal, char *par_name);
+
+extern LIntExport 
+void tupleconvert(Hctuple *val, BSTR *bstrVal, char *par_name);
+
+extern LIntExport 
+void tupleconvert(Htuple &val, VARIANT *varVal, char *par_name);
+
+extern LIntExport 
+void tupleconvert(Hctuple *val, VARIANT *varVal, char *par_name);
+
+class ConversionException
+{
+public:
+  char *msg;
+  ConversionException(char *m)
+  {
+    msg = ::new char [strlen(m)+1];
+    strcpy(msg, m);
+  }
+  ConversionException(const ConversionException &src)
+  {
+    msg = ::new char [strlen(src.msg)+1];
+    strcpy(msg, src.msg);
+  }
+  ~ConversionException(void)
+  {
+    delete [] msg;
+  }
+};
+
+/* Macros for storing object parameters */
+
+#define HCOMSTOREIO(INDEX,NAME) \
+  if (NAME == NULL) \
+    errorStatus = HXC_NULL_POINTER - HALCONX_ERR_BASE; \
+  else \
+  { \
+    CComQIPtr<IHandleAccess, &IID_IHandleAccess> piha(NAME); \
+    errorStatus = HcomStoreIOHandleAccess(ph,INDEX,piha); \
+  }
+
+#ifndef HALCON_COM_INTERNAL_H
+
+#define HCOMSTOREOO(INDEX,NAME,TYPE) \
+  CComQIPtr<I##TYPE, &IID_I##TYPE> p##NAME;                             \
+  p##NAME.CoCreateInstance(L"HalconX." L#TYPE);                         \
+  CComQIPtr<IHandleAccess, &IID_IHandleAccess> pi##NAME(p##NAME);       \
+  errorStatus = HcomStoreOOHandleAccess(ph,INDEX,pi##NAME,errorStatus); \
+  p##NAME->QueryInterface(IID_I##TYPE, (void**)NAME)
+
+#endif
+
+#endif

3rdparty/include22/halcon/com/HalconXimport.h

@@ -0,0 +1,519 @@
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+/* File created by MIDL compiler version 5.01.0164 */
+/* at Sat Feb 26 17:53:32 2000
+ */
+/* Compiler settings for C:\Halcon\source\packages\grayfeat\source\com\HalconXimport.idl:
+    Os (OptLev=s), W1, Zp8, env=Win32, ms_ext, c_ext
+    error checks: allocation ref bounds_check enum stub_data 
+*/
+//@@MIDL_FILE_HEADING(  )
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 440
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif // __RPCNDR_H_VERSION__
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __HalconXimport_h__
+#define __HalconXimport_h__
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+/* Forward Declarations */ 
+
+#ifndef __IHObjectX_FWD_DEFINED__
+#define __IHObjectX_FWD_DEFINED__
+typedef interface IHObjectX IHObjectX;
+#endif  /* __IHObjectX_FWD_DEFINED__ */
+
+
+#ifndef __IHUntypedObjectX_FWD_DEFINED__
+#define __IHUntypedObjectX_FWD_DEFINED__
+typedef interface IHUntypedObjectX IHUntypedObjectX;
+#endif  /* __IHUntypedObjectX_FWD_DEFINED__ */
+
+
+#ifndef __IHandleAccess_FWD_DEFINED__
+#define __IHandleAccess_FWD_DEFINED__
+typedef interface IHandleAccess IHandleAccess;
+#endif  /* __IHandleAccess_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+
+void __RPC_FAR * __RPC_USER MIDL_user_allocate(size_t);
+void __RPC_USER MIDL_user_free( void __RPC_FAR * ); 
+
+#ifndef __IHObjectX_INTERFACE_DEFINED__
+#define __IHObjectX_INTERFACE_DEFINED__
+
+/* interface IHObjectX */
+/* [unique][helpstring][dual][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IHObjectX;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6ebd90c3-d219-11d2-ade5-0000c00f4ef9")
+    IHObjectX : public IDispatch
+    {
+    public:
+    };
+    
+#else   /* C style interface */
+
+#pragma pack(push,8) /* sets the struct member alignment to 8 (default) */
+
+    typedef struct IHObjectXVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( 
+            IHObjectX __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( 
+            IHObjectX __RPC_FAR * This);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( 
+            IHObjectX __RPC_FAR * This);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfoCount )( 
+            IHObjectX __RPC_FAR * This,
+            /* [out] */ UINT __RPC_FAR *pctinfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfo )( 
+            IHObjectX __RPC_FAR * This,
+            /* [in] */ UINT iTInfo,
+            /* [in] */ LCID lcid,
+            /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetIDsOfNames )( 
+            IHObjectX __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
+            /* [in] */ UINT cNames,
+            /* [in] */ LCID lcid,
+            /* [size_is][out] */ DISPID __RPC_FAR *rgDispId);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Invoke )( 
+            IHObjectX __RPC_FAR * This,
+            /* [in] */ DISPID dispIdMember,
+            /* [in] */ REFIID riid,
+            /* [in] */ LCID lcid,
+            /* [in] */ WORD wFlags,
+            /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
+            /* [out] */ VARIANT __RPC_FAR *pVarResult,
+            /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
+            /* [out] */ UINT __RPC_FAR *puArgErr);
+        
+        END_INTERFACE
+    } IHObjectXVtbl;
+
+#pragma pack(pop)
+
+    interface IHObjectX
+    {
+        CONST_VTBL struct IHObjectXVtbl __RPC_FAR *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IHObjectX_QueryInterface(This,riid,ppvObject) \
+    (This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
+
+#define IHObjectX_AddRef(This)  \
+    (This)->lpVtbl -> AddRef(This)
+
+#define IHObjectX_Release(This) \
+    (This)->lpVtbl -> Release(This)
+
+
+#define IHObjectX_GetTypeInfoCount(This,pctinfo)  \
+    (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo)
+
+#define IHObjectX_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
+    (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo)
+
+#define IHObjectX_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
+    (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
+
+#define IHObjectX_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
+    (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)
+
+
+#endif /* COBJMACROS */
+
+
+#endif  /* C style interface */
+
+
+
+
+#endif  /* __IHObjectX_INTERFACE_DEFINED__ */
+
+
+#ifndef __IHUntypedObjectX_INTERFACE_DEFINED__
+#define __IHUntypedObjectX_INTERFACE_DEFINED__
+
+/* interface IHUntypedObjectX */
+/* [unique][helpstring][dual][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IHUntypedObjectX;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6ebd90c4-d219-11d2-ade5-0000c00f4ef9")
+    IHUntypedObjectX : public IDispatch
+    {
+    public:
+    };
+    
+#else   /* C style interface */
+
+#pragma pack(push,8) /* sets the struct member alignment to 8 (default) */
+
+    typedef struct IHUntypedObjectXVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( 
+            IHUntypedObjectX __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( 
+            IHUntypedObjectX __RPC_FAR * This);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( 
+            IHUntypedObjectX __RPC_FAR * This);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfoCount )( 
+            IHUntypedObjectX __RPC_FAR * This,
+            /* [out] */ UINT __RPC_FAR *pctinfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfo )( 
+            IHUntypedObjectX __RPC_FAR * This,
+            /* [in] */ UINT iTInfo,
+            /* [in] */ LCID lcid,
+            /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetIDsOfNames )( 
+            IHUntypedObjectX __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
+            /* [in] */ UINT cNames,
+            /* [in] */ LCID lcid,
+            /* [size_is][out] */ DISPID __RPC_FAR *rgDispId);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Invoke )( 
+            IHUntypedObjectX __RPC_FAR * This,
+            /* [in] */ DISPID dispIdMember,
+            /* [in] */ REFIID riid,
+            /* [in] */ LCID lcid,
+            /* [in] */ WORD wFlags,
+            /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
+            /* [out] */ VARIANT __RPC_FAR *pVarResult,
+            /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
+            /* [out] */ UINT __RPC_FAR *puArgErr);
+        
+        END_INTERFACE
+    } IHUntypedObjectXVtbl;
+
+#pragma pack(pop)
+
+    interface IHUntypedObjectX
+    {
+        CONST_VTBL struct IHUntypedObjectXVtbl __RPC_FAR *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IHUntypedObjectX_QueryInterface(This,riid,ppvObject)  \
+    (This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
+
+#define IHUntypedObjectX_AddRef(This) \
+    (This)->lpVtbl -> AddRef(This)
+
+#define IHUntypedObjectX_Release(This)  \
+    (This)->lpVtbl -> Release(This)
+
+
+#define IHUntypedObjectX_GetTypeInfoCount(This,pctinfo) \
+    (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo)
+
+#define IHUntypedObjectX_GetTypeInfo(This,iTInfo,lcid,ppTInfo)  \
+    (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo)
+
+#define IHUntypedObjectX_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)  \
+    (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
+
+#define IHUntypedObjectX_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)  \
+    (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)
+
+
+#endif /* COBJMACROS */
+
+
+#endif  /* C style interface */
+
+
+
+
+#endif  /* __IHUntypedObjectX_INTERFACE_DEFINED__ */
+
+
+#ifndef __IHandleAccess_INTERFACE_DEFINED__
+#define __IHandleAccess_INTERFACE_DEFINED__
+
+/* interface IHandleAccess */
+/* [unique][helpstring][dual][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IHandleAccess;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6ebd90d2-d219-11d2-ade5-0000c00f4ef9")
+    IHandleAccess : public IDispatch
+    {
+    public:
+        virtual /* [helpstring][hidden][id] */ HRESULT STDMETHODCALLTYPE HandleAccess( 
+            /* [retval][out] */ long __RPC_FAR *rVal) = 0;
+        
+        virtual /* [helpstring][hidden][id] */ HRESULT STDMETHODCALLTYPE HandleEnterCriticalSection( void) = 0;
+        
+        virtual /* [helpstring][hidden][id] */ HRESULT STDMETHODCALLTYPE HandleLeaveCriticalSection( void) = 0;
+        
+        virtual /* [helpstring][hidden][id] */ HRESULT STDMETHODCALLTYPE HandleCleanUp( 
+            /* [in] */ BOOL CallDestructor) = 0;
+        
+        virtual /* [helpstring][id] */ HRESULT STDMETHODCALLTYPE HandleIsValid( 
+            /* [retval][out] */ long __RPC_FAR *isValid) = 0;
+        
+    };
+    
+#else   /* C style interface */
+
+#pragma pack(push,8)
+
+    typedef struct IHandleAccessVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( 
+            IHandleAccess __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( 
+            IHandleAccess __RPC_FAR * This);
+        
+        ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( 
+            IHandleAccess __RPC_FAR * This);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfoCount )( 
+            IHandleAccess __RPC_FAR * This,
+            /* [out] */ UINT __RPC_FAR *pctinfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetTypeInfo )( 
+            IHandleAccess __RPC_FAR * This,
+            /* [in] */ UINT iTInfo,
+            /* [in] */ LCID lcid,
+            /* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo);
+        
+        HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetIDsOfNames )( 
+            IHandleAccess __RPC_FAR * This,
+            /* [in] */ REFIID riid,
+            /* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
+            /* [in] */ UINT cNames,
+            /* [in] */ LCID lcid,
+            /* [size_is][out] */ DISPID __RPC_FAR *rgDispId);
+        
+        /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Invoke )( 
+            IHandleAccess __RPC_FAR * This,
+            /* [in] */ DISPID dispIdMember,
+            /* [in] */ REFIID riid,
+            /* [in] */ LCID lcid,
+            /* [in] */ WORD wFlags,
+            /* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
+            /* [out] */ VARIANT __RPC_FAR *pVarResult,
+            /* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
+            /* [out] */ UINT __RPC_FAR *puArgErr);
+        
+        /* [helpstring][hidden][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *HandleAccess )( 
+            IHandleAccess __RPC_FAR * This,
+            /* [retval][out] */ long __RPC_FAR *rVal);
+        
+        /* [helpstring][hidden][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *HandleEnterCriticalSection )( 
+            IHandleAccess __RPC_FAR * This);
+        
+        /* [helpstring][hidden][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *HandleLeaveCriticalSection )( 
+            IHandleAccess __RPC_FAR * This);
+        
+        /* [helpstring][hidden][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *HandleCleanUp )( 
+            IHandleAccess __RPC_FAR * This,
+            /* [in] */ BOOL CallDestructor);
+        
+        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *HandleIsValid )( 
+            IHandleAccess __RPC_FAR * This,
+            /* [retval][out] */ long __RPC_FAR *isValid);
+        
+        END_INTERFACE
+    } IHandleAccessVtbl;
+
+#pragma pack(pop)
+
+    interface IHandleAccess
+    {
+        CONST_VTBL struct IHandleAccessVtbl __RPC_FAR *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IHandleAccess_QueryInterface(This,riid,ppvObject) \
+    (This)->lpVtbl -> QueryInterface(This,riid,ppvObject)
+
+#define IHandleAccess_AddRef(This)  \
+    (This)->lpVtbl -> AddRef(This)
+
+#define IHandleAccess_Release(This) \
+    (This)->lpVtbl -> Release(This)
+
+
+#define IHandleAccess_GetTypeInfoCount(This,pctinfo)  \
+    (This)->lpVtbl -> GetTypeInfoCount(This,pctinfo)
+
+#define IHandleAccess_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
+    (This)->lpVtbl -> GetTypeInfo(This,iTInfo,lcid,ppTInfo)
+
+#define IHandleAccess_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
+    (This)->lpVtbl -> GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId)
+
+#define IHandleAccess_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
+    (This)->lpVtbl -> Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr)
+
+
+#define IHandleAccess_HandleAccess(This,rVal) \
+    (This)->lpVtbl -> HandleAccess(This,rVal)
+
+#define IHandleAccess_HandleEnterCriticalSection(This)  \
+    (This)->lpVtbl -> HandleEnterCriticalSection(This)
+
+#define IHandleAccess_HandleLeaveCriticalSection(This)  \
+    (This)->lpVtbl -> HandleLeaveCriticalSection(This)
+
+#define IHandleAccess_HandleCleanUp(This,CallDestructor)  \
+    (This)->lpVtbl -> HandleCleanUp(This,CallDestructor)
+
+#define IHandleAccess_HandleIsValid(This,isValid) \
+    (This)->lpVtbl -> HandleIsValid(This,isValid)
+
+#endif /* COBJMACROS */
+
+
+#endif  /* C style interface */
+
+
+
+/* [helpstring][hidden][id] */ HRESULT STDMETHODCALLTYPE IHandleAccess_HandleAccess_Proxy( 
+    IHandleAccess __RPC_FAR * This,
+    /* [retval][out] */ long __RPC_FAR *rVal);
+
+
+void __RPC_STUB IHandleAccess_HandleAccess_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [helpstring][hidden][id] */ HRESULT STDMETHODCALLTYPE IHandleAccess_HandleEnterCriticalSection_Proxy( 
+    IHandleAccess __RPC_FAR * This);
+
+
+void __RPC_STUB IHandleAccess_HandleEnterCriticalSection_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [helpstring][hidden][id] */ HRESULT STDMETHODCALLTYPE IHandleAccess_HandleLeaveCriticalSection_Proxy( 
+    IHandleAccess __RPC_FAR * This);
+
+
+void __RPC_STUB IHandleAccess_HandleLeaveCriticalSection_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [helpstring][hidden][id] */ HRESULT STDMETHODCALLTYPE IHandleAccess_HandleCleanUp_Proxy( 
+    IHandleAccess __RPC_FAR * This,
+    /* [in] */ BOOL CallDestructor);
+
+
+void __RPC_STUB IHandleAccess_HandleCleanUp_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+/* [helpstring][id] */ HRESULT STDMETHODCALLTYPE IHandleAccess_HandleIsValid_Proxy( 
+    IHandleAccess __RPC_FAR * This,
+    /* [retval][out] */ long __RPC_FAR *isValid);
+
+
+void __RPC_STUB IHandleAccess_HandleIsValid_Stub(
+    IRpcStubBuffer *This,
+    IRpcChannelBuffer *_pRpcChannelBuffer,
+    PRPC_MESSAGE _pRpcMessage,
+    DWORD *_pdwStubPhase);
+
+
+
+#endif  /* __IHandleAccess_INTERFACE_DEFINED__ */
+
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rdparty/include22/halcon/com/HalconXimport.idl

@@ -0,0 +1,63 @@
+/*****************************************************************************
+ * HalconXimport.idl
+ ***************************************************************************** 
+ *
+ * Project:     HALCON/COM
+ * Description: Interfaces required for building COM extension packages
+ *
+ * (c) 1996-2020 by MVTec Software GmbH
+ *               www.mvtec.com 
+ * 
+ *****************************************************************************/
+
+import "oaidl.idl";
+import "ocidl.idl";
+
+// Interface: IHObjectX
+[
+  object,
+  uuid(6ebd90c3-d219-11d2-ade5-0000c00f4ef9),
+  dual,
+  helpstring("Instance of an iconic object. Base class for HImage, HRegion,..."),
+  pointer_default(unique)
+]
+interface IHObjectX : IDispatch
+{
+}
+
+// Interface: IHUntypedObjectX
+[
+  object,
+  uuid(6ebd90c4-d219-11d2-ade5-0000c00f4ef9),
+  dual,
+  helpstring("weak typed data type for object parameters."),
+  pointer_default(unique)
+]
+interface IHUntypedObjectX : IDispatch
+{
+}
+
+
+
+// Interface: IHandleAccess
+[
+  object,
+  uuid(6ebd90d2-d219-11d2-ade5-0000c00f4ef9),
+  dual,
+  helpstring("interface for accessing the handle"),
+  pointer_default(unique)
+]
+interface IHandleAccess : IDispatch
+{
+    [id(0), hidden, helpstring("read out the handle...")]
+        HRESULT HandleAccess([out, retval] long *rVal);
+    [id(1), hidden, helpstring("set the semaphore")]
+        HRESULT HandleEnterCriticalSection();
+    [id(2), hidden, helpstring("release the semaphore")]
+        HRESULT HandleLeaveCriticalSection();
+    [id(3), hidden, helpstring("call the class destructor")]
+        HRESULT HandleCleanUp([in] BOOL CallDestructor);
+    [id(4), helpstring("check handle - is the object valid?")]
+        HRESULT HandleIsValid([out, retval] long *isValid);
+}
+

3rdparty/include22/halcon/com/HalconXimport_i.c

@@ -0,0 +1,54 @@
+/* this file contains the actual definitions of */
+/* the IIDs and CLSIDs */
+
+/* link this file in with the server and any clients */
+
+
+/* File created by MIDL compiler version 5.01.0164 */
+/* at Sat Feb 26 17:53:32 2000
+ */
+/* Compiler settings for C:\Halcon\source\packages\grayfeat\source\com\HalconXimport.idl:
+    Os (OptLev=s), W1, Zp8, env=Win32, ms_ext, c_ext
+    error checks: allocation ref bounds_check enum stub_data 
+*/
+//@@MIDL_FILE_HEADING(  )
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+#ifndef __IID_DEFINED__
+#define __IID_DEFINED__
+
+#pragma pack(push,8) /* sets the struct member alignment to 8 bytes (default)*/
+
+typedef struct _IID
+{
+    unsigned long x;
+    unsigned short s1;
+    unsigned short s2;
+    unsigned char  c[8];
+} IID;
+
+#pragma pack(pop)
+
+#endif // __IID_DEFINED__
+
+#ifndef CLSID_DEFINED
+#define CLSID_DEFINED
+typedef IID CLSID;
+#endif // CLSID_DEFINED
+
+const IID IID_IHObjectX = {0x6ebd90c3,0xd219,0x11d2,{0xad,0xe5,0x00,0x00,0xc0,0x0f,0x4e,0xf9}};
+
+
+const IID IID_IHUntypedObjectX = {0x6ebd90c4,0xd219,0x11d2,{0xad,0xe5,0x00,0x00,0xc0,0x0f,0x4e,0xf9}};
+
+
+const IID IID_IHandleAccess = {0x6ebd90d2,0xd219,0x11d2,{0xad,0xe5,0x00,0x00,0xc0,0x0f,0x4e,0xf9}};
+
+
+#ifdef __cplusplus
+}
+#endif
+

3rdparty/include22/halcon/halconc/Hdevthread.h

@@ -0,0 +1,208 @@
+/*****************************************************************************
+ * Hdevthread.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/C
+ * Description: generic HALCON/C thread interface for hdevelop's HALCON/C
+ *              export (for internal use only, signatures and functionality 
+ *              may change )
+ *
+ * (c) 2014-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ ****************************************************************************/
+
+#ifndef HDEVTHREAD_H
+#define HDEVTHREAD_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+typedef Hlong Hdevthread;
+typedef Hlong Hdevthread_context;
+#define HDEVTHREAD_UNDEF          0
+#define HDEVTHREAD_CONTEXT_UNDEF  0
+
+/**************************************************************************
+ * HALCON/C Hdevthread interface
+ * This interface is for HDevelop C-Export only!
+ **************************************************************************/
+
+/* A thread context marks for the started thread the period the father
+ * (=caller) thread stays within the function in which the thread was
+ * started. This period is equivalent to the period the output parameters of
+ * procedure started within a thread are valid. I.e., a thread has to be
+ * joined in the function where it was started if the output parameters
+ * should be used.
+ * The procedure that is starting a thread has to call create_hdevthread_context
+ * after entering (at least before starting the first thread).
+ * clear_hdevthread_contex must be called before leaving the calling procedure,
+ * but at least after the last join call within this procedure (if present).
+ */
+LIntExport Herror
+create_hdevthread_context( Hdevthread_context *H_RESTRICT context_handle);
+LIntExport Herror
+clear_hdevthread_context( Hdevthread_context context_handle);
+
+/* create_hdevthread allocates and initializes a HALCON/C thread handle
+ * 'hthread_handle'. This handle will hold the input and output parameters
+ * of the procedure that should be called as thread. Therefore, the basic
+ * address of this procedure is passed in 'proc' (arbitrary sequence of
+ * input/output HALCON/C types, return type void). Accordingly, the total
+ * number of input object parameters (iop_num), output object parameters
+ * (oop_num), input vector parameters (ivp_num), output vector parameters
+ * (ovp_num), input control parameters (icp_num) and output control
+ * parameters (ocp_num) of the procedure is passed. The thread instance will
+ * be owned  by the started thread and needn't be cleared by the calling
+ * thread. */
+LIntExport Herror
+create_hdevthread( Hdevthread_context const context_handle, void const *proc,
+                   Hlong ip_num, Hlong op_num,
+                   Hdevthread *H_RESTRICT hthread_handle);
+
+/* exit thread is called at the end of the thread's execution and clears
+ * the hthread handle. */
+LIntExport Herror
+exit_hdevthread( Hdevthread hthread_handle);
+
+/* clear_hdevthread frees all data hold by the hthread handle. Generally,
+ * it will be called by exit_hdevthread implicitly and needn't be called
+ * explicitly. */
+LIntExport Herror
+clear_hdevthread( Hdevthread hthread_handle);
+
+/* -------------------------------------------------------------------
+ * Functions to set the input/output parameters of the procedure 'proc'
+ * within the father thread before starting the new (child) thread:
+ * -------------------------------------------------------------------*/
+/* set_hdevthread_iop sets a input object parameter of the procedure that should
+ * be started as a thread. The object parameter
+ * is copied (lazy copy). parpos denotes the x-th occurrence of an input
+ * object parameter within the signature of proc, starting with 0.*/
+LIntExport Herror
+set_hdevthread_iop( Hdevthread hthread_handle, Hlong parpos, Hobject const obj);
+
+/* set_hdevthread_oop sets a reference on a output object parameter of the
+ * procedure that should be started as a thread. parpos denotes the x-th
+ * occurrence of an output object parameter within the signature of proc,
+ * starting with 0.*/
+LIntExport Herror
+bind_hdevthread_oop( Hdevthread hthread_handle, Hlong parpos, HBOOL glb_flag,
+                     Hobject *obj);
+
+/* set_hdevthread_ivp sets a input vector parameter (Hvector) of the procedure
+ * that should be started as a thread. The input parameter is copied
+ * (deep copy). parpos denotes the x-th occurrence of the input vector
+ * parameter within the signature of proc, starting with 0.*/
+LIntExport Herror
+set_hdevthread_ivp( Hdevthread hthread_handle, Hlong parpos, 
+                    Hvector const vector);
+
+/* set_hdevthread_ovp sets the reference on a output vector parameter (Hvector*)
+ * of the procedure that should be started as a thread. If a sub vector
+ * should be set, the reference of the original vector is passed in  vector,
+ * the indices of the sub vector are passed in vec_idx.
+ * parpos denotes the x-th occurrence of the output vector
+ * parameter within the signature of proc, starting with 0.*/
+LIntExport Herror
+bind_hdevthread_ovp( Hdevthread hthread_handle, Hlong parpos, HBOOL glb_flag,
+                     Hvector *vector, Htuple const vec_idx);
+
+/* set_hdevthread_icp sets a input control parameter (Htuple) of the procedure
+ * that should be started as a thread. The control parameter is copied
+ * (deep copy). parpos denotes the x-th occurrence of the input
+ * control parameter within the signature of proc, starting with 0.*/
+LIntExport Herror
+set_hdevthread_icp( Hdevthread hthread_handle, Hlong parpos,
+                    Htuple const tpl);
+
+/* bind_hdevthread_ocp sets a reference on a output control parameter (Htuple*)
+ * of the procedure that should be started as a thread.
+ * parpos denotes the x-th
+ * occurrence of an output control parameter within the signature of proc,
+ * starting with 0.*/
+LIntExport Herror
+bind_hdevthread_ocp( Hdevthread hthread_handle, Hlong parpos, HBOOL glb_flag,
+                     Htuple *H_RESTRICT tpl);
+
+/* -------------------------------------------------------------------
+ * Functions to set the input/output parameters of the procedure 'proc'
+ * within the child thread:
+ * -------------------------------------------------------------------*/
+/* get_hdevthread_iop returns a reference on the copied object set with
+ * set_hdevthread_iop. */
+LIntExport Herror
+get_hdevthread_iop( Hdevthread const hthread_handle, Hlong parpos,
+                    Hobject *H_RESTRICT* obj);
+
+/* overwrite_hdevthread_oop writes back the output object parameter on the
+ * reference passed in set_hdevthread_oop. */
+LIntExport Herror
+store_hdevthread_oop( Hdevthread hthread_handle,Hlong parpos,Hobject const obj);
+
+/* get_hdevthread_ivp returns a reference on the copied vector parameter
+ * set with set_hdevthread_ivp. */
+LIntExport Herror
+get_hdevthread_ivp( Hdevthread const hthread_handle,
+                    Hlong parpos, Hvector *H_RESTRICT* vec);
+
+/* store_hdevthread_ovp writes back the output (sub) vector parameter
+ * (generated with create_hdevthread_ovp) on the reference passed in
+ * set_hdevthread_ovp. */
+LIntExport Herror
+store_hdevthread_ovp( Hdevthread hthread_handle, Hlong parpos,
+                      Hvector const vector);
+
+/* get_hdevthread_icp returns a reference on the copied tuple control parameter
+ * set with set_hdevthread_icp. */
+LIntExport Herror
+get_hdevthread_icp( Hdevthread const hthread_handle,
+                    Hlong parpos, Htuple *H_RESTRICT* tpl);
+
+/* store_hdevthread_ocp writes back the output control parameter on the
+ * reference passed in set_hdevthread_ocp. */
+LIntExport Herror
+store_hdevthread_ocp( Hdevthread hthread_handle, Hlong parpos,
+		      Htuple const tpl);
+
+/* start_hdevthread is called by the father thread to start the thread after
+ * the parameters are set. Contrary to par_start_hdevthread, start_hdevthread can
+ * be used when no thread has to join with the started thread. No thread id
+ * is returned, therefore.
+ * Attention: Different to HDevelop, the child thread must not run anymore
+ * when exiting the program or unloading the HALCON library. Violating this
+ * rule might lead to a segmentation fault on exit/unload,
+ *  especially on unix systems. */
+LIntExport Herror
+start_hdevthread( Hdevthread const hthread_handle);
+
+/* par_start_hdevthread is called by the father thread to start the thread after
+ * the parameters are set. Contrary to start_thread, a thread id (par_handle)
+ * is returned that can be used by par_join to wait for the started thread
+ * exiting.
+ * Attention: Different to HDevelop, the child thread must not run anymore
+ * when exiting the program or unloading the HALCON library. Violating this
+ * rule might lead to a segmentation fault on exit/unload,
+ *  especially on unix systems. */
+LIntExport Herror
+par_start_hdevthread( Hdevthread const hthread_handle,
+                      Htuple *H_RESTRICT par_handle);
+
+/* call_hdevthread_proc calls the procedure specified in create_hdevthread
+ * synchronously. This must be used for synchronous procedure calls, when
+ * the procedure was started as thread with the same output parameters within
+ *  the same hthread context.  */
+LIntExport Herror
+call_hdevthread_proc( Hdevthread const hthread_handle);
+
+/* T_par_join_hdevthread waits until all threads addressed by their thread id in
+ * par_handle finished. */
+LIntExport Herror
+T_par_join_hdevthread( Htuple const par_handles);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

3rdparty/include22/halcon/halconc/Hvector.h

@@ -0,0 +1,225 @@
+/*****************************************************************************
+ * Hvector.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/C
+ * Description: HALCON/C implementation of HDevelop vectors
+ *
+ * (c) 2014-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ ****************************************************************************/
+
+#ifndef HVECTOR_H
+#define HVECTOR_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/*
+ * The data structure Hvector is used to the vector functionality of the
+ * hdevelop language. Creating, access and deletion must only be done with the
+ * supplied procedures.
+ */
+typedef Hlong Hvector; /* Handle implementation of vector */
+typedef enum {
+  eVector=0x05EC0000,eTupleVector,eTupleLeaf,eObjectVector,eObjectLeaf
+} Hvectype;
+
+#define HVECTOR_UNDEF 0
+
+/**************************************************************************
+ * Hvector functionality
+ *************************************************************************/
+
+/* create_obj_vector creates an empty vector of dimension dim. The vector is
+ * returned in vec and can contain objects only.*/
+LIntExport Herror V_create_obj_vector(Hlong dim, Hvector *H_RESTRICT vec);
+
+/* create_tuple_vector creates an empty vector of dimension dim. The vector is
+ * returned in vec and can contain tuples only.*/
+LIntExport Herror V_create_tuple_vector(Hlong dim, Hvector *H_RESTRICT vec);
+
+/* destroy_vector frees the vector, its subvectors and leafs of any type and
+ * dimension. */
+LIntExport Herror V_destroy_vector(Hvector vec);
+
+/* copy_vector returns a copy of src in dest. Deep copy is performed. */
+LIntExport Herror V_copy_vector(Hvector const src, Hvector *H_RESTRICT dest);
+
+/* set_vector_elem sets a sub vector subvec in vector vec. Therefore,
+ * index addresses a sub vector that gets replaced by subvec. The old sub
+ * vector is freed if existing. Otherwise, vec is extended accordingly (and
+ * initialized with empty elements) to fulfill index.(self modifying)
+ * Precondition: type(subvec) == type(vec) && dim(vec) == dim(subvec)+|index|
+ */
+LIntExport Herror V_set_vector_elem(Hvector vec, Htuple const vec_idx,
+                                    Hvector const subvec);
+
+/* set_vector_obj sets a iconic object obj in vector vec. Therefore,
+ * vec_idx addresses an object in vec that gets replaced by obj. The old
+ * iconic object in vec is freed if existing. Otherwise, vec is extended
+ * accordingly (and initialized with empty elements) to fulfill vec_idx.(self
+ * modifying)
+ * Precondition: type(vec) == eObjectVector && dim(vec) == dim(subvec)+|index|
+ */
+LIntExport Herror V_set_vector_obj(Hobject const obj, Hvector vec,
+                                   Htuple const vec_idx);
+
+/* set_vector_tuple sets a tuple tpl in vector vec. Therefore,
+ * vec_idx addresses a tuple in vec that gets replaced by obj. The old tuple
+ * in vec is freed if existing. Otherwise, vec is extended accordingly (and
+ * initialized with empty elements) to fulfill vec_idx.(self modifying)
+ * Precondition: type(vec) == eTupleVector && dim(vec) == |index|
+ */
+LIntExport Herror V_set_vector_tuple(Hvector vec, Htuple const vec_idx,
+                                     Htuple const tpl);
+
+/* set_vector_tuple_elem executes a self modifying tuple_replace in the indexed
+ * tuple in vec. vec_idx is a tuple of n=dim elements and indexes the tuple
+ * in vec. tpl_idx contains the tuple indices to be replaced. val contains
+ * the values to set.
+ * If the length of any sub vector indexed by vec_idx is not sufficient,
+ * set_vector_tuple_elem extends it automatically (initialized with empty
+ * elements).
+ * Precondition: type(vec) == eTupleVector && dim(vec) == |vec_idx|. */
+LIntExport Herror V_set_vector_tuple_elem(Hvector vec, Htuple const vec_idx,
+                                          Htuple const tpl_idx, 
+                                          Htuple const val);
+
+
+/* get_vector_elem returns a copy of the sub vector of vec at index. The
+ * error H_ERR_WIPV2 is returned if any value of index addresses an element
+ * of a sub vector of vec beyond its length.
+ * Remark: dim(subvec) = dim(vec)-|index|
+ *         type(subvec) = type(vec) */
+LIntExport Herror V_get_vector_elem(Hvector const vec, Htuple const index,
+                                    Hvector *H_RESTRICT subvec);
+
+/* get_vector_obj returns a copy of an iconic object of vec at index. The
+ * error H_ERR_WIPV2 is returned if any value of index addresses an element of a
+ * sub vector of vec beyond its length.
+ * Precondition: dim(vec) == |index| && type(vec) == eObjectVector */
+LIntExport Herror V_get_vector_obj(Hobject *H_RESTRICT obj, Hvector const vec,
+                                   Htuple const index);
+
+/* get_vector_tuple returns a copy of a tuple of vector vec at index. The
+ * error H_ERR_WIPV2 is returned if any value of index addresses an element of
+ * a sub vector of vec beyond its length.
+ * Precondition: dim(vec) == |index| && type(vec) == eTupleVector */
+LIntExport Herror V_get_vector_tuple( Hvector const vec, Htuple const index,
+                                      Htuple *H_RESTRICT tpl);
+
+
+/* concat_vector appends vec2 at vec1 and returns the concatenated vector in
+ * concat. vec1 and vec2 have to be of same dimension and type. */
+LIntExport Herror V_concat_vector(Hvector const vec1, Hvector const vec2,
+                                  Hvector *H_RESTRICT vec_concat);
+
+/* insert_vector_elem inserts a vector ins at position ins_idx into a
+ * sub vector of vec, indexed by vec_idx.
+ * Different to set_vector_elem, the length of the sub vector indexed by
+ * vec_idx gets increased by one. (self modifying)
+ * Precondition: dim(vec) == dim(ins)+|vec_ins|
+ *               type(ins) == type(vec)
+ *               |ins_idx| == 1 */
+LIntExport Herror V_insert_vector_elem(Hvector vec, Htuple const vec_idx,
+                                       Htuple const ins_idx,
+                                       Hvector const ins);
+
+/* remove_vector_elem is the counterpart of insert_vector_elem. It frees all
+ * contents at position rmv_idx of a sub vector indexed by vec_idx.
+ * If the sub vector indexed by vec_idx does not exist, it gets created.
+ * The length of the sub vector indexed by vec_idx gets decreased by one,
+ * when rmv_idx is smaller than the length of the sub vector. (self modifying)
+ * Precondition: dim(vec)>=|vec_idx| */
+LIntExport Herror V_remove_vector_elem(Hvector vec, Htuple const vec_idx,
+                                       Htuple const rmv_idx);
+
+/* clear_vector frees all contents of a sub vector of vec and makes it empty.
+ * The sub vector is indexed by 'index'. Type and dimension of the sub
+ * vector remain. (self modifying)
+ * Precondition: dim(vec)>=|index| */
+LIntExport Herror V_clear_vector(Hvector vec, Htuple const index);
+
+/* insert_vector_obj inserts an iconic object obj at position ins_idx into a
+ * sub vector of vec, indexed by vec_idx.
+ * Different to set_vector_obj, the length of the sub vector indexed by
+ * vec_idx gets increased by one. (self modifying)
+ * Precondition: dim(vec) == |vec_ins|
+ *               type(vec) == eObjectVector
+ *               |ins_idx| == 1 */
+LIntExport Herror V_insert_vector_obj(Hobject const obj, Hvector vec,
+                                      Htuple const vec_idx,Htuple const ins_idx);
+
+/* insert_vector_tupel inserts a tuple tpl at position ins_idx into a
+ * sub vector of vec, indexed by vec_idx.
+ * Different to set_vector_tuple, the length of the sub vector indexed by
+ * vec_idx gets increased by one. (self modifying)
+ * Precondition: dim(vec) == |vec_ins|
+ *               type(vec) == eTupleVector
+ *               |ins_idx| == 1 */
+LIntExport Herror V_insert_vector_tuple(Hvector vec, Htuple const vec_idx,
+                                        Htuple const ins_idx, Htuple const tpl);
+
+/* convert_vector_to_tuple concatenates the tuple leafs of a tuple vector
+ * vec  into one tuple tpl.
+ * Precondition: type(vec) == eTupleVector */
+LIntExport Herror V_convert_vector_to_tuple( Hvector const vec, 
+                                             Htuple *H_RESTRICT tpl);
+
+/* convert_tuple_to_vector_1d separates the tuple elements of tpl according
+ * to the length values in lengths into new sub tuples and generates a new
+ * tuple vector vec with all these tuples as leafs. If lengths contains only
+ * one value, tpl is separated into tuples of the same length (with the last
+ * tuple containing the residuum).
+ * Precondition: |lengths|==1 || sum(lengths)==|tpl|
+ *   dim(vec)=1, type(vec)=eTupleVector */
+LIntExport Herror V_convert_tuple_to_vector_1d( Htuple const tpl,
+                                                Htuple const lengths,
+                                                Hvector *H_RESTRICT vec);
+
+/* vector_equal returns TRUE if both vectors are identic. I.e.
+ * both vectors have the same 'tree', the same type, and test_equal_obj
+ * (tuple_equal, respectively) is true for all leafs. Else, equal is set
+ * to FALSE.*/
+LIntExport Herror V_vector_equal(Hvector const vec1, Hvector const vec2,
+                                 HBOOL *H_RESTRICT equal);
+
+/* vector_dim returns the dimensionality of the vector vec */
+LIntExport Herror V_vector_dim(Hvector const vec, Hlong *H_RESTRICT dim);
+
+/* vector type returns the type of the vector. eTupleVector, eObjectVector
+ * are possible values */
+LIntExport Herror V_vector_type(Hvector const vec, Hvectype *H_RESTRICT type);
+
+/* vector_length returns the number of elements in vec */
+LIntExport Herror V_vector_length(Hvector const vec,
+                                  Hlong *H_RESTRICT length);
+
+/* V_sub_vector_length returns the number of elements of a sub vector of vec,
+ * indexed by vec_idx. Passing an empty tuple for vec_idx receives the same 
+ * result as V_vector_length. */
+LIntExport Herror V_sub_vector_length(Hvector const vec, Htuple const vec_idx,
+                                      Hlong *H_RESTRICT length);
+
+/* Some printf auxiliary functions for debug support. They allow to transform
+ * the basic HALCON/C data types into readable strings.
+ * str points to a pre-allocated buffer of size bytes.
+ * Upon successful completion, the Hsnprintf_* functions shall return the
+ * number of bytes that would be written to str had size been sufficiently
+ * large excluding the terminating null byte. If an output error was
+ * encountered, these functions shall return a negative value.*/
+LIntExport int Hsnprintf_Hvector( char *H_RESTRICT str, Hlong size,
+                                  Hvector const vec);
+LIntExport int Hsnprintf_Htuple( char *H_RESTRICT str, Hlong size,
+                                  Htuple const tpl);
+LIntExport int Hsnprintf_Hobject( char *H_RESTRICT str, Hlong size,
+                                  Hobject const obj);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

3rdparty/include22/halcon/halconcpp/HBarCode.h

@@ -0,0 +1,317 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HBARCODE
+#define HCPP_HBARCODE
+
+namespace HalconCpp
+{
+
+// Represents an instance of a bar code reader.
+class LIntExport HBarCode : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HBarCode():HHandle() {}
+
+  // Copy constructor
+  HBarCode(const HBarCode& source) : HHandle(source) {}
+
+  // Copy constructor
+  HBarCode(const HHandle& handle);
+
+  // Create HBarCode from handle, taking ownership
+  explicit HBarCode(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('barcode')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HBarCode Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_bar_code_model: Read a bar code model from a file and create a new model.
+  explicit HBarCode(const HString& FileName);
+
+  // read_bar_code_model: Read a bar code model from a file and create a new model.
+  explicit HBarCode(const char* FileName);
+
+#ifdef _WIN32
+  // read_bar_code_model: Read a bar code model from a file and create a new model.
+  explicit HBarCode(const wchar_t* FileName);
+#endif
+
+  // create_bar_code_model: Create a model of a bar code reader.
+  explicit HBarCode(const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // create_bar_code_model: Create a model of a bar code reader.
+  explicit HBarCode(const HString& GenParamName, double GenParamValue);
+
+  // create_bar_code_model: Create a model of a bar code reader.
+  explicit HBarCode(const char* GenParamName, double GenParamValue);
+
+#ifdef _WIN32
+  // create_bar_code_model: Create a model of a bar code reader.
+  explicit HBarCode(const wchar_t* GenParamName, double GenParamValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Deserialize a bar code model.
+  void DeserializeBarCodeModel(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a bar code model.
+  HSerializedItem SerializeBarCodeModel() const;
+
+  // Read a bar code model from a file and create a new model.
+  void ReadBarCodeModel(const HString& FileName);
+
+  // Read a bar code model from a file and create a new model.
+  void ReadBarCodeModel(const char* FileName);
+
+#ifdef _WIN32
+  // Read a bar code model from a file and create a new model.
+  void ReadBarCodeModel(const wchar_t* FileName);
+#endif
+
+  // Write a bar code model to a file.
+  void WriteBarCodeModel(const HString& FileName) const;
+
+  // Write a bar code model to a file.
+  void WriteBarCodeModel(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a bar code model to a file.
+  void WriteBarCodeModel(const wchar_t* FileName) const;
+#endif
+
+  // Access iconic objects that were created during the search or decoding of bar code symbols.
+  HObject GetBarCodeObject(const HTuple& CandidateHandle, const HString& ObjectName) const;
+
+  // Access iconic objects that were created during the search or decoding of bar code symbols.
+  HObject GetBarCodeObject(const HString& CandidateHandle, const HString& ObjectName) const;
+
+  // Access iconic objects that were created during the search or decoding of bar code symbols.
+  HObject GetBarCodeObject(const char* CandidateHandle, const char* ObjectName) const;
+
+#ifdef _WIN32
+  // Access iconic objects that were created during the search or decoding of bar code symbols.
+  HObject GetBarCodeObject(const wchar_t* CandidateHandle, const wchar_t* ObjectName) const;
+#endif
+
+  // Get the alphanumerical results that were accumulated during the decoding of bar code symbols.
+  HTuple GetBarCodeResult(const HTuple& CandidateHandle, const HString& ResultName) const;
+
+  // Get the alphanumerical results that were accumulated during the decoding of bar code symbols.
+  HTuple GetBarCodeResult(const HString& CandidateHandle, const HString& ResultName) const;
+
+  // Get the alphanumerical results that were accumulated during the decoding of bar code symbols.
+  HTuple GetBarCodeResult(const char* CandidateHandle, const char* ResultName) const;
+
+#ifdef _WIN32
+  // Get the alphanumerical results that were accumulated during the decoding of bar code symbols.
+  HTuple GetBarCodeResult(const wchar_t* CandidateHandle, const wchar_t* ResultName) const;
+#endif
+
+  // Decode bar code symbols within a rectangle.
+  HTuple DecodeBarCodeRectangle2(const HImage& Image, const HTuple& CodeType, const HTuple& Row, const HTuple& Column, const HTuple& Phi, const HTuple& Length1, const HTuple& Length2) const;
+
+  // Decode bar code symbols within a rectangle.
+  HString DecodeBarCodeRectangle2(const HImage& Image, const HString& CodeType, double Row, double Column, double Phi, double Length1, double Length2) const;
+
+  // Decode bar code symbols within a rectangle.
+  HString DecodeBarCodeRectangle2(const HImage& Image, const char* CodeType, double Row, double Column, double Phi, double Length1, double Length2) const;
+
+#ifdef _WIN32
+  // Decode bar code symbols within a rectangle.
+  HString DecodeBarCodeRectangle2(const HImage& Image, const wchar_t* CodeType, double Row, double Column, double Phi, double Length1, double Length2) const;
+#endif
+
+  // Detect and read bar code symbols in an image.
+  HRegion FindBarCode(const HImage& Image, const HTuple& CodeType, HTuple* DecodedDataStrings) const;
+
+  // Detect and read bar code symbols in an image.
+  HRegion FindBarCode(const HImage& Image, const HString& CodeType, HString* DecodedDataStrings) const;
+
+  // Detect and read bar code symbols in an image.
+  HRegion FindBarCode(const HImage& Image, const char* CodeType, HString* DecodedDataStrings) const;
+
+#ifdef _WIN32
+  // Detect and read bar code symbols in an image.
+  HRegion FindBarCode(const HImage& Image, const wchar_t* CodeType, HString* DecodedDataStrings) const;
+#endif
+
+  // Get the names of the parameters that can be used in set_bar_code* and get_bar_code* operators for a given bar code model
+  HTuple QueryBarCodeParams(const HString& Properties) const;
+
+  // Get the names of the parameters that can be used in set_bar_code* and get_bar_code* operators for a given bar code model
+  HTuple QueryBarCodeParams(const char* Properties) const;
+
+#ifdef _WIN32
+  // Get the names of the parameters that can be used in set_bar_code* and get_bar_code* operators for a given bar code model
+  HTuple QueryBarCodeParams(const wchar_t* Properties) const;
+#endif
+
+  // Get parameters that are used by the bar code reader when processing a specific bar code type. 
+  HTuple GetBarCodeParamSpecific(const HTuple& CodeTypes, const HTuple& GenParamName) const;
+
+  // Get parameters that are used by the bar code reader when processing a specific bar code type. 
+  HTuple GetBarCodeParamSpecific(const HString& CodeTypes, const HString& GenParamName) const;
+
+  // Get parameters that are used by the bar code reader when processing a specific bar code type. 
+  HTuple GetBarCodeParamSpecific(const char* CodeTypes, const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Get parameters that are used by the bar code reader when processing a specific bar code type. 
+  HTuple GetBarCodeParamSpecific(const wchar_t* CodeTypes, const wchar_t* GenParamName) const;
+#endif
+
+  // Get one or several parameters that describe the bar code model.
+  HTuple GetBarCodeParam(const HTuple& GenParamName) const;
+
+  // Get one or several parameters that describe the bar code model.
+  HTuple GetBarCodeParam(const HString& GenParamName) const;
+
+  // Get one or several parameters that describe the bar code model.
+  HTuple GetBarCodeParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Get one or several parameters that describe the bar code model.
+  HTuple GetBarCodeParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Set selected parameters of the bar code model for selected bar code types
+  void SetBarCodeParamSpecific(const HTuple& CodeTypes, const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set selected parameters of the bar code model for selected bar code types
+  void SetBarCodeParamSpecific(const HString& CodeTypes, const HString& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set selected parameters of the bar code model for selected bar code types
+  void SetBarCodeParamSpecific(const char* CodeTypes, const char* GenParamName, const HTuple& GenParamValue) const;
+
+#ifdef _WIN32
+  // Set selected parameters of the bar code model for selected bar code types
+  void SetBarCodeParamSpecific(const wchar_t* CodeTypes, const wchar_t* GenParamName, const HTuple& GenParamValue) const;
+#endif
+
+  // Set selected parameters of the bar code model.
+  void SetBarCodeParam(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set selected parameters of the bar code model.
+  void SetBarCodeParam(const HString& GenParamName, double GenParamValue) const;
+
+  // Set selected parameters of the bar code model.
+  void SetBarCodeParam(const char* GenParamName, double GenParamValue) const;
+
+#ifdef _WIN32
+  // Set selected parameters of the bar code model.
+  void SetBarCodeParam(const wchar_t* GenParamName, double GenParamValue) const;
+#endif
+
+  // Delete a bar code model and free the allocated memory
+  static void ClearBarCodeModel(const HBarCodeArray& BarCodeHandle);
+
+  // Delete a bar code model and free the allocated memory
+  void ClearBarCodeModel() const;
+
+  // Create a model of a bar code reader.
+  void CreateBarCodeModel(const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Create a model of a bar code reader.
+  void CreateBarCodeModel(const HString& GenParamName, double GenParamValue);
+
+  // Create a model of a bar code reader.
+  void CreateBarCodeModel(const char* GenParamName, double GenParamValue);
+
+#ifdef _WIN32
+  // Create a model of a bar code reader.
+  void CreateBarCodeModel(const wchar_t* GenParamName, double GenParamValue);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HBarCode> HBarCodeArrayRef;
+typedef HSmartPtr< HBarCodeArrayRef > HBarCodeArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HBarCodeArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HBarCodeArray();
+
+  // Create array from native array of tool instances
+  HBarCodeArray(HBarCode* classes, Hlong length);
+
+  // Copy constructor
+  HBarCodeArray(const HBarCodeArray &tool_array);
+
+  // Destructor
+  virtual ~HBarCodeArray();
+
+  // Assignment operator
+  HBarCodeArray &operator=(const HBarCodeArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HBarCode* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HBarCodeArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HBarrier.h

@@ -0,0 +1,152 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HBARRIER
+#define HCPP_HBARRIER
+
+namespace HalconCpp
+{
+
+// Represents an instance of a barrier synchronization object.
+class LIntExport HBarrier : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HBarrier():HHandle() {}
+
+  // Copy constructor
+  HBarrier(const HBarrier& source) : HHandle(source) {}
+
+  // Copy constructor
+  HBarrier(const HHandle& handle);
+
+  // Create HBarrier from handle, taking ownership
+  explicit HBarrier(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('barrier')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_barrier: Create a barrier synchronization object.
+  explicit HBarrier(const HTuple& AttribName, const HTuple& AttribValue, Hlong TeamSize);
+
+  // create_barrier: Create a barrier synchronization object.
+  explicit HBarrier(const HString& AttribName, const HString& AttribValue, Hlong TeamSize);
+
+  // create_barrier: Create a barrier synchronization object.
+  explicit HBarrier(const char* AttribName, const char* AttribValue, Hlong TeamSize);
+
+#ifdef _WIN32
+  // create_barrier: Create a barrier synchronization object.
+  explicit HBarrier(const wchar_t* AttribName, const wchar_t* AttribValue, Hlong TeamSize);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Destroy a barrier synchronization object.
+  void ClearBarrier() const;
+
+  // Wait on the release of a barrier synchronization object.
+  void WaitBarrier() const;
+
+  // Create a barrier synchronization object.
+  void CreateBarrier(const HTuple& AttribName, const HTuple& AttribValue, Hlong TeamSize);
+
+  // Create a barrier synchronization object.
+  void CreateBarrier(const HString& AttribName, const HString& AttribValue, Hlong TeamSize);
+
+  // Create a barrier synchronization object.
+  void CreateBarrier(const char* AttribName, const char* AttribValue, Hlong TeamSize);
+
+#ifdef _WIN32
+  // Create a barrier synchronization object.
+  void CreateBarrier(const wchar_t* AttribName, const wchar_t* AttribValue, Hlong TeamSize);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HBarrier> HBarrierArrayRef;
+typedef HSmartPtr< HBarrierArrayRef > HBarrierArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HBarrierArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HBarrierArray();
+
+  // Create array from native array of tool instances
+  HBarrierArray(HBarrier* classes, Hlong length);
+
+  // Copy constructor
+  HBarrierArray(const HBarrierArray &tool_array);
+
+  // Destructor
+  virtual ~HBarrierArray();
+
+  // Assignment operator
+  HBarrierArray &operator=(const HBarrierArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HBarrier* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HBarrierArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HBeadInspectionModel.h

@@ -0,0 +1,180 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HBEADINSPECTIONMODEL
+#define HCPP_HBEADINSPECTIONMODEL
+
+namespace HalconCpp
+{
+
+// Represents an instance of the data structure used to inspect beads.
+class LIntExport HBeadInspectionModel : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HBeadInspectionModel():HHandle() {}
+
+  // Copy constructor
+  HBeadInspectionModel(const HBeadInspectionModel& source) : HHandle(source) {}
+
+  // Copy constructor
+  HBeadInspectionModel(const HHandle& handle);
+
+  // Create HBeadInspectionModel from handle, taking ownership
+  explicit HBeadInspectionModel(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('bead_inspection_model')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_bead_inspection_model: Create a model to inspect beads or adhesive in images.
+  explicit HBeadInspectionModel(const HXLD& BeadContour, const HTuple& TargetThickness, const HTuple& ThicknessTolerance, const HTuple& PositionTolerance, const HString& Polarity, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // create_bead_inspection_model: Create a model to inspect beads or adhesive in images.
+  explicit HBeadInspectionModel(const HXLD& BeadContour, Hlong TargetThickness, Hlong ThicknessTolerance, Hlong PositionTolerance, const HString& Polarity, const HString& GenParamName, Hlong GenParamValue);
+
+  // create_bead_inspection_model: Create a model to inspect beads or adhesive in images.
+  explicit HBeadInspectionModel(const HXLD& BeadContour, Hlong TargetThickness, Hlong ThicknessTolerance, Hlong PositionTolerance, const char* Polarity, const char* GenParamName, Hlong GenParamValue);
+
+#ifdef _WIN32
+  // create_bead_inspection_model: Create a model to inspect beads or adhesive in images.
+  explicit HBeadInspectionModel(const HXLD& BeadContour, Hlong TargetThickness, Hlong ThicknessTolerance, Hlong PositionTolerance, const wchar_t* Polarity, const wchar_t* GenParamName, Hlong GenParamValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Get the value of a parameter in a specific bead inspection model.
+  HTuple GetBeadInspectionParam(const HTuple& GenParamName) const;
+
+  // Get the value of a parameter in a specific bead inspection model.
+  HTuple GetBeadInspectionParam(const HString& GenParamName) const;
+
+  // Get the value of a parameter in a specific bead inspection model.
+  HTuple GetBeadInspectionParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Get the value of a parameter in a specific bead inspection model.
+  HTuple GetBeadInspectionParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Set parameters of the bead inspection model.
+  void SetBeadInspectionParam(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set parameters of the bead inspection model.
+  void SetBeadInspectionParam(const HString& GenParamName, const HString& GenParamValue) const;
+
+  // Set parameters of the bead inspection model.
+  void SetBeadInspectionParam(const char* GenParamName, const char* GenParamValue) const;
+
+#ifdef _WIN32
+  // Set parameters of the bead inspection model.
+  void SetBeadInspectionParam(const wchar_t* GenParamName, const wchar_t* GenParamValue) const;
+#endif
+
+  // Inspect beads in an image, as defined by the bead inspection model.
+  HXLD ApplyBeadInspectionModel(const HImage& Image, HXLD* RightContour, HXLD* ErrorSegment, HTuple* ErrorType) const;
+
+  // Delete the bead inspection model and free the allocated memory.
+  void ClearBeadInspectionModel() const;
+
+  // Create a model to inspect beads or adhesive in images.
+  void CreateBeadInspectionModel(const HXLD& BeadContour, const HTuple& TargetThickness, const HTuple& ThicknessTolerance, const HTuple& PositionTolerance, const HString& Polarity, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Create a model to inspect beads or adhesive in images.
+  void CreateBeadInspectionModel(const HXLD& BeadContour, Hlong TargetThickness, Hlong ThicknessTolerance, Hlong PositionTolerance, const HString& Polarity, const HString& GenParamName, Hlong GenParamValue);
+
+  // Create a model to inspect beads or adhesive in images.
+  void CreateBeadInspectionModel(const HXLD& BeadContour, Hlong TargetThickness, Hlong ThicknessTolerance, Hlong PositionTolerance, const char* Polarity, const char* GenParamName, Hlong GenParamValue);
+
+#ifdef _WIN32
+  // Create a model to inspect beads or adhesive in images.
+  void CreateBeadInspectionModel(const HXLD& BeadContour, Hlong TargetThickness, Hlong ThicknessTolerance, Hlong PositionTolerance, const wchar_t* Polarity, const wchar_t* GenParamName, Hlong GenParamValue);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HBeadInspectionModel> HBeadInspectionModelArrayRef;
+typedef HSmartPtr< HBeadInspectionModelArrayRef > HBeadInspectionModelArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HBeadInspectionModelArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HBeadInspectionModelArray();
+
+  // Create array from native array of tool instances
+  HBeadInspectionModelArray(HBeadInspectionModel* classes, Hlong length);
+
+  // Copy constructor
+  HBeadInspectionModelArray(const HBeadInspectionModelArray &tool_array);
+
+  // Destructor
+  virtual ~HBeadInspectionModelArray();
+
+  // Assignment operator
+  HBeadInspectionModelArray &operator=(const HBeadInspectionModelArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HBeadInspectionModel* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HBeadInspectionModelArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HBgEsti.h

@@ -0,0 +1,166 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HBGESTI
+#define HCPP_HBGESTI
+
+namespace HalconCpp
+{
+
+// Represents an instance of a background estimator.
+class LIntExport HBgEsti : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HBgEsti():HHandle() {}
+
+  // Copy constructor
+  HBgEsti(const HBgEsti& source) : HHandle(source) {}
+
+  // Copy constructor
+  HBgEsti(const HHandle& handle);
+
+  // Create HBgEsti from handle, taking ownership
+  explicit HBgEsti(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('bg_estimation')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_bg_esti: Generate and initialize a data set for the background estimation.
+  explicit HBgEsti(const HImage& InitializeImage, double Syspar1, double Syspar2, const HString& GainMode, double Gain1, double Gain2, const HString& AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC);
+
+  // create_bg_esti: Generate and initialize a data set for the background estimation.
+  explicit HBgEsti(const HImage& InitializeImage, double Syspar1, double Syspar2, const char* GainMode, double Gain1, double Gain2, const char* AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC);
+
+#ifdef _WIN32
+  // create_bg_esti: Generate and initialize a data set for the background estimation.
+  explicit HBgEsti(const HImage& InitializeImage, double Syspar1, double Syspar2, const wchar_t* GainMode, double Gain1, double Gain2, const wchar_t* AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Delete the background estimation data set.
+  void CloseBgEsti() const;
+
+  // Return the estimated background image.
+  HImage GiveBgEsti() const;
+
+  // Change the estimated background image.
+  void UpdateBgEsti(const HImage& PresentImage, const HRegion& UpDateRegion) const;
+
+  // Estimate the background and return the foreground region.
+  HRegion RunBgEsti(const HImage& PresentImage) const;
+
+  // Return the parameters of the data set.
+  double GetBgEstiParams(double* Syspar2, HString* GainMode, double* Gain1, double* Gain2, HString* AdaptMode, double* MinDiff, Hlong* StatNum, double* ConfidenceC, double* TimeC) const;
+
+  // Change the parameters of the data set.
+  void SetBgEstiParams(double Syspar1, double Syspar2, const HString& GainMode, double Gain1, double Gain2, const HString& AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC) const;
+
+  // Change the parameters of the data set.
+  void SetBgEstiParams(double Syspar1, double Syspar2, const char* GainMode, double Gain1, double Gain2, const char* AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC) const;
+
+#ifdef _WIN32
+  // Change the parameters of the data set.
+  void SetBgEstiParams(double Syspar1, double Syspar2, const wchar_t* GainMode, double Gain1, double Gain2, const wchar_t* AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC) const;
+#endif
+
+  // Generate and initialize a data set for the background estimation.
+  void CreateBgEsti(const HImage& InitializeImage, double Syspar1, double Syspar2, const HString& GainMode, double Gain1, double Gain2, const HString& AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC);
+
+  // Generate and initialize a data set for the background estimation.
+  void CreateBgEsti(const HImage& InitializeImage, double Syspar1, double Syspar2, const char* GainMode, double Gain1, double Gain2, const char* AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC);
+
+#ifdef _WIN32
+  // Generate and initialize a data set for the background estimation.
+  void CreateBgEsti(const HImage& InitializeImage, double Syspar1, double Syspar2, const wchar_t* GainMode, double Gain1, double Gain2, const wchar_t* AdaptMode, double MinDiff, Hlong StatNum, double ConfidenceC, double TimeC);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HBgEsti> HBgEstiArrayRef;
+typedef HSmartPtr< HBgEstiArrayRef > HBgEstiArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HBgEstiArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HBgEstiArray();
+
+  // Create array from native array of tool instances
+  HBgEstiArray(HBgEsti* classes, Hlong length);
+
+  // Copy constructor
+  HBgEstiArray(const HBgEstiArray &tool_array);
+
+  // Destructor
+  virtual ~HBgEstiArray();
+
+  // Assignment operator
+  HBgEstiArray &operator=(const HBgEstiArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HBgEsti* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HBgEstiArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HCalibData.h

@@ -0,0 +1,293 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCALIBDATA
+#define HCPP_HCALIBDATA
+
+namespace HalconCpp
+{
+
+// Represents an instance of a camera calibration model.
+class LIntExport HCalibData : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HCalibData():HHandle() {}
+
+  // Copy constructor
+  HCalibData(const HCalibData& source) : HHandle(source) {}
+
+  // Copy constructor
+  HCalibData(const HHandle& handle);
+
+  // Create HCalibData from handle, taking ownership
+  explicit HCalibData(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('calib_data')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HCalibData Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_calib_data: Restore a calibration data model from a file.
+  explicit HCalibData(const HString& FileName);
+
+  // read_calib_data: Restore a calibration data model from a file.
+  explicit HCalibData(const char* FileName);
+
+#ifdef _WIN32
+  // read_calib_data: Restore a calibration data model from a file.
+  explicit HCalibData(const wchar_t* FileName);
+#endif
+
+  // create_calib_data: Create a HALCON calibration data model.
+  explicit HCalibData(const HString& CalibSetup, Hlong NumCameras, Hlong NumCalibObjects);
+
+  // create_calib_data: Create a HALCON calibration data model.
+  explicit HCalibData(const char* CalibSetup, Hlong NumCameras, Hlong NumCalibObjects);
+
+#ifdef _WIN32
+  // create_calib_data: Create a HALCON calibration data model.
+  explicit HCalibData(const wchar_t* CalibSetup, Hlong NumCameras, Hlong NumCalibObjects);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Free the memory of a calibration data model.
+  void ClearCalibData() const;
+
+  // Deserialize a serialized calibration data model.
+  void DeserializeCalibData(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a calibration data model.
+  HSerializedItem SerializeCalibData() const;
+
+  // Restore a calibration data model from a file.
+  void ReadCalibData(const HString& FileName);
+
+  // Restore a calibration data model from a file.
+  void ReadCalibData(const char* FileName);
+
+#ifdef _WIN32
+  // Restore a calibration data model from a file.
+  void ReadCalibData(const wchar_t* FileName);
+#endif
+
+  // Store a calibration data model into a file.
+  void WriteCalibData(const HString& FileName) const;
+
+  // Store a calibration data model into a file.
+  void WriteCalibData(const char* FileName) const;
+
+#ifdef _WIN32
+  // Store a calibration data model into a file.
+  void WriteCalibData(const wchar_t* FileName) const;
+#endif
+
+  // Perform a hand-eye calibration.
+  HTuple CalibrateHandEye() const;
+
+  // Determine all camera parameters by a simultaneous minimization process.
+  double CalibrateCameras() const;
+
+  // Remove a data set from a calibration data model.
+  void RemoveCalibData(const HString& ItemType, const HTuple& ItemIdx) const;
+
+  // Remove a data set from a calibration data model.
+  void RemoveCalibData(const HString& ItemType, Hlong ItemIdx) const;
+
+  // Remove a data set from a calibration data model.
+  void RemoveCalibData(const char* ItemType, Hlong ItemIdx) const;
+
+#ifdef _WIN32
+  // Remove a data set from a calibration data model.
+  void RemoveCalibData(const wchar_t* ItemType, Hlong ItemIdx) const;
+#endif
+
+  // Set data in a calibration data model.
+  void SetCalibData(const HString& ItemType, const HTuple& ItemIdx, const HString& DataName, const HTuple& DataValue) const;
+
+  // Set data in a calibration data model.
+  void SetCalibData(const HString& ItemType, Hlong ItemIdx, const HString& DataName, const HString& DataValue) const;
+
+  // Set data in a calibration data model.
+  void SetCalibData(const char* ItemType, Hlong ItemIdx, const char* DataName, const char* DataValue) const;
+
+#ifdef _WIN32
+  // Set data in a calibration data model.
+  void SetCalibData(const wchar_t* ItemType, Hlong ItemIdx, const wchar_t* DataName, const wchar_t* DataValue) const;
+#endif
+
+  // Find the HALCON calibration plate and set the extracted points and contours in a calibration data model.
+  void FindCalibObject(const HImage& Image, Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx, const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Remove observation data from a calibration data model.
+  void RemoveCalibDataObserv(Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx) const;
+
+  // Get contour-based observation data from a calibration data model.
+  HXLDCont GetCalibDataObservContours(const HString& ContourName, Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx) const;
+
+  // Get contour-based observation data from a calibration data model.
+  HXLDCont GetCalibDataObservContours(const char* ContourName, Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx) const;
+
+#ifdef _WIN32
+  // Get contour-based observation data from a calibration data model.
+  HXLDCont GetCalibDataObservContours(const wchar_t* ContourName, Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx) const;
+#endif
+
+  // Get observed calibration object poses from a calibration data model.
+  HPose GetCalibDataObservPose(Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx) const;
+
+  // Set observed calibration object poses in a calibration data model.
+  void SetCalibDataObservPose(Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx, const HPose& ObjInCameraPose) const;
+
+  // Get point-based observation data from a calibration data model.
+  void GetCalibDataObservPoints(Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx, HTuple* Row, HTuple* Column, HTuple* Index, HTuple* Pose) const;
+
+  // Set point-based observation data in a calibration data model.
+  void SetCalibDataObservPoints(Hlong CameraIdx, Hlong CalibObjIdx, Hlong CalibObjPoseIdx, const HTuple& Row, const HTuple& Column, const HTuple& Index, const HTuple& Pose) const;
+
+  // Query information about the relations between cameras, calibration objects, and calibration object poses.
+  HTuple QueryCalibDataObservIndices(const HString& ItemType, Hlong ItemIdx, HTuple* Index2) const;
+
+  // Query information about the relations between cameras, calibration objects, and calibration object poses.
+  HTuple QueryCalibDataObservIndices(const char* ItemType, Hlong ItemIdx, HTuple* Index2) const;
+
+#ifdef _WIN32
+  // Query information about the relations between cameras, calibration objects, and calibration object poses.
+  HTuple QueryCalibDataObservIndices(const wchar_t* ItemType, Hlong ItemIdx, HTuple* Index2) const;
+#endif
+
+  // Query data stored or computed in a calibration data model.
+  HTuple GetCalibData(const HString& ItemType, const HTuple& ItemIdx, const HTuple& DataName) const;
+
+  // Query data stored or computed in a calibration data model.
+  HTuple GetCalibData(const HString& ItemType, Hlong ItemIdx, const HString& DataName) const;
+
+  // Query data stored or computed in a calibration data model.
+  HTuple GetCalibData(const char* ItemType, Hlong ItemIdx, const char* DataName) const;
+
+#ifdef _WIN32
+  // Query data stored or computed in a calibration data model.
+  HTuple GetCalibData(const wchar_t* ItemType, Hlong ItemIdx, const wchar_t* DataName) const;
+#endif
+
+  // Define a calibration object in a calibration model.
+  void SetCalibDataCalibObject(Hlong CalibObjIdx, const HTuple& CalibObjDescr) const;
+
+  // Define a calibration object in a calibration model.
+  void SetCalibDataCalibObject(Hlong CalibObjIdx, double CalibObjDescr) const;
+
+  // Set type and initial parameters of a camera in a calibration data model.
+  void SetCalibDataCamParam(const HTuple& CameraIdx, const HTuple& CameraType, const HCamPar& CameraParam) const;
+
+  // Set type and initial parameters of a camera in a calibration data model.
+  void SetCalibDataCamParam(const HTuple& CameraIdx, const HString& CameraType, const HCamPar& CameraParam) const;
+
+  // Set type and initial parameters of a camera in a calibration data model.
+  void SetCalibDataCamParam(const HTuple& CameraIdx, const char* CameraType, const HCamPar& CameraParam) const;
+
+#ifdef _WIN32
+  // Set type and initial parameters of a camera in a calibration data model.
+  void SetCalibDataCamParam(const HTuple& CameraIdx, const wchar_t* CameraType, const HCamPar& CameraParam) const;
+#endif
+
+  // Create a HALCON calibration data model.
+  void CreateCalibData(const HString& CalibSetup, Hlong NumCameras, Hlong NumCalibObjects);
+
+  // Create a HALCON calibration data model.
+  void CreateCalibData(const char* CalibSetup, Hlong NumCameras, Hlong NumCalibObjects);
+
+#ifdef _WIN32
+  // Create a HALCON calibration data model.
+  void CreateCalibData(const wchar_t* CalibSetup, Hlong NumCameras, Hlong NumCalibObjects);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HCalibData> HCalibDataArrayRef;
+typedef HSmartPtr< HCalibDataArrayRef > HCalibDataArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HCalibDataArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HCalibDataArray();
+
+  // Create array from native array of tool instances
+  HCalibDataArray(HCalibData* classes, Hlong length);
+
+  // Copy constructor
+  HCalibDataArray(const HCalibDataArray &tool_array);
+
+  // Destructor
+  virtual ~HCalibDataArray();
+
+  // Assignment operator
+  HCalibDataArray &operator=(const HCalibDataArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HCalibData* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HCalibDataArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HCameraSetupModel.h

@@ -0,0 +1,222 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCAMERASETUPMODEL
+#define HCPP_HCAMERASETUPMODEL
+
+namespace HalconCpp
+{
+
+// Represents an instance of a camera setup model.
+class LIntExport HCameraSetupModel : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HCameraSetupModel():HHandle() {}
+
+  // Copy constructor
+  HCameraSetupModel(const HCameraSetupModel& source) : HHandle(source) {}
+
+  // Copy constructor
+  HCameraSetupModel(const HHandle& handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('camera_setup_model')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HCameraSetupModel Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_camera_setup_model: Restore a camera setup model from a file.
+  explicit HCameraSetupModel(const HString& FileName);
+
+  // read_camera_setup_model: Restore a camera setup model from a file.
+  explicit HCameraSetupModel(const char* FileName);
+
+#ifdef _WIN32
+  // read_camera_setup_model: Restore a camera setup model from a file.
+  explicit HCameraSetupModel(const wchar_t* FileName);
+#endif
+
+  // create_camera_setup_model: Create a model for a setup of calibrated cameras.
+  explicit HCameraSetupModel(Hlong NumCameras);
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Create a HALCON stereo model.
+  HStereoModel CreateStereoModel(const HString& Method, const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Create a HALCON stereo model.
+  HStereoModel CreateStereoModel(const HString& Method, const HString& GenParamName, const HTuple& GenParamValue) const;
+
+  // Create a HALCON stereo model.
+  HStereoModel CreateStereoModel(const char* Method, const char* GenParamName, const HTuple& GenParamValue) const;
+
+#ifdef _WIN32
+  // Create a HALCON stereo model.
+  HStereoModel CreateStereoModel(const wchar_t* Method, const wchar_t* GenParamName, const HTuple& GenParamValue) const;
+#endif
+
+  // Free the memory of a calibration setup model.
+  void ClearCameraSetupModel() const;
+
+  // Serialize a camera setup model.
+  HSerializedItem SerializeCameraSetupModel() const;
+
+  // Deserialize a serialized camera setup model.
+  void DeserializeCameraSetupModel(const HSerializedItem& SerializedItemHandle);
+
+  // Store a camera setup model into a file.
+  void WriteCameraSetupModel(const HString& FileName) const;
+
+  // Store a camera setup model into a file.
+  void WriteCameraSetupModel(const char* FileName) const;
+
+#ifdef _WIN32
+  // Store a camera setup model into a file.
+  void WriteCameraSetupModel(const wchar_t* FileName) const;
+#endif
+
+  // Restore a camera setup model from a file.
+  void ReadCameraSetupModel(const HString& FileName);
+
+  // Restore a camera setup model from a file.
+  void ReadCameraSetupModel(const char* FileName);
+
+#ifdef _WIN32
+  // Restore a camera setup model from a file.
+  void ReadCameraSetupModel(const wchar_t* FileName);
+#endif
+
+  // Get generic camera setup model parameters.
+  HTuple GetCameraSetupParam(const HTuple& CameraIdx, const HString& GenParamName) const;
+
+  // Get generic camera setup model parameters.
+  HTuple GetCameraSetupParam(Hlong CameraIdx, const HString& GenParamName) const;
+
+  // Get generic camera setup model parameters.
+  HTuple GetCameraSetupParam(Hlong CameraIdx, const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Get generic camera setup model parameters.
+  HTuple GetCameraSetupParam(Hlong CameraIdx, const wchar_t* GenParamName) const;
+#endif
+
+  // Set generic camera setup model parameters.
+  void SetCameraSetupParam(const HTuple& CameraIdx, const HString& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set generic camera setup model parameters.
+  void SetCameraSetupParam(Hlong CameraIdx, const HString& GenParamName, double GenParamValue) const;
+
+  // Set generic camera setup model parameters.
+  void SetCameraSetupParam(Hlong CameraIdx, const char* GenParamName, double GenParamValue) const;
+
+#ifdef _WIN32
+  // Set generic camera setup model parameters.
+  void SetCameraSetupParam(Hlong CameraIdx, const wchar_t* GenParamName, double GenParamValue) const;
+#endif
+
+  // Define type, parameters, and relative pose of a camera in a camera setup model.
+  void SetCameraSetupCamParam(const HTuple& CameraIdx, const HTuple& CameraType, const HCamPar& CameraParam, const HTuple& CameraPose) const;
+
+  // Define type, parameters, and relative pose of a camera in a camera setup model.
+  void SetCameraSetupCamParam(const HTuple& CameraIdx, const HString& CameraType, const HCamPar& CameraParam, const HTuple& CameraPose) const;
+
+  // Define type, parameters, and relative pose of a camera in a camera setup model.
+  void SetCameraSetupCamParam(const HTuple& CameraIdx, const char* CameraType, const HCamPar& CameraParam, const HTuple& CameraPose) const;
+
+#ifdef _WIN32
+  // Define type, parameters, and relative pose of a camera in a camera setup model.
+  void SetCameraSetupCamParam(const HTuple& CameraIdx, const wchar_t* CameraType, const HCamPar& CameraParam, const HTuple& CameraPose) const;
+#endif
+
+  // Create a model for a setup of calibrated cameras.
+  void CreateCameraSetupModel(Hlong NumCameras);
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HCameraSetupModel> HCameraSetupModelArrayRef;
+typedef HSmartPtr< HCameraSetupModelArrayRef > HCameraSetupModelArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HCameraSetupModelArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HCameraSetupModelArray();
+
+  // Create array from native array of tool instances
+  HCameraSetupModelArray(HCameraSetupModel* classes, Hlong length);
+
+  // Copy constructor
+  HCameraSetupModelArray(const HCameraSetupModelArray &tool_array);
+
+  // Destructor
+  virtual ~HCameraSetupModelArray();
+
+  // Assignment operator
+  HCameraSetupModelArray &operator=(const HCameraSetupModelArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HCameraSetupModel* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HCameraSetupModelArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HClassBox.h

@@ -0,0 +1,215 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCLASSBOX
+#define HCPP_HCLASSBOX
+
+namespace HalconCpp
+{
+
+// Represents an instance of a classifier.
+class LIntExport HClassBox : public HHandle
+{
+
+public:
+
+  // Copy constructor
+  HClassBox(const HClassBox& source) : HHandle(source) {}
+
+  // Copy constructor
+  HClassBox(const HHandle& handle);
+
+  // Create HClassBox from handle, taking ownership
+  explicit HClassBox(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('class_box')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HClassBox Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_class_box: Create a new classifier.
+  explicit HClassBox();
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Train a classificator using a multi-channel image.
+  void LearnNdimBox(const HRegion& Foreground, const HRegion& Background, const HImage& MultiChannelImage) const;
+
+  // Classify pixels using hyper-cuboids.
+  HRegion ClassNdimBox(const HImage& MultiChannelImage) const;
+
+  // Deserialize a serialized classifier.
+  void DeserializeClassBox(const HSerializedItem& SerializedItemHandle) const;
+
+  // Serialize a classifier.
+  HSerializedItem SerializeClassBox() const;
+
+  // Save a classifier in a file.
+  void WriteClassBox(const HString& FileName) const;
+
+  // Save a classifier in a file.
+  void WriteClassBox(const char* FileName) const;
+
+#ifdef _WIN32
+  // Save a classifier in a file.
+  void WriteClassBox(const wchar_t* FileName) const;
+#endif
+
+  // Set system parameters for classification.
+  void SetClassBoxParam(const HString& Flag, const HTuple& Value) const;
+
+  // Set system parameters for classification.
+  void SetClassBoxParam(const HString& Flag, double Value) const;
+
+  // Set system parameters for classification.
+  void SetClassBoxParam(const char* Flag, double Value) const;
+
+#ifdef _WIN32
+  // Set system parameters for classification.
+  void SetClassBoxParam(const wchar_t* Flag, double Value) const;
+#endif
+
+  // Read a classifier from a file.
+  void ReadClassBox(const HString& FileName) const;
+
+  // Read a classifier from a file.
+  void ReadClassBox(const char* FileName) const;
+
+#ifdef _WIN32
+  // Read a classifier from a file.
+  void ReadClassBox(const wchar_t* FileName) const;
+#endif
+
+  // Train the classifier with one data set.
+  void LearnSampsetBox(const HFeatureSet& SampKey, const HString& Outfile, Hlong NSamples, double StopError, Hlong ErrorN) const;
+
+  // Train the classifier with one data set.
+  void LearnSampsetBox(const HFeatureSet& SampKey, const char* Outfile, Hlong NSamples, double StopError, Hlong ErrorN) const;
+
+#ifdef _WIN32
+  // Train the classifier with one data set.
+  void LearnSampsetBox(const HFeatureSet& SampKey, const wchar_t* Outfile, Hlong NSamples, double StopError, Hlong ErrorN) const;
+#endif
+
+  // Train the classifier.
+  void LearnClassBox(const HTuple& Features, Hlong Class) const;
+
+  // Get information about the current parameter.
+  HTuple GetClassBoxParam(const HString& Flag) const;
+
+  // Get information about the current parameter.
+  HTuple GetClassBoxParam(const char* Flag) const;
+
+#ifdef _WIN32
+  // Get information about the current parameter.
+  HTuple GetClassBoxParam(const wchar_t* Flag) const;
+#endif
+
+  // Destroy the classifier.
+  void CloseClassBox() const;
+
+  // Create a new classifier.
+  void CreateClassBox();
+
+  // Describe the classes of a box classifier.
+  HTuple DescriptClassBox(Hlong Dimensions, HTuple* BoxIdx, HTuple* BoxLowerBound, HTuple* BoxHigherBound, HTuple* BoxNumSamplesTrain, HTuple* BoxNumSamplesWrong) const;
+
+  // Describe the classes of a box classifier.
+  Hlong DescriptClassBox(Hlong Dimensions, Hlong* BoxIdx, Hlong* BoxLowerBound, Hlong* BoxHigherBound, Hlong* BoxNumSamplesTrain, Hlong* BoxNumSamplesWrong) const;
+
+  // Classify a set of arrays.
+  double TestSampsetBox(const HFeatureSet& SampKey) const;
+
+  // Classify a tuple of attributes with rejection class.
+  Hlong EnquireRejectClassBox(const HTuple& FeatureList) const;
+
+  // Classify a tuple of attributes.
+  Hlong EnquireClassBox(const HTuple& FeatureList) const;
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HClassBox> HClassBoxArrayRef;
+typedef HSmartPtr< HClassBoxArrayRef > HClassBoxArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HClassBoxArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HClassBoxArray();
+
+  // Create array from native array of tool instances
+  HClassBoxArray(HClassBox* classes, Hlong length);
+
+  // Copy constructor
+  HClassBoxArray(const HClassBoxArray &tool_array);
+
+  // Destructor
+  virtual ~HClassBoxArray();
+
+  // Assignment operator
+  HClassBoxArray &operator=(const HClassBoxArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HClassBox* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HClassBoxArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HClassGmm.h

@@ -0,0 +1,291 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCLASSGMM
+#define HCPP_HCLASSGMM
+
+namespace HalconCpp
+{
+
+// Represents an instance of a Gaussian mixture model.
+class LIntExport HClassGmm : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HClassGmm():HHandle() {}
+
+  // Copy constructor
+  HClassGmm(const HClassGmm& source) : HHandle(source) {}
+
+  // Copy constructor
+  HClassGmm(const HHandle& handle);
+
+  // Create HClassGmm from handle, taking ownership
+  explicit HClassGmm(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('class_gmm')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HClassGmm Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_class_gmm: Read a Gaussian Mixture Model from a file.
+  explicit HClassGmm(const HString& FileName);
+
+  // read_class_gmm: Read a Gaussian Mixture Model from a file.
+  explicit HClassGmm(const char* FileName);
+
+#ifdef _WIN32
+  // read_class_gmm: Read a Gaussian Mixture Model from a file.
+  explicit HClassGmm(const wchar_t* FileName);
+#endif
+
+  // create_class_gmm: Create a Gaussian Mixture Model for classification
+  explicit HClassGmm(Hlong NumDim, Hlong NumClasses, const HTuple& NumCenters, const HString& CovarType, const HString& Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+  // create_class_gmm: Create a Gaussian Mixture Model for classification
+  explicit HClassGmm(Hlong NumDim, Hlong NumClasses, Hlong NumCenters, const HString& CovarType, const HString& Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+  // create_class_gmm: Create a Gaussian Mixture Model for classification
+  explicit HClassGmm(Hlong NumDim, Hlong NumClasses, Hlong NumCenters, const char* CovarType, const char* Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+#ifdef _WIN32
+  // create_class_gmm: Create a Gaussian Mixture Model for classification
+  explicit HClassGmm(Hlong NumDim, Hlong NumClasses, Hlong NumCenters, const wchar_t* CovarType, const wchar_t* Preprocessing, Hlong NumComponents, Hlong RandSeed);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Classify an image with a Gaussian Mixture Model.
+  HRegion ClassifyImageClassGmm(const HImage& Image, double RejectionThreshold) const;
+
+  // Add training samples from an image to the training data of a Gaussian Mixture Model.
+  void AddSamplesImageClassGmm(const HImage& Image, const HRegion& ClassRegions, double Randomize) const;
+
+  // Get the training data of a Gaussian Mixture Model (GMM).
+  HClassTrainData GetClassTrainDataGmm() const;
+
+  // Add training data to a Gaussian Mixture Model (GMM).
+  void AddClassTrainDataGmm(const HClassTrainData& ClassTrainDataHandle) const;
+
+  // Selects an optimal combination from a set of features to classify the  provided data.
+  HTuple SelectFeatureSetGmm(const HClassTrainData& ClassTrainDataHandle, const HString& SelectionMethod, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* Score);
+
+  // Selects an optimal combination from a set of features to classify the  provided data.
+  HTuple SelectFeatureSetGmm(const HClassTrainData& ClassTrainDataHandle, const HString& SelectionMethod, const HString& GenParamName, double GenParamValue, HTuple* Score);
+
+  // Selects an optimal combination from a set of features to classify the  provided data.
+  HTuple SelectFeatureSetGmm(const HClassTrainData& ClassTrainDataHandle, const char* SelectionMethod, const char* GenParamName, double GenParamValue, HTuple* Score);
+
+#ifdef _WIN32
+  // Selects an optimal combination from a set of features to classify the  provided data.
+  HTuple SelectFeatureSetGmm(const HClassTrainData& ClassTrainDataHandle, const wchar_t* SelectionMethod, const wchar_t* GenParamName, double GenParamValue, HTuple* Score);
+#endif
+
+  // Create a look-up table using a gaussian mixture model to classify byte images.
+  HClassLUT CreateClassLutGmm(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Clear a Gaussian Mixture Model.
+  static void ClearClassGmm(const HClassGmmArray& GMMHandle);
+
+  // Clear a Gaussian Mixture Model.
+  void ClearClassGmm() const;
+
+  // Clear the training data of a Gaussian Mixture Model.
+  static void ClearSamplesClassGmm(const HClassGmmArray& GMMHandle);
+
+  // Clear the training data of a Gaussian Mixture Model.
+  void ClearSamplesClassGmm() const;
+
+  // Deserialize a serialized Gaussian Mixture Model.
+  void DeserializeClassGmm(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a Gaussian Mixture Model (GMM).
+  HSerializedItem SerializeClassGmm() const;
+
+  // Read a Gaussian Mixture Model from a file.
+  void ReadClassGmm(const HString& FileName);
+
+  // Read a Gaussian Mixture Model from a file.
+  void ReadClassGmm(const char* FileName);
+
+#ifdef _WIN32
+  // Read a Gaussian Mixture Model from a file.
+  void ReadClassGmm(const wchar_t* FileName);
+#endif
+
+  // Write a Gaussian Mixture Model to a file.
+  void WriteClassGmm(const HString& FileName) const;
+
+  // Write a Gaussian Mixture Model to a file.
+  void WriteClassGmm(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a Gaussian Mixture Model to a file.
+  void WriteClassGmm(const wchar_t* FileName) const;
+#endif
+
+  // Read the training data of a Gaussian Mixture Model from a file.
+  void ReadSamplesClassGmm(const HString& FileName) const;
+
+  // Read the training data of a Gaussian Mixture Model from a file.
+  void ReadSamplesClassGmm(const char* FileName) const;
+
+#ifdef _WIN32
+  // Read the training data of a Gaussian Mixture Model from a file.
+  void ReadSamplesClassGmm(const wchar_t* FileName) const;
+#endif
+
+  // Write the training data of a Gaussian Mixture Model to a file.
+  void WriteSamplesClassGmm(const HString& FileName) const;
+
+  // Write the training data of a Gaussian Mixture Model to a file.
+  void WriteSamplesClassGmm(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write the training data of a Gaussian Mixture Model to a file.
+  void WriteSamplesClassGmm(const wchar_t* FileName) const;
+#endif
+
+  // Calculate the class of a feature vector by a Gaussian Mixture Model.
+  HTuple ClassifyClassGmm(const HTuple& Features, Hlong Num, HTuple* ClassProb, HTuple* Density, HTuple* KSigmaProb) const;
+
+  // Evaluate a feature vector by a Gaussian Mixture Model.
+  HTuple EvaluateClassGmm(const HTuple& Features, double* Density, double* KSigmaProb) const;
+
+  // Train a Gaussian Mixture Model.
+  HTuple TrainClassGmm(Hlong MaxIter, double Threshold, const HString& ClassPriors, double Regularize, HTuple* Iter) const;
+
+  // Train a Gaussian Mixture Model.
+  HTuple TrainClassGmm(Hlong MaxIter, double Threshold, const char* ClassPriors, double Regularize, HTuple* Iter) const;
+
+#ifdef _WIN32
+  // Train a Gaussian Mixture Model.
+  HTuple TrainClassGmm(Hlong MaxIter, double Threshold, const wchar_t* ClassPriors, double Regularize, HTuple* Iter) const;
+#endif
+
+  // Compute the information content of the preprocessed feature vectors of a GMM.
+  HTuple GetPrepInfoClassGmm(const HString& Preprocessing, HTuple* CumInformationCont) const;
+
+  // Compute the information content of the preprocessed feature vectors of a GMM.
+  HTuple GetPrepInfoClassGmm(const char* Preprocessing, HTuple* CumInformationCont) const;
+
+#ifdef _WIN32
+  // Compute the information content of the preprocessed feature vectors of a GMM.
+  HTuple GetPrepInfoClassGmm(const wchar_t* Preprocessing, HTuple* CumInformationCont) const;
+#endif
+
+  // Return the number of training samples stored in the training data of a Gaussian Mixture Model (GMM).
+  Hlong GetSampleNumClassGmm() const;
+
+  // Return a training sample from the training data of a Gaussian Mixture Models (GMM).
+  HTuple GetSampleClassGmm(Hlong NumSample, Hlong* ClassID) const;
+
+  // Add a training sample to the training data of a Gaussian Mixture Model.
+  void AddSampleClassGmm(const HTuple& Features, Hlong ClassID, double Randomize) const;
+
+  // Return the parameters of a Gaussian Mixture Model.
+  Hlong GetParamsClassGmm(Hlong* NumClasses, HTuple* MinCenters, HTuple* MaxCenters, HString* CovarType) const;
+
+  // Create a Gaussian Mixture Model for classification
+  void CreateClassGmm(Hlong NumDim, Hlong NumClasses, const HTuple& NumCenters, const HString& CovarType, const HString& Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+  // Create a Gaussian Mixture Model for classification
+  void CreateClassGmm(Hlong NumDim, Hlong NumClasses, Hlong NumCenters, const HString& CovarType, const HString& Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+  // Create a Gaussian Mixture Model for classification
+  void CreateClassGmm(Hlong NumDim, Hlong NumClasses, Hlong NumCenters, const char* CovarType, const char* Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+#ifdef _WIN32
+  // Create a Gaussian Mixture Model for classification
+  void CreateClassGmm(Hlong NumDim, Hlong NumClasses, Hlong NumCenters, const wchar_t* CovarType, const wchar_t* Preprocessing, Hlong NumComponents, Hlong RandSeed);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HClassGmm> HClassGmmArrayRef;
+typedef HSmartPtr< HClassGmmArrayRef > HClassGmmArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HClassGmmArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HClassGmmArray();
+
+  // Create array from native array of tool instances
+  HClassGmmArray(HClassGmm* classes, Hlong length);
+
+  // Copy constructor
+  HClassGmmArray(const HClassGmmArray &tool_array);
+
+  // Destructor
+  virtual ~HClassGmmArray();
+
+  // Assignment operator
+  HClassGmmArray &operator=(const HClassGmmArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HClassGmm* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HClassGmmArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HClassKnn.h

@@ -0,0 +1,222 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCLASSKNN
+#define HCPP_HCLASSKNN
+
+namespace HalconCpp
+{
+
+// Represents an instance of a k-NearestNeighbor classifier.
+class LIntExport HClassKnn : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HClassKnn():HHandle() {}
+
+  // Copy constructor
+  HClassKnn(const HClassKnn& source) : HHandle(source) {}
+
+  // Copy constructor
+  HClassKnn(const HHandle& handle);
+
+  // Create HClassKnn from handle, taking ownership
+  explicit HClassKnn(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('class_knn')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HClassKnn Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_class_knn: Read the k-NN classifier from a file.
+  explicit HClassKnn(const HString& FileName);
+
+  // read_class_knn: Read the k-NN classifier from a file.
+  explicit HClassKnn(const char* FileName);
+
+#ifdef _WIN32
+  // read_class_knn: Read the k-NN classifier from a file.
+  explicit HClassKnn(const wchar_t* FileName);
+#endif
+
+  // create_class_knn: Create a k-nearest neighbors (k-NN) classifier.
+  explicit HClassKnn(const HTuple& NumDim);
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Classify an image with a k-Nearest-Neighbor classifier.
+  HRegion ClassifyImageClassKnn(const HImage& Image, HImage* DistanceImage, double RejectionThreshold) const;
+
+  // Add training samples from an image to the training data of a k-Nearest-Neighbor classifier.
+  void AddSamplesImageClassKnn(const HImage& Image, const HRegion& ClassRegions) const;
+
+  // Get the training data of a k-nearest neighbors (k-NN) classifier.
+  HClassTrainData GetClassTrainDataKnn() const;
+
+  // Add training data to a k-nearest neighbors (k-NN) classifier.
+  void AddClassTrainDataKnn(const HClassTrainData& ClassTrainDataHandle) const;
+
+  // Selects an optimal subset from a set of features to solve a certain  classification problem.
+  HTuple SelectFeatureSetKnn(const HClassTrainData& ClassTrainDataHandle, const HString& SelectionMethod, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* Score);
+
+  // Selects an optimal subset from a set of features to solve a certain  classification problem.
+  HTuple SelectFeatureSetKnn(const HClassTrainData& ClassTrainDataHandle, const HString& SelectionMethod, const HString& GenParamName, double GenParamValue, HTuple* Score);
+
+  // Selects an optimal subset from a set of features to solve a certain  classification problem.
+  HTuple SelectFeatureSetKnn(const HClassTrainData& ClassTrainDataHandle, const char* SelectionMethod, const char* GenParamName, double GenParamValue, HTuple* Score);
+
+#ifdef _WIN32
+  // Selects an optimal subset from a set of features to solve a certain  classification problem.
+  HTuple SelectFeatureSetKnn(const HClassTrainData& ClassTrainDataHandle, const wchar_t* SelectionMethod, const wchar_t* GenParamName, double GenParamValue, HTuple* Score);
+#endif
+
+  // Clear a k-NN classifier.
+  void ClearClassKnn() const;
+
+  // Return the number of training samples stored in the training data of a k-nearest neighbors (k-NN) classifier.
+  Hlong GetSampleNumClassKnn() const;
+
+  // Return a training sample from the training data of a k-nearest neighbors  (k-NN) classifier.
+  HTuple GetSampleClassKnn(Hlong IndexSample, HTuple* ClassID) const;
+
+  // Deserialize a serialized k-NN classifier.
+  void DeserializeClassKnn(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a k-NN classifier.
+  HSerializedItem SerializeClassKnn() const;
+
+  // Read the k-NN classifier from a file.
+  void ReadClassKnn(const HString& FileName);
+
+  // Read the k-NN classifier from a file.
+  void ReadClassKnn(const char* FileName);
+
+#ifdef _WIN32
+  // Read the k-NN classifier from a file.
+  void ReadClassKnn(const wchar_t* FileName);
+#endif
+
+  // Save the k-NN classifier in a file.
+  void WriteClassKnn(const HString& FileName) const;
+
+  // Save the k-NN classifier in a file.
+  void WriteClassKnn(const char* FileName) const;
+
+#ifdef _WIN32
+  // Save the k-NN classifier in a file.
+  void WriteClassKnn(const wchar_t* FileName) const;
+#endif
+
+  // Get parameters of a k-NN classification.
+  HTuple GetParamsClassKnn(const HTuple& GenParamName) const;
+
+  // Set parameters for k-NN classification.
+  void SetParamsClassKnn(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Search for the next neighbors for a given feature vector.
+  HTuple ClassifyClassKnn(const HTuple& Features, HTuple* Rating) const;
+
+  // Creates the search trees for a k-NN classifier.
+  void TrainClassKnn(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Add a sample to a  k-nearest neighbors (k-NN) classifier.
+  void AddSampleClassKnn(const HTuple& Features, const HTuple& ClassID) const;
+
+  // Add a sample to a  k-nearest neighbors (k-NN) classifier.
+  void AddSampleClassKnn(double Features, Hlong ClassID) const;
+
+  // Create a k-nearest neighbors (k-NN) classifier.
+  void CreateClassKnn(const HTuple& NumDim);
+
+  // Create a look-up table using a k-nearest neighbors classifier (k-NN) to classify byte images.
+  HClassLUT CreateClassLutKnn(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HClassKnn> HClassKnnArrayRef;
+typedef HSmartPtr< HClassKnnArrayRef > HClassKnnArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HClassKnnArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HClassKnnArray();
+
+  // Create array from native array of tool instances
+  HClassKnnArray(HClassKnn* classes, Hlong length);
+
+  // Copy constructor
+  HClassKnnArray(const HClassKnnArray &tool_array);
+
+  // Destructor
+  virtual ~HClassKnnArray();
+
+  // Assignment operator
+  HClassKnnArray &operator=(const HClassKnnArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HClassKnn* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HClassKnnArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HClassLUT.h

@@ -0,0 +1,151 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCLASSLUT
+#define HCPP_HCLASSLUT
+
+namespace HalconCpp
+{
+
+// Represents an instance of a classification lookup table
+class LIntExport HClassLUT : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HClassLUT():HHandle() {}
+
+  // Copy constructor
+  HClassLUT(const HClassLUT& source) : HHandle(source) {}
+
+  // Copy constructor
+  HClassLUT(const HHandle& handle);
+
+  // Create HClassLUT from handle, taking ownership
+  explicit HClassLUT(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('class_lut')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_class_lut_knn: Create a look-up table using a k-nearest neighbors classifier (k-NN) to classify byte images.
+  explicit HClassLUT(const HClassKnn& KNNHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // create_class_lut_gmm: Create a look-up table using a gaussian mixture model to classify byte images.
+  explicit HClassLUT(const HClassGmm& GMMHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // create_class_lut_svm: Create a look-up table using a Support-Vector-Machine to classify byte images.
+  explicit HClassLUT(const HClassSvm& SVMHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // create_class_lut_mlp: Create a look-up table using a multi-layer perceptron to classify byte images.
+  explicit HClassLUT(const HClassMlp& MLPHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Classify a byte image using a look-up table.
+  HRegion ClassifyImageClassLut(const HImage& Image) const;
+
+  // Clear a look-up table classifier.
+  static void ClearClassLut(const HClassLUTArray& ClassLUTHandle);
+
+  // Clear a look-up table classifier.
+  void ClearClassLut() const;
+
+  // Create a look-up table using a k-nearest neighbors classifier (k-NN) to classify byte images.
+  void CreateClassLutKnn(const HClassKnn& KNNHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Create a look-up table using a gaussian mixture model to classify byte images.
+  void CreateClassLutGmm(const HClassGmm& GMMHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Create a look-up table using a Support-Vector-Machine to classify byte images.
+  void CreateClassLutSvm(const HClassSvm& SVMHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Create a look-up table using a multi-layer perceptron to classify byte images.
+  void CreateClassLutMlp(const HClassMlp& MLPHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HClassLUT> HClassLUTArrayRef;
+typedef HSmartPtr< HClassLUTArrayRef > HClassLUTArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HClassLUTArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HClassLUTArray();
+
+  // Create array from native array of tool instances
+  HClassLUTArray(HClassLUT* classes, Hlong length);
+
+  // Copy constructor
+  HClassLUTArray(const HClassLUTArray &tool_array);
+
+  // Destructor
+  virtual ~HClassLUTArray();
+
+  // Assignment operator
+  HClassLUTArray &operator=(const HClassLUTArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HClassLUT* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HClassLUTArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HClassMlp.h

@@ -0,0 +1,336 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCLASSMLP
+#define HCPP_HCLASSMLP
+
+namespace HalconCpp
+{
+
+// Represents an instance of a multilayer perceptron.
+class LIntExport HClassMlp : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HClassMlp():HHandle() {}
+
+  // Copy constructor
+  HClassMlp(const HClassMlp& source) : HHandle(source) {}
+
+  // Copy constructor
+  HClassMlp(const HHandle& handle);
+
+  // Create HClassMlp from handle, taking ownership
+  explicit HClassMlp(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('class_mlp')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HClassMlp Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_class_mlp: Read a multilayer perceptron from a file.
+  explicit HClassMlp(const HString& FileName);
+
+  // read_class_mlp: Read a multilayer perceptron from a file.
+  explicit HClassMlp(const char* FileName);
+
+#ifdef _WIN32
+  // read_class_mlp: Read a multilayer perceptron from a file.
+  explicit HClassMlp(const wchar_t* FileName);
+#endif
+
+  // create_class_mlp: Create a multilayer perceptron for classification or regression.
+  explicit HClassMlp(Hlong NumInput, Hlong NumHidden, Hlong NumOutput, const HString& OutputFunction, const HString& Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+  // create_class_mlp: Create a multilayer perceptron for classification or regression.
+  explicit HClassMlp(Hlong NumInput, Hlong NumHidden, Hlong NumOutput, const char* OutputFunction, const char* Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+#ifdef _WIN32
+  // create_class_mlp: Create a multilayer perceptron for classification or regression.
+  explicit HClassMlp(Hlong NumInput, Hlong NumHidden, Hlong NumOutput, const wchar_t* OutputFunction, const wchar_t* Preprocessing, Hlong NumComponents, Hlong RandSeed);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Classify an image with a multilayer perceptron.
+  HRegion ClassifyImageClassMlp(const HImage& Image, double RejectionThreshold) const;
+
+  // Add training samples from an image to the training data of a multilayer perceptron.
+  void AddSamplesImageClassMlp(const HImage& Image, const HRegion& ClassRegions) const;
+
+  // Get the training data of a multilayer perceptron (MLP).
+  HClassTrainData GetClassTrainDataMlp() const;
+
+  // Add training data to a multilayer perceptron (MLP).
+  void AddClassTrainDataMlp(const HClassTrainData& ClassTrainDataHandle) const;
+
+  // Selects an optimal combination of features to classify the provided data.
+  HTuple SelectFeatureSetMlp(const HClassTrainData& ClassTrainDataHandle, const HString& SelectionMethod, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* Score);
+
+  // Selects an optimal combination of features to classify the provided data.
+  HTuple SelectFeatureSetMlp(const HClassTrainData& ClassTrainDataHandle, const HString& SelectionMethod, const HString& GenParamName, double GenParamValue, HTuple* Score);
+
+  // Selects an optimal combination of features to classify the provided data.
+  HTuple SelectFeatureSetMlp(const HClassTrainData& ClassTrainDataHandle, const char* SelectionMethod, const char* GenParamName, double GenParamValue, HTuple* Score);
+
+#ifdef _WIN32
+  // Selects an optimal combination of features to classify the provided data.
+  HTuple SelectFeatureSetMlp(const HClassTrainData& ClassTrainDataHandle, const wchar_t* SelectionMethod, const wchar_t* GenParamName, double GenParamValue, HTuple* Score);
+#endif
+
+  // Create a look-up table using a multi-layer perceptron to classify byte images.
+  HClassLUT CreateClassLutMlp(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Clear a multilayer perceptron.
+  static void ClearClassMlp(const HClassMlpArray& MLPHandle);
+
+  // Clear a multilayer perceptron.
+  void ClearClassMlp() const;
+
+  // Clear the training data of a multilayer perceptron.
+  static void ClearSamplesClassMlp(const HClassMlpArray& MLPHandle);
+
+  // Clear the training data of a multilayer perceptron.
+  void ClearSamplesClassMlp() const;
+
+  // Deserialize a serialized multilayer perceptron.
+  void DeserializeClassMlp(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a multilayer perceptron (MLP).
+  HSerializedItem SerializeClassMlp() const;
+
+  // Read a multilayer perceptron from a file.
+  void ReadClassMlp(const HString& FileName);
+
+  // Read a multilayer perceptron from a file.
+  void ReadClassMlp(const char* FileName);
+
+#ifdef _WIN32
+  // Read a multilayer perceptron from a file.
+  void ReadClassMlp(const wchar_t* FileName);
+#endif
+
+  // Write a multilayer perceptron to a file.
+  void WriteClassMlp(const HString& FileName) const;
+
+  // Write a multilayer perceptron to a file.
+  void WriteClassMlp(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a multilayer perceptron to a file.
+  void WriteClassMlp(const wchar_t* FileName) const;
+#endif
+
+  // Read the training data of a multilayer perceptron from a file.
+  void ReadSamplesClassMlp(const HString& FileName) const;
+
+  // Read the training data of a multilayer perceptron from a file.
+  void ReadSamplesClassMlp(const char* FileName) const;
+
+#ifdef _WIN32
+  // Read the training data of a multilayer perceptron from a file.
+  void ReadSamplesClassMlp(const wchar_t* FileName) const;
+#endif
+
+  // Write the training data of a multilayer perceptron to a file.
+  void WriteSamplesClassMlp(const HString& FileName) const;
+
+  // Write the training data of a multilayer perceptron to a file.
+  void WriteSamplesClassMlp(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write the training data of a multilayer perceptron to a file.
+  void WriteSamplesClassMlp(const wchar_t* FileName) const;
+#endif
+
+  // Calculate the class of a feature vector by a multilayer perceptron.
+  HTuple ClassifyClassMlp(const HTuple& Features, const HTuple& Num, HTuple* Confidence) const;
+
+  // Calculate the class of a feature vector by a multilayer perceptron.
+  Hlong ClassifyClassMlp(const HTuple& Features, const HTuple& Num, double* Confidence) const;
+
+  // Calculate the evaluation of a feature vector by a multilayer perceptron.
+  HTuple EvaluateClassMlp(const HTuple& Features) const;
+
+  // Train a multilayer perceptron.
+  double TrainClassMlp(Hlong MaxIterations, double WeightTolerance, double ErrorTolerance, HTuple* ErrorLog) const;
+
+  // Compute the information content of the preprocessed feature vectors of a multilayer perceptron.
+  HTuple GetPrepInfoClassMlp(const HString& Preprocessing, HTuple* CumInformationCont) const;
+
+  // Compute the information content of the preprocessed feature vectors of a multilayer perceptron.
+  HTuple GetPrepInfoClassMlp(const char* Preprocessing, HTuple* CumInformationCont) const;
+
+#ifdef _WIN32
+  // Compute the information content of the preprocessed feature vectors of a multilayer perceptron.
+  HTuple GetPrepInfoClassMlp(const wchar_t* Preprocessing, HTuple* CumInformationCont) const;
+#endif
+
+  // Return the number of training samples stored in the training data of a multilayer perceptron.
+  Hlong GetSampleNumClassMlp() const;
+
+  // Return a training sample from the training data of a multilayer perceptron.
+  HTuple GetSampleClassMlp(Hlong IndexSample, HTuple* Target) const;
+
+  // Get the parameters of a rejection class.
+  HTuple GetRejectionParamsClassMlp(const HTuple& GenParamName) const;
+
+  // Get the parameters of a rejection class.
+  HTuple GetRejectionParamsClassMlp(const HString& GenParamName) const;
+
+  // Get the parameters of a rejection class.
+  HTuple GetRejectionParamsClassMlp(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Get the parameters of a rejection class.
+  HTuple GetRejectionParamsClassMlp(const wchar_t* GenParamName) const;
+#endif
+
+  // Set the parameters of a rejection class.
+  void SetRejectionParamsClassMlp(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set the parameters of a rejection class.
+  void SetRejectionParamsClassMlp(const HString& GenParamName, const HString& GenParamValue) const;
+
+  // Set the parameters of a rejection class.
+  void SetRejectionParamsClassMlp(const char* GenParamName, const char* GenParamValue) const;
+
+#ifdef _WIN32
+  // Set the parameters of a rejection class.
+  void SetRejectionParamsClassMlp(const wchar_t* GenParamName, const wchar_t* GenParamValue) const;
+#endif
+
+  // Add a training sample to the training data of a multilayer perceptron.
+  void AddSampleClassMlp(const HTuple& Features, const HTuple& Target) const;
+
+  // Add a training sample to the training data of a multilayer perceptron.
+  void AddSampleClassMlp(const HTuple& Features, Hlong Target) const;
+
+  // Return the regularization parameters of a multilayer perceptron.
+  HTuple GetRegularizationParamsClassMlp(const HString& GenParamName) const;
+
+  // Return the regularization parameters of a multilayer perceptron.
+  HTuple GetRegularizationParamsClassMlp(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Return the regularization parameters of a multilayer perceptron.
+  HTuple GetRegularizationParamsClassMlp(const wchar_t* GenParamName) const;
+#endif
+
+  // Set the regularization parameters of a multilayer perceptron.
+  void SetRegularizationParamsClassMlp(const HString& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set the regularization parameters of a multilayer perceptron.
+  void SetRegularizationParamsClassMlp(const HString& GenParamName, double GenParamValue) const;
+
+  // Set the regularization parameters of a multilayer perceptron.
+  void SetRegularizationParamsClassMlp(const char* GenParamName, double GenParamValue) const;
+
+#ifdef _WIN32
+  // Set the regularization parameters of a multilayer perceptron.
+  void SetRegularizationParamsClassMlp(const wchar_t* GenParamName, double GenParamValue) const;
+#endif
+
+  // Return the parameters of a multilayer perceptron.
+  Hlong GetParamsClassMlp(Hlong* NumHidden, Hlong* NumOutput, HString* OutputFunction, HString* Preprocessing, Hlong* NumComponents) const;
+
+  // Create a multilayer perceptron for classification or regression.
+  void CreateClassMlp(Hlong NumInput, Hlong NumHidden, Hlong NumOutput, const HString& OutputFunction, const HString& Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+  // Create a multilayer perceptron for classification or regression.
+  void CreateClassMlp(Hlong NumInput, Hlong NumHidden, Hlong NumOutput, const char* OutputFunction, const char* Preprocessing, Hlong NumComponents, Hlong RandSeed);
+
+#ifdef _WIN32
+  // Create a multilayer perceptron for classification or regression.
+  void CreateClassMlp(Hlong NumInput, Hlong NumHidden, Hlong NumOutput, const wchar_t* OutputFunction, const wchar_t* Preprocessing, Hlong NumComponents, Hlong RandSeed);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HClassMlp> HClassMlpArrayRef;
+typedef HSmartPtr< HClassMlpArrayRef > HClassMlpArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HClassMlpArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HClassMlpArray();
+
+  // Create array from native array of tool instances
+  HClassMlpArray(HClassMlp* classes, Hlong length);
+
+  // Copy constructor
+  HClassMlpArray(const HClassMlpArray &tool_array);
+
+  // Destructor
+  virtual ~HClassMlpArray();
+
+  // Assignment operator
+  HClassMlpArray &operator=(const HClassMlpArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HClassMlp* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HClassMlpArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HClassSvm.h

@@ -0,0 +1,308 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCLASSSVM
+#define HCPP_HCLASSSVM
+
+namespace HalconCpp
+{
+
+// Represents an instance of a support vector machine.
+class LIntExport HClassSvm : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HClassSvm():HHandle() {}
+
+  // Copy constructor
+  HClassSvm(const HClassSvm& source) : HHandle(source) {}
+
+  // Copy constructor
+  HClassSvm(const HHandle& handle);
+
+  // Create HClassSvm from handle, taking ownership
+  explicit HClassSvm(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('class_svm')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HClassSvm Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_class_svm: Read a support vector machine from a file.
+  explicit HClassSvm(const HString& FileName);
+
+  // read_class_svm: Read a support vector machine from a file.
+  explicit HClassSvm(const char* FileName);
+
+#ifdef _WIN32
+  // read_class_svm: Read a support vector machine from a file.
+  explicit HClassSvm(const wchar_t* FileName);
+#endif
+
+  // create_class_svm: Create a support vector machine for pattern classification.
+  explicit HClassSvm(Hlong NumFeatures, const HString& KernelType, double KernelParam, double Nu, Hlong NumClasses, const HString& Mode, const HString& Preprocessing, Hlong NumComponents);
+
+  // create_class_svm: Create a support vector machine for pattern classification.
+  explicit HClassSvm(Hlong NumFeatures, const char* KernelType, double KernelParam, double Nu, Hlong NumClasses, const char* Mode, const char* Preprocessing, Hlong NumComponents);
+
+#ifdef _WIN32
+  // create_class_svm: Create a support vector machine for pattern classification.
+  explicit HClassSvm(Hlong NumFeatures, const wchar_t* KernelType, double KernelParam, double Nu, Hlong NumClasses, const wchar_t* Mode, const wchar_t* Preprocessing, Hlong NumComponents);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Classify an image with a support vector machine.
+  HRegion ClassifyImageClassSvm(const HImage& Image) const;
+
+  // Add training samples from an image to the training data of a support vector machine.
+  void AddSamplesImageClassSvm(const HImage& Image, const HRegion& ClassRegions) const;
+
+  // Get the training data of a support vector machine (SVM).
+  HClassTrainData GetClassTrainDataSvm() const;
+
+  // Add training data to a support vector machine (SVM).
+  void AddClassTrainDataSvm(const HClassTrainData& ClassTrainDataHandle) const;
+
+  // Selects an optimal combination of features to classify the provided data.
+  HTuple SelectFeatureSetSvm(const HClassTrainData& ClassTrainDataHandle, const HString& SelectionMethod, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* Score);
+
+  // Selects an optimal combination of features to classify the provided data.
+  HTuple SelectFeatureSetSvm(const HClassTrainData& ClassTrainDataHandle, const HString& SelectionMethod, const HString& GenParamName, double GenParamValue, HTuple* Score);
+
+  // Selects an optimal combination of features to classify the provided data.
+  HTuple SelectFeatureSetSvm(const HClassTrainData& ClassTrainDataHandle, const char* SelectionMethod, const char* GenParamName, double GenParamValue, HTuple* Score);
+
+#ifdef _WIN32
+  // Selects an optimal combination of features to classify the provided data.
+  HTuple SelectFeatureSetSvm(const HClassTrainData& ClassTrainDataHandle, const wchar_t* SelectionMethod, const wchar_t* GenParamName, double GenParamValue, HTuple* Score);
+#endif
+
+  // Create a look-up table using a Support-Vector-Machine to classify byte images.
+  HClassLUT CreateClassLutSvm(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Clear a support vector machine.
+  static void ClearClassSvm(const HClassSvmArray& SVMHandle);
+
+  // Clear a support vector machine.
+  void ClearClassSvm() const;
+
+  // Clear the training data of a support vector machine.
+  static void ClearSamplesClassSvm(const HClassSvmArray& SVMHandle);
+
+  // Clear the training data of a support vector machine.
+  void ClearSamplesClassSvm() const;
+
+  // Deserialize a serialized support vector machine (SVM).
+  void DeserializeClassSvm(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a support vector machine (SVM).
+  HSerializedItem SerializeClassSvm() const;
+
+  // Read a support vector machine from a file.
+  void ReadClassSvm(const HString& FileName);
+
+  // Read a support vector machine from a file.
+  void ReadClassSvm(const char* FileName);
+
+#ifdef _WIN32
+  // Read a support vector machine from a file.
+  void ReadClassSvm(const wchar_t* FileName);
+#endif
+
+  // Write a support vector machine to a file.
+  void WriteClassSvm(const HString& FileName) const;
+
+  // Write a support vector machine to a file.
+  void WriteClassSvm(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a support vector machine to a file.
+  void WriteClassSvm(const wchar_t* FileName) const;
+#endif
+
+  // Read the training data of a support vector machine from a file.
+  void ReadSamplesClassSvm(const HString& FileName) const;
+
+  // Read the training data of a support vector machine from a file.
+  void ReadSamplesClassSvm(const char* FileName) const;
+
+#ifdef _WIN32
+  // Read the training data of a support vector machine from a file.
+  void ReadSamplesClassSvm(const wchar_t* FileName) const;
+#endif
+
+  // Write the training data of a support vector machine to a file.
+  void WriteSamplesClassSvm(const HString& FileName) const;
+
+  // Write the training data of a support vector machine to a file.
+  void WriteSamplesClassSvm(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write the training data of a support vector machine to a file.
+  void WriteSamplesClassSvm(const wchar_t* FileName) const;
+#endif
+
+  // Evaluate a feature vector by a support vector machine.
+  HTuple EvaluateClassSvm(const HTuple& Features) const;
+
+  // Classify a feature vector by a support vector machine.
+  HTuple ClassifyClassSvm(const HTuple& Features, const HTuple& Num) const;
+
+  // Approximate a trained support vector machine by a reduced support vector machine for faster classification.
+  HClassSvm ReduceClassSvm(const HString& Method, Hlong MinRemainingSV, double MaxError) const;
+
+  // Approximate a trained support vector machine by a reduced support vector machine for faster classification.
+  HClassSvm ReduceClassSvm(const char* Method, Hlong MinRemainingSV, double MaxError) const;
+
+#ifdef _WIN32
+  // Approximate a trained support vector machine by a reduced support vector machine for faster classification.
+  HClassSvm ReduceClassSvm(const wchar_t* Method, Hlong MinRemainingSV, double MaxError) const;
+#endif
+
+  // Train a support vector machine.
+  void TrainClassSvm(double Epsilon, const HTuple& TrainMode) const;
+
+  // Train a support vector machine.
+  void TrainClassSvm(double Epsilon, const HString& TrainMode) const;
+
+  // Train a support vector machine.
+  void TrainClassSvm(double Epsilon, const char* TrainMode) const;
+
+#ifdef _WIN32
+  // Train a support vector machine.
+  void TrainClassSvm(double Epsilon, const wchar_t* TrainMode) const;
+#endif
+
+  // Compute the information content of the preprocessed feature vectors of a support vector machine
+  HTuple GetPrepInfoClassSvm(const HString& Preprocessing, HTuple* CumInformationCont) const;
+
+  // Compute the information content of the preprocessed feature vectors of a support vector machine
+  HTuple GetPrepInfoClassSvm(const char* Preprocessing, HTuple* CumInformationCont) const;
+
+#ifdef _WIN32
+  // Compute the information content of the preprocessed feature vectors of a support vector machine
+  HTuple GetPrepInfoClassSvm(const wchar_t* Preprocessing, HTuple* CumInformationCont) const;
+#endif
+
+  // Return the number of support vectors of a support vector machine.
+  Hlong GetSupportVectorNumClassSvm(HTuple* NumSVPerSVM) const;
+
+  // Return the index of a support vector from a trained support vector machine.
+  double GetSupportVectorClassSvm(Hlong IndexSupportVector) const;
+
+  // Return the number of training samples stored in the training data of a support vector machine.
+  Hlong GetSampleNumClassSvm() const;
+
+  // Return a training sample from the training data of a support vector machine.
+  HTuple GetSampleClassSvm(Hlong IndexSample, Hlong* Target) const;
+
+  // Add a training sample to the training data of a support vector machine.
+  void AddSampleClassSvm(const HTuple& Features, const HTuple& Class) const;
+
+  // Add a training sample to the training data of a support vector machine.
+  void AddSampleClassSvm(const HTuple& Features, Hlong Class) const;
+
+  // Return the parameters of a support vector machine.
+  Hlong GetParamsClassSvm(HString* KernelType, double* KernelParam, double* Nu, Hlong* NumClasses, HString* Mode, HString* Preprocessing, Hlong* NumComponents) const;
+
+  // Create a support vector machine for pattern classification.
+  void CreateClassSvm(Hlong NumFeatures, const HString& KernelType, double KernelParam, double Nu, Hlong NumClasses, const HString& Mode, const HString& Preprocessing, Hlong NumComponents);
+
+  // Create a support vector machine for pattern classification.
+  void CreateClassSvm(Hlong NumFeatures, const char* KernelType, double KernelParam, double Nu, Hlong NumClasses, const char* Mode, const char* Preprocessing, Hlong NumComponents);
+
+#ifdef _WIN32
+  // Create a support vector machine for pattern classification.
+  void CreateClassSvm(Hlong NumFeatures, const wchar_t* KernelType, double KernelParam, double Nu, Hlong NumClasses, const wchar_t* Mode, const wchar_t* Preprocessing, Hlong NumComponents);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HClassSvm> HClassSvmArrayRef;
+typedef HSmartPtr< HClassSvmArrayRef > HClassSvmArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HClassSvmArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HClassSvmArray();
+
+  // Create array from native array of tool instances
+  HClassSvmArray(HClassSvm* classes, Hlong length);
+
+  // Copy constructor
+  HClassSvmArray(const HClassSvmArray &tool_array);
+
+  // Destructor
+  virtual ~HClassSvmArray();
+
+  // Assignment operator
+  HClassSvmArray &operator=(const HClassSvmArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HClassSvm* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HClassSvmArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HClassTrainData.h

@@ -0,0 +1,269 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCLASSTRAINDATA
+#define HCPP_HCLASSTRAINDATA
+
+namespace HalconCpp
+{
+
+// Represents an instance of a training data management class.
+class LIntExport HClassTrainData : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HClassTrainData():HHandle() {}
+
+  // Copy constructor
+  HClassTrainData(const HClassTrainData& source) : HHandle(source) {}
+
+  // Copy constructor
+  HClassTrainData(const HHandle& handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('class_train_data')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HClassTrainData Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_class_train_data: Read the training data for classifiers from a file.
+  explicit HClassTrainData(const HString& FileName);
+
+  // read_class_train_data: Read the training data for classifiers from a file.
+  explicit HClassTrainData(const char* FileName);
+
+#ifdef _WIN32
+  // read_class_train_data: Read the training data for classifiers from a file.
+  explicit HClassTrainData(const wchar_t* FileName);
+#endif
+
+  // create_class_train_data: Create a handle for training data for classifiers.
+  explicit HClassTrainData(Hlong NumDim);
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Deserialize serialized training data for classifiers.
+  void DeserializeClassTrainData(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize training data for classifiers.
+  HSerializedItem SerializeClassTrainData() const;
+
+  // Read the training data for classifiers from a file.
+  void ReadClassTrainData(const HString& FileName);
+
+  // Read the training data for classifiers from a file.
+  void ReadClassTrainData(const char* FileName);
+
+#ifdef _WIN32
+  // Read the training data for classifiers from a file.
+  void ReadClassTrainData(const wchar_t* FileName);
+#endif
+
+  // Save the training data for classifiers in a file.
+  void WriteClassTrainData(const HString& FileName) const;
+
+  // Save the training data for classifiers in a file.
+  void WriteClassTrainData(const char* FileName) const;
+
+#ifdef _WIN32
+  // Save the training data for classifiers in a file.
+  void WriteClassTrainData(const wchar_t* FileName) const;
+#endif
+
+  // Select certain features from training data to create  training data containing less features.
+  HClassTrainData SelectSubFeatureClassTrainData(const HTuple& SubFeatureIndices) const;
+
+  // Define subfeatures in training data.
+  void SetFeatureLengthsClassTrainData(const HTuple& SubFeatureLength, const HTuple& Names) const;
+
+  // Get the training data of a Gaussian Mixture Model (GMM).
+  void GetClassTrainDataGmm(const HClassGmm& GMMHandle);
+
+  // Add training data to a Gaussian Mixture Model (GMM).
+  void AddClassTrainDataGmm(const HClassGmm& GMMHandle) const;
+
+  // Get the training data of a multilayer perceptron (MLP).
+  void GetClassTrainDataMlp(const HClassMlp& MLPHandle);
+
+  // Add training data to a multilayer perceptron (MLP).
+  void AddClassTrainDataMlp(const HClassMlp& MLPHandle) const;
+
+  // Get the training data of a k-nearest neighbors (k-NN) classifier.
+  void GetClassTrainDataKnn(const HClassKnn& KNNHandle);
+
+  // Add training data to a k-nearest neighbors (k-NN) classifier.
+  void AddClassTrainDataKnn(const HClassKnn& KNNHandle) const;
+
+  // Get the training data of a support vector machine (SVM).
+  void GetClassTrainDataSvm(const HClassSvm& SVMHandle);
+
+  // Add training data to a support vector machine (SVM).
+  void AddClassTrainDataSvm(const HClassSvm& SVMHandle) const;
+
+  // Return the number of training samples stored in the training data.
+  Hlong GetSampleNumClassTrainData() const;
+
+  // Return a training sample from training data.
+  HTuple GetSampleClassTrainData(Hlong IndexSample, Hlong* ClassID) const;
+
+  // Clears training data for classifiers.
+  void ClearClassTrainData() const;
+
+  // Add a training sample to training data.
+  void AddSampleClassTrainData(const HString& Order, const HTuple& Features, const HTuple& ClassID) const;
+
+  // Add a training sample to training data.
+  void AddSampleClassTrainData(const char* Order, const HTuple& Features, const HTuple& ClassID) const;
+
+#ifdef _WIN32
+  // Add a training sample to training data.
+  void AddSampleClassTrainData(const wchar_t* Order, const HTuple& Features, const HTuple& ClassID) const;
+#endif
+
+  // Create a handle for training data for classifiers.
+  void CreateClassTrainData(Hlong NumDim);
+
+  // Selects an optimal combination of features to classify the provided data.
+  HClassMlp SelectFeatureSetMlp(const HString& SelectionMethod, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+  // Selects an optimal combination of features to classify the provided data.
+  HClassMlp SelectFeatureSetMlp(const HString& SelectionMethod, const HString& GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+  // Selects an optimal combination of features to classify the provided data.
+  HClassMlp SelectFeatureSetMlp(const char* SelectionMethod, const char* GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+#ifdef _WIN32
+  // Selects an optimal combination of features to classify the provided data.
+  HClassMlp SelectFeatureSetMlp(const wchar_t* SelectionMethod, const wchar_t* GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+#endif
+
+  // Selects an optimal combination of features to classify the provided data.
+  HClassSvm SelectFeatureSetSvm(const HString& SelectionMethod, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+  // Selects an optimal combination of features to classify the provided data.
+  HClassSvm SelectFeatureSetSvm(const HString& SelectionMethod, const HString& GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+  // Selects an optimal combination of features to classify the provided data.
+  HClassSvm SelectFeatureSetSvm(const char* SelectionMethod, const char* GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+#ifdef _WIN32
+  // Selects an optimal combination of features to classify the provided data.
+  HClassSvm SelectFeatureSetSvm(const wchar_t* SelectionMethod, const wchar_t* GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+#endif
+
+  // Selects an optimal combination from a set of features to classify the  provided data.
+  HClassGmm SelectFeatureSetGmm(const HString& SelectionMethod, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+  // Selects an optimal combination from a set of features to classify the  provided data.
+  HClassGmm SelectFeatureSetGmm(const HString& SelectionMethod, const HString& GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+  // Selects an optimal combination from a set of features to classify the  provided data.
+  HClassGmm SelectFeatureSetGmm(const char* SelectionMethod, const char* GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+#ifdef _WIN32
+  // Selects an optimal combination from a set of features to classify the  provided data.
+  HClassGmm SelectFeatureSetGmm(const wchar_t* SelectionMethod, const wchar_t* GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+#endif
+
+  // Selects an optimal subset from a set of features to solve a certain  classification problem.
+  HClassKnn SelectFeatureSetKnn(const HString& SelectionMethod, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+  // Selects an optimal subset from a set of features to solve a certain  classification problem.
+  HClassKnn SelectFeatureSetKnn(const HString& SelectionMethod, const HString& GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+  // Selects an optimal subset from a set of features to solve a certain  classification problem.
+  HClassKnn SelectFeatureSetKnn(const char* SelectionMethod, const char* GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+
+#ifdef _WIN32
+  // Selects an optimal subset from a set of features to solve a certain  classification problem.
+  HClassKnn SelectFeatureSetKnn(const wchar_t* SelectionMethod, const wchar_t* GenParamName, double GenParamValue, HTuple* SelectedFeatureIndices, HTuple* Score) const;
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HClassTrainData> HClassTrainDataArrayRef;
+typedef HSmartPtr< HClassTrainDataArrayRef > HClassTrainDataArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HClassTrainDataArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HClassTrainDataArray();
+
+  // Create array from native array of tool instances
+  HClassTrainDataArray(HClassTrainData* classes, Hlong length);
+
+  // Copy constructor
+  HClassTrainDataArray(const HClassTrainDataArray &tool_array);
+
+  // Destructor
+  virtual ~HClassTrainDataArray();
+
+  // Assignment operator
+  HClassTrainDataArray &operator=(const HClassTrainDataArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HClassTrainData* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HClassTrainDataArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HColorTransLUT.h

@@ -0,0 +1,146 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCOLORTRANSLUT
+#define HCPP_HCOLORTRANSLUT
+
+namespace HalconCpp
+{
+
+// Represents an instance of a color space transformation lookup table
+class LIntExport HColorTransLUT : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HColorTransLUT():HHandle() {}
+
+  // Copy constructor
+  HColorTransLUT(const HColorTransLUT& source) : HHandle(source) {}
+
+  // Copy constructor
+  HColorTransLUT(const HHandle& handle);
+
+  // Create HColorTransLUT from handle, taking ownership
+  explicit HColorTransLUT(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('color_trans_lut')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_color_trans_lut: Creates the look-up-table for transformation of an image from the RGB color space to an arbitrary color space.
+  explicit HColorTransLUT(const HString& ColorSpace, const HString& TransDirection, Hlong NumBits);
+
+  // create_color_trans_lut: Creates the look-up-table for transformation of an image from the RGB color space to an arbitrary color space.
+  explicit HColorTransLUT(const char* ColorSpace, const char* TransDirection, Hlong NumBits);
+
+#ifdef _WIN32
+  // create_color_trans_lut: Creates the look-up-table for transformation of an image from the RGB color space to an arbitrary color space.
+  explicit HColorTransLUT(const wchar_t* ColorSpace, const wchar_t* TransDirection, Hlong NumBits);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Release the look-up-table needed for color space transformation.
+  void ClearColorTransLut() const;
+
+  // Color space transformation using pre-generated look-up-table.
+  HImage ApplyColorTransLut(const HImage& Image1, const HImage& Image2, const HImage& Image3, HImage* ImageResult2, HImage* ImageResult3) const;
+
+  // Creates the look-up-table for transformation of an image from the RGB color space to an arbitrary color space.
+  void CreateColorTransLut(const HString& ColorSpace, const HString& TransDirection, Hlong NumBits);
+
+  // Creates the look-up-table for transformation of an image from the RGB color space to an arbitrary color space.
+  void CreateColorTransLut(const char* ColorSpace, const char* TransDirection, Hlong NumBits);
+
+#ifdef _WIN32
+  // Creates the look-up-table for transformation of an image from the RGB color space to an arbitrary color space.
+  void CreateColorTransLut(const wchar_t* ColorSpace, const wchar_t* TransDirection, Hlong NumBits);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HColorTransLUT> HColorTransLUTArrayRef;
+typedef HSmartPtr< HColorTransLUTArrayRef > HColorTransLUTArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HColorTransLUTArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HColorTransLUTArray();
+
+  // Create array from native array of tool instances
+  HColorTransLUTArray(HColorTransLUT* classes, Hlong length);
+
+  // Copy constructor
+  HColorTransLUTArray(const HColorTransLUTArray &tool_array);
+
+  // Destructor
+  virtual ~HColorTransLUTArray();
+
+  // Assignment operator
+  HColorTransLUTArray &operator=(const HColorTransLUTArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HColorTransLUT* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HColorTransLUTArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HComponentTraining.h

@@ -0,0 +1,258 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCOMPONENTTRAINING
+#define HCPP_HCOMPONENTTRAINING
+
+namespace HalconCpp
+{
+
+// Represents an instance of a training result for the component-based matching.
+class LIntExport HComponentTraining : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HComponentTraining():HHandle() {}
+
+  // Copy constructor
+  HComponentTraining(const HComponentTraining& source) : HHandle(source) {}
+
+  // Copy constructor
+  HComponentTraining(const HHandle& handle);
+
+  // Create HComponentTraining from handle, taking ownership
+  explicit HComponentTraining(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('component_training')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HComponentTraining Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // train_model_components: Train components and relations for the component-based matching.
+  explicit HComponentTraining(const HImage& ModelImage, const HRegion& InitialComponents, const HImage& TrainingImages, HRegion* ModelComponents, const HTuple& ContrastLow, const HTuple& ContrastHigh, const HTuple& MinSize, const HTuple& MinScore, const HTuple& SearchRowTol, const HTuple& SearchColumnTol, const HTuple& SearchAngleTol, const HString& TrainingEmphasis, const HString& AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold);
+
+  // train_model_components: Train components and relations for the component-based matching.
+  explicit HComponentTraining(const HImage& ModelImage, const HRegion& InitialComponents, const HImage& TrainingImages, HRegion* ModelComponents, Hlong ContrastLow, Hlong ContrastHigh, Hlong MinSize, double MinScore, Hlong SearchRowTol, Hlong SearchColumnTol, double SearchAngleTol, const HString& TrainingEmphasis, const HString& AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold);
+
+  // train_model_components: Train components and relations for the component-based matching.
+  explicit HComponentTraining(const HImage& ModelImage, const HRegion& InitialComponents, const HImage& TrainingImages, HRegion* ModelComponents, Hlong ContrastLow, Hlong ContrastHigh, Hlong MinSize, double MinScore, Hlong SearchRowTol, Hlong SearchColumnTol, double SearchAngleTol, const char* TrainingEmphasis, const char* AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold);
+
+#ifdef _WIN32
+  // train_model_components: Train components and relations for the component-based matching.
+  explicit HComponentTraining(const HImage& ModelImage, const HRegion& InitialComponents, const HImage& TrainingImages, HRegion* ModelComponents, Hlong ContrastLow, Hlong ContrastHigh, Hlong MinSize, double MinScore, Hlong SearchRowTol, Hlong SearchColumnTol, double SearchAngleTol, const wchar_t* TrainingEmphasis, const wchar_t* AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Prepare a component model for matching based on trained components.
+  HComponentModel CreateTrainedComponentModel(double AngleStart, double AngleExtent, const HTuple& MinContrastComp, const HTuple& MinScoreComp, const HTuple& NumLevelsComp, const HTuple& AngleStepComp, const HString& OptimizationComp, const HTuple& MetricComp, const HTuple& PregenerationComp, HTuple* RootRanking) const;
+
+  // Prepare a component model for matching based on trained components.
+  HComponentModel CreateTrainedComponentModel(double AngleStart, double AngleExtent, Hlong MinContrastComp, double MinScoreComp, Hlong NumLevelsComp, double AngleStepComp, const HString& OptimizationComp, const HString& MetricComp, const HString& PregenerationComp, Hlong* RootRanking) const;
+
+  // Prepare a component model for matching based on trained components.
+  HComponentModel CreateTrainedComponentModel(double AngleStart, double AngleExtent, Hlong MinContrastComp, double MinScoreComp, Hlong NumLevelsComp, double AngleStepComp, const char* OptimizationComp, const char* MetricComp, const char* PregenerationComp, Hlong* RootRanking) const;
+
+#ifdef _WIN32
+  // Prepare a component model for matching based on trained components.
+  HComponentModel CreateTrainedComponentModel(double AngleStart, double AngleExtent, Hlong MinContrastComp, double MinScoreComp, Hlong NumLevelsComp, double AngleStepComp, const wchar_t* OptimizationComp, const wchar_t* MetricComp, const wchar_t* PregenerationComp, Hlong* RootRanking) const;
+#endif
+
+  // Free the memory of a component training result.
+  void ClearTrainingComponents() const;
+
+  // Return the relations between the model components that are contained in a training result.
+  HRegion GetComponentRelations(Hlong ReferenceComponent, const HTuple& Image, HTuple* Row, HTuple* Column, HTuple* Phi, HTuple* Length1, HTuple* Length2, HTuple* AngleStart, HTuple* AngleExtent) const;
+
+  // Return the relations between the model components that are contained in a training result.
+  HRegion GetComponentRelations(Hlong ReferenceComponent, const HString& Image, double* Row, double* Column, double* Phi, double* Length1, double* Length2, double* AngleStart, double* AngleExtent) const;
+
+  // Return the relations between the model components that are contained in a training result.
+  HRegion GetComponentRelations(Hlong ReferenceComponent, const char* Image, double* Row, double* Column, double* Phi, double* Length1, double* Length2, double* AngleStart, double* AngleExtent) const;
+
+#ifdef _WIN32
+  // Return the relations between the model components that are contained in a training result.
+  HRegion GetComponentRelations(Hlong ReferenceComponent, const wchar_t* Image, double* Row, double* Column, double* Phi, double* Length1, double* Length2, double* AngleStart, double* AngleExtent) const;
+#endif
+
+  // Return the initial or model components in a certain image.
+  HRegion GetTrainingComponents(const HTuple& Components, const HTuple& Image, const HString& MarkOrientation, HTuple* Row, HTuple* Column, HTuple* Angle, HTuple* Score) const;
+
+  // Return the initial or model components in a certain image.
+  HRegion GetTrainingComponents(const HString& Components, const HString& Image, const HString& MarkOrientation, double* Row, double* Column, double* Angle, double* Score) const;
+
+  // Return the initial or model components in a certain image.
+  HRegion GetTrainingComponents(const char* Components, const char* Image, const char* MarkOrientation, double* Row, double* Column, double* Angle, double* Score) const;
+
+#ifdef _WIN32
+  // Return the initial or model components in a certain image.
+  HRegion GetTrainingComponents(const wchar_t* Components, const wchar_t* Image, const wchar_t* MarkOrientation, double* Row, double* Column, double* Angle, double* Score) const;
+#endif
+
+  // Modify the relations within a training result.
+  void ModifyComponentRelations(const HTuple& ReferenceComponent, const HTuple& ToleranceComponent, const HTuple& PositionTolerance, const HTuple& AngleTolerance) const;
+
+  // Modify the relations within a training result.
+  void ModifyComponentRelations(const HString& ReferenceComponent, const HString& ToleranceComponent, double PositionTolerance, double AngleTolerance) const;
+
+  // Modify the relations within a training result.
+  void ModifyComponentRelations(const char* ReferenceComponent, const char* ToleranceComponent, double PositionTolerance, double AngleTolerance) const;
+
+#ifdef _WIN32
+  // Modify the relations within a training result.
+  void ModifyComponentRelations(const wchar_t* ReferenceComponent, const wchar_t* ToleranceComponent, double PositionTolerance, double AngleTolerance) const;
+#endif
+
+  // Deserialize a component training result.
+  void DeserializeTrainingComponents(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a component training result.
+  HSerializedItem SerializeTrainingComponents() const;
+
+  // Read a component training result from a file.
+  void ReadTrainingComponents(const HString& FileName);
+
+  // Read a component training result from a file.
+  void ReadTrainingComponents(const char* FileName);
+
+#ifdef _WIN32
+  // Read a component training result from a file.
+  void ReadTrainingComponents(const wchar_t* FileName);
+#endif
+
+  // Write a component training result to a file.
+  void WriteTrainingComponents(const HString& FileName) const;
+
+  // Write a component training result to a file.
+  void WriteTrainingComponents(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a component training result to a file.
+  void WriteTrainingComponents(const wchar_t* FileName) const;
+#endif
+
+  // Adopt new parameters that are used to create the model components into the training result.
+  HRegion ClusterModelComponents(const HImage& TrainingImages, const HString& AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold) const;
+
+  // Adopt new parameters that are used to create the model components into the training result.
+  HRegion ClusterModelComponents(const HImage& TrainingImages, const char* AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold) const;
+
+#ifdef _WIN32
+  // Adopt new parameters that are used to create the model components into the training result.
+  HRegion ClusterModelComponents(const HImage& TrainingImages, const wchar_t* AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold) const;
+#endif
+
+  // Inspect the rigid model components obtained from the training.
+  HRegion InspectClusteredComponents(const HString& AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold) const;
+
+  // Inspect the rigid model components obtained from the training.
+  HRegion InspectClusteredComponents(const char* AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold) const;
+
+#ifdef _WIN32
+  // Inspect the rigid model components obtained from the training.
+  HRegion InspectClusteredComponents(const wchar_t* AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold) const;
+#endif
+
+  // Train components and relations for the component-based matching.
+  HRegion TrainModelComponents(const HImage& ModelImage, const HRegion& InitialComponents, const HImage& TrainingImages, const HTuple& ContrastLow, const HTuple& ContrastHigh, const HTuple& MinSize, const HTuple& MinScore, const HTuple& SearchRowTol, const HTuple& SearchColumnTol, const HTuple& SearchAngleTol, const HString& TrainingEmphasis, const HString& AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold);
+
+  // Train components and relations for the component-based matching.
+  HRegion TrainModelComponents(const HImage& ModelImage, const HRegion& InitialComponents, const HImage& TrainingImages, Hlong ContrastLow, Hlong ContrastHigh, Hlong MinSize, double MinScore, Hlong SearchRowTol, Hlong SearchColumnTol, double SearchAngleTol, const HString& TrainingEmphasis, const HString& AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold);
+
+  // Train components and relations for the component-based matching.
+  HRegion TrainModelComponents(const HImage& ModelImage, const HRegion& InitialComponents, const HImage& TrainingImages, Hlong ContrastLow, Hlong ContrastHigh, Hlong MinSize, double MinScore, Hlong SearchRowTol, Hlong SearchColumnTol, double SearchAngleTol, const char* TrainingEmphasis, const char* AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold);
+
+#ifdef _WIN32
+  // Train components and relations for the component-based matching.
+  HRegion TrainModelComponents(const HImage& ModelImage, const HRegion& InitialComponents, const HImage& TrainingImages, Hlong ContrastLow, Hlong ContrastHigh, Hlong MinSize, double MinScore, Hlong SearchRowTol, Hlong SearchColumnTol, double SearchAngleTol, const wchar_t* TrainingEmphasis, const wchar_t* AmbiguityCriterion, double MaxContourOverlap, double ClusterThreshold);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HComponentTraining> HComponentTrainingArrayRef;
+typedef HSmartPtr< HComponentTrainingArrayRef > HComponentTrainingArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HComponentTrainingArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HComponentTrainingArray();
+
+  // Create array from native array of tool instances
+  HComponentTrainingArray(HComponentTraining* classes, Hlong length);
+
+  // Copy constructor
+  HComponentTrainingArray(const HComponentTrainingArray &tool_array);
+
+  // Destructor
+  virtual ~HComponentTrainingArray();
+
+  // Assignment operator
+  HComponentTrainingArray &operator=(const HComponentTrainingArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HComponentTraining* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HComponentTrainingArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HComputeDevice.h

@@ -0,0 +1,178 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCOMPUTEDEVICE
+#define HCPP_HCOMPUTEDEVICE
+
+namespace HalconCpp
+{
+
+// Class representing a compute device handle.
+class LIntExport HComputeDevice : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HComputeDevice():HHandle() {}
+
+  // Copy constructor
+  HComputeDevice(const HComputeDevice& source) : HHandle(source) {}
+
+  // Copy constructor
+  HComputeDevice(const HHandle& handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('compute_device')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // open_compute_device: Open a compute device.
+  explicit HComputeDevice(Hlong DeviceIdentifier);
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Query compute device parameters.
+  HTuple GetComputeDeviceParam(const HString& GenParamName) const;
+
+  // Query compute device parameters.
+  HTuple GetComputeDeviceParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Query compute device parameters.
+  HTuple GetComputeDeviceParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Set parameters of an compute device.
+  void SetComputeDeviceParam(const HString& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set parameters of an compute device.
+  void SetComputeDeviceParam(const HString& GenParamName, const HString& GenParamValue) const;
+
+  // Set parameters of an compute device.
+  void SetComputeDeviceParam(const char* GenParamName, const char* GenParamValue) const;
+
+#ifdef _WIN32
+  // Set parameters of an compute device.
+  void SetComputeDeviceParam(const wchar_t* GenParamName, const wchar_t* GenParamValue) const;
+#endif
+
+  // Close all compute devices.
+  static void ReleaseAllComputeDevices();
+
+  // Close a compute_device.
+  void ReleaseComputeDevice() const;
+
+  // Deactivate all compute devices.
+  static void DeactivateAllComputeDevices();
+
+  // Deactivate a compute device.
+  void DeactivateComputeDevice() const;
+
+  // Activate a compute device.
+  void ActivateComputeDevice() const;
+
+  // Initialize a compute device.
+  void InitComputeDevice(const HTuple& Operators) const;
+
+  // Open a compute device.
+  void OpenComputeDevice(Hlong DeviceIdentifier);
+
+  // Get information on a compute device.
+  static HTuple GetComputeDeviceInfo(Hlong DeviceIdentifier, const HString& InfoName);
+
+  // Get information on a compute device.
+  static HTuple GetComputeDeviceInfo(Hlong DeviceIdentifier, const char* InfoName);
+
+#ifdef _WIN32
+  // Get information on a compute device.
+  static HTuple GetComputeDeviceInfo(Hlong DeviceIdentifier, const wchar_t* InfoName);
+#endif
+
+  // Get the list of available compute devices.
+  static HTuple QueryAvailableComputeDevices();
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HComputeDevice> HComputeDeviceArrayRef;
+typedef HSmartPtr< HComputeDeviceArrayRef > HComputeDeviceArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HComputeDeviceArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HComputeDeviceArray();
+
+  // Create array from native array of tool instances
+  HComputeDeviceArray(HComputeDevice* classes, Hlong length);
+
+  // Copy constructor
+  HComputeDeviceArray(const HComputeDeviceArray &tool_array);
+
+  // Destructor
+  virtual ~HComputeDeviceArray();
+
+  // Assignment operator
+  HComputeDeviceArray &operator=(const HComputeDeviceArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HComputeDevice* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HComputeDeviceArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HCondition.h

@@ -0,0 +1,161 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HCONDITION
+#define HCPP_HCONDITION
+
+namespace HalconCpp
+{
+
+// Represents an instance of a condition synchronization object.
+class LIntExport HCondition : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HCondition():HHandle() {}
+
+  // Copy constructor
+  HCondition(const HCondition& source) : HHandle(source) {}
+
+  // Copy constructor
+  HCondition(const HHandle& handle);
+
+  // Create HCondition from handle, taking ownership
+  explicit HCondition(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('condition')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_condition: Create a condition variable synchronization object.
+  explicit HCondition(const HTuple& AttribName, const HTuple& AttribValue);
+
+  // create_condition: Create a condition variable synchronization object.
+  explicit HCondition(const HString& AttribName, const HString& AttribValue);
+
+  // create_condition: Create a condition variable synchronization object.
+  explicit HCondition(const char* AttribName, const char* AttribValue);
+
+#ifdef _WIN32
+  // create_condition: Create a condition variable synchronization object.
+  explicit HCondition(const wchar_t* AttribName, const wchar_t* AttribValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Destroy a condition synchronization object.
+  void ClearCondition() const;
+
+  // Signal a condition synchronization object.
+  void BroadcastCondition() const;
+
+  // Signal a condition synchronization object.
+  void SignalCondition() const;
+
+  // Bounded wait on the signal of a condition synchronization object.
+  void TimedWaitCondition(const HMutex& MutexHandle, Hlong Timeout) const;
+
+  // wait on the signal of a condition synchronization object.
+  void WaitCondition(const HMutex& MutexHandle) const;
+
+  // Create a condition variable synchronization object.
+  void CreateCondition(const HTuple& AttribName, const HTuple& AttribValue);
+
+  // Create a condition variable synchronization object.
+  void CreateCondition(const HString& AttribName, const HString& AttribValue);
+
+  // Create a condition variable synchronization object.
+  void CreateCondition(const char* AttribName, const char* AttribValue);
+
+#ifdef _WIN32
+  // Create a condition variable synchronization object.
+  void CreateCondition(const wchar_t* AttribName, const wchar_t* AttribValue);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HCondition> HConditionArrayRef;
+typedef HSmartPtr< HConditionArrayRef > HConditionArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HConditionArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HConditionArray();
+
+  // Create array from native array of tool instances
+  HConditionArray(HCondition* classes, Hlong length);
+
+  // Copy constructor
+  HConditionArray(const HConditionArray &tool_array);
+
+  // Destructor
+  virtual ~HConditionArray();
+
+  // Assignment operator
+  HConditionArray &operator=(const HConditionArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HCondition* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HConditionArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDataBase.h

@@ -0,0 +1,102 @@
+/*****************************************************************************
+ * HDataBase.h
+ ***************************************************************************** 
+ *
+ * Project:     HALCON/C++
+ * Description: Base class for all iconic objects
+ *
+ * (c) 2010-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ * 
+ *****************************************************************************
+ *
+ *
+ *****************************************************************************/
+
+
+#ifndef HCPP_DATA_BASE_H
+#define HCPP_DATA_BASE_H
+
+
+namespace HalconCpp
+{
+
+class LIntExport HDataBase
+{
+
+public:
+
+  // Create an uninitialized data object
+  HDataBase();
+
+  // Create data object from tuple data
+  HDataBase(const HTuple& data);
+
+  // Copy constructor
+  HDataBase(const HDataBase& data);
+
+  // Assignment
+  HDataBase& operator = (const HDataBase& data);
+  HDataBase& operator = (const HTuple& data);
+
+  // Cast
+  operator HTuple() const;
+
+  // Set data from tuple
+  void SetFromTuple(const HTuple& data);
+
+  // Get data as tuple
+  HTuple ConvertToTuple() const;
+
+  void Clear();
+
+protected:
+
+  HTuple mData;
+};
+
+
+
+class LIntExport HDataArray
+{
+
+public:
+
+  // Create empty tool array for use as output parameter
+  HDataArray();
+
+  virtual ~HDataArray();
+
+  // Assignment
+  HDataArray& operator = (const HDataArray& data_array);
+
+  HDataBase* Data();
+  const HDataBase* Data() const;
+
+  Hlong Length() const;
+
+  void Clear();
+
+  // Create data class array from splittable tuple
+  void SetFromTuple(const HTuple& concatenated);
+
+  // Get concatenated data tuple for data array
+  HTuple ConvertToTuple() const;
+
+protected:
+
+  void InitFromArray(HDataBase* data, Hlong length);
+
+  virtual void CreateArray(Hlong length) = 0;
+
+  virtual int GetFixedSize() const = 0;
+
+  HDataBase* mArray;
+  Hlong      mLength;
+};
+
+
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDataCode2D.h

@@ -0,0 +1,272 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDATACODE2D
+#define HCPP_HDATACODE2D
+
+namespace HalconCpp
+{
+
+// Represents an instance of a 2D data code reader.
+class LIntExport HDataCode2D : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDataCode2D():HHandle() {}
+
+  // Copy constructor
+  HDataCode2D(const HDataCode2D& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDataCode2D(const HHandle& handle);
+
+  // Create HDataCode2D from handle, taking ownership
+  explicit HDataCode2D(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('datacode_2d')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HDataCode2D Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_data_code_2d_model: Read a 2D data code model from a file and create a new model.
+  explicit HDataCode2D(const HString& FileName);
+
+  // read_data_code_2d_model: Read a 2D data code model from a file and create a new model.
+  explicit HDataCode2D(const char* FileName);
+
+#ifdef _WIN32
+  // read_data_code_2d_model: Read a 2D data code model from a file and create a new model.
+  explicit HDataCode2D(const wchar_t* FileName);
+#endif
+
+  // create_data_code_2d_model: Create a model of a 2D data code class.
+  explicit HDataCode2D(const HString& SymbolType, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // create_data_code_2d_model: Create a model of a 2D data code class.
+  explicit HDataCode2D(const HString& SymbolType, const HString& GenParamName, const HString& GenParamValue);
+
+  // create_data_code_2d_model: Create a model of a 2D data code class.
+  explicit HDataCode2D(const char* SymbolType, const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // create_data_code_2d_model: Create a model of a 2D data code class.
+  explicit HDataCode2D(const wchar_t* SymbolType, const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Access iconic objects that were created during the search for 2D data code symbols.
+  HObject GetDataCode2dObjects(const HTuple& CandidateHandle, const HString& ObjectName) const;
+
+  // Access iconic objects that were created during the search for 2D data code symbols.
+  HObject GetDataCode2dObjects(Hlong CandidateHandle, const HString& ObjectName) const;
+
+  // Access iconic objects that were created during the search for 2D data code symbols.
+  HObject GetDataCode2dObjects(Hlong CandidateHandle, const char* ObjectName) const;
+
+#ifdef _WIN32
+  // Access iconic objects that were created during the search for 2D data code symbols.
+  HObject GetDataCode2dObjects(Hlong CandidateHandle, const wchar_t* ObjectName) const;
+#endif
+
+  // Get the alphanumerical results that were accumulated during the search for 2D data code symbols.
+  HTuple GetDataCode2dResults(const HTuple& CandidateHandle, const HTuple& ResultNames) const;
+
+  // Get the alphanumerical results that were accumulated during the search for 2D data code symbols.
+  HTuple GetDataCode2dResults(const HString& CandidateHandle, const HString& ResultNames) const;
+
+  // Get the alphanumerical results that were accumulated during the search for 2D data code symbols.
+  HTuple GetDataCode2dResults(const char* CandidateHandle, const char* ResultNames) const;
+
+#ifdef _WIN32
+  // Get the alphanumerical results that were accumulated during the search for 2D data code symbols.
+  HTuple GetDataCode2dResults(const wchar_t* CandidateHandle, const wchar_t* ResultNames) const;
+#endif
+
+  // Detect and read 2D data code symbols in an image or train the 2D data code model.
+  HXLDCont FindDataCode2d(const HImage& Image, const HTuple& GenParamName, const HTuple& GenParamValue, HTuple* ResultHandles, HTuple* DecodedDataStrings) const;
+
+  // Detect and read 2D data code symbols in an image or train the 2D data code model.
+  HXLDCont FindDataCode2d(const HImage& Image, const HString& GenParamName, Hlong GenParamValue, Hlong* ResultHandles, HString* DecodedDataStrings) const;
+
+  // Detect and read 2D data code symbols in an image or train the 2D data code model.
+  HXLDCont FindDataCode2d(const HImage& Image, const char* GenParamName, Hlong GenParamValue, Hlong* ResultHandles, HString* DecodedDataStrings) const;
+
+#ifdef _WIN32
+  // Detect and read 2D data code symbols in an image or train the 2D data code model.
+  HXLDCont FindDataCode2d(const HImage& Image, const wchar_t* GenParamName, Hlong GenParamValue, Hlong* ResultHandles, HString* DecodedDataStrings) const;
+#endif
+
+  // Set selected parameters of the 2D data code model.
+  void SetDataCode2dParam(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set selected parameters of the 2D data code model.
+  void SetDataCode2dParam(const HString& GenParamName, const HString& GenParamValue) const;
+
+  // Set selected parameters of the 2D data code model.
+  void SetDataCode2dParam(const char* GenParamName, const char* GenParamValue) const;
+
+#ifdef _WIN32
+  // Set selected parameters of the 2D data code model.
+  void SetDataCode2dParam(const wchar_t* GenParamName, const wchar_t* GenParamValue) const;
+#endif
+
+  // Get one or several parameters that describe the 2D data code model.
+  HTuple GetDataCode2dParam(const HTuple& GenParamName) const;
+
+  // Get one or several parameters that describe the 2D data code model.
+  HTuple GetDataCode2dParam(const HString& GenParamName) const;
+
+  // Get one or several parameters that describe the 2D data code model.
+  HTuple GetDataCode2dParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Get one or several parameters that describe the 2D data code model.
+  HTuple GetDataCode2dParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Get for a given 2D data code model the names of the generic parameters or objects that can be used in the other 2D data code operators.
+  HTuple QueryDataCode2dParams(const HString& QueryName) const;
+
+  // Get for a given 2D data code model the names of the generic parameters or objects that can be used in the other 2D data code operators.
+  HTuple QueryDataCode2dParams(const char* QueryName) const;
+
+#ifdef _WIN32
+  // Get for a given 2D data code model the names of the generic parameters or objects that can be used in the other 2D data code operators.
+  HTuple QueryDataCode2dParams(const wchar_t* QueryName) const;
+#endif
+
+  // Deserialize a serialized 2D data code model.
+  void DeserializeDataCode2dModel(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a 2D data code model.
+  HSerializedItem SerializeDataCode2dModel() const;
+
+  // Read a 2D data code model from a file and create a new model.
+  void ReadDataCode2dModel(const HString& FileName);
+
+  // Read a 2D data code model from a file and create a new model.
+  void ReadDataCode2dModel(const char* FileName);
+
+#ifdef _WIN32
+  // Read a 2D data code model from a file and create a new model.
+  void ReadDataCode2dModel(const wchar_t* FileName);
+#endif
+
+  // Writes a 2D data code model into a file.
+  void WriteDataCode2dModel(const HString& FileName) const;
+
+  // Writes a 2D data code model into a file.
+  void WriteDataCode2dModel(const char* FileName) const;
+
+#ifdef _WIN32
+  // Writes a 2D data code model into a file.
+  void WriteDataCode2dModel(const wchar_t* FileName) const;
+#endif
+
+  // Delete a 2D data code model and free the allocated memory.
+  void ClearDataCode2dModel() const;
+
+  // Create a model of a 2D data code class.
+  void CreateDataCode2dModel(const HString& SymbolType, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Create a model of a 2D data code class.
+  void CreateDataCode2dModel(const HString& SymbolType, const HString& GenParamName, const HString& GenParamValue);
+
+  // Create a model of a 2D data code class.
+  void CreateDataCode2dModel(const char* SymbolType, const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // Create a model of a 2D data code class.
+  void CreateDataCode2dModel(const wchar_t* SymbolType, const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDataCode2D> HDataCode2DArrayRef;
+typedef HSmartPtr< HDataCode2DArrayRef > HDataCode2DArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDataCode2DArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDataCode2DArray();
+
+  // Create array from native array of tool instances
+  HDataCode2DArray(HDataCode2D* classes, Hlong length);
+
+  // Copy constructor
+  HDataCode2DArray(const HDataCode2DArray &tool_array);
+
+  // Destructor
+  virtual ~HDataCode2DArray();
+
+  // Assignment operator
+  HDataCode2DArray &operator=(const HDataCode2DArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDataCode2D* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDataCode2DArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDeformableSurfaceMatchingResult.h

@@ -0,0 +1,152 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDEFORMABLESURFACEMATCHINGRESULT
+#define HCPP_HDEFORMABLESURFACEMATCHINGRESULT
+
+namespace HalconCpp
+{
+
+// Represents an instance of a deformable surface matching result.
+class LIntExport HDeformableSurfaceMatchingResult : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDeformableSurfaceMatchingResult():HHandle() {}
+
+  // Copy constructor
+  HDeformableSurfaceMatchingResult(const HDeformableSurfaceMatchingResult& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDeformableSurfaceMatchingResult(const HHandle& handle);
+
+  // Create HDeformableSurfaceMatchingResult from handle, taking ownership
+  explicit HDeformableSurfaceMatchingResult(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('deformable_surface_matching_result')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Get details of a result from deformable surface based matching.
+  HTuple GetDeformableSurfaceMatchingResult(const HTuple& ResultName, const HTuple& ResultIndex) const;
+
+  // Get details of a result from deformable surface based matching.
+  HTuple GetDeformableSurfaceMatchingResult(const HString& ResultName, Hlong ResultIndex) const;
+
+  // Get details of a result from deformable surface based matching.
+  HTuple GetDeformableSurfaceMatchingResult(const char* ResultName, Hlong ResultIndex) const;
+
+#ifdef _WIN32
+  // Get details of a result from deformable surface based matching.
+  HTuple GetDeformableSurfaceMatchingResult(const wchar_t* ResultName, Hlong ResultIndex) const;
+#endif
+
+  // Free the memory of a deformable surface matching result.
+  static void ClearDeformableSurfaceMatchingResult(const HDeformableSurfaceMatchingResultArray& DeformableSurfaceMatchingResult);
+
+  // Free the memory of a deformable surface matching result.
+  void ClearDeformableSurfaceMatchingResult() const;
+
+  // Refine the position and deformation of a deformable surface model in a 3D scene.
+  static HTuple RefineDeformableSurfaceModel(const HDeformableSurfaceModel& DeformableSurfaceModel, const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HObjectModel3D& InitialDeformationObjectModel3D, const HTuple& GenParamName, const HTuple& GenParamValue, HDeformableSurfaceMatchingResultArray* DeformableSurfaceMatchingResult);
+
+  // Refine the position and deformation of a deformable surface model in a 3D scene.
+  double RefineDeformableSurfaceModel(const HDeformableSurfaceModel& DeformableSurfaceModel, const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HObjectModel3D& InitialDeformationObjectModel3D, const HString& GenParamName, const HString& GenParamValue);
+
+  // Refine the position and deformation of a deformable surface model in a 3D scene.
+  double RefineDeformableSurfaceModel(const HDeformableSurfaceModel& DeformableSurfaceModel, const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HObjectModel3D& InitialDeformationObjectModel3D, const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // Refine the position and deformation of a deformable surface model in a 3D scene.
+  double RefineDeformableSurfaceModel(const HDeformableSurfaceModel& DeformableSurfaceModel, const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HObjectModel3D& InitialDeformationObjectModel3D, const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+  // Find the best match of a deformable surface model in a 3D scene.
+  static HTuple FindDeformableSurfaceModel(const HDeformableSurfaceModel& DeformableSurfaceModel, const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HTuple& MinScore, const HTuple& GenParamName, const HTuple& GenParamValue, HDeformableSurfaceMatchingResultArray* DeformableSurfaceMatchingResult);
+
+  // Find the best match of a deformable surface model in a 3D scene.
+  double FindDeformableSurfaceModel(const HDeformableSurfaceModel& DeformableSurfaceModel, const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, double MinScore, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDeformableSurfaceMatchingResult> HDeformableSurfaceMatchingResultArrayRef;
+typedef HSmartPtr< HDeformableSurfaceMatchingResultArrayRef > HDeformableSurfaceMatchingResultArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDeformableSurfaceMatchingResultArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDeformableSurfaceMatchingResultArray();
+
+  // Create array from native array of tool instances
+  HDeformableSurfaceMatchingResultArray(HDeformableSurfaceMatchingResult* classes, Hlong length);
+
+  // Copy constructor
+  HDeformableSurfaceMatchingResultArray(const HDeformableSurfaceMatchingResultArray &tool_array);
+
+  // Destructor
+  virtual ~HDeformableSurfaceMatchingResultArray();
+
+  // Assignment operator
+  HDeformableSurfaceMatchingResultArray &operator=(const HDeformableSurfaceMatchingResultArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDeformableSurfaceMatchingResult* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDeformableSurfaceMatchingResultArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDeformableSurfaceModel.h

@@ -0,0 +1,240 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDEFORMABLESURFACEMODEL
+#define HCPP_HDEFORMABLESURFACEMODEL
+
+namespace HalconCpp
+{
+
+// Represents an instance of a deformable surface model.
+class LIntExport HDeformableSurfaceModel : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDeformableSurfaceModel():HHandle() {}
+
+  // Copy constructor
+  HDeformableSurfaceModel(const HDeformableSurfaceModel& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDeformableSurfaceModel(const HHandle& handle);
+
+  // Create HDeformableSurfaceModel from handle, taking ownership
+  explicit HDeformableSurfaceModel(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('deformable_surface_model')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HDeformableSurfaceModel Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_deformable_surface_model: Read a deformable surface model from a file.
+  explicit HDeformableSurfaceModel(const HString& FileName);
+
+  // read_deformable_surface_model: Read a deformable surface model from a file.
+  explicit HDeformableSurfaceModel(const char* FileName);
+
+#ifdef _WIN32
+  // read_deformable_surface_model: Read a deformable surface model from a file.
+  explicit HDeformableSurfaceModel(const wchar_t* FileName);
+#endif
+
+  // create_deformable_surface_model: Create the data structure needed to perform deformable surface-based matching.
+  explicit HDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // create_deformable_surface_model: Create the data structure needed to perform deformable surface-based matching.
+  explicit HDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HString& GenParamName, const HString& GenParamValue);
+
+  // create_deformable_surface_model: Create the data structure needed to perform deformable surface-based matching.
+  explicit HDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // create_deformable_surface_model: Create the data structure needed to perform deformable surface-based matching.
+  explicit HDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Free the memory of a deformable surface model.
+  static void ClearDeformableSurfaceModel(const HDeformableSurfaceModelArray& DeformableSurfaceModel);
+
+  // Free the memory of a deformable surface model.
+  void ClearDeformableSurfaceModel() const;
+
+  // Deserialize a deformable surface model.
+  void DeserializeDeformableSurfaceModel(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a deformable surface_model.
+  HSerializedItem SerializeDeformableSurfaceModel() const;
+
+  // Read a deformable surface model from a file.
+  void ReadDeformableSurfaceModel(const HString& FileName);
+
+  // Read a deformable surface model from a file.
+  void ReadDeformableSurfaceModel(const char* FileName);
+
+#ifdef _WIN32
+  // Read a deformable surface model from a file.
+  void ReadDeformableSurfaceModel(const wchar_t* FileName);
+#endif
+
+  // Write a deformable surface model to a file.
+  void WriteDeformableSurfaceModel(const HString& FileName) const;
+
+  // Write a deformable surface model to a file.
+  void WriteDeformableSurfaceModel(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a deformable surface model to a file.
+  void WriteDeformableSurfaceModel(const wchar_t* FileName) const;
+#endif
+
+  // Refine the position and deformation of a deformable surface model in a 3D scene.
+  HTuple RefineDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HObjectModel3D& InitialDeformationObjectModel3D, const HTuple& GenParamName, const HTuple& GenParamValue, HDeformableSurfaceMatchingResultArray* DeformableSurfaceMatchingResult) const;
+
+  // Refine the position and deformation of a deformable surface model in a 3D scene.
+  double RefineDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HObjectModel3D& InitialDeformationObjectModel3D, const HString& GenParamName, const HString& GenParamValue, HDeformableSurfaceMatchingResult* DeformableSurfaceMatchingResult) const;
+
+  // Refine the position and deformation of a deformable surface model in a 3D scene.
+  double RefineDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HObjectModel3D& InitialDeformationObjectModel3D, const char* GenParamName, const char* GenParamValue, HDeformableSurfaceMatchingResult* DeformableSurfaceMatchingResult) const;
+
+#ifdef _WIN32
+  // Refine the position and deformation of a deformable surface model in a 3D scene.
+  double RefineDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HObjectModel3D& InitialDeformationObjectModel3D, const wchar_t* GenParamName, const wchar_t* GenParamValue, HDeformableSurfaceMatchingResult* DeformableSurfaceMatchingResult) const;
+#endif
+
+  // Find the best match of a deformable surface model in a 3D scene.
+  HTuple FindDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HTuple& MinScore, const HTuple& GenParamName, const HTuple& GenParamValue, HDeformableSurfaceMatchingResultArray* DeformableSurfaceMatchingResult) const;
+
+  // Find the best match of a deformable surface model in a 3D scene.
+  double FindDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, double MinScore, const HTuple& GenParamName, const HTuple& GenParamValue, HDeformableSurfaceMatchingResult* DeformableSurfaceMatchingResult) const;
+
+  // Return the parameters and properties of a deformable surface model.
+  HTuple GetDeformableSurfaceModelParam(const HTuple& GenParamName) const;
+
+  // Return the parameters and properties of a deformable surface model.
+  HTuple GetDeformableSurfaceModelParam(const HString& GenParamName) const;
+
+  // Return the parameters and properties of a deformable surface model.
+  HTuple GetDeformableSurfaceModelParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Return the parameters and properties of a deformable surface model.
+  HTuple GetDeformableSurfaceModelParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Add a reference point to a deformable surface model.
+  HTuple AddDeformableSurfaceModelReferencePoint(const HTuple& ReferencePointX, const HTuple& ReferencePointY, const HTuple& ReferencePointZ) const;
+
+  // Add a reference point to a deformable surface model.
+  Hlong AddDeformableSurfaceModelReferencePoint(double ReferencePointX, double ReferencePointY, double ReferencePointZ) const;
+
+  // Add a sample deformation to a deformable surface model
+  void AddDeformableSurfaceModelSample(const HObjectModel3DArray& ObjectModel3D) const;
+
+  // Add a sample deformation to a deformable surface model
+  void AddDeformableSurfaceModelSample(const HObjectModel3D& ObjectModel3D) const;
+
+  // Create the data structure needed to perform deformable surface-based matching.
+  void CreateDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Create the data structure needed to perform deformable surface-based matching.
+  void CreateDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const HString& GenParamName, const HString& GenParamValue);
+
+  // Create the data structure needed to perform deformable surface-based matching.
+  void CreateDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // Create the data structure needed to perform deformable surface-based matching.
+  void CreateDeformableSurfaceModel(const HObjectModel3D& ObjectModel3D, double RelSamplingDistance, const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDeformableSurfaceModel> HDeformableSurfaceModelArrayRef;
+typedef HSmartPtr< HDeformableSurfaceModelArrayRef > HDeformableSurfaceModelArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDeformableSurfaceModelArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDeformableSurfaceModelArray();
+
+  // Create array from native array of tool instances
+  HDeformableSurfaceModelArray(HDeformableSurfaceModel* classes, Hlong length);
+
+  // Copy constructor
+  HDeformableSurfaceModelArray(const HDeformableSurfaceModelArray &tool_array);
+
+  // Destructor
+  virtual ~HDeformableSurfaceModelArray();
+
+  // Assignment operator
+  HDeformableSurfaceModelArray &operator=(const HDeformableSurfaceModelArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDeformableSurfaceModel* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDeformableSurfaceModelArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDescriptorModel.h

@@ -0,0 +1,281 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDESCRIPTORMODEL
+#define HCPP_HDESCRIPTORMODEL
+
+namespace HalconCpp
+{
+
+// Represents an instance of a descriptor model.
+class LIntExport HDescriptorModel : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDescriptorModel():HHandle() {}
+
+  // Copy constructor
+  HDescriptorModel(const HDescriptorModel& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDescriptorModel(const HHandle& handle);
+
+  // Create HDescriptorModel from handle, taking ownership
+  explicit HDescriptorModel(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('descriptor_model')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HDescriptorModel Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_descriptor_model: Read a descriptor model from a file.
+  explicit HDescriptorModel(const HString& FileName);
+
+  // read_descriptor_model: Read a descriptor model from a file.
+  explicit HDescriptorModel(const char* FileName);
+
+#ifdef _WIN32
+  // read_descriptor_model: Read a descriptor model from a file.
+  explicit HDescriptorModel(const wchar_t* FileName);
+#endif
+
+  // create_calib_descriptor_model: Create a descriptor model for calibrated perspective matching.
+  explicit HDescriptorModel(const HImage& Template, const HCamPar& CamParam, const HPose& ReferencePose, const HString& DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+
+  // create_calib_descriptor_model: Create a descriptor model for calibrated perspective matching.
+  explicit HDescriptorModel(const HImage& Template, const HCamPar& CamParam, const HPose& ReferencePose, const char* DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+
+#ifdef _WIN32
+  // create_calib_descriptor_model: Create a descriptor model for calibrated perspective matching.
+  explicit HDescriptorModel(const HImage& Template, const HCamPar& CamParam, const HPose& ReferencePose, const wchar_t* DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+#endif
+
+  // create_uncalib_descriptor_model: Prepare a descriptor model for interest point matching.
+  explicit HDescriptorModel(const HImage& Template, const HString& DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+
+  // create_uncalib_descriptor_model: Prepare a descriptor model for interest point matching.
+  explicit HDescriptorModel(const HImage& Template, const char* DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+
+#ifdef _WIN32
+  // create_uncalib_descriptor_model: Prepare a descriptor model for interest point matching.
+  explicit HDescriptorModel(const HImage& Template, const wchar_t* DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Free the memory of a descriptor model.
+  static void ClearDescriptorModel(const HDescriptorModelArray& ModelID);
+
+  // Free the memory of a descriptor model.
+  void ClearDescriptorModel() const;
+
+  // Deserialize a descriptor model.
+  void DeserializeDescriptorModel(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a descriptor model.
+  HSerializedItem SerializeDescriptorModel() const;
+
+  // Read a descriptor model from a file.
+  void ReadDescriptorModel(const HString& FileName);
+
+  // Read a descriptor model from a file.
+  void ReadDescriptorModel(const char* FileName);
+
+#ifdef _WIN32
+  // Read a descriptor model from a file.
+  void ReadDescriptorModel(const wchar_t* FileName);
+#endif
+
+  // Write a descriptor model to a file.
+  void WriteDescriptorModel(const HString& FileName) const;
+
+  // Write a descriptor model to a file.
+  void WriteDescriptorModel(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a descriptor model to a file.
+  void WriteDescriptorModel(const wchar_t* FileName) const;
+#endif
+
+  // Find the best matches of a calibrated descriptor model in an image and return their 3D pose.
+  HPoseArray FindCalibDescriptorModel(const HImage& Image, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, const HTuple& MinScore, Hlong NumMatches, const HCamPar& CamParam, const HTuple& ScoreType, HTuple* Score) const;
+
+  // Find the best matches of a calibrated descriptor model in an image and return their 3D pose.
+  HPose FindCalibDescriptorModel(const HImage& Image, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, double MinScore, Hlong NumMatches, const HCamPar& CamParam, const HString& ScoreType, double* Score) const;
+
+  // Find the best matches of a calibrated descriptor model in an image and return their 3D pose.
+  HPose FindCalibDescriptorModel(const HImage& Image, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, double MinScore, Hlong NumMatches, const HCamPar& CamParam, const char* ScoreType, double* Score) const;
+
+#ifdef _WIN32
+  // Find the best matches of a calibrated descriptor model in an image and return their 3D pose.
+  HPose FindCalibDescriptorModel(const HImage& Image, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, double MinScore, Hlong NumMatches, const HCamPar& CamParam, const wchar_t* ScoreType, double* Score) const;
+#endif
+
+  // Find the best matches of a descriptor model in an image.
+  HHomMat2DArray FindUncalibDescriptorModel(const HImage& Image, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, const HTuple& MinScore, Hlong NumMatches, const HTuple& ScoreType, HTuple* Score) const;
+
+  // Find the best matches of a descriptor model in an image.
+  HHomMat2D FindUncalibDescriptorModel(const HImage& Image, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, double MinScore, Hlong NumMatches, const HString& ScoreType, double* Score) const;
+
+  // Find the best matches of a descriptor model in an image.
+  HHomMat2D FindUncalibDescriptorModel(const HImage& Image, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, double MinScore, Hlong NumMatches, const char* ScoreType, double* Score) const;
+
+#ifdef _WIN32
+  // Find the best matches of a descriptor model in an image.
+  HHomMat2D FindUncalibDescriptorModel(const HImage& Image, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, double MinScore, Hlong NumMatches, const wchar_t* ScoreType, double* Score) const;
+#endif
+
+  // Query the interest points of the descriptor model or the last processed search image.
+  void GetDescriptorModelPoints(const HString& Set, const HTuple& Subset, HTuple* Row, HTuple* Column) const;
+
+  // Query the interest points of the descriptor model or the last processed search image.
+  void GetDescriptorModelPoints(const HString& Set, Hlong Subset, HTuple* Row, HTuple* Column) const;
+
+  // Query the interest points of the descriptor model or the last processed search image.
+  void GetDescriptorModelPoints(const char* Set, Hlong Subset, HTuple* Row, HTuple* Column) const;
+
+#ifdef _WIN32
+  // Query the interest points of the descriptor model or the last processed search image.
+  void GetDescriptorModelPoints(const wchar_t* Set, Hlong Subset, HTuple* Row, HTuple* Column) const;
+#endif
+
+  // Return the parameters of a descriptor model.
+  HString GetDescriptorModelParams(HTuple* DetectorParamName, HTuple* DetectorParamValue, HTuple* DescriptorParamName, HTuple* DescriptorParamValue) const;
+
+  // Create a descriptor model for calibrated perspective matching.
+  void CreateCalibDescriptorModel(const HImage& Template, const HCamPar& CamParam, const HPose& ReferencePose, const HString& DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+
+  // Create a descriptor model for calibrated perspective matching.
+  void CreateCalibDescriptorModel(const HImage& Template, const HCamPar& CamParam, const HPose& ReferencePose, const char* DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+
+#ifdef _WIN32
+  // Create a descriptor model for calibrated perspective matching.
+  void CreateCalibDescriptorModel(const HImage& Template, const HCamPar& CamParam, const HPose& ReferencePose, const wchar_t* DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+#endif
+
+  // Prepare a descriptor model for interest point matching.
+  void CreateUncalibDescriptorModel(const HImage& Template, const HString& DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+
+  // Prepare a descriptor model for interest point matching.
+  void CreateUncalibDescriptorModel(const HImage& Template, const char* DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+
+#ifdef _WIN32
+  // Prepare a descriptor model for interest point matching.
+  void CreateUncalibDescriptorModel(const HImage& Template, const wchar_t* DetectorType, const HTuple& DetectorParamName, const HTuple& DetectorParamValue, const HTuple& DescriptorParamName, const HTuple& DescriptorParamValue, Hlong Seed);
+#endif
+
+  // Query alphanumerical results that were accumulated during descriptor-based matching.
+  HTuple GetDescriptorModelResults(const HTuple& ObjectID, const HString& ResultNames) const;
+
+  // Query alphanumerical results that were accumulated during descriptor-based matching.
+  HTuple GetDescriptorModelResults(Hlong ObjectID, const HString& ResultNames) const;
+
+  // Query alphanumerical results that were accumulated during descriptor-based matching.
+  HTuple GetDescriptorModelResults(Hlong ObjectID, const char* ResultNames) const;
+
+#ifdef _WIN32
+  // Query alphanumerical results that were accumulated during descriptor-based matching.
+  HTuple GetDescriptorModelResults(Hlong ObjectID, const wchar_t* ResultNames) const;
+#endif
+
+  // Return the origin of a descriptor model.
+  void GetDescriptorModelOrigin(HTuple* Row, HTuple* Column) const;
+
+  // Return the origin of a descriptor model.
+  void GetDescriptorModelOrigin(double* Row, double* Column) const;
+
+  // Sets the origin of a descriptor model.
+  void SetDescriptorModelOrigin(const HTuple& Row, const HTuple& Column) const;
+
+  // Sets the origin of a descriptor model.
+  void SetDescriptorModelOrigin(double Row, double Column) const;
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDescriptorModel> HDescriptorModelArrayRef;
+typedef HSmartPtr< HDescriptorModelArrayRef > HDescriptorModelArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDescriptorModelArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDescriptorModelArray();
+
+  // Create array from native array of tool instances
+  HDescriptorModelArray(HDescriptorModel* classes, Hlong length);
+
+  // Copy constructor
+  HDescriptorModelArray(const HDescriptorModelArray &tool_array);
+
+  // Destructor
+  virtual ~HDescriptorModelArray();
+
+  // Assignment operator
+  HDescriptorModelArray &operator=(const HDescriptorModelArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDescriptorModel* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDescriptorModelArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDevThread.h

@@ -0,0 +1,134 @@
+/*****************************************************************************
+ * HDevThread.h
+ *****************************************************************************
+ *
+ * Project:     Halcon/C++
+ * Description: Helper class for export of HDevelop's parallel 
+ *              language extensions.
+ *
+ * (c) 2014-2020 by MVTec Software GmbH
+ *               www.mvtec.com
+ *
+ *****************************************************************************
+ *
+ *
+ *****************************************************************************/
+
+
+#ifndef HCPP_DEV_THREAD_H
+#define HCPP_DEV_THREAD_H
+
+
+namespace HalconCpp
+{
+
+class LIntExport HDevThreadContext
+{
+
+public:
+
+  HDevThreadContext();
+  ~HDevThreadContext();
+
+  void* GetHandle() const 
+  {
+    return mContextHandle;
+  }
+
+private:
+
+  void* mContextHandle;
+};
+
+
+class HDevInputParam;
+class HDevOutputParam;
+
+
+class LIntExport HDevThread
+{
+
+public:
+
+  // Manage threads and procedure calls
+
+  explicit HDevThread(const HDevThreadContext& context, 
+                      const void* proc, Hlong num_in, Hlong num_out);
+  ~HDevThread();
+
+
+  void Start();
+
+  void ParStart(HTuple *par_handle);
+
+  static void ParJoin(const HTuple& par_handles);
+
+  void Exit(void);
+
+  void CallProc();
+
+  bool IsDirectCall() const {return mDirectCall;}
+
+
+
+  // Store copy of input parameter value in thread-specific context
+
+  void SetInputIconicParamObject(Hlong par_index, const HObject& obj);
+  void SetInputIconicParamVector(Hlong par_index,
+                                 const HObjectVector& vector);
+  void SetInputCtrlParamTuple(Hlong par_index, const HTuple& tuple);
+  void SetInputCtrlParamVector(Hlong par_index,
+                               const HTupleVector& vector);
+
+
+  // Access thread-specific copy of input value
+
+  const HObject& GetInputIconicParamObject(Hlong par_index) const;
+  const HObjectVector& GetInputIconicParamVector(Hlong par_index) const;
+  const HTuple& GetInputCtrlParamTuple(Hlong par_index) const;
+  const HTupleVector& GetInputCtrlParamVector(Hlong par_index) const;
+
+
+  // Bind variable reference to output parameter
+
+  void BindOutputIconicParamObject(Hlong par_index, bool global,
+                                   HObject* obj);
+  void BindOutputIconicParamVector(Hlong par_index, bool global,
+                                   HObjectVector* vector,
+                                   HTuple index = HTuple());
+  void BindOutputCtrlParamTuple(Hlong par_index, bool global, HTuple* obj);
+  void BindOutputCtrlParamVector(Hlong par_index, bool global,
+                                 HTupleVector* vector,
+                                 HTuple index = HTuple());
+
+
+  // Store result of procedure call into bound output variables
+
+  void StoreOutputIconicParamObject(Hlong par_index, const HObject& obj);
+  void StoreOutputIconicParamVector(Hlong par_index,
+                                    const HObjectVector& vector);
+  void StoreOutputCtrlParamTuple(Hlong par_index, const HTuple& tuple);
+  void StoreOutputCtrlParamVector(Hlong par_index,
+                                  const HTupleVector& vector);
+
+
+
+protected:
+
+  void* mThreadHandle;
+
+  const void* mProc;
+
+  bool mDirectCall;
+
+  Hlong mNumParamsInput;
+  Hlong mNumParamsOutput;
+
+  HDevInputParam**  mParamsInput;
+  HDevOutputParam** mParamsOutput;
+
+};
+
+} // namespace HalconCpp
+
+#endif

3rdparty/include22/halcon/halconcpp/HDevWindowStack.h

@@ -0,0 +1,58 @@
+/*****************************************************************************
+ * HDevWindowStack.h
+ ***************************************************************************** 
+ *
+ * Project:     HALCON/C++
+ * Description: Window management for exported HDevelop code
+ *
+ * (c) 2010-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ * 
+ *****************************************************************************
+ *
+ *
+ *****************************************************************************/
+
+
+#ifndef HCPP_DEV_WINDOW_STACK_H
+#define HCPP_DEV_WINDOW_STACK_H
+
+
+#include "halconcpp/HTuple.h"
+
+
+namespace HalconCpp
+{
+
+// The class HDevWindowStack can be used to emulate the behavior of HDevelop
+// graphics windows for HALCON graphics windows. It is primarily intended for
+// usage in C++ programs exported from HDevelop programs containing HDevelop
+// window operators (e.g. dev_set_window, dev_open_window, dev_close_window...)
+class LIntExport HDevWindowStack
+{
+
+public:  
+
+  // Push handle for new window (dev_open_window)
+  static void   Push(const HTuple &win_handle);
+  
+  // Pop handle for closed window (dev_close_window)
+  static HTuple Pop();
+  
+  // Get handle for active window
+  static HTuple GetActive();
+  
+  // Set active window (dev_set_window)
+  static void   SetActive(const HTuple &win_handle);
+  
+  // Test if any open window is available
+  static bool   IsOpen();
+  
+  // Close all open windows
+  static void   CloseAll();
+  
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDict.h

@@ -0,0 +1,261 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDICT
+#define HCPP_HDICT
+
+namespace HalconCpp
+{
+
+// Represents an instance of a Dictionary.
+class LIntExport HDict : public HHandle
+{
+
+public:
+
+  // Copy constructor
+  HDict(const HDict& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDict(const HHandle& handle);
+
+  // Create HDict from handle, taking ownership
+  explicit HDict(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('dict')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_dict: Create a new empty dictionary.
+  explicit HDict();
+
+  // read_dict: Read a dictionary from a file.
+  explicit HDict(const HString& FileName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // read_dict: Read a dictionary from a file.
+  explicit HDict(const HString& FileName, const HString& GenParamName, const HString& GenParamValue);
+
+  // read_dict: Read a dictionary from a file.
+  explicit HDict(const char* FileName, const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // read_dict: Read a dictionary from a file.
+  explicit HDict(const wchar_t* FileName, const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Copy a dictionary.
+  HDict CopyDict(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Copy a dictionary.
+  HDict CopyDict(const HString& GenParamName, const HString& GenParamValue) const;
+
+  // Copy a dictionary.
+  HDict CopyDict(const char* GenParamName, const char* GenParamValue) const;
+
+#ifdef _WIN32
+  // Copy a dictionary.
+  HDict CopyDict(const wchar_t* GenParamName, const wchar_t* GenParamValue) const;
+#endif
+
+  // Create a new empty dictionary.
+  void CreateDict();
+
+  // Retrieve an object associated with the key from the dictionary.
+  HObject GetDictObject(const HTuple& Key) const;
+
+  // Retrieve an object associated with the key from the dictionary.
+  HObject GetDictObject(const HString& Key) const;
+
+  // Retrieve an object associated with the key from the dictionary.
+  HObject GetDictObject(const char* Key) const;
+
+#ifdef _WIN32
+  // Retrieve an object associated with the key from the dictionary.
+  HObject GetDictObject(const wchar_t* Key) const;
+#endif
+
+  // Query dictionary parameters or information about a dictionary.
+  HTuple GetDictParam(const HString& GenParamName, const HTuple& Key) const;
+
+  // Query dictionary parameters or information about a dictionary.
+  HTuple GetDictParam(const HString& GenParamName, const HString& Key) const;
+
+  // Query dictionary parameters or information about a dictionary.
+  HTuple GetDictParam(const char* GenParamName, const char* Key) const;
+
+#ifdef _WIN32
+  // Query dictionary parameters or information about a dictionary.
+  HTuple GetDictParam(const wchar_t* GenParamName, const wchar_t* Key) const;
+#endif
+
+  // Retrieve a tuple associated with the key from the dictionary.
+  HTuple GetDictTuple(const HTuple& Key) const;
+
+  // Retrieve a tuple associated with the key from the dictionary.
+  HTuple GetDictTuple(const HString& Key) const;
+
+  // Retrieve a tuple associated with the key from the dictionary.
+  HTuple GetDictTuple(const char* Key) const;
+
+#ifdef _WIN32
+  // Retrieve a tuple associated with the key from the dictionary.
+  HTuple GetDictTuple(const wchar_t* Key) const;
+#endif
+
+  // Read a dictionary from a file.
+  void ReadDict(const HString& FileName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Read a dictionary from a file.
+  void ReadDict(const HString& FileName, const HString& GenParamName, const HString& GenParamValue);
+
+  // Read a dictionary from a file.
+  void ReadDict(const char* FileName, const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // Read a dictionary from a file.
+  void ReadDict(const wchar_t* FileName, const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+  // Remove keys from a dictionary.
+  void RemoveDictKey(const HTuple& Key) const;
+
+  // Remove keys from a dictionary.
+  void RemoveDictKey(const HString& Key) const;
+
+  // Remove keys from a dictionary.
+  void RemoveDictKey(const char* Key) const;
+
+#ifdef _WIN32
+  // Remove keys from a dictionary.
+  void RemoveDictKey(const wchar_t* Key) const;
+#endif
+
+  // Add a key/object pair to the dictionary.
+  void SetDictObject(const HObject& Object, const HTuple& Key) const;
+
+  // Add a key/object pair to the dictionary.
+  void SetDictObject(const HObject& Object, const HString& Key) const;
+
+  // Add a key/object pair to the dictionary.
+  void SetDictObject(const HObject& Object, const char* Key) const;
+
+#ifdef _WIN32
+  // Add a key/object pair to the dictionary.
+  void SetDictObject(const HObject& Object, const wchar_t* Key) const;
+#endif
+
+  // Add a key/tuple pair to the dictionary.
+  void SetDictTuple(const HTuple& Key, const HTuple& Tuple) const;
+
+  // Add a key/tuple pair to the dictionary.
+  void SetDictTuple(const HString& Key, const HTuple& Tuple) const;
+
+  // Add a key/tuple pair to the dictionary.
+  void SetDictTuple(const char* Key, const HTuple& Tuple) const;
+
+#ifdef _WIN32
+  // Add a key/tuple pair to the dictionary.
+  void SetDictTuple(const wchar_t* Key, const HTuple& Tuple) const;
+#endif
+
+  // Write a dictionary to a file.
+  void WriteDict(const HString& FileName, const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Write a dictionary to a file.
+  void WriteDict(const HString& FileName, const HString& GenParamName, const HString& GenParamValue) const;
+
+  // Write a dictionary to a file.
+  void WriteDict(const char* FileName, const char* GenParamName, const char* GenParamValue) const;
+
+#ifdef _WIN32
+  // Write a dictionary to a file.
+  void WriteDict(const wchar_t* FileName, const wchar_t* GenParamName, const wchar_t* GenParamValue) const;
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDict> HDictArrayRef;
+typedef HSmartPtr< HDictArrayRef > HDictArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDictArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDictArray();
+
+  // Create array from native array of tool instances
+  HDictArray(HDict* classes, Hlong length);
+
+  // Copy constructor
+  HDictArray(const HDictArray &tool_array);
+
+  // Destructor
+  virtual ~HDictArray();
+
+  // Assignment operator
+  HDictArray &operator=(const HDictArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDict* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDictArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDlClassifier.h

@@ -0,0 +1,197 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDLCLASSIFIER
+#define HCPP_HDLCLASSIFIER
+
+namespace HalconCpp
+{
+
+// Represents an instance of a Deep Neural Network.
+class LIntExport HDlClassifier : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDlClassifier():HHandle() {}
+
+  // Copy constructor
+  HDlClassifier(const HDlClassifier& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDlClassifier(const HHandle& handle);
+
+  // Create HDlClassifier from handle, taking ownership
+  explicit HDlClassifier(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('dl_classifier')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HDlClassifier Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_dl_classifier: Read a deep-learning-based classifier from a file.
+  explicit HDlClassifier(const HString& FileName);
+
+  // read_dl_classifier: Read a deep-learning-based classifier from a file.
+  explicit HDlClassifier(const char* FileName);
+
+#ifdef _WIN32
+  // read_dl_classifier: Read a deep-learning-based classifier from a file.
+  explicit HDlClassifier(const wchar_t* FileName);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Infer the class affiliations for a set of images using a  deep-learning-based classifier.
+  HDlClassifierResult ApplyDlClassifier(const HImage& Images) const;
+
+  // Clear a deep-learning-based classifier.
+  static void ClearDlClassifier(const HDlClassifierArray& DLClassifierHandle);
+
+  // Clear a deep-learning-based classifier.
+  void ClearDlClassifier() const;
+
+  // Deserialize a deep-learning-based classifier.
+  void DeserializeDlClassifier(const HSerializedItem& SerializedItemHandle);
+
+  // Return the parameters of a deep-learning-based classifier.
+  HTuple GetDlClassifierParam(const HTuple& GenParamName) const;
+
+  // Return the parameters of a deep-learning-based classifier.
+  HTuple GetDlClassifierParam(const HString& GenParamName) const;
+
+  // Return the parameters of a deep-learning-based classifier.
+  HTuple GetDlClassifierParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Return the parameters of a deep-learning-based classifier.
+  HTuple GetDlClassifierParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Read a deep-learning-based classifier from a file.
+  void ReadDlClassifier(const HString& FileName);
+
+  // Read a deep-learning-based classifier from a file.
+  void ReadDlClassifier(const char* FileName);
+
+#ifdef _WIN32
+  // Read a deep-learning-based classifier from a file.
+  void ReadDlClassifier(const wchar_t* FileName);
+#endif
+
+  // Serialize a deep-learning-based classifier.
+  HSerializedItem SerializeDlClassifier() const;
+
+  // Set the parameters of a deep-learning-based classifier.
+  void SetDlClassifierParam(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set the parameters of a deep-learning-based classifier.
+  void SetDlClassifierParam(const HString& GenParamName, const HString& GenParamValue) const;
+
+  // Set the parameters of a deep-learning-based classifier.
+  void SetDlClassifierParam(const char* GenParamName, const char* GenParamValue) const;
+
+#ifdef _WIN32
+  // Set the parameters of a deep-learning-based classifier.
+  void SetDlClassifierParam(const wchar_t* GenParamName, const wchar_t* GenParamValue) const;
+#endif
+
+  // Write a deep-learning-based classifier in a file.
+  void WriteDlClassifier(const HString& FileName) const;
+
+  // Write a deep-learning-based classifier in a file.
+  void WriteDlClassifier(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a deep-learning-based classifier in a file.
+  void WriteDlClassifier(const wchar_t* FileName) const;
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDlClassifier> HDlClassifierArrayRef;
+typedef HSmartPtr< HDlClassifierArrayRef > HDlClassifierArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDlClassifierArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDlClassifierArray();
+
+  // Create array from native array of tool instances
+  HDlClassifierArray(HDlClassifier* classes, Hlong length);
+
+  // Copy constructor
+  HDlClassifierArray(const HDlClassifierArray &tool_array);
+
+  // Destructor
+  virtual ~HDlClassifierArray();
+
+  // Assignment operator
+  HDlClassifierArray &operator=(const HDlClassifierArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDlClassifier* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDlClassifierArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDlClassifierResult.h

@@ -0,0 +1,141 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDLCLASSIFIERRESULT
+#define HCPP_HDLCLASSIFIERRESULT
+
+namespace HalconCpp
+{
+
+// Represents an instance of a Deep Neural Network inference step result.
+class LIntExport HDlClassifierResult : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDlClassifierResult():HHandle() {}
+
+  // Copy constructor
+  HDlClassifierResult(const HDlClassifierResult& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDlClassifierResult(const HHandle& handle);
+
+  // Create HDlClassifierResult from handle, taking ownership
+  explicit HDlClassifierResult(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('dl_classifier_result')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // apply_dl_classifier: Infer the class affiliations for a set of images using a  deep-learning-based classifier.
+  explicit HDlClassifierResult(const HImage& Images, const HDlClassifier& DLClassifierHandle);
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Clear a handle containing the results of the deep-learning-based classification.
+  static void ClearDlClassifierResult(const HDlClassifierResultArray& DLClassifierResultHandle);
+
+  // Clear a handle containing the results of the deep-learning-based classification.
+  void ClearDlClassifierResult() const;
+
+  // Retrieve classification results inferred by a deep-learning-based  classifier.
+  HTuple GetDlClassifierResult(const HTuple& Index, const HTuple& GenResultName) const;
+
+  // Retrieve classification results inferred by a deep-learning-based  classifier.
+  HTuple GetDlClassifierResult(const HString& Index, const HString& GenResultName) const;
+
+  // Retrieve classification results inferred by a deep-learning-based  classifier.
+  HTuple GetDlClassifierResult(const char* Index, const char* GenResultName) const;
+
+#ifdef _WIN32
+  // Retrieve classification results inferred by a deep-learning-based  classifier.
+  HTuple GetDlClassifierResult(const wchar_t* Index, const wchar_t* GenResultName) const;
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDlClassifierResult> HDlClassifierResultArrayRef;
+typedef HSmartPtr< HDlClassifierResultArrayRef > HDlClassifierResultArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDlClassifierResultArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDlClassifierResultArray();
+
+  // Create array from native array of tool instances
+  HDlClassifierResultArray(HDlClassifierResult* classes, Hlong length);
+
+  // Copy constructor
+  HDlClassifierResultArray(const HDlClassifierResultArray &tool_array);
+
+  // Destructor
+  virtual ~HDlClassifierResultArray();
+
+  // Assignment operator
+  HDlClassifierResultArray &operator=(const HDlClassifierResultArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDlClassifierResult* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDlClassifierResultArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDlClassifierTrainResult.h

@@ -0,0 +1,144 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDLCLASSIFIERTRAINRESULT
+#define HCPP_HDLCLASSIFIERTRAINRESULT
+
+namespace HalconCpp
+{
+
+// Represents an instance of a Deep Neural Network training step result.
+class LIntExport HDlClassifierTrainResult : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDlClassifierTrainResult():HHandle() {}
+
+  // Copy constructor
+  HDlClassifierTrainResult(const HDlClassifierTrainResult& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDlClassifierTrainResult(const HHandle& handle);
+
+  // Create HDlClassifierTrainResult from handle, taking ownership
+  explicit HDlClassifierTrainResult(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('dl_classifier_train_result')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // train_dl_classifier_batch: Perform a training step of a deep-learning-based classifier on a batch of  images.
+  explicit HDlClassifierTrainResult(const HImage& BatchImages, const HDlClassifier& DLClassifierHandle, const HTuple& BatchLabels);
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Clear the handle of a deep-learning-based classifier training result.
+  static void ClearDlClassifierTrainResult(const HDlClassifierTrainResultArray& DLClassifierTrainResultHandle);
+
+  // Clear the handle of a deep-learning-based classifier training result.
+  void ClearDlClassifierTrainResult() const;
+
+  // Return the results for the single training step of a deep-learning-based  classifier.
+  HTuple GetDlClassifierTrainResult(const HTuple& GenParamName) const;
+
+  // Return the results for the single training step of a deep-learning-based  classifier.
+  HTuple GetDlClassifierTrainResult(const HString& GenParamName) const;
+
+  // Return the results for the single training step of a deep-learning-based  classifier.
+  HTuple GetDlClassifierTrainResult(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Return the results for the single training step of a deep-learning-based  classifier.
+  HTuple GetDlClassifierTrainResult(const wchar_t* GenParamName) const;
+#endif
+
+  // Perform a training step of a deep-learning-based classifier on a batch of  images.
+  void TrainDlClassifierBatch(const HImage& BatchImages, const HDlClassifier& DLClassifierHandle, const HTuple& BatchLabels);
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDlClassifierTrainResult> HDlClassifierTrainResultArrayRef;
+typedef HSmartPtr< HDlClassifierTrainResultArrayRef > HDlClassifierTrainResultArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDlClassifierTrainResultArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDlClassifierTrainResultArray();
+
+  // Create array from native array of tool instances
+  HDlClassifierTrainResultArray(HDlClassifierTrainResult* classes, Hlong length);
+
+  // Copy constructor
+  HDlClassifierTrainResultArray(const HDlClassifierTrainResultArray &tool_array);
+
+  // Destructor
+  virtual ~HDlClassifierTrainResultArray();
+
+  // Assignment operator
+  HDlClassifierTrainResultArray &operator=(const HDlClassifierTrainResultArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDlClassifierTrainResult* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDlClassifierTrainResultArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDlDevice.h

@@ -0,0 +1,137 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDLDEVICE
+#define HCPP_HDLDEVICE
+
+namespace HalconCpp
+{
+
+// Represents an instance of a Deep Learning capable compute device.
+class LIntExport HDlDevice : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDlDevice():HHandle() {}
+
+  // Copy constructor
+  HDlDevice(const HDlDevice& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDlDevice(const HHandle& handle);
+
+  // Create HDlDevice from handle, taking ownership
+  explicit HDlDevice(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('dl_device')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Return the parameters of a deep-learning-capable hardware device.
+  HTuple GetDlDeviceParam(const HString& GenParamName) const;
+
+  // Return the parameters of a deep-learning-capable hardware device.
+  HTuple GetDlDeviceParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Return the parameters of a deep-learning-capable hardware device.
+  HTuple GetDlDeviceParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Get list of deep-learning-capable hardware devices.
+  static HDlDeviceArray QueryAvailableDlDevices(const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Get list of deep-learning-capable hardware devices.
+  void QueryAvailableDlDevices(const HString& GenParamName, const HString& GenParamValue);
+
+  // Get list of deep-learning-capable hardware devices.
+  void QueryAvailableDlDevices(const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // Get list of deep-learning-capable hardware devices.
+  void QueryAvailableDlDevices(const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDlDevice> HDlDeviceArrayRef;
+typedef HSmartPtr< HDlDeviceArrayRef > HDlDeviceArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDlDeviceArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDlDeviceArray();
+
+  // Create array from native array of tool instances
+  HDlDeviceArray(HDlDevice* classes, Hlong length);
+
+  // Copy constructor
+  HDlDeviceArray(const HDlDeviceArray &tool_array);
+
+  // Destructor
+  virtual ~HDlDeviceArray();
+
+  // Assignment operator
+  HDlDeviceArray &operator=(const HDlDeviceArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDlDevice* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDlDeviceArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDlModel.h

@@ -0,0 +1,250 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDLMODEL
+#define HCPP_HDLMODEL
+
+namespace HalconCpp
+{
+
+// Represents an instance of a Deep Neural Network.
+class LIntExport HDlModel : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDlModel():HHandle() {}
+
+  // Copy constructor
+  HDlModel(const HDlModel& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDlModel(const HHandle& handle);
+
+  // Create HDlModel from handle, taking ownership
+  explicit HDlModel(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('dl_model')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HDlModel Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_dl_model_detection: Create a deep learning network for object detection.
+  explicit HDlModel(const HString& Backbone, Hlong NumClasses, const HDict& DLModelDetectionParam);
+
+  // create_dl_model_detection: Create a deep learning network for object detection.
+  explicit HDlModel(const char* Backbone, Hlong NumClasses, const HDict& DLModelDetectionParam);
+
+#ifdef _WIN32
+  // create_dl_model_detection: Create a deep learning network for object detection.
+  explicit HDlModel(const wchar_t* Backbone, Hlong NumClasses, const HDict& DLModelDetectionParam);
+#endif
+
+  // read_dl_model: Read a deep learning model from a file.
+  explicit HDlModel(const HString& FileName);
+
+  // read_dl_model: Read a deep learning model from a file.
+  explicit HDlModel(const char* FileName);
+
+#ifdef _WIN32
+  // read_dl_model: Read a deep learning model from a file.
+  explicit HDlModel(const wchar_t* FileName);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Apply a deep-learning-based network on a set of images for inference.
+  HDictArray ApplyDlModel(const HDictArray& DLSampleBatch, const HTuple& Outputs) const;
+
+  // Clear a deep learning model.
+  static void ClearDlModel(const HDlModelArray& DLModelHandle);
+
+  // Clear a deep learning model.
+  void ClearDlModel() const;
+
+  // Create a deep learning network for object detection.
+  void CreateDlModelDetection(const HString& Backbone, Hlong NumClasses, const HDict& DLModelDetectionParam);
+
+  // Create a deep learning network for object detection.
+  void CreateDlModelDetection(const char* Backbone, Hlong NumClasses, const HDict& DLModelDetectionParam);
+
+#ifdef _WIN32
+  // Create a deep learning network for object detection.
+  void CreateDlModelDetection(const wchar_t* Backbone, Hlong NumClasses, const HDict& DLModelDetectionParam);
+#endif
+
+  // Deserialize a deep learning model.
+  void DeserializeDlModel(const HSerializedItem& SerializedItemHandle);
+
+  // Return the parameters of a deep learning model.
+  HTuple GetDlModelParam(const HString& GenParamName) const;
+
+  // Return the parameters of a deep learning model.
+  HTuple GetDlModelParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Return the parameters of a deep learning model.
+  HTuple GetDlModelParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Read a deep learning model from a file.
+  void ReadDlModel(const HString& FileName);
+
+  // Read a deep learning model from a file.
+  void ReadDlModel(const char* FileName);
+
+#ifdef _WIN32
+  // Read a deep learning model from a file.
+  void ReadDlModel(const wchar_t* FileName);
+#endif
+
+  // Serialize a deep learning model.
+  HSerializedItem SerializeDlModel() const;
+
+  // Set the parameters of a deep learning model.
+  void SetDlModelParam(const HString& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set the parameters of a deep learning model.
+  void SetDlModelParam(const HString& GenParamName, double GenParamValue) const;
+
+  // Set the parameters of a deep learning model.
+  void SetDlModelParam(const char* GenParamName, double GenParamValue) const;
+
+#ifdef _WIN32
+  // Set the parameters of a deep learning model.
+  void SetDlModelParam(const wchar_t* GenParamName, double GenParamValue) const;
+#endif
+
+  // Train a deep learning model.
+  HDict TrainDlModelBatch(const HDictArray& DLSampleBatch) const;
+
+  // Write a deep learning model in a file.
+  void WriteDlModel(const HString& FileName) const;
+
+  // Write a deep learning model in a file.
+  void WriteDlModel(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a deep learning model in a file.
+  void WriteDlModel(const wchar_t* FileName) const;
+#endif
+
+  // Infer the sample and generate a heatmap.
+  HDictArray GenDlModelHeatmap(const HDictArray& DLSample, const HString& HeatmapMethod, const HTuple& TargetClasses, const HDict& GenParam) const;
+
+  // Infer the sample and generate a heatmap.
+  HDictArray GenDlModelHeatmap(const HDictArray& DLSample, const char* HeatmapMethod, const HTuple& TargetClasses, const HDict& GenParam) const;
+
+#ifdef _WIN32
+  // Infer the sample and generate a heatmap.
+  HDictArray GenDlModelHeatmap(const HDictArray& DLSample, const wchar_t* HeatmapMethod, const HTuple& TargetClasses, const HDict& GenParam) const;
+#endif
+
+  // Train a deep learning model for anomaly detection.
+  HDict TrainDlModelAnomalyDataset(const HDictArray& DLSamples, const HDict& DLTrainParam) const;
+
+  // Calculate scores to prune a deep learning model.
+  void AddDlPruningBatch(const HDlPrune& DLPruningHandle, const HDictArray& DLSampleBatch) const;
+
+  // Create a pruning data handle.
+  HDlPrune CreateDlPruning(const HString& Mode, const HDict& GenParam) const;
+
+  // Create a pruning data handle.
+  HDlPrune CreateDlPruning(const char* Mode, const HDict& GenParam) const;
+
+#ifdef _WIN32
+  // Create a pruning data handle.
+  HDlPrune CreateDlPruning(const wchar_t* Mode, const HDict& GenParam) const;
+#endif
+
+  // Prune a deep learning model.
+  HDlModel GenDlPrunedModel(const HDlPrune& DLPruningHandle) const;
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDlModel> HDlModelArrayRef;
+typedef HSmartPtr< HDlModelArrayRef > HDlModelArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDlModelArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDlModelArray();
+
+  // Create array from native array of tool instances
+  HDlModelArray(HDlModel* classes, Hlong length);
+
+  // Copy constructor
+  HDlModelArray(const HDlModelArray &tool_array);
+
+  // Destructor
+  virtual ~HDlModelArray();
+
+  // Assignment operator
+  HDlModelArray &operator=(const HDlModelArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDlModel* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDlModelArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDlModelOcr.h

@@ -0,0 +1,215 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDLMODELOCR
+#define HCPP_HDLMODELOCR
+
+namespace HalconCpp
+{
+
+// Represents an instance of a Deep Neural Network based OCR model.
+class LIntExport HDlModelOcr : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDlModelOcr():HHandle() {}
+
+  // Copy constructor
+  HDlModelOcr(const HDlModelOcr& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDlModelOcr(const HHandle& handle);
+
+  // Create HDlModelOcr from handle, taking ownership
+  explicit HDlModelOcr(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('deep_ocr')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_deep_ocr: Create a Deep OCR model.
+  explicit HDlModelOcr(const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // create_deep_ocr: Create a Deep OCR model.
+  explicit HDlModelOcr(const HString& GenParamName, const HString& GenParamValue);
+
+  // create_deep_ocr: Create a Deep OCR model.
+  explicit HDlModelOcr(const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // create_deep_ocr: Create a Deep OCR model.
+  explicit HDlModelOcr(const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+  // read_deep_ocr: Read a Deep OCR model from a file.
+  explicit HDlModelOcr(const HString& FileName);
+
+  // read_deep_ocr: Read a Deep OCR model from a file.
+  explicit HDlModelOcr(const char* FileName);
+
+#ifdef _WIN32
+  // read_deep_ocr: Read a Deep OCR model from a file.
+  explicit HDlModelOcr(const wchar_t* FileName);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Apply a Deep OCR model on a set of images for inference.
+  HDictArray ApplyDeepOcr(const HImage& Image, const HString& Mode) const;
+
+  // Apply a Deep OCR model on a set of images for inference.
+  HDictArray ApplyDeepOcr(const HImage& Image, const char* Mode) const;
+
+#ifdef _WIN32
+  // Apply a Deep OCR model on a set of images for inference.
+  HDictArray ApplyDeepOcr(const HImage& Image, const wchar_t* Mode) const;
+#endif
+
+  // Create a Deep OCR model.
+  void CreateDeepOcr(const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Create a Deep OCR model.
+  void CreateDeepOcr(const HString& GenParamName, const HString& GenParamValue);
+
+  // Create a Deep OCR model.
+  void CreateDeepOcr(const char* GenParamName, const char* GenParamValue);
+
+#ifdef _WIN32
+  // Create a Deep OCR model.
+  void CreateDeepOcr(const wchar_t* GenParamName, const wchar_t* GenParamValue);
+#endif
+
+  // Return the parameters of a Deep OCR model.
+  HTuple GetDeepOcrParam(const HString& GenParamName) const;
+
+  // Return the parameters of a Deep OCR model.
+  HTuple GetDeepOcrParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Return the parameters of a Deep OCR model.
+  HTuple GetDeepOcrParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Read a Deep OCR model from a file.
+  void ReadDeepOcr(const HString& FileName);
+
+  // Read a Deep OCR model from a file.
+  void ReadDeepOcr(const char* FileName);
+
+#ifdef _WIN32
+  // Read a Deep OCR model from a file.
+  void ReadDeepOcr(const wchar_t* FileName);
+#endif
+
+  // Set the parameters of a Deep OCR model.
+  void SetDeepOcrParam(const HString& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set the parameters of a Deep OCR model.
+  void SetDeepOcrParam(const HString& GenParamName, double GenParamValue) const;
+
+  // Set the parameters of a Deep OCR model.
+  void SetDeepOcrParam(const char* GenParamName, double GenParamValue) const;
+
+#ifdef _WIN32
+  // Set the parameters of a Deep OCR model.
+  void SetDeepOcrParam(const wchar_t* GenParamName, double GenParamValue) const;
+#endif
+
+  // Write a Deep OCR model in a file.
+  void WriteDeepOcr(const HString& FileName) const;
+
+  // Write a Deep OCR model in a file.
+  void WriteDeepOcr(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a Deep OCR model in a file.
+  void WriteDeepOcr(const wchar_t* FileName) const;
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDlModelOcr> HDlModelOcrArrayRef;
+typedef HSmartPtr< HDlModelOcrArrayRef > HDlModelOcrArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDlModelOcrArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDlModelOcrArray();
+
+  // Create array from native array of tool instances
+  HDlModelOcrArray(HDlModelOcr* classes, Hlong length);
+
+  // Copy constructor
+  HDlModelOcrArray(const HDlModelOcrArray &tool_array);
+
+  // Destructor
+  virtual ~HDlModelOcrArray();
+
+  // Assignment operator
+  HDlModelOcrArray &operator=(const HDlModelOcrArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDlModelOcr* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDlModelOcrArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDlPrune.h

@@ -0,0 +1,168 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDLPRUNE
+#define HCPP_HDLPRUNE
+
+namespace HalconCpp
+{
+
+// Represents an instance of the parameter information for pruning a Deep Neural Network model.
+class LIntExport HDlPrune : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDlPrune():HHandle() {}
+
+  // Copy constructor
+  HDlPrune(const HDlPrune& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDlPrune(const HHandle& handle);
+
+  // Create HDlPrune from handle, taking ownership
+  explicit HDlPrune(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('dl_pruning')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_dl_pruning: Create a pruning data handle.
+  explicit HDlPrune(const HDlModel& DLModelHandle, const HString& Mode, const HDict& GenParam);
+
+  // create_dl_pruning: Create a pruning data handle.
+  explicit HDlPrune(const HDlModel& DLModelHandle, const char* Mode, const HDict& GenParam);
+
+#ifdef _WIN32
+  // create_dl_pruning: Create a pruning data handle.
+  explicit HDlPrune(const HDlModel& DLModelHandle, const wchar_t* Mode, const HDict& GenParam);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Calculate scores to prune a deep learning model.
+  void AddDlPruningBatch(const HDlModel& DLModelHandleToPrune, const HDictArray& DLSampleBatch) const;
+
+  // Create a pruning data handle.
+  void CreateDlPruning(const HDlModel& DLModelHandle, const HString& Mode, const HDict& GenParam);
+
+  // Create a pruning data handle.
+  void CreateDlPruning(const HDlModel& DLModelHandle, const char* Mode, const HDict& GenParam);
+
+#ifdef _WIN32
+  // Create a pruning data handle.
+  void CreateDlPruning(const HDlModel& DLModelHandle, const wchar_t* Mode, const HDict& GenParam);
+#endif
+
+  // Get information from a pruning data handle.
+  HTuple GetDlPruningParam(const HString& GenParamName) const;
+
+  // Get information from a pruning data handle.
+  HTuple GetDlPruningParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Get information from a pruning data handle.
+  HTuple GetDlPruningParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Set parameter in a pruning data handle.
+  void SetDlPruningParam(const HString& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set parameter in a pruning data handle.
+  void SetDlPruningParam(const HString& GenParamName, double GenParamValue) const;
+
+  // Set parameter in a pruning data handle.
+  void SetDlPruningParam(const char* GenParamName, double GenParamValue) const;
+
+#ifdef _WIN32
+  // Set parameter in a pruning data handle.
+  void SetDlPruningParam(const wchar_t* GenParamName, double GenParamValue) const;
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDlPrune> HDlPruneArrayRef;
+typedef HSmartPtr< HDlPruneArrayRef > HDlPruneArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDlPruneArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDlPruneArray();
+
+  // Create array from native array of tool instances
+  HDlPruneArray(HDlPrune* classes, Hlong length);
+
+  // Copy constructor
+  HDlPruneArray(const HDlPruneArray &tool_array);
+
+  // Destructor
+  virtual ~HDlPruneArray();
+
+  // Assignment operator
+  HDlPruneArray &operator=(const HDlPruneArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDlPrune* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDlPruneArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDrawingObject.h

@@ -0,0 +1,243 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDRAWINGOBJECT
+#define HCPP_HDRAWINGOBJECT
+
+namespace HalconCpp
+{
+
+// Represents an instance of a drawing object.
+class LIntExport HDrawingObject : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDrawingObject():HHandle() {}
+
+  // Copy constructor
+  HDrawingObject(const HDrawingObject& source) : HHandle(source) {}
+
+  // Copy constructor
+  HDrawingObject(const HHandle& handle);
+
+  // Create HDrawingObject from handle, taking ownership
+  explicit HDrawingObject(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('drawing_object')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_drawing_object_circle: Create a circle which can be modified interactively.
+  explicit HDrawingObject(double Row, double Column, double Radius);
+
+  // create_drawing_object_rectangle2: Create a rectangle of any orientation which can be modified interactively.
+  explicit HDrawingObject(double Row, double Column, double Phi, double Length1, double Length2);
+
+  // create_drawing_object_rectangle1: Create a rectangle parallel to the coordinate axis which can be modified interactively.
+  explicit HDrawingObject(double Row1, double Column1, double Row2, double Column2);
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Add a callback function to a drawing object.
+  void SetDrawingObjectCallback(const HTuple& DrawObjectEvent, const HTuple& CallbackFunction) const;
+
+  // Add a callback function to a drawing object.
+  void SetDrawingObjectCallback(const HString& DrawObjectEvent, void* CallbackFunction) const;
+
+  // Add a callback function to a drawing object.
+  void SetDrawingObjectCallback(const char* DrawObjectEvent, void* CallbackFunction) const;
+
+#ifdef _WIN32
+  // Add a callback function to a drawing object.
+  void SetDrawingObjectCallback(const wchar_t* DrawObjectEvent, void* CallbackFunction) const;
+#endif
+
+  // Detach the background image from a HALCON window.
+  static void DetachBackgroundFromWindow(const HWindow& WindowHandle);
+
+  // Attach a background image to a HALCON window.
+  static void AttachBackgroundToWindow(const HImage& Image, const HWindow& WindowHandle);
+
+  // Create a text object which can be moved interactively.
+  void CreateDrawingObjectText(Hlong Row, Hlong Column, const HString& String);
+
+  // Create a text object which can be moved interactively.
+  void CreateDrawingObjectText(Hlong Row, Hlong Column, const char* String);
+
+#ifdef _WIN32
+  // Create a text object which can be moved interactively.
+  void CreateDrawingObjectText(Hlong Row, Hlong Column, const wchar_t* String);
+#endif
+
+  // Return the iconic object of a drawing object.
+  HObject GetDrawingObjectIconic() const;
+
+  // Delete drawing object.
+  void ClearDrawingObject() const;
+
+  // Set the parameters of a drawing object.
+  void SetDrawingObjectParams(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Set the parameters of a drawing object.
+  void SetDrawingObjectParams(const HString& GenParamName, double GenParamValue) const;
+
+  // Set the parameters of a drawing object.
+  void SetDrawingObjectParams(const char* GenParamName, double GenParamValue) const;
+
+#ifdef _WIN32
+  // Set the parameters of a drawing object.
+  void SetDrawingObjectParams(const wchar_t* GenParamName, double GenParamValue) const;
+#endif
+
+  // Get the parameters of a drawing object.
+  HTuple GetDrawingObjectParams(const HTuple& GenParamName) const;
+
+  // Get the parameters of a drawing object.
+  HTuple GetDrawingObjectParams(const HString& GenParamName) const;
+
+  // Get the parameters of a drawing object.
+  HTuple GetDrawingObjectParams(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Get the parameters of a drawing object.
+  HTuple GetDrawingObjectParams(const wchar_t* GenParamName) const;
+#endif
+
+  // Set the contour of an interactive draw XLD.
+  void SetDrawingObjectXld(const HXLDCont& Contour) const;
+
+  // Create a XLD contour which can be modified interactively.
+  void CreateDrawingObjectXld(const HTuple& Row, const HTuple& Column);
+
+  // Create a circle sector which can be modified interactively.
+  void CreateDrawingObjectCircleSector(double Row, double Column, double Radius, double StartAngle, double EndAngle);
+
+  // Create an elliptic sector which can be modified interactively.
+  void CreateDrawingObjectEllipseSector(double Row, double Column, double Phi, double Radius1, double Radius2, double StartAngle, double EndAngle);
+
+  // Create a line which can be modified interactively.
+  void CreateDrawingObjectLine(double Row1, double Column1, double Row2, double Column2);
+
+  // Create a circle which can be modified interactively.
+  void CreateDrawingObjectCircle(double Row, double Column, double Radius);
+
+  // Create an ellipse which can be modified interactively.
+  void CreateDrawingObjectEllipse(double Row, double Column, double Phi, double Radius1, double Radius2);
+
+  // Create a rectangle of any orientation which can be modified interactively.
+  void CreateDrawingObjectRectangle2(double Row, double Column, double Phi, double Length1, double Length2);
+
+  // Create a rectangle parallel to the coordinate axis which can be modified interactively.
+  void CreateDrawingObjectRectangle1(double Row1, double Column1, double Row2, double Column2);
+
+  // Send an event to a buffer window signaling a mouse double click event.
+  static HString SendMouseDoubleClickEvent(const HWindow& WindowHandle, const HTuple& Row, const HTuple& Column, Hlong Button);
+
+  // Send an event to a buffer window signaling a mouse double click event.
+  static HString SendMouseDoubleClickEvent(const HWindow& WindowHandle, Hlong Row, Hlong Column, Hlong Button);
+
+  // Send an event to a window buffer signaling a mouse down event.
+  static HString SendMouseDownEvent(const HWindow& WindowHandle, const HTuple& Row, const HTuple& Column, Hlong Button);
+
+  // Send an event to a window buffer signaling a mouse down event.
+  static HString SendMouseDownEvent(const HWindow& WindowHandle, Hlong Row, Hlong Column, Hlong Button);
+
+  // Send an event to a buffer window signaling a mouse drag event.
+  static HString SendMouseDragEvent(const HWindow& WindowHandle, const HTuple& Row, const HTuple& Column, Hlong Button);
+
+  // Send an event to a buffer window signaling a mouse drag event.
+  static HString SendMouseDragEvent(const HWindow& WindowHandle, Hlong Row, Hlong Column, Hlong Button);
+
+  // Send an event to a buffer window signaling a mouse up event.
+  static HString SendMouseUpEvent(const HWindow& WindowHandle, const HTuple& Row, const HTuple& Column, Hlong Button);
+
+  // Send an event to a buffer window signaling a mouse up event.
+  static HString SendMouseUpEvent(const HWindow& WindowHandle, Hlong Row, Hlong Column, Hlong Button);
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HDrawingObject> HDrawingObjectArrayRef;
+typedef HSmartPtr< HDrawingObjectArrayRef > HDrawingObjectArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HDrawingObjectArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HDrawingObjectArray();
+
+  // Create array from native array of tool instances
+  HDrawingObjectArray(HDrawingObject* classes, Hlong length);
+
+  // Copy constructor
+  HDrawingObjectArray(const HDrawingObjectArray &tool_array);
+
+  // Destructor
+  virtual ~HDrawingObjectArray();
+
+  // Assignment operator
+  HDrawingObjectArray &operator=(const HDrawingObjectArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HDrawingObject* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HDrawingObjectArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HDualQuaternion.h

@@ -0,0 +1,189 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HDUALQUATERNION
+#define HCPP_HDUALQUATERNION
+
+namespace HalconCpp
+{
+
+// Represents a dual quaternion.
+class LIntExport HDualQuaternion : public HDataBase
+{
+
+public:
+
+  // Create an uninitialized instance
+  HDualQuaternion():HDataBase() {}
+
+  // Copy constructor
+  HDualQuaternion(const HDualQuaternion& source) : HDataBase(source) {}
+
+  // Constructor from HTuple
+  explicit HDualQuaternion(const HTuple& tuple) : HDataBase(tuple) {}
+
+  // Deep copy of all data represented by this object instance
+  HDualQuaternion Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // pose_to_dual_quat: Convert a 3D pose to a unit dual quaternion.
+  explicit HDualQuaternion(const HPose& Pose);
+
+  // screw_to_dual_quat: Convert a screw into a dual quaternion.
+  explicit HDualQuaternion(const HString& ScrewFormat, const HTuple& AxisDirectionX, const HTuple& AxisDirectionY, const HTuple& AxisDirectionZ, const HTuple& AxisMomentOrPointX, const HTuple& AxisMomentOrPointY, const HTuple& AxisMomentOrPointZ, const HTuple& Rotation, const HTuple& Translation);
+
+  // screw_to_dual_quat: Convert a screw into a dual quaternion.
+  explicit HDualQuaternion(const HString& ScrewFormat, double AxisDirectionX, double AxisDirectionY, double AxisDirectionZ, double AxisMomentOrPointX, double AxisMomentOrPointY, double AxisMomentOrPointZ, double Rotation, double Translation);
+
+  // screw_to_dual_quat: Convert a screw into a dual quaternion.
+  explicit HDualQuaternion(const char* ScrewFormat, double AxisDirectionX, double AxisDirectionY, double AxisDirectionZ, double AxisMomentOrPointX, double AxisMomentOrPointY, double AxisMomentOrPointZ, double Rotation, double Translation);
+
+#ifdef _WIN32
+  // screw_to_dual_quat: Convert a screw into a dual quaternion.
+  explicit HDualQuaternion(const wchar_t* ScrewFormat, double AxisDirectionX, double AxisDirectionY, double AxisDirectionZ, double AxisMomentOrPointX, double AxisMomentOrPointY, double AxisMomentOrPointZ, double Rotation, double Translation);
+#endif
+
+
+/*****************************************************************************
+ * Operator overloads (non-member overloads reside in HOperatorOverloads.h)
+ *****************************************************************************/
+
+  // Convert to matrix
+  operator HHomMat3D() const;
+
+  // Convert to pose
+  operator HPose() const;
+
+  // Conjugate dual quaternion
+  HDualQuaternion operator ~ () const;
+
+  // Create a dual quaternion from eight double values, where 
+  // (RealW, RealX, RealY, RealZ) are the elements of the real part and
+  // (DualW, DualX, DualY, DualZ) are the elements of the dual part.
+  explicit HDualQuaternion(double RealW, double RealX,
+                           double RealY, double RealZ,
+                           double DualW, double DualX,
+                           double DualY, double DualZ);
+
+  // Create a dual quaternion from two quaternions for the real and the 
+  // dual part.
+  explicit HDualQuaternion(HQuaternion QuatReal, HQuaternion QuatDual);
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Deserialize a serialized dual quaternion.
+  void DeserializeDualQuat(const HSerializedItem& SerializedItemHandle);
+
+  // Multiply two dual quaternions.
+  static HDualQuaternionArray DualQuatCompose(const HDualQuaternionArray& DualQuaternionLeft, const HDualQuaternionArray& DualQuaternionRight);
+
+  // Multiply two dual quaternions.
+  HDualQuaternion DualQuatCompose(const HDualQuaternion& DualQuaternionRight) const;
+
+  // Conjugate a dual quaternion.
+  static HDualQuaternionArray DualQuatConjugate(const HDualQuaternionArray& DualQuaternion);
+
+  // Conjugate a dual quaternion.
+  HDualQuaternion DualQuatConjugate() const;
+
+  // Interpolate two dual quaternions.
+  HDualQuaternionArray DualQuatInterpolate(const HDualQuaternion& DualQuaternionEnd, const HTuple& InterpPos) const;
+
+  // Interpolate two dual quaternions.
+  HDualQuaternion DualQuatInterpolate(const HDualQuaternion& DualQuaternionEnd, double InterpPos) const;
+
+  // Normalize a dual quaternion.
+  static HDualQuaternionArray DualQuatNormalize(const HDualQuaternionArray& DualQuaternion);
+
+  // Normalize a dual quaternion.
+  HDualQuaternion DualQuatNormalize() const;
+
+  // Convert a unit dual quaternion into a homogeneous transformation matrix.
+  HHomMat3D DualQuatToHomMat3d() const;
+
+  // Convert a dual quaternion to a 3D pose.
+  static HPoseArray DualQuatToPose(const HDualQuaternionArray& DualQuaternion);
+
+  // Convert a dual quaternion to a 3D pose.
+  HPose DualQuatToPose() const;
+
+  // Convert a unit dual quaternion into a screw.
+  void DualQuatToScrew(const HString& ScrewFormat, double* AxisDirectionX, double* AxisDirectionY, double* AxisDirectionZ, double* AxisMomentOrPointX, double* AxisMomentOrPointY, double* AxisMomentOrPointZ, double* Rotation, double* Translation) const;
+
+  // Convert a unit dual quaternion into a screw.
+  void DualQuatToScrew(const char* ScrewFormat, double* AxisDirectionX, double* AxisDirectionY, double* AxisDirectionZ, double* AxisMomentOrPointX, double* AxisMomentOrPointY, double* AxisMomentOrPointZ, double* Rotation, double* Translation) const;
+
+#ifdef _WIN32
+  // Convert a unit dual quaternion into a screw.
+  void DualQuatToScrew(const wchar_t* ScrewFormat, double* AxisDirectionX, double* AxisDirectionY, double* AxisDirectionZ, double* AxisMomentOrPointX, double* AxisMomentOrPointY, double* AxisMomentOrPointZ, double* Rotation, double* Translation) const;
+#endif
+
+  // Transform a 3D line with a unit dual quaternion.
+  void DualQuatTransLine3d(const HString& LineFormat, const HTuple& LineDirectionX, const HTuple& LineDirectionY, const HTuple& LineDirectionZ, const HTuple& LineMomentOrPointX, const HTuple& LineMomentOrPointY, const HTuple& LineMomentOrPointZ, HTuple* TransLineDirectionX, HTuple* TransLineDirectionY, HTuple* TransLineDirectionZ, HTuple* TransLineMomentOrPointX, HTuple* TransLineMomentOrPointY, HTuple* TransLineMomentOrPointZ) const;
+
+  // Transform a 3D line with a unit dual quaternion.
+  void DualQuatTransLine3d(const HString& LineFormat, double LineDirectionX, double LineDirectionY, double LineDirectionZ, double LineMomentOrPointX, double LineMomentOrPointY, double LineMomentOrPointZ, double* TransLineDirectionX, double* TransLineDirectionY, double* TransLineDirectionZ, double* TransLineMomentOrPointX, double* TransLineMomentOrPointY, double* TransLineMomentOrPointZ) const;
+
+  // Transform a 3D line with a unit dual quaternion.
+  void DualQuatTransLine3d(const char* LineFormat, double LineDirectionX, double LineDirectionY, double LineDirectionZ, double LineMomentOrPointX, double LineMomentOrPointY, double LineMomentOrPointZ, double* TransLineDirectionX, double* TransLineDirectionY, double* TransLineDirectionZ, double* TransLineMomentOrPointX, double* TransLineMomentOrPointY, double* TransLineMomentOrPointZ) const;
+
+#ifdef _WIN32
+  // Transform a 3D line with a unit dual quaternion.
+  void DualQuatTransLine3d(const wchar_t* LineFormat, double LineDirectionX, double LineDirectionY, double LineDirectionZ, double LineMomentOrPointX, double LineMomentOrPointY, double LineMomentOrPointZ, double* TransLineDirectionX, double* TransLineDirectionY, double* TransLineDirectionZ, double* TransLineMomentOrPointX, double* TransLineMomentOrPointY, double* TransLineMomentOrPointZ) const;
+#endif
+
+  // Convert a 3D pose to a unit dual quaternion.
+  static HDualQuaternionArray PoseToDualQuat(const HPoseArray& Pose);
+
+  // Convert a 3D pose to a unit dual quaternion.
+  void PoseToDualQuat(const HPose& Pose);
+
+  // Convert a screw into a dual quaternion.
+  void ScrewToDualQuat(const HString& ScrewFormat, const HTuple& AxisDirectionX, const HTuple& AxisDirectionY, const HTuple& AxisDirectionZ, const HTuple& AxisMomentOrPointX, const HTuple& AxisMomentOrPointY, const HTuple& AxisMomentOrPointZ, const HTuple& Rotation, const HTuple& Translation);
+
+  // Convert a screw into a dual quaternion.
+  void ScrewToDualQuat(const HString& ScrewFormat, double AxisDirectionX, double AxisDirectionY, double AxisDirectionZ, double AxisMomentOrPointX, double AxisMomentOrPointY, double AxisMomentOrPointZ, double Rotation, double Translation);
+
+  // Convert a screw into a dual quaternion.
+  void ScrewToDualQuat(const char* ScrewFormat, double AxisDirectionX, double AxisDirectionY, double AxisDirectionZ, double AxisMomentOrPointX, double AxisMomentOrPointY, double AxisMomentOrPointZ, double Rotation, double Translation);
+
+#ifdef _WIN32
+  // Convert a screw into a dual quaternion.
+  void ScrewToDualQuat(const wchar_t* ScrewFormat, double AxisDirectionX, double AxisDirectionY, double AxisDirectionZ, double AxisMomentOrPointX, double AxisMomentOrPointY, double AxisMomentOrPointZ, double Rotation, double Translation);
+#endif
+
+  // Serialize a dual quaternion.
+  HSerializedItem SerializeDualQuat() const;
+
+};
+
+class LIntExport HDualQuaternionArray : public HDataArray
+{
+public:
+  HDualQuaternionArray();
+  HDualQuaternionArray(HDualQuaternion* classes, Hlong length);
+  /* Define a default constructor to prevent compilers that support
+   * C++11 R-Value References v3.0 declaring an implicite move
+   * assignment/constructor. */
+  ~HDualQuaternionArray() {}
+protected:
+  virtual void CreateArray(Hlong length);
+  virtual int GetFixedSize() const;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HEvent.h

@@ -0,0 +1,158 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HEVENT
+#define HCPP_HEVENT
+
+namespace HalconCpp
+{
+
+// Represents an instance of an event synchronization object.
+class LIntExport HEvent : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HEvent():HHandle() {}
+
+  // Copy constructor
+  HEvent(const HEvent& source) : HHandle(source) {}
+
+  // Copy constructor
+  HEvent(const HHandle& handle);
+
+  // Create HEvent from handle, taking ownership
+  explicit HEvent(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('event')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_event: Create an event synchronization object.
+  explicit HEvent(const HTuple& AttribName, const HTuple& AttribValue);
+
+  // create_event: Create an event synchronization object.
+  explicit HEvent(const HString& AttribName, const HString& AttribValue);
+
+  // create_event: Create an event synchronization object.
+  explicit HEvent(const char* AttribName, const char* AttribValue);
+
+#ifdef _WIN32
+  // create_event: Create an event synchronization object.
+  explicit HEvent(const wchar_t* AttribName, const wchar_t* AttribValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Clear the event synchronization object.
+  void ClearEvent() const;
+
+  // Unlock an event synchronization object. 
+  void SignalEvent() const;
+
+  // Lock an event synchronization object only if it is unlocked.
+  Hlong TryWaitEvent() const;
+
+  // Lock an event synchronization object.
+  void WaitEvent() const;
+
+  // Create an event synchronization object.
+  void CreateEvent(const HTuple& AttribName, const HTuple& AttribValue);
+
+  // Create an event synchronization object.
+  void CreateEvent(const HString& AttribName, const HString& AttribValue);
+
+  // Create an event synchronization object.
+  void CreateEvent(const char* AttribName, const char* AttribValue);
+
+#ifdef _WIN32
+  // Create an event synchronization object.
+  void CreateEvent(const wchar_t* AttribName, const wchar_t* AttribValue);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HEvent> HEventArrayRef;
+typedef HSmartPtr< HEventArrayRef > HEventArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HEventArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HEventArray();
+
+  // Create array from native array of tool instances
+  HEventArray(HEvent* classes, Hlong length);
+
+  // Copy constructor
+  HEventArray(const HEventArray &tool_array);
+
+  // Destructor
+  virtual ~HEventArray();
+
+  // Assignment operator
+  HEventArray &operator=(const HEventArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HEvent* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HEventArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HException.h

@@ -0,0 +1,198 @@
+/*****************************************************************************
+ * HException.h
+ ***************************************************************************** 
+ *
+ * Project:     HALCON/C++
+ * Description: Error handling
+ *
+ * (c) 2010-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************
+ *
+ *
+ *****************************************************************************/
+
+
+#ifndef HCPP_EXCEPTION_H
+#define HCPP_EXCEPTION_H
+
+
+#include "halconcpp/HString.h"
+#include "halconcpp/HTuple.h"
+
+
+namespace HalconCpp
+{
+
+
+// Base class for all exception that is raised for generic
+// errors within the HALCON/C++ interface
+
+class LIntExport HException 
+{
+
+public:
+
+  // Constructors / Destructor
+
+  HException(const char *proc_name, Herror err);
+
+  HException(const char *proc_name, const char *msg, Herror err = H_MSG_OK);
+
+  HException(const HException &except);
+
+  HException(const HTuple &tuple);
+
+  virtual ~HException();
+
+
+  // Raising exceptions (synchronization-aware)
+
+  virtual void ThrowInstance() const;
+
+  static void Throw(const char *proc_name, const char *msg, Herror err = H_MSG_OK);
+
+  static void Throw(const char *proc_name, Herror err);
+
+
+  // Conversion and copying
+
+  static void    GetExceptionData(const HTuple &exception,
+                                  const HTuple &name, HTuple *value);
+
+  void           ToHTuple(HTuple *exception) const;
+
+  HException&    operator = (const HException &except);
+
+
+  // Accessors
+
+  const HString& ProcName()    const {return mProcName;}
+  const HString& ErrorMessage()   const {return mErrorMessage;}
+  Herror         ErrorCode() const {return mErrorCode;}
+  HDEPRECATED(const HString& ErrorText() const ,
+              "deprecated, please use ErrorMessage instead.")
+              {return mErrorMessage;}
+  HDEPRECATED(Herror ErrorNumber() const ,
+             "deprecated, please use ErrorCode instead.")
+             {return mErrorCode;}
+  const HTuple&  UserData()    const {return mUserData;}
+
+  // Legacy
+#ifdef HCPP_LEGACY_EXCEPTION
+  // Handler for user defined exception handling.
+  // Used with InstallHHandler()
+  typedef void (*Handler)(const HException &exception);
+
+  void           React(Hproc_handle proc_handle) const;
+
+  static Handler InstallHHandler(Handler proc);
+  // default exception handler
+  void           PrintException(void) const;
+  static Handler handler;   /* handler in use */
+#endif
+
+protected:
+
+  HString        mProcName;     // Name of procedure/operator
+  HString        mErrorMessage; // Error message
+  Herror         mErrorCode;    // Error code
+
+  HTuple         mUserData;    // User defined error data
+
+private:
+
+  void InitException(const HString& proc_name, const HString& msg,
+                     Herror err, const HTuple& user_data);
+
+};
+
+
+// Exception that is raised if operator call in HALCON library fails 
+
+class LIntExport HOperatorException : public HException
+{
+public:
+
+  // Failure during operator call
+  HOperatorException(Hproc_handle proc, Herror err);
+
+  // Precall failure before procedure handle is available
+  HOperatorException(HINT proc_index, Herror err);
+
+  // Failure during operator-like call, e.g. emulated dev_* operators
+  HOperatorException(const char* name, Herror err);
+
+  HOperatorException(const HOperatorException &except);
+
+  static void Throw(Hproc_handle proc, Herror err);
+
+  static void Throw(HINT proc_index, Herror err);
+
+  static void Throw(const char* name, Herror err);
+
+  void ThrowInstance() const;
+
+  // Extended Error Info
+  HString  ExtendedErrorMessage() const;
+  INT4_8   ExtendedErrorCode() const;
+
+};
+
+
+// Exception that is raised from user code (code export)
+
+class LIntExport HUserException : public HException
+{
+public:
+
+  HUserException(Herror err, const char *msg);
+
+  HUserException(const HUserException &except);
+
+  HUserException(const HTuple &tuple);
+
+};
+
+
+// Exception that is raised for tuple-related errors
+
+class LIntExport HTupleAccessException: public HException
+{
+public:
+
+  HTupleAccessException(void) : HException("","Illegal operation on tuple") {}
+  HTupleAccessException(const char *m) : HException("",m) {}
+  HTupleAccessException(Herror err) : HException("",err) {}
+  static void Throw(void);
+  static void Throw(const char* m);
+  static void Throw(Herror err);
+  void ThrowInstance() const;
+  ~HTupleAccessException();
+};
+
+
+
+// Exception that is raised for vector-related errors
+
+class LIntExport HVectorAccessException: public HException
+{
+public:
+
+  HVectorAccessException(void) : HException("",
+                                   "Illegal operation on vector") {}
+  HVectorAccessException(const char *m) : HException("",m) {}
+  HVectorAccessException(Herror err) : HException("",err) {}
+  HVectorAccessException(const char *m, Herror err) : HException("",m,err) {}
+  static void Throw(void);
+  static void Throw(const char* m);
+  static void Throw(Herror err);
+  void ThrowInstance() const;
+  ~HVectorAccessException();
+};
+
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HFeatureSet.h

@@ -0,0 +1,157 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HFEATURESET
+#define HCPP_HFEATURESET
+
+namespace HalconCpp
+{
+
+// Represents an instance of a training used for the classifier.
+class LIntExport HFeatureSet : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HFeatureSet():HHandle() {}
+
+  // Copy constructor
+  HFeatureSet(const HFeatureSet& source) : HHandle(source) {}
+
+  // Copy constructor
+  HFeatureSet(const HHandle& handle);
+
+  // Create HFeatureSet from handle, taking ownership
+  explicit HFeatureSet(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('feature_set')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // read_sampset: Read a training data set from a file.
+  explicit HFeatureSet(const HString& FileName);
+
+  // read_sampset: Read a training data set from a file.
+  explicit HFeatureSet(const char* FileName);
+
+#ifdef _WIN32
+  // read_sampset: Read a training data set from a file.
+  explicit HFeatureSet(const wchar_t* FileName);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Read a training data set from a file.
+  void ReadSampset(const HString& FileName);
+
+  // Read a training data set from a file.
+  void ReadSampset(const char* FileName);
+
+#ifdef _WIN32
+  // Read a training data set from a file.
+  void ReadSampset(const wchar_t* FileName);
+#endif
+
+  // Train the classifier with one data set.
+  void LearnSampsetBox(const HClassBox& ClassifHandle, const HString& Outfile, Hlong NSamples, double StopError, Hlong ErrorN) const;
+
+  // Train the classifier with one data set.
+  void LearnSampsetBox(const HClassBox& ClassifHandle, const char* Outfile, Hlong NSamples, double StopError, Hlong ErrorN) const;
+
+#ifdef _WIN32
+  // Train the classifier with one data set.
+  void LearnSampsetBox(const HClassBox& ClassifHandle, const wchar_t* Outfile, Hlong NSamples, double StopError, Hlong ErrorN) const;
+#endif
+
+  // Free memory of a data set.
+  void ClearSampset() const;
+
+  // Classify a set of arrays.
+  double TestSampsetBox(const HClassBox& ClassifHandle) const;
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HFeatureSet> HFeatureSetArrayRef;
+typedef HSmartPtr< HFeatureSetArrayRef > HFeatureSetArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HFeatureSetArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HFeatureSetArray();
+
+  // Create array from native array of tool instances
+  HFeatureSetArray(HFeatureSet* classes, Hlong length);
+
+  // Copy constructor
+  HFeatureSetArray(const HFeatureSetArray &tool_array);
+
+  // Destructor
+  virtual ~HFeatureSetArray();
+
+  // Assignment operator
+  HFeatureSetArray &operator=(const HFeatureSetArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HFeatureSet* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HFeatureSetArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HFile.h

@@ -0,0 +1,184 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HFILE
+#define HCPP_HFILE
+
+namespace HalconCpp
+{
+
+// Represents an instance of a file.
+class LIntExport HFile : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HFile():HHandle() {}
+
+  // Copy constructor
+  HFile(const HFile& source) : HHandle(source) {}
+
+  // Copy constructor
+  HFile(const HHandle& handle);
+
+  // Create HFile from handle, taking ownership
+  explicit HFile(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('file')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // open_file: Open a file in text or binary format.
+  explicit HFile(const HString& FileName, const HTuple& FileType);
+
+  // open_file: Open a file in text or binary format.
+  explicit HFile(const HString& FileName, const HString& FileType);
+
+  // open_file: Open a file in text or binary format.
+  explicit HFile(const char* FileName, const char* FileType);
+
+#ifdef _WIN32
+  // open_file: Open a file in text or binary format.
+  explicit HFile(const wchar_t* FileName, const wchar_t* FileType);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Open a file in text or binary format.
+  void OpenFile(const HString& FileName, const HTuple& FileType);
+
+  // Open a file in text or binary format.
+  void OpenFile(const HString& FileName, const HString& FileType);
+
+  // Open a file in text or binary format.
+  void OpenFile(const char* FileName, const char* FileType);
+
+#ifdef _WIN32
+  // Open a file in text or binary format.
+  void OpenFile(const wchar_t* FileName, const wchar_t* FileType);
+#endif
+
+  // Write strings and numbers into a text file.
+  void FwriteString(const HTuple& String) const;
+
+  // Write strings and numbers into a text file.
+  void FwriteString(const HString& String) const;
+
+  // Write strings and numbers into a text file.
+  void FwriteString(const char* String) const;
+
+#ifdef _WIN32
+  // Write strings and numbers into a text file.
+  void FwriteString(const wchar_t* String) const;
+#endif
+
+  // Read a character line from a text file.
+  HString FreadLine(Hlong* IsEOF) const;
+
+  // Read a string from a text file.
+  HString FreadString(Hlong* IsEOF) const;
+
+  // Read one character from a text file.
+  HString FreadChar() const;
+
+  // Write a line break and clear the output buffer.
+  void FnewLine() const;
+
+  // Closing a text file.
+  static void CloseFile(const HFileArray& FileHandle);
+
+  // Closing a text file.
+  void CloseFile() const;
+
+  // Read bytes from a binary file.
+  HTuple FreadBytes(Hlong NumberOfBytes, Hlong* IsEOF) const;
+
+  // Write bytes to a binary file.
+  Hlong FwriteBytes(const HTuple& DataToWrite) const;
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HFile> HFileArrayRef;
+typedef HSmartPtr< HFileArrayRef > HFileArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HFileArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HFileArray();
+
+  // Create array from native array of tool instances
+  HFileArray(HFile* classes, Hlong length);
+
+  // Copy constructor
+  HFileArray(const HFileArray &tool_array);
+
+  // Destructor
+  virtual ~HFileArray();
+
+  // Assignment operator
+  HFileArray &operator=(const HFileArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HFile* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HFileArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HFramegrabber.h

@@ -0,0 +1,226 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HFRAMEGRABBER
+#define HCPP_HFRAMEGRABBER
+
+namespace HalconCpp
+{
+
+// Represents an instance of an image acquisition device.
+class LIntExport HFramegrabber : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HFramegrabber():HHandle() {}
+
+  // Copy constructor
+  HFramegrabber(const HFramegrabber& source) : HHandle(source) {}
+
+  // Copy constructor
+  HFramegrabber(const HHandle& handle);
+
+  // Create HFramegrabber from handle, taking ownership
+  explicit HFramegrabber(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('framegrabber')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // open_framegrabber: Open and configure an image acquisition device.
+  explicit HFramegrabber(const HString& Name, Hlong HorizontalResolution, Hlong VerticalResolution, Hlong ImageWidth, Hlong ImageHeight, Hlong StartRow, Hlong StartColumn, const HString& Field, const HTuple& BitsPerChannel, const HTuple& ColorSpace, const HTuple& Generic, const HString& ExternalTrigger, const HTuple& CameraType, const HTuple& Device, const HTuple& Port, const HTuple& LineIn);
+
+  // open_framegrabber: Open and configure an image acquisition device.
+  explicit HFramegrabber(const HString& Name, Hlong HorizontalResolution, Hlong VerticalResolution, Hlong ImageWidth, Hlong ImageHeight, Hlong StartRow, Hlong StartColumn, const HString& Field, Hlong BitsPerChannel, const HString& ColorSpace, double Generic, const HString& ExternalTrigger, const HString& CameraType, const HString& Device, Hlong Port, Hlong LineIn);
+
+  // open_framegrabber: Open and configure an image acquisition device.
+  explicit HFramegrabber(const char* Name, Hlong HorizontalResolution, Hlong VerticalResolution, Hlong ImageWidth, Hlong ImageHeight, Hlong StartRow, Hlong StartColumn, const char* Field, Hlong BitsPerChannel, const char* ColorSpace, double Generic, const char* ExternalTrigger, const char* CameraType, const char* Device, Hlong Port, Hlong LineIn);
+
+#ifdef _WIN32
+  // open_framegrabber: Open and configure an image acquisition device.
+  explicit HFramegrabber(const wchar_t* Name, Hlong HorizontalResolution, Hlong VerticalResolution, Hlong ImageWidth, Hlong ImageHeight, Hlong StartRow, Hlong StartColumn, const wchar_t* Field, Hlong BitsPerChannel, const wchar_t* ColorSpace, double Generic, const wchar_t* ExternalTrigger, const wchar_t* CameraType, const wchar_t* Device, Hlong Port, Hlong LineIn);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Query specific parameters of an image acquisition device.
+  HTuple GetFramegrabberParam(const HTuple& Param) const;
+
+  // Query specific parameters of an image acquisition device.
+  HTuple GetFramegrabberParam(const HString& Param) const;
+
+  // Query specific parameters of an image acquisition device.
+  HTuple GetFramegrabberParam(const char* Param) const;
+
+#ifdef _WIN32
+  // Query specific parameters of an image acquisition device.
+  HTuple GetFramegrabberParam(const wchar_t* Param) const;
+#endif
+
+  // Set specific parameters of an image acquisition device.
+  void SetFramegrabberParam(const HTuple& Param, const HTuple& Value) const;
+
+  // Set specific parameters of an image acquisition device.
+  void SetFramegrabberParam(const HString& Param, const HString& Value) const;
+
+  // Set specific parameters of an image acquisition device.
+  void SetFramegrabberParam(const char* Param, const char* Value) const;
+
+#ifdef _WIN32
+  // Set specific parameters of an image acquisition device.
+  void SetFramegrabberParam(const wchar_t* Param, const wchar_t* Value) const;
+#endif
+
+  // Query callback function of an image acquisition device.
+  void* GetFramegrabberCallback(const HString& CallbackType, void** UserContext) const;
+
+  // Query callback function of an image acquisition device.
+  void* GetFramegrabberCallback(const char* CallbackType, void** UserContext) const;
+
+#ifdef _WIN32
+  // Query callback function of an image acquisition device.
+  void* GetFramegrabberCallback(const wchar_t* CallbackType, void** UserContext) const;
+#endif
+
+  // Register a callback function for an image acquisition device.
+  void SetFramegrabberCallback(const HString& CallbackType, void* CallbackFunction, void* UserContext) const;
+
+  // Register a callback function for an image acquisition device.
+  void SetFramegrabberCallback(const char* CallbackType, void* CallbackFunction, void* UserContext) const;
+
+#ifdef _WIN32
+  // Register a callback function for an image acquisition device.
+  void SetFramegrabberCallback(const wchar_t* CallbackType, void* CallbackFunction, void* UserContext) const;
+#endif
+
+  // Asynchronous grab of images and preprocessed image data from the specified image acquisition device.
+  HImage GrabDataAsync(HRegion* Region, HXLDCont* Contours, double MaxDelay, HTuple* Data) const;
+
+  // Asynchronous grab of images and preprocessed image data from the specified image acquisition device.
+  HImage GrabDataAsync(HRegion* Region, HXLDCont* Contours, double MaxDelay, HString* Data) const;
+
+  // Synchronous grab of images and preprocessed image data from the specified image acquisition device.
+  HImage GrabData(HRegion* Region, HXLDCont* Contours, HTuple* Data) const;
+
+  // Synchronous grab of images and preprocessed image data from the specified image acquisition device.
+  HImage GrabData(HRegion* Region, HXLDCont* Contours, HString* Data) const;
+
+  // Asynchronous grab of an image from the specified image acquisition device.
+  HImage GrabImageAsync(double MaxDelay) const;
+
+  // Start an asynchronous grab from the specified image acquisition device.
+  void GrabImageStart(double MaxDelay) const;
+
+  // Synchronous grab of an image from the specified image acquisition device.
+  HImage GrabImage() const;
+
+  // Close specified image acquisition device.
+  void CloseFramegrabber() const;
+
+  // Open and configure an image acquisition device.
+  void OpenFramegrabber(const HString& Name, Hlong HorizontalResolution, Hlong VerticalResolution, Hlong ImageWidth, Hlong ImageHeight, Hlong StartRow, Hlong StartColumn, const HString& Field, const HTuple& BitsPerChannel, const HTuple& ColorSpace, const HTuple& Generic, const HString& ExternalTrigger, const HTuple& CameraType, const HTuple& Device, const HTuple& Port, const HTuple& LineIn);
+
+  // Open and configure an image acquisition device.
+  void OpenFramegrabber(const HString& Name, Hlong HorizontalResolution, Hlong VerticalResolution, Hlong ImageWidth, Hlong ImageHeight, Hlong StartRow, Hlong StartColumn, const HString& Field, Hlong BitsPerChannel, const HString& ColorSpace, double Generic, const HString& ExternalTrigger, const HString& CameraType, const HString& Device, Hlong Port, Hlong LineIn);
+
+  // Open and configure an image acquisition device.
+  void OpenFramegrabber(const char* Name, Hlong HorizontalResolution, Hlong VerticalResolution, Hlong ImageWidth, Hlong ImageHeight, Hlong StartRow, Hlong StartColumn, const char* Field, Hlong BitsPerChannel, const char* ColorSpace, double Generic, const char* ExternalTrigger, const char* CameraType, const char* Device, Hlong Port, Hlong LineIn);
+
+#ifdef _WIN32
+  // Open and configure an image acquisition device.
+  void OpenFramegrabber(const wchar_t* Name, Hlong HorizontalResolution, Hlong VerticalResolution, Hlong ImageWidth, Hlong ImageHeight, Hlong StartRow, Hlong StartColumn, const wchar_t* Field, Hlong BitsPerChannel, const wchar_t* ColorSpace, double Generic, const wchar_t* ExternalTrigger, const wchar_t* CameraType, const wchar_t* Device, Hlong Port, Hlong LineIn);
+#endif
+
+  // Query look-up table of the image acquisition device.
+  void GetFramegrabberLut(HTuple* ImageRed, HTuple* ImageGreen, HTuple* ImageBlue) const;
+
+  // Set look-up table of the image acquisition device.
+  void SetFramegrabberLut(const HTuple& ImageRed, const HTuple& ImageGreen, const HTuple& ImageBlue) const;
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HFramegrabber> HFramegrabberArrayRef;
+typedef HSmartPtr< HFramegrabberArrayRef > HFramegrabberArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HFramegrabberArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HFramegrabberArray();
+
+  // Create array from native array of tool instances
+  HFramegrabberArray(HFramegrabber* classes, Hlong length);
+
+  // Copy constructor
+  HFramegrabberArray(const HFramegrabberArray &tool_array);
+
+  // Destructor
+  virtual ~HFramegrabberArray();
+
+  // Assignment operator
+  HFramegrabberArray &operator=(const HFramegrabberArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HFramegrabber* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HFramegrabberArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HFunction1D.h

@@ -0,0 +1,233 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HFUNCTION1D
+#define HCPP_HFUNCTION1D
+
+namespace HalconCpp
+{
+
+// Represents an instance of a 1d function.
+class LIntExport HFunction1D : public HDataBase
+{
+
+public:
+
+  // Create an uninitialized instance
+  HFunction1D():HDataBase() {}
+
+  // Copy constructor
+  HFunction1D(const HFunction1D& source) : HDataBase(source) {}
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // create_funct_1d_array: Create a function from a sequence of y values.
+  explicit HFunction1D(const HTuple& YValues);
+
+  // create_funct_1d_array: Create a function from a sequence of y values.
+  explicit HFunction1D(double YValues);
+
+  // create_funct_1d_pairs: Create a function from a set of (x,y) pairs.
+  explicit HFunction1D(const HTuple& XValues, const HTuple& YValues);
+
+  // create_funct_1d_pairs: Create a function from a set of (x,y) pairs.
+  explicit HFunction1D(double XValues, double YValues);
+
+
+/*****************************************************************************
+ * Operator overloads (non-member overloads reside in HOperatorOverloads.h)  *
+ *****************************************************************************/
+
+  // Negate function
+  HFunction1D operator - () const;
+
+  // Invert function
+  HFunction1D operator ! () const;
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Plot a function using gnuplot.
+  void GnuplotPlotFunct1d(const HGnuplot& GnuplotFileID) const;
+
+  // Compose two functions.
+  HFunction1D ComposeFunct1d(const HFunction1D& Function2, const HString& Border) const;
+
+  // Compose two functions.
+  HFunction1D ComposeFunct1d(const HFunction1D& Function2, const char* Border) const;
+
+#ifdef _WIN32
+  // Compose two functions.
+  HFunction1D ComposeFunct1d(const HFunction1D& Function2, const wchar_t* Border) const;
+#endif
+
+  // Calculate the inverse of a function.
+  HFunction1D InvertFunct1d() const;
+
+  // Calculate the derivatives of a function.
+  HFunction1D DerivateFunct1d(const HString& Mode) const;
+
+  // Calculate the derivatives of a function.
+  HFunction1D DerivateFunct1d(const char* Mode) const;
+
+#ifdef _WIN32
+  // Calculate the derivatives of a function.
+  HFunction1D DerivateFunct1d(const wchar_t* Mode) const;
+#endif
+
+  // Calculate the local minimum and maximum points of a function.
+  void LocalMinMaxFunct1d(const HString& Mode, const HString& Interpolation, HTuple* Min, HTuple* Max) const;
+
+  // Calculate the local minimum and maximum points of a function.
+  void LocalMinMaxFunct1d(const char* Mode, const char* Interpolation, HTuple* Min, HTuple* Max) const;
+
+#ifdef _WIN32
+  // Calculate the local minimum and maximum points of a function.
+  void LocalMinMaxFunct1d(const wchar_t* Mode, const wchar_t* Interpolation, HTuple* Min, HTuple* Max) const;
+#endif
+
+  // Calculate the zero crossings of a function.
+  HTuple ZeroCrossingsFunct1d() const;
+
+  // Multiplication and addition of the y values.
+  HFunction1D ScaleYFunct1d(double Mult, double Add) const;
+
+  // Negation of the y values.
+  HFunction1D NegateFunct1d() const;
+
+  // Absolute value of the y values.
+  HFunction1D AbsFunct1d() const;
+
+  // Return the value of a function at an arbitrary position.
+  HTuple GetYValueFunct1d(const HTuple& X, const HString& Border) const;
+
+  // Return the value of a function at an arbitrary position.
+  double GetYValueFunct1d(double X, const HString& Border) const;
+
+  // Return the value of a function at an arbitrary position.
+  double GetYValueFunct1d(double X, const char* Border) const;
+
+#ifdef _WIN32
+  // Return the value of a function at an arbitrary position.
+  double GetYValueFunct1d(double X, const wchar_t* Border) const;
+#endif
+
+  // Access a function value using the index of the control points.
+  void GetPairFunct1d(const HTuple& Index, HTuple* X, HTuple* Y) const;
+
+  // Access a function value using the index of the control points.
+  void GetPairFunct1d(Hlong Index, double* X, double* Y) const;
+
+  // Number of control points of the function.
+  Hlong NumPointsFunct1d() const;
+
+  // Smallest and largest y value of the function.
+  void YRangeFunct1d(double* YMin, double* YMax) const;
+
+  // Smallest and largest x value of the function.
+  void XRangeFunct1d(double* XMin, double* XMax) const;
+
+  // Access to the x/y values of a function.
+  void Funct1dToPairs(HTuple* XValues, HTuple* YValues) const;
+
+  // Sample a function equidistantly in an interval.
+  HFunction1D SampleFunct1d(const HTuple& XMin, const HTuple& XMax, const HTuple& XDist, const HString& Border) const;
+
+  // Sample a function equidistantly in an interval.
+  HFunction1D SampleFunct1d(double XMin, double XMax, double XDist, const HString& Border) const;
+
+  // Sample a function equidistantly in an interval.
+  HFunction1D SampleFunct1d(double XMin, double XMax, double XDist, const char* Border) const;
+
+#ifdef _WIN32
+  // Sample a function equidistantly in an interval.
+  HFunction1D SampleFunct1d(double XMin, double XMax, double XDist, const wchar_t* Border) const;
+#endif
+
+  // Transform a function using given transformation parameters.
+  HFunction1D TransformFunct1d(const HTuple& Params) const;
+
+  // Calculate transformation parameters between two functions.
+  HTuple MatchFunct1dTrans(const HFunction1D& Function2, const HString& Border, const HTuple& ParamsConst, const HTuple& UseParams, double* ChiSquare, HTuple* Covar) const;
+
+  // Calculate transformation parameters between two functions.
+  HTuple MatchFunct1dTrans(const HFunction1D& Function2, const char* Border, const HTuple& ParamsConst, const HTuple& UseParams, double* ChiSquare, HTuple* Covar) const;
+
+#ifdef _WIN32
+  // Calculate transformation parameters between two functions.
+  HTuple MatchFunct1dTrans(const HFunction1D& Function2, const wchar_t* Border, const HTuple& ParamsConst, const HTuple& UseParams, double* ChiSquare, HTuple* Covar) const;
+#endif
+
+  // Compute the distance of two functions.
+  HTuple DistanceFunct1d(const HFunction1D& Function2, const HTuple& Mode, const HTuple& Sigma) const;
+
+  // Compute the distance of two functions.
+  HTuple DistanceFunct1d(const HFunction1D& Function2, const HString& Mode, double Sigma) const;
+
+  // Compute the distance of two functions.
+  HTuple DistanceFunct1d(const HFunction1D& Function2, const char* Mode, double Sigma) const;
+
+#ifdef _WIN32
+  // Compute the distance of two functions.
+  HTuple DistanceFunct1d(const HFunction1D& Function2, const wchar_t* Mode, double Sigma) const;
+#endif
+
+  // Smooth an equidistant 1D function with a Gaussian function.
+  HFunction1D SmoothFunct1dGauss(double Sigma) const;
+
+  // Compute the positive and negative areas of a function.
+  double IntegrateFunct1d(HTuple* Negative) const;
+
+  // Read a function from a file.
+  void ReadFunct1d(const HString& FileName);
+
+  // Read a function from a file.
+  void ReadFunct1d(const char* FileName);
+
+#ifdef _WIN32
+  // Read a function from a file.
+  void ReadFunct1d(const wchar_t* FileName);
+#endif
+
+  // Write a function to a file.
+  void WriteFunct1d(const HString& FileName) const;
+
+  // Write a function to a file.
+  void WriteFunct1d(const char* FileName) const;
+
+#ifdef _WIN32
+  // Write a function to a file.
+  void WriteFunct1d(const wchar_t* FileName) const;
+#endif
+
+  // Create a function from a sequence of y values.
+  void CreateFunct1dArray(const HTuple& YValues);
+
+  // Create a function from a sequence of y values.
+  void CreateFunct1dArray(double YValues);
+
+  // Create a function from a set of (x,y) pairs.
+  void CreateFunct1dPairs(const HTuple& XValues, const HTuple& YValues);
+
+  // Create a function from a set of (x,y) pairs.
+  void CreateFunct1dPairs(double XValues, double YValues);
+
+  // Smooth an equidistant 1D function by averaging its values.
+  HFunction1D SmoothFunct1dMean(Hlong SmoothSize, Hlong Iterations) const;
+
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HGnuplot.h

@@ -0,0 +1,149 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HGNUPLOT
+#define HCPP_HGNUPLOT
+
+namespace HalconCpp
+{
+
+// Represents an instance of a connection to a gnuplot process.
+class LIntExport HGnuplot : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HGnuplot():HHandle() {}
+
+  // Copy constructor
+  HGnuplot(const HGnuplot& source) : HHandle(source) {}
+
+  // Copy constructor
+  HGnuplot(const HHandle& handle);
+
+  // Create HGnuplot from handle, taking ownership
+  explicit HGnuplot(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('gnuplot')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Plot a function using gnuplot.
+  void GnuplotPlotFunct1d(const HFunction1D& Function) const;
+
+  // Plot control values using gnuplot.
+  void GnuplotPlotCtrl(const HTuple& Values) const;
+
+  // Visualize images using gnuplot.
+  void GnuplotPlotImage(const HImage& Image, Hlong SamplesX, Hlong SamplesY, const HTuple& ViewRotX, const HTuple& ViewRotZ, const HString& Hidden3D) const;
+
+  // Visualize images using gnuplot.
+  void GnuplotPlotImage(const HImage& Image, Hlong SamplesX, Hlong SamplesY, double ViewRotX, double ViewRotZ, const HString& Hidden3D) const;
+
+  // Visualize images using gnuplot.
+  void GnuplotPlotImage(const HImage& Image, Hlong SamplesX, Hlong SamplesY, double ViewRotX, double ViewRotZ, const char* Hidden3D) const;
+
+#ifdef _WIN32
+  // Visualize images using gnuplot.
+  void GnuplotPlotImage(const HImage& Image, Hlong SamplesX, Hlong SamplesY, double ViewRotX, double ViewRotZ, const wchar_t* Hidden3D) const;
+#endif
+
+  // Close all open gnuplot files or terminate an active gnuplot sub-process.
+  void GnuplotClose() const;
+
+  // Open a gnuplot file for visualization of images and control values.
+  void GnuplotOpenFile(const HString& FileName);
+
+  // Open a gnuplot file for visualization of images and control values.
+  void GnuplotOpenFile(const char* FileName);
+
+#ifdef _WIN32
+  // Open a gnuplot file for visualization of images and control values.
+  void GnuplotOpenFile(const wchar_t* FileName);
+#endif
+
+  // Open a pipe to a gnuplot process for visualization of images and control values.
+  void GnuplotOpenPipe();
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HGnuplot> HGnuplotArrayRef;
+typedef HSmartPtr< HGnuplotArrayRef > HGnuplotArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HGnuplotArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HGnuplotArray();
+
+  // Create array from native array of tool instances
+  HGnuplotArray(HGnuplot* classes, Hlong length);
+
+  // Copy constructor
+  HGnuplotArray(const HGnuplotArray &tool_array);
+
+  // Destructor
+  virtual ~HGnuplotArray();
+
+  // Assignment operator
+  HGnuplotArray &operator=(const HGnuplotArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HGnuplot* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HGnuplotArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HHandle.h

@@ -0,0 +1,138 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HHANDLE
+#define HCPP_HHANDLE
+
+namespace HalconCpp
+{
+
+// Represents a generic instance of a handle.
+class LIntExport HHandle : public HHandleBase
+{
+
+public:
+
+  // Create an uninitialized instance
+  HHandle():HHandleBase() {}
+
+  // Copy constructor
+  HHandle(const HHandle& source) : HHandleBase(source) {}
+
+  friend class HTupleElement;
+  // Create HHandle from handle, taking ownership
+  explicit HHandle(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Internal Hphandle constructor
+  HHandle(const Hphandle handle, bool copy): HHandleBase(handle,copy) {}
+
+  // Verify matching semantic type ('handle')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+  // Deep copy of all data represented by this object instance
+  HHandle Clone() const;
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Clear the content of a handle. 
+  void ClearHandle() const;
+
+  // Deserialize a serialized item. 
+  void DeserializeHandle(const HSerializedItem& SerializedItem);
+
+  // Serialize the content of a handle. 
+  HSerializedItem SerializeHandle() const;
+
+  // Test if a tuple is serializable.
+  Hlong TupleIsSerializable() const;
+
+  // Check if a handle is valid. 
+  HTuple TupleIsValidHandle() const;
+
+  // Return the semantic type of a tuple.
+  HString TupleSemType() const;
+
+};
+
+#if defined(HCPP_LEGACY_HANDLE_API)
+  typedef HHandle HToolBase;
+#endif
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HHandle> HHandleArrayRef;
+typedef HSmartPtr< HHandleArrayRef > HHandleArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HHandleArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HHandleArray();
+
+  // Create array from native array of tool instances
+  HHandleArray(HHandle* classes, Hlong length);
+
+  // Copy constructor
+  HHandleArray(const HHandleArray &tool_array);
+
+  // Destructor
+  virtual ~HHandleArray();
+
+  // Assignment operator
+  HHandleArray &operator=(const HHandleArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HHandle* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HHandleArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HHandleBase.h

@@ -0,0 +1,183 @@
+/*****************************************************************************
+ * HHandleBase.h
+ *****************************************************************************
+ *
+ * Project:     HALCON/C++
+ * Description: Base class for wrapping all handle types
+ *
+ * (c) 2017-2020 by MVTec Software GmbH
+ *                  www.mvtec.com
+ *
+ *****************************************************************************
+ *
+ *
+ *****************************************************************************/
+
+#ifndef HCPP_HANDLE_BASE_H
+#define HCPP_HANDLE_BASE_H
+
+#include "Halcon.h"
+
+#include "halconcpp/HString.h"
+
+namespace HalconCpp
+{
+
+class LIntExport HHandleBase
+{
+
+friend class HTuple;
+friend class HTupleElement;
+friend class HalconAPI;
+friend class HalconAPIInternal;
+
+public:
+
+  // Create an uninitialized handle
+  HHandleBase();
+
+  // Creation from numeric handle, for interacting with legacy code
+  // or for transferring handle across language interface boundaries
+  explicit HHandleBase(Hlong handle);
+
+  // Copy constructor
+  HHandleBase(const HHandleBase &handle);
+
+  // Destructor
+  virtual ~HHandleBase();
+
+  // Set from numeric handle, for interacting with legacy code or
+  // for transferring handle across language interface boundaries
+  void SetHandle(Hlong handle);
+
+  // Return the managed handle
+  Hlong GetHandle() const;
+
+  // Return true if this handle instance manages a valid handle. Returns
+  // false if the managed handle has already been destroyed or when this
+  // instance manages no handle (uninitialized or cleared). Equivalent to
+  // new HALCON operator HandleIsValid but kept for convenience of having
+  // boolean signature and backwards compatible name.
+  bool IsInitialized() const;
+
+  // Return a textual representation of the handle. This is mainly for
+  // logging and debugging purposes, result should not be parsed and text
+  // format may change in the future.
+  HString ToString() const;
+
+  // Release the managed handle (decreases reference count of handle)
+  void Clear();
+
+
+  /******************************************************************/
+  /* Operator overloads                                             */
+  /******************************************************************/
+
+  // Assignment
+  HHandleBase& operator = (const HHandleBase& obj);
+
+  // Comparison
+  bool operator==(const HHandleBase& obj) const;
+  bool operator!=(const HHandleBase& obj) const;
+
+#if defined(HCPP_LEGACY_HANDLE_API)
+
+  // Extraction to long is now rare use case and should be done explicitely
+  operator Hlong() const;
+
+  // For all practical purposes now handled by HHandle constructor of HTuple
+  operator HTuple() const;
+
+#endif
+
+
+  /******************************************************************/
+  /* Internal operations, exposed for use by extension package only */
+  /******************************************************************/
+
+  // Load output handle from HALCON operator call
+  void   Load(Hproc_handle proc, HINT par_index, Herror err) const;
+
+  // Store as input handle for HALCON operator call
+  Herror Store(Hproc_handle proc, HINT par_index) const;
+
+
+  /******************************************************************/
+  /* Legacy handle management                                       */
+  /******************************************************************/
+
+#if defined(HCPP_LEGACY_HANDLE_API)
+
+  // Not useful with new reference counting mechanism
+  void Detach();
+
+  // Not useful with new reference counting mechanism
+  void InvalidateHandle();
+
+  // Deprecated, replaced by IsInitialized
+  bool IsToolValid() const { return IsInitialized(); };
+
+#endif
+
+
+protected:
+
+  // Over management of input handle
+  HHandleBase(Hphandle handle, bool copy);
+
+  // Return the managed handle
+  Hphandle GetHandleInternal() const;
+
+  // For copy=false takes over management of input handle
+  void SetHandleInternal(Hphandle handle, bool copy);
+
+  // Verify type of external handle, raise exception on mismatch
+  virtual void AssertType(Hphandle handle) const;
+
+  // Verify type of wrapped handle, raise exception on mismatch
+  void AssertType() const;
+
+
+protected:
+
+  static const Hphandle HANDLE_INVALID;
+
+  Hphandle mHandle;
+
+};
+
+
+
+// Base class for actual tool array classes
+
+class LIntExport HHandleBaseArray
+{
+
+public:
+
+  // Destructor
+  virtual ~HHandleBaseArray() {};
+
+  // Clears array and all tool instances
+  virtual void Clear() = 0;
+
+  // Get number of tools
+  virtual Hlong Length() const = 0;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles) = 0;
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const = 0;
+
+};
+
+// Forward declaration
+class HHandle;
+
+// Constant for supporting export of HNULL literal from HDevelop
+extern const LIntExport HHandle HNULL;
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HHomMat3D.h

@@ -0,0 +1,187 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HHOMMAT3D
+#define HCPP_HHOMMAT3D
+
+namespace HalconCpp
+{
+
+// Represents a homogeneous 3D transformation matrix.
+class LIntExport HHomMat3D : public HDataBase
+{
+
+public:
+
+  // Copy constructor
+  HHomMat3D(const HHomMat3D& source) : HDataBase(source) {}
+
+  // Constructor from HTuple
+  explicit HHomMat3D(const HTuple& tuple) : HDataBase(tuple) {}
+
+  // Deep copy of all data represented by this object instance
+  HHomMat3D Clone() const;
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // hom_mat3d_identity: Generate the homogeneous transformation matrix of the identical 3D transformation.
+  explicit HHomMat3D();
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Deserialize a serialized homogeneous 3D transformation matrix.
+  void DeserializeHomMat3d(const HSerializedItem& SerializedItemHandle);
+
+  // Serialize a homogeneous 3D transformation matrix.
+  HSerializedItem SerializeHomMat3d() const;
+
+  // Project a homogeneous 3D point using a projective transformation matrix.
+  HTuple ProjectiveTransHomPoint3d(const HTuple& Px, const HTuple& Py, const HTuple& Pz, const HTuple& Pw, HTuple* Qy, HTuple* Qz, HTuple* Qw) const;
+
+  // Project a homogeneous 3D point using a projective transformation matrix.
+  double ProjectiveTransHomPoint3d(double Px, double Py, double Pz, double Pw, double* Qy, double* Qz, double* Qw) const;
+
+  // Project a 3D point using a projective transformation matrix.
+  HTuple ProjectiveTransPoint3d(const HTuple& Px, const HTuple& Py, const HTuple& Pz, HTuple* Qy, HTuple* Qz) const;
+
+  // Project a 3D point using a projective transformation matrix.
+  double ProjectiveTransPoint3d(double Px, double Py, double Pz, double* Qy, double* Qz) const;
+
+  // Apply an arbitrary affine 3D transformation to points.
+  HTuple AffineTransPoint3d(const HTuple& Px, const HTuple& Py, const HTuple& Pz, HTuple* Qy, HTuple* Qz) const;
+
+  // Apply an arbitrary affine 3D transformation to points.
+  double AffineTransPoint3d(double Px, double Py, double Pz, double* Qy, double* Qz) const;
+
+  // Approximate a 3D transformation from point correspondences.
+  void VectorToHomMat3d(const HString& TransformationType, const HTuple& Px, const HTuple& Py, const HTuple& Pz, const HTuple& Qx, const HTuple& Qy, const HTuple& Qz);
+
+  // Approximate a 3D transformation from point correspondences.
+  void VectorToHomMat3d(const char* TransformationType, const HTuple& Px, const HTuple& Py, const HTuple& Pz, const HTuple& Qx, const HTuple& Qy, const HTuple& Qz);
+
+#ifdef _WIN32
+  // Approximate a 3D transformation from point correspondences.
+  void VectorToHomMat3d(const wchar_t* TransformationType, const HTuple& Px, const HTuple& Py, const HTuple& Pz, const HTuple& Qx, const HTuple& Qy, const HTuple& Qz);
+#endif
+
+  // Compute the determinant of a homogeneous 3D transformation matrix.
+  double HomMat3dDeterminant() const;
+
+  // Transpose a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dTranspose() const;
+
+  // Invert a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dInvert() const;
+
+  // Multiply two homogeneous 3D transformation matrices.
+  HHomMat3D HomMat3dCompose(const HHomMat3D& HomMat3DRight) const;
+
+  // Add a rotation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dRotateLocal(const HTuple& Phi, const HTuple& Axis) const;
+
+  // Add a rotation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dRotateLocal(double Phi, const HString& Axis) const;
+
+  // Add a rotation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dRotateLocal(double Phi, const char* Axis) const;
+
+#ifdef _WIN32
+  // Add a rotation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dRotateLocal(double Phi, const wchar_t* Axis) const;
+#endif
+
+  // Add a rotation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dRotate(const HTuple& Phi, const HTuple& Axis, const HTuple& Px, const HTuple& Py, const HTuple& Pz) const;
+
+  // Add a rotation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dRotate(double Phi, const HString& Axis, double Px, double Py, double Pz) const;
+
+  // Add a rotation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dRotate(double Phi, const char* Axis, double Px, double Py, double Pz) const;
+
+#ifdef _WIN32
+  // Add a rotation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dRotate(double Phi, const wchar_t* Axis, double Px, double Py, double Pz) const;
+#endif
+
+  // Add a scaling to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dScaleLocal(const HTuple& Sx, const HTuple& Sy, const HTuple& Sz) const;
+
+  // Add a scaling to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dScaleLocal(double Sx, double Sy, double Sz) const;
+
+  // Add a scaling to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dScale(const HTuple& Sx, const HTuple& Sy, const HTuple& Sz, const HTuple& Px, const HTuple& Py, const HTuple& Pz) const;
+
+  // Add a scaling to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dScale(double Sx, double Sy, double Sz, double Px, double Py, double Pz) const;
+
+  // Add a translation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dTranslateLocal(const HTuple& Tx, const HTuple& Ty, const HTuple& Tz) const;
+
+  // Add a translation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dTranslateLocal(double Tx, double Ty, double Tz) const;
+
+  // Add a translation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dTranslate(const HTuple& Tx, const HTuple& Ty, const HTuple& Tz) const;
+
+  // Add a translation to a homogeneous 3D transformation matrix.
+  HHomMat3D HomMat3dTranslate(double Tx, double Ty, double Tz) const;
+
+  // Generate the homogeneous transformation matrix of the identical 3D transformation.
+  void HomMat3dIdentity();
+
+  // Project an affine 3D transformation matrix to a 2D projective transformation matrix.
+  HHomMat2D HomMat3dProject(const HTuple& PrincipalPointRow, const HTuple& PrincipalPointCol, const HTuple& Focus) const;
+
+  // Project an affine 3D transformation matrix to a 2D projective transformation matrix.
+  HHomMat2D HomMat3dProject(double PrincipalPointRow, double PrincipalPointCol, double Focus) const;
+
+  // Project a homogeneous 3D point using a 3x4 projection matrix.
+  HTuple ProjectHomPointHomMat3d(const HTuple& Px, const HTuple& Py, const HTuple& Pz, const HTuple& Pw, HTuple* Qy, HTuple* Qw) const;
+
+  // Project a homogeneous 3D point using a 3x4 projection matrix.
+  double ProjectHomPointHomMat3d(double Px, double Py, double Pz, double Pw, double* Qy, double* Qw) const;
+
+  // Project a 3D point using a 3x4 projection matrix.
+  HTuple ProjectPointHomMat3d(const HTuple& Px, const HTuple& Py, const HTuple& Pz, HTuple* Qy) const;
+
+  // Project a 3D point using a 3x4 projection matrix.
+  double ProjectPointHomMat3d(double Px, double Py, double Pz, double* Qy) const;
+
+  // Convert a homogeneous transformation matrix into a 3D pose.
+  HPose HomMat3dToPose() const;
+
+};
+
+class LIntExport HHomMat3DArray : public HDataArray
+{
+public:
+  HHomMat3DArray();
+  HHomMat3DArray(HHomMat3D* classes, Hlong length);
+  /* Define a default constructor to prevent compilers that support
+   * C++11 R-Value References v3.0 declaring an implicite move
+   * assignment/constructor. */
+  ~HHomMat3DArray() {}
+protected:
+  virtual void CreateArray(Hlong length);
+  virtual int GetFixedSize() const;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HIOChannel.h

@@ -0,0 +1,195 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HIOCHANNEL
+#define HCPP_HIOCHANNEL
+
+namespace HalconCpp
+{
+
+// Represents an instance of a channel of an I/O device.
+class LIntExport HIOChannel : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HIOChannel():HHandle() {}
+
+  // Copy constructor
+  HIOChannel(const HIOChannel& source) : HHandle(source) {}
+
+  // Copy constructor
+  HIOChannel(const HHandle& handle);
+
+  // Create HIOChannel from handle, taking ownership
+  explicit HIOChannel(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('io_channel')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // open_io_channel: Open and configure I/O channels.
+  explicit HIOChannel(const HIODevice& IODeviceHandle, const HString& IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // open_io_channel: Open and configure I/O channels.
+  explicit HIOChannel(const HIODevice& IODeviceHandle, const char* IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+#ifdef _WIN32
+  // open_io_channel: Open and configure I/O channels.
+  explicit HIOChannel(const HIODevice& IODeviceHandle, const wchar_t* IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Perform an action on I/O channels.
+  static HTuple ControlIoChannel(const HIOChannelArray& IOChannelHandle, const HString& ParamAction, const HTuple& ParamArgument);
+
+  // Perform an action on I/O channels.
+  HTuple ControlIoChannel(const HString& ParamAction, const HTuple& ParamArgument) const;
+
+  // Perform an action on I/O channels.
+  HTuple ControlIoChannel(const char* ParamAction, const HTuple& ParamArgument) const;
+
+#ifdef _WIN32
+  // Perform an action on I/O channels.
+  HTuple ControlIoChannel(const wchar_t* ParamAction, const HTuple& ParamArgument) const;
+#endif
+
+  // Write a value to the specified I/O channels.
+  static HTuple WriteIoChannel(const HIOChannelArray& IOChannelHandle, const HTuple& Value);
+
+  // Write a value to the specified I/O channels.
+  HTuple WriteIoChannel(const HTuple& Value) const;
+
+  // Read a value from the specified I/O channels.
+  static HTuple ReadIoChannel(const HIOChannelArray& IOChannelHandle, HTuple* Status);
+
+  // Read a value from the specified I/O channels.
+  HTuple ReadIoChannel(HTuple* Status) const;
+
+  // Set specific parameters of I/O channels.
+  static void SetIoChannelParam(const HIOChannelArray& IOChannelHandle, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Set specific parameters of I/O channels.
+  void SetIoChannelParam(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Query specific parameters of I/O channels.
+  static HTuple GetIoChannelParam(const HIOChannelArray& IOChannelHandle, const HTuple& GenParamName);
+
+  // Query specific parameters of I/O channels.
+  HTuple GetIoChannelParam(const HString& GenParamName) const;
+
+  // Query specific parameters of I/O channels.
+  HTuple GetIoChannelParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Query specific parameters of I/O channels.
+  HTuple GetIoChannelParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Close I/O channels.
+  static void CloseIoChannel(const HIOChannelArray& IOChannelHandle);
+
+  // Close I/O channels.
+  void CloseIoChannel() const;
+
+  // Open and configure I/O channels.
+  static HIOChannelArray OpenIoChannel(const HIODevice& IODeviceHandle, const HTuple& IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Open and configure I/O channels.
+  void OpenIoChannel(const HIODevice& IODeviceHandle, const HString& IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Open and configure I/O channels.
+  void OpenIoChannel(const HIODevice& IODeviceHandle, const char* IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+#ifdef _WIN32
+  // Open and configure I/O channels.
+  void OpenIoChannel(const HIODevice& IODeviceHandle, const wchar_t* IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HIOChannel> HIOChannelArrayRef;
+typedef HSmartPtr< HIOChannelArrayRef > HIOChannelArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HIOChannelArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HIOChannelArray();
+
+  // Create array from native array of tool instances
+  HIOChannelArray(HIOChannel* classes, Hlong length);
+
+  // Copy constructor
+  HIOChannelArray(const HIOChannelArray &tool_array);
+
+  // Destructor
+  virtual ~HIOChannelArray();
+
+  // Assignment operator
+  HIOChannelArray &operator=(const HIOChannelArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HIOChannel* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HIOChannelArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif

3rdparty/include22/halcon/halconcpp/HIODevice.h

@@ -0,0 +1,241 @@
+/***********************************************************
+ * File generated by the HALCON-Compiler hcomp version 20.11
+ * Usage: Interface to C++
+ *
+ * Software by: MVTec Software GmbH, www.mvtec.com
+ ***********************************************************/
+
+
+#ifndef HCPP_HIODEVICE
+#define HCPP_HIODEVICE
+
+namespace HalconCpp
+{
+
+// Represents an instance of an I/O device.
+class LIntExport HIODevice : public HHandle
+{
+
+public:
+
+  // Create an uninitialized instance
+  HIODevice():HHandle() {}
+
+  // Copy constructor
+  HIODevice(const HIODevice& source) : HHandle(source) {}
+
+  // Copy constructor
+  HIODevice(const HHandle& handle);
+
+  // Create HIODevice from handle, taking ownership
+  explicit HIODevice(Hlong handle);
+
+  bool operator==(const HHandle& obj) const
+  {
+    return HHandleBase::operator==(obj);
+  }
+
+  bool operator!=(const HHandle& obj) const
+  {
+    return HHandleBase::operator!=(obj);
+  }
+
+protected:
+
+  // Verify matching semantic type ('io_device')!
+  virtual void AssertType(Hphandle handle) const;
+
+public:
+
+
+
+/*****************************************************************************
+ * Operator-based class constructors
+ *****************************************************************************/
+
+  // open_io_device: Open and configure an I/O device. 
+  explicit HIODevice(const HString& IOInterfaceName, const HTuple& IODeviceName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // open_io_device: Open and configure an I/O device. 
+  explicit HIODevice(const char* IOInterfaceName, const HTuple& IODeviceName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+#ifdef _WIN32
+  // open_io_device: Open and configure an I/O device. 
+  explicit HIODevice(const wchar_t* IOInterfaceName, const HTuple& IODeviceName, const HTuple& GenParamName, const HTuple& GenParamValue);
+#endif
+
+
+
+
+  /***************************************************************************
+   * Operators                                                               *
+   ***************************************************************************/
+
+  // Open and configure I/O channels.
+  HIOChannelArray OpenIoChannel(const HTuple& IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Open and configure I/O channels.
+  HIOChannel OpenIoChannel(const HString& IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Open and configure I/O channels.
+  HIOChannel OpenIoChannel(const char* IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+#ifdef _WIN32
+  // Open and configure I/O channels.
+  HIOChannel OpenIoChannel(const wchar_t* IOChannelName, const HTuple& GenParamName, const HTuple& GenParamValue) const;
+#endif
+
+  // Query information about channels of the specified I/O device. 
+  HTuple QueryIoDevice(const HTuple& IOChannelName, const HTuple& Query) const;
+
+  // Query information about channels of the specified I/O device. 
+  HTuple QueryIoDevice(const HString& IOChannelName, const HTuple& Query) const;
+
+  // Query information about channels of the specified I/O device. 
+  HTuple QueryIoDevice(const char* IOChannelName, const HTuple& Query) const;
+
+#ifdef _WIN32
+  // Query information about channels of the specified I/O device. 
+  HTuple QueryIoDevice(const wchar_t* IOChannelName, const HTuple& Query) const;
+#endif
+
+  // Perform an action on the I/O device.
+  HTuple ControlIoDevice(const HString& Action, const HTuple& Argument) const;
+
+  // Perform an action on the I/O device.
+  HTuple ControlIoDevice(const HString& Action, const HString& Argument) const;
+
+  // Perform an action on the I/O device.
+  HTuple ControlIoDevice(const char* Action, const char* Argument) const;
+
+#ifdef _WIN32
+  // Perform an action on the I/O device.
+  HTuple ControlIoDevice(const wchar_t* Action, const wchar_t* Argument) const;
+#endif
+
+  // Configure a specific I/O device instance.
+  void SetIoDeviceParam(const HTuple& GenParamName, const HTuple& GenParamValue) const;
+
+  // Configure a specific I/O device instance.
+  void SetIoDeviceParam(const HString& GenParamName, const HString& GenParamValue) const;
+
+  // Configure a specific I/O device instance.
+  void SetIoDeviceParam(const char* GenParamName, const char* GenParamValue) const;
+
+#ifdef _WIN32
+  // Configure a specific I/O device instance.
+  void SetIoDeviceParam(const wchar_t* GenParamName, const wchar_t* GenParamValue) const;
+#endif
+
+  // Query settings of an I/O device instance. 
+  HTuple GetIoDeviceParam(const HTuple& GenParamName) const;
+
+  // Query settings of an I/O device instance. 
+  HTuple GetIoDeviceParam(const HString& GenParamName) const;
+
+  // Query settings of an I/O device instance. 
+  HTuple GetIoDeviceParam(const char* GenParamName) const;
+
+#ifdef _WIN32
+  // Query settings of an I/O device instance. 
+  HTuple GetIoDeviceParam(const wchar_t* GenParamName) const;
+#endif
+
+  // Close the specified I/O device. 
+  void CloseIoDevice() const;
+
+  // Open and configure an I/O device. 
+  void OpenIoDevice(const HString& IOInterfaceName, const HTuple& IODeviceName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+  // Open and configure an I/O device. 
+  void OpenIoDevice(const char* IOInterfaceName, const HTuple& IODeviceName, const HTuple& GenParamName, const HTuple& GenParamValue);
+
+#ifdef _WIN32
+  // Open and configure an I/O device. 
+  void OpenIoDevice(const wchar_t* IOInterfaceName, const HTuple& IODeviceName, const HTuple& GenParamName, const HTuple& GenParamValue);
+#endif
+
+  // Perform an action on the I/O interface.
+  static HTuple ControlIoInterface(const HString& IOInterfaceName, const HString& Action, const HTuple& Argument);
+
+  // Perform an action on the I/O interface.
+  static HTuple ControlIoInterface(const HString& IOInterfaceName, const HString& Action, const HString& Argument);
+
+  // Perform an action on the I/O interface.
+  static HTuple ControlIoInterface(const char* IOInterfaceName, const char* Action, const char* Argument);
+
+#ifdef _WIN32
+  // Perform an action on the I/O interface.
+  static HTuple ControlIoInterface(const wchar_t* IOInterfaceName, const wchar_t* Action, const wchar_t* Argument);
+#endif
+
+  // Query information about the specified I/O device interface.
+  static HTuple QueryIoInterface(const HString& IOInterfaceName, const HTuple& Query);
+
+  // Query information about the specified I/O device interface.
+  static HTuple QueryIoInterface(const HString& IOInterfaceName, const HString& Query);
+
+  // Query information about the specified I/O device interface.
+  static HTuple QueryIoInterface(const char* IOInterfaceName, const char* Query);
+
+#ifdef _WIN32
+  // Query information about the specified I/O device interface.
+  static HTuple QueryIoInterface(const wchar_t* IOInterfaceName, const wchar_t* Query);
+#endif
+
+};
+
+// forward declarations and types for internal array implementation
+
+template<class T> class HSmartPtr;
+template<class T> class HHandleBaseArrayRef;
+
+typedef HHandleBaseArrayRef<HIODevice> HIODeviceArrayRef;
+typedef HSmartPtr< HIODeviceArrayRef > HIODeviceArrayPtr;
+
+
+// Represents multiple tool instances
+class LIntExport HIODeviceArray : public HHandleBaseArray
+{
+
+public:
+
+  // Create empty array
+  HIODeviceArray();
+
+  // Create array from native array of tool instances
+  HIODeviceArray(HIODevice* classes, Hlong length);
+
+  // Copy constructor
+  HIODeviceArray(const HIODeviceArray &tool_array);
+
+  // Destructor
+  virtual ~HIODeviceArray();
+
+  // Assignment operator
+  HIODeviceArray &operator=(const HIODeviceArray &tool_array);
+
+  // Clears array and all tool instances
+  virtual void Clear();
+
+  // Get array of native tool instances
+  const HIODevice* Tools() const;
+
+  // Get number of tools
+  virtual Hlong Length() const;
+
+  // Create tool array from tuple of handles
+  virtual void SetFromTuple(const HTuple& handles);
+
+  // Get tuple of handles for tool array
+  virtual HTuple ConvertToTuple() const;
+
+protected:
+
+// Smart pointer to internal data container
+   HIODeviceArrayPtr *mArrayPtr;
+};
+
+}
+
+#endif