GrabBag/App/WorkpieceHole/WorkpieceHoleConfig/Inc/IVrConfig.h

#ifndef IVRCONFIG_H
#define IVRCONFIG_H

#include <iostream>
#include <string>
#include <vector>
#include <utility>
#include <algorithm>
#include <cstring>

// 包含公共配置结构体
#include "VrCommonConfig.h"
#include "VrHandEyeCalibConfig.h"

/**
 * @brief 离群点滤波参数
 */
struct VrOutlierFilterParam
{
    double continuityTh = 20.0;  // 连续性阈值，噪声滤除。当相邻点的z跳变大于此门限时，检查是否为噪声
    double outlierTh = 5.0;      // 离群点判断阈值，若长度小于此值，视为噪声
};

/**
 * @brief 线段分割参数
 */
struct VrLineSegParam
{
    double distScale = 3.0;      // 计算方向角的窗口比例因子
    double segGapTh_y = 15.0;     // Y方向间隔阈值，大于此值认为是分段
    double segGapTh_z = 0.0;    // Z方向间隔阈值，大于此值认为是分段
};

/**
 * @brief 树生长参数
 */
struct VrTreeGrowParam
{
    int maxLineSkipNum = 2;         // 生长时允许跳过的最大线条数
    double yDeviation_max = 4.0;    // 生长时允许的最大Y偏差
    double maxSkipDistance = 0.0;   // 最大跳跃距离
    double zDeviation_max = 10.0;    // 生长时允许的最大Z偏差
    double minLTypeTreeLen = 2.0;  // L型树的最小长度
    double minVTypeTreeLen = 2.0;  // V型树的最小长度
};

/**
 * @brief 工件孔参数
 */
struct VrWorkpieceHoleParam
{
    int workpieceType = 0;       // 工件类型
    double holeDiameter = 6.0;   // 孔直径 (mm)
    double bigHoleDiameter = 33.0; // 大孔直径 (mm)，工件3算法使用
    double holeDist_L = 40.0;    // 孔间距_长 (mm)
    double holeDist_W = 32.0;    // 孔间距_宽 (mm)
    double xLen = 44.0;          // x轴方向长度，用于绘制平面 (mm)
    double yLen = 70.0;          // y轴方向长度，用于绘制平面 (mm)
    double H = 47.0;             // 高度 (mm)
};

/**
 * @brief PLC Modbus 寄存器地址配置
 *
 * 汇川 PLC D 寄存器映射到 Modbus 保持寄存器地址：
 * D寄存器 + 40001 = Modbus地址
 * 代码协议地址 = D寄存器 + 1
 *
 * 示例：
 *   D1000 -> Modbus 41001 -> 代码协议地址 1001
 *   D1002 -> Modbus 41003 -> 代码协议地址 1003
 *   D2000 -> Modbus 42001 -> 代码协议地址 2001
 */
struct VrPlcRegisterConfig
{
    int addrPhotoRequest = 1001;      // D1000: 拍照请求寄存器地址（读：=1触发拍照）
    int addrDataComplete = 1003;      // D1002: 数据输出完成标志寄存器地址（写：=1完成）
    int addrCoordDataStart = 2002;    // D2000: 坐标数据起始寄存器地址

    // 显式赋值构造函数
    VrPlcRegisterConfig& operator=(const VrPlcRegisterConfig& other) {
        if (this != &other) {
            addrPhotoRequest = other.addrPhotoRequest;
            addrDataComplete = other.addrDataComplete;
            addrCoordDataStart = other.addrCoordDataStart;
        }
        return *this;
    }

    // 显式复制构造函数
    VrPlcRegisterConfig(const VrPlcRegisterConfig& other)
        : addrPhotoRequest(other.addrPhotoRequest)
        , addrDataComplete(other.addrDataComplete)
        , addrCoordDataStart(other.addrCoordDataStart) {
    }

    // 默认构造函数
    VrPlcRegisterConfig() = default;
};

/**
 * @brief 姿态输出顺序枚举
 *
 * 定义机械臂姿态数据的输出顺序
 */
enum VrPoseOutputOrder
{
    POSE_ORDER_RPY = 0,  // Roll, Pitch, Yaw（默认）
    POSE_ORDER_RYP = 1,  // Roll, Yaw, Pitch
    POSE_ORDER_PRY = 2,  // Pitch, Roll, Yaw
    POSE_ORDER_PYR = 3,  // Pitch, Yaw, Roll
    POSE_ORDER_YRP = 4,  // Yaw, Roll, Pitch
    POSE_ORDER_YPR = 5   // Yaw, Pitch, Roll
};

/**
 * @brief 方向向量反向配置枚举
 *
 * 定义机械臂方向向量的反向配置
 * 用于调整相机坐标系到机械臂坐标系的方向向量转换
 */
enum VrDirVectorInvert
{
    DIR_INVERT_NONE = 0,  // 不反向
    DIR_INVERT_XY   = 1,  // X和Y方向反向
    DIR_INVERT_XZ   = 2,  // X和Z方向反向
    DIR_INVERT_YZ   = 3   // Y和Z方向反向（默认，兼容原有行为）
};

/**
 * @brief 数据字节序枚举
 *
 * 定义 PLC 通信时浮点数的字节序
 * 不同 PLC 厂商可能使用不同的字节序
 */
enum VrByteOrder
{
    BYTE_ORDER_BIG_ENDIAN    = 0,  // 大端序 (ABCD) - 高字节在前
    BYTE_ORDER_LITTLE_ENDIAN = 1   // 小端序 (DCBA) - 低字节在前
};

/**
 * @brief PLC和机械臂服务端配置
 *
 * 默认值参考 Doc/porotol.jpg 协议文档：
 * - 汇川PLC-easy320: 192.168.0.88:502
 * - 配天机械臂: 192.168.0.90:502
 */
struct VrPlcRobotServerConfig
{
    std::string plcServerIp = "192.168.0.88";       // PLC服务端IP地址（汇川PLC-easy320）
    int plcServerPort = 502;                         // PLC服务端端口（Modbus TCP默认502）
    std::string robotServerIp = "192.168.0.90";     // 机械臂服务端IP地址（配天机械臂）
    int robotServerPort = 502;                       // 机械臂服务端端口（Modbus TCP默认502）
    VrPlcRegisterConfig registerConfig;              // PLC 寄存器地址配置
    int poseOutputOrder = POSE_ORDER_RPY;            // 姿态输出顺序，默认RPY
    int dirVectorInvert = DIR_INVERT_YZ;             // 方向向量反向配置，默认YZ反向（兼容原有行为）
    int byteOrder = BYTE_ORDER_BIG_ENDIAN;           // 数据字节序，默认大端序

    // 显式赋值构造函数
    VrPlcRobotServerConfig& operator=(const VrPlcRobotServerConfig& other) {
        if (this != &other) {
            plcServerIp = other.plcServerIp;
            plcServerPort = other.plcServerPort;
            robotServerIp = other.robotServerIp;
            robotServerPort = other.robotServerPort;
            registerConfig = other.registerConfig;
            poseOutputOrder = other.poseOutputOrder;
            dirVectorInvert = other.dirVectorInvert;
            byteOrder = other.byteOrder;
        }
        return *this;
    }

    // 显式复制构造函数
    VrPlcRobotServerConfig(const VrPlcRobotServerConfig& other)
        : plcServerIp(other.plcServerIp)
        , plcServerPort(other.plcServerPort)
        , robotServerIp(other.robotServerIp)
        , robotServerPort(other.robotServerPort)
        , registerConfig(other.registerConfig)
        , poseOutputOrder(other.poseOutputOrder)
        , dirVectorInvert(other.dirVectorInvert)
        , byteOrder(other.byteOrder) {
    }

    // 默认构造函数
    VrPlcRobotServerConfig() = default;
};

/**
 * @brief 单个工件对应的算法参数组
 */
struct VrWorkpieceAlgorithmProfile
{
    int workpieceNumber = 1;
    VrWorkpieceHoleParam workpieceHoleParam;
    VrLineSegParam lineSegParam;
    VrOutlierFilterParam filterParam;
    VrTreeGrowParam growParam;

    VrWorkpieceAlgorithmProfile() = default;

    explicit VrWorkpieceAlgorithmProfile(int number)
        : workpieceNumber(number)
    {
        ApplyTestDefaults(number);
    }

    void ApplyTestDefaults(int number)
    {
        workpieceNumber = number;

        workpieceHoleParam.workpieceType = 0;
        workpieceHoleParam.holeDiameter = 6.0;
        workpieceHoleParam.bigHoleDiameter = 33.0;
        workpieceHoleParam.holeDist_L = 40.0;
        workpieceHoleParam.holeDist_W = 32.0;
        workpieceHoleParam.xLen = 44.0;
        workpieceHoleParam.yLen = 70.0;
        workpieceHoleParam.H = 47.0;

        lineSegParam.distScale = 3.0;
        lineSegParam.segGapTh_y = 15.0;
        lineSegParam.segGapTh_z = 0.0;

        filterParam.continuityTh = (number == 1) ? 20.0 : 5.0;
        filterParam.outlierTh = 5.0;

        growParam.maxLineSkipNum = 2;
        growParam.yDeviation_max = 4.0;
        growParam.maxSkipDistance = 0.0;
        growParam.zDeviation_max = 10.0;
        growParam.minLTypeTreeLen = 2.0;
        growParam.minVTypeTreeLen = 2.0;

        if (number == 3 || number == 4) {
            workpieceHoleParam.H = 60.0;
            lineSegParam.distScale = 30.0;
            lineSegParam.segGapTh_y = 40.0;
        } else if (number == 5) {
            workpieceHoleParam.holeDiameter = 10.0;
            workpieceHoleParam.H = 28.0;
        }
    }
};

/**
 * @brief 算法参数配置结构
 */
struct VrAlgorithmParams
{
    VrPlaneCalibParam planeCalibParam;                           // 全局平面校准参数
    std::vector<VrWorkpieceAlgorithmProfile> workpieceProfiles; // 各工件独立算法参数

    VrAlgorithmParams()
    {
        for (int workpieceNumber = 1; workpieceNumber <= 5; ++workpieceNumber) {
            workpieceProfiles.push_back(VrWorkpieceAlgorithmProfile(workpieceNumber));
        }
    }

    const VrWorkpieceAlgorithmProfile* FindWorkpieceProfile(int workpieceNumber) const
    {
        for (unsigned int i = 0; i < workpieceProfiles.size(); ++i) {
            if (workpieceProfiles[i].workpieceNumber == workpieceNumber) {
                return &workpieceProfiles[i];
            }
        }
        return nullptr;
    }

    VrWorkpieceAlgorithmProfile* FindWorkpieceProfile(int workpieceNumber)
    {
        for (unsigned int i = 0; i < workpieceProfiles.size(); ++i) {
            if (workpieceProfiles[i].workpieceNumber == workpieceNumber) {
                return &workpieceProfiles[i];
            }
        }
        return nullptr;
    }

    VrWorkpieceAlgorithmProfile& GetOrCreateWorkpieceProfile(int workpieceNumber)
    {
        VrWorkpieceAlgorithmProfile* profile = FindWorkpieceProfile(workpieceNumber);
        if (profile) {
            return *profile;
        }

        workpieceProfiles.push_back(VrWorkpieceAlgorithmProfile(workpieceNumber));
        return workpieceProfiles.back();
    }
};

/**
 * @brief 配置加载结果
 */
struct ConfigResult
{
    std::vector<DeviceInfo>    cameraList;
    std::vector<DeviceInfo>    deviceList;
    VrAlgorithmParams          algorithmParams;       // 算法参数
    std::vector<VrHandEyeCalibMatrix> handEyeCalibMatrixList;  // 多相机手眼标定矩阵列表
    VrDebugParam               debugParam;            // 调试参数
    SerialConfig               serialConfig;          // 串口配置
    VrPlcRobotServerConfig     plcRobotServerConfig;  // PLC和机械臂服务端配置

    // 显式赋值构造函数，确保正确的深拷贝
    ConfigResult& operator=(const ConfigResult& other) {
        if (this != &other) {
            cameraList = other.cameraList;
            deviceList = other.deviceList;
            algorithmParams = other.algorithmParams;
            handEyeCalibMatrixList = other.handEyeCalibMatrixList;
            debugParam = other.debugParam;
            serialConfig = other.serialConfig;
            plcRobotServerConfig = other.plcRobotServerConfig;
        }
        return *this;
    }

    // 显式复制构造函数
    ConfigResult(const ConfigResult& other)
        : cameraList(other.cameraList)
        , deviceList(other.deviceList)
        , algorithmParams(other.algorithmParams)
        , handEyeCalibMatrixList(other.handEyeCalibMatrixList)
        , debugParam(other.debugParam)
        , serialConfig(other.serialConfig)
        , plcRobotServerConfig(other.plcRobotServerConfig) {
    }

    // 默认构造函数
    ConfigResult() = default;
};

/**
 * @brief 配置加载错误代码
 */
enum LoadConfigErrorCode
{
    LOAD_CONFIG_SUCCESS = 0,              // 加载成功
    LOAD_CONFIG_FILE_NOT_FOUND = -1,      // 配置文件不存在
    LOAD_CONFIG_PARSE_ERROR = -2,         // 配置文件解析错误
    LOAD_CONFIG_INVALID_FORMAT = -3,      // 配置文件格式无效
    LOAD_CONFIG_UNKNOWN_ERROR = -99       // 未知错误
};

/**
 * @brief VrConfig接口类
 */
class IVrConfig
{
public:
    /**
     * @brief 虚析构函数
     */
    virtual ~IVrConfig() {}

    /**
     * @brief 创建实例
     * @return 实例
     */
    static bool CreateInstance(IVrConfig** ppVrConfig);

    /**
     * @brief 加载配置文件
     * @param filePath 配置文件路径
     * @param configResult 输出参数，加载的配置结果
     * @return 错误代码 (LoadConfigErrorCode): 0=成功, 负值表示错误
     */
    virtual int LoadConfig(const std::string& filePath, ConfigResult& configResult) = 0;

    /**
     * @brief 保存配置文件
     * @param filePath 配置文件路径
     * @param configResult 配置结果
     * @return 是否保存成功
     */
    virtual bool SaveConfig(const std::string& filePath, ConfigResult& configResult) = 0;

    /**
     * @brief 设置配置改变通知回调
     * @param notify 通知接口指针
     */
    virtual void SetConfigChangeNotify(IVrConfigChangeNotify* notify) = 0;
};

#endif // IVRCONFIG_H