#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

#include "JZsdkLib.h"
#include "version_choose.h"
#include "BaseConfig.h"
#include "MediaProc/MediaParm.h"
#include <math.h>
#include "../../StreamProc/StreamProc.h"
#include "../../ImageProc/PseudoColor/PseudoColor.h"
#include "../../ImageProc/BadPixelProc/BadPixelProc.h"
#include "./Kt_Irc_deal.h"

#define SPC_DATA_DIR "/root/spc_save_data.raw"

extern int JZsdk_RawBadPixelCheck_Flag;  //原始盲点记录标志
extern int JZsdk_GrayBadPixelCheck_flag; //灰度图坏点纠正标志
extern int JZsdk_SPCCheck_flag; // 单点纠正标志
extern int JZsdk_GasEnhancementCorrect_flag ; //气体增强纠正标志


extern int g_CameraRegionBox_FirstPixel[2];  
extern int g_CameraRegionBox_SecondPixel[2]; 
extern int g_CameraRegionBox_ClickTime;

int g_temp_GasValueMax = 160;
int g_temp_GasValueMin = 30;

#define BAD_PIXEL_MODE JZ_FLAGCODE_OFF

static T_JZsdkReturnCode Kt_Irc_TempCalibrate_Read(int flag, U16_t *Image, unsigned int maxLen);
static T_JZsdkReturnCode Kt_Irc_TempCalibrate_Save(int flag, U16_t *Image, unsigned int maxLen);
static T_JZsdkReturnCode Kt_Irc_ReadAndSave_threshold(int flag, int order,unsigned int *num);


/**********************************************
 * 
 *  直方均衡, 提高图像的对比度，以降低过曝和曝光不足问题
 *  从直方图来看，即将 密集的直方图向两边扩散，从而变疏和均匀
 *  https://blog.csdn.net/qq_43416206/article/details/138680036
 * 
 * 
 *  输入源数据 直方图数据 输出承载数组 配置信息
 * *****************************************************/
static T_JZsdkReturnCode StraightBalancing_U16(U16_t *rawData, unsigned int *StraightDraw, U16_t *outData, struct Kt_Irc_deal *dealInfo )
{
    double result=0;

    for (int i = 0; i < dealInfo->PixelNum; i++)
    {
        result = 0.0;
        for (int temp = 0; temp < rawData[i]; temp++)
        {
            result += StraightDraw[temp];
        }

        result = (result*dealInfo->ExpectedMax) / dealInfo->PixelNum;
        outData[i] =  (U16_t)((int)result); 
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/**********************************************
 * 
 *  直方拉伸
 *  https://blog.csdn.net/qq_43416206/article/details/138680036
 *  输入源数据 直方图数据 输出承载数组 配置信息
 * *****************************************************/
static T_JZsdkReturnCode StraightStretching(U16_t *rawData, unsigned int *StraightDraw, U16_t *outData, struct Kt_Irc_deal *dealInfo )
{
    int LeftDrop = dealInfo->LeftDrop;
    int RightDrop = dealInfo->RightDrop;
    int hist_cnt = 0;
    int find_min = 0, find_max = 0;
    int LowIndex = 0, HighIndex = 0;
    for (int i = 0; i < dealInfo->ExpectedMax; i++)
    {
        hist_cnt += StraightDraw[i];
        
        if ((hist_cnt >= LeftDrop) && (!find_min))
        {
            
            LowIndex = i;
            //JZSDK_LOG_INFO("lowindex:%d", LowIndex);
            find_min = 1;
        }
        if((hist_cnt >= (dealInfo->PixelNum - RightDrop) )&&(!find_max))
        {
            HighIndex = i;
            //JZSDK_LOG_INFO("HighIndex:%d", HighIndex);
            find_max = 1;
        }
    }

    if (HighIndex == LowIndex)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
    for (int i = 0; i < dealInfo->PixelNum; i++)
    {
        if (rawData[i]<= LowIndex) 
        {
            outData[i]= 0;
        }
        else if (rawData[i]>= HighIndex) 
        {
            outData[i]= dealInfo->ExpectedMax;
        }
        else
        { 
            outData[i]= ((rawData[i]- LowIndex)*dealInfo->ExpectedMax) /(HighIndex- LowIndex);
        }
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*计算直方图均衡化并转换为8位灰度值
	    U16_t in_str 输入的数据
                int in_str_len 输入的数据长度
    灰度0为黑色，灰度255为白色
*/
static T_JZsdkReturnCode JZsdk_vKT(U16_t *in_str, U8_t **out_str, int *out_str_len, struct Kt_Irc_deal *dealInfo)
{
    //无图像
    if (in_str == NULL || dealInfo == NULL) 
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  

    // 分配输出结果的内存空间
    *out_str = (unsigned char*)malloc(sizeof(unsigned char) * dealInfo->PixelNum);
    if (*out_str == NULL) {
        // 如果内存分配失败，打印错误信息并返回空指针
        JZSDK_LOG_ERROR("Error: Memory allocation failed\n");
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

/**********************************************
 * 
 *  获取图像的直方图
 * 
 * 
 * *****************************************************/

    // 初始化变量
    unsigned int ThisPixelGray = 0;     //当前处理像素点的灰度值
    long SumAllLegalGray = 0;       //存储的总灰度值

    // 分配当前灰度值出现次数的内存空间，并初始化为0
    //用于记录每个灰度值在输入向量中出现的次数。具体来说，它是一个无符号整型数组，
    //其索引表示灰度值，数组中的值表示该灰度值在输入向量中出现的次数。
    //在遍历输入向量时，将每个像素的灰度值记录在相应的 ThisGrayAppendTime 数组中。
    //这是直方图均衡化算法中需要用到的一个重要步骤，用于统计每个灰度值的出现次数 
    //为保证每一个灰度值都被包括，所以用 dealInfo->ExpectedMax 写长度
    unsigned int* ThisGrayAppendTime = (unsigned int*)calloc(dealInfo->ExpectedMax + 1, sizeof(unsigned int));
    if (ThisGrayAppendTime == NULL) {
        JZSDK_LOG_ERROR("Error: Memory allocation failed\n");
        free(*out_str);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    // 遍历输入向量，统计各灰度值出现次数和总灰度和
    for (int i = 0; i < dealInfo->PixelNum; ++i) 
    {
        //获取本像素点的灰度值，且避免超过最大灰度值
        ThisPixelGray = in_str[i];
        if (ThisPixelGray > dealInfo->ExpectedMax) 
        {
            ThisPixelGray = dealInfo->ExpectedMax;
        }

        //直方图的 x坐标ThisPixelGray 的y值 即次数+1
        ThisGrayAppendTime[ThisPixelGray]++;

        //计算总灰度值
        SumAllLegalGray += ThisPixelGray;
    }

/*
    注：图像对比度：直方图分布越均匀，图像的对比度越高
        图像亮度：  直方图分布越靠右（最大值），则亮度越高
*/

/********************
 * 
 * 直方拉伸
 * 
 * 
 * *****************/
    U16_t StrDraw[dealInfo->PixelNum];
    StraightStretching(in_str, ThisGrayAppendTime, StrDraw, dealInfo);

/****************************
 * 
 *  将14位图，右移为8位图
 * 
 * 
 * *****************************/
   
    // 将均衡化后的灰度值转换为8位，并存储在输出向量中
    //直方图均衡化后的结果进行操作，将每个值转换为8位灰度值。具体操作是将in_str[i]中的值右移(InBits - 8)位
    //然后将结果转换为unsigned char类型，存储到输出向量对应的位置上。这样操作的目的是将原本可能不是8位的灰度值转换为8位灰度值，以便后续的处理和存储。
    for (int i = 0; i < dealInfo->PixelNum; i ++) 
    {
        (*out_str)[i] = (unsigned char)(StrDraw[i] >> (dealInfo->ImgDataBits - 8));
        //(*out_str)[i] = (unsigned char)(in_str[i] >> (dealInfo->ImgDataBits - 8));
    }

    *out_str_len = dealInfo->PixelNum; 
   
   
    // 释放动态分配的内存空间
    free(ThisGrayAppendTime);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*计算直方图均衡化并转换为8位灰度值
	    U16_t in_str 输入的数据
                int in_str_len 输入的数据长度
    灰度0为黑色，灰度255为白色
*/
static T_JZsdkReturnCode Kt_Irc_Histogram_vKT(U16_t *in_str, U8_t **out_str, int *out_str_len, struct Kt_Irc_deal *dealInfo)
{
    //无图像
    if (in_str == NULL || dealInfo == NULL) 
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  

    // 分配输出结果的内存空间
    *out_str = (unsigned char*)malloc(sizeof(unsigned char) * dealInfo->PixelNum);
    if (*out_str == NULL) {
        // 如果内存分配失败，打印错误信息并返回空指针
        JZSDK_LOG_ERROR("Error: Memory allocation failed\n");
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

/**********************************************
 * 
 *  获取图像的直方图
 * 
 * 
 * *****************************************************/

    // 初始化变量
    unsigned int ThisPixelGray = 0;     //当前处理像素点的灰度值
    long SumAllLegalGray = 0;       //存储的总灰度值

    // 分配当前灰度值出现次数的内存空间，并初始化为0
    //用于记录每个灰度值在输入向量中出现的次数。具体来说，它是一个无符号整型数组，
    //其索引表示灰度值，数组中的值表示该灰度值在输入向量中出现的次数。
    //在遍历输入向量时，将每个像素的灰度值记录在相应的 ThisGrayAppendTime 数组中。
    //这是直方图均衡化算法中需要用到的一个重要步骤，用于统计每个灰度值的出现次数 
    //为保证每一个灰度值都被包括，所以用 dealInfo->ExpectedMax 写长度
    unsigned int* ThisGrayAppendTime = (unsigned int*)calloc(dealInfo->ExpectedMax + 1, sizeof(unsigned int));
    if (ThisGrayAppendTime == NULL) {
        JZSDK_LOG_ERROR("Error: Memory allocation failed\n");
        free(*out_str);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    // 遍历输入向量，统计各灰度值出现次数和总灰度和
    for (int i = 0; i < dealInfo->PixelNum; ++i) 
    {
        //获取本像素点的灰度值，且避免超过最大灰度值
        ThisPixelGray = in_str[i];
        if (ThisPixelGray > dealInfo->ExpectedMax) 
        {
            ThisPixelGray = dealInfo->ExpectedMax;
        }

        //直方图的 x坐标ThisPixelGray 的y值 即次数+1
        ThisGrayAppendTime[ThisPixelGray]++;

        //计算总灰度值
        SumAllLegalGray += ThisPixelGray;
    }

/*
    注：图像对比度：直方图分布越均匀，图像的对比度越高
        图像亮度：  直方图分布越靠右（最大值），则亮度越高
*/

/**********************************************************************************************************/

    // 初始化边界值和阈值增益
    unsigned int LowLimit = 0; //用于指定直方图均衡化的最低灰度值范围，通常为0。
    unsigned int HighLimit = 0; //用于指定直方图均衡化的最高灰度值范围，通常为最大灰度值。
    unsigned int VMax = dealInfo->ExpectedMax; //表示输入图像中可能的最大灰度值。
    unsigned int VMin = 0; //通常为0，表示输入图像中可能的最小灰度值。
    unsigned int ThresholdLimits = dealInfo->Gain * dealInfo->ImgDataBits; //阈值参数，是一个根据增益和位深度计算得出的阈值，用于在直方图均衡化时进行限制，确保输出图像的对比度合适。
    double AvgGray = SumAllLegalGray / (dealInfo->PixelNum * 1.0); //平均灰度值，表示输入图像中所有合法灰度值的平均值，用于直方图均衡化算法中计算每个像素点的增益值。

    // 计算灰度直方图的边界值,找到合适的灰度范围用于直方图均衡化
    for (int i = 0; i < dealInfo->ExpectedMax; ++i) 
    {
        if (LowLimit < dealInfo->LeftDrop) {
            LowLimit += ThisGrayAppendTime[i];
            VMin = i;
        }
        if (HighLimit < (dealInfo->PixelNum - dealInfo->RightDrop)) 
        {
            HighLimit += ThisGrayAppendTime[i];
            VMax = i;
        }
    }

    //(ThresholdLimits / 12) 是一个阈值的限制
    //根据增益和位深度计算得出的阈值，用于在直方图均衡化时进行限制，确保输出图像的对比度合适

    //将 VMax 增加 (ThresholdLimits / 12) 的目的是为了保证直方图均衡化后的最高灰度值范围与阈值限制的要求相符，
    //从而确保输出图像的对比度得到合适的控制，并且不会超出预期的范围。
    if (VMax < dealInfo->ExpectedMax - (ThresholdLimits / 12)) 
    {
        VMax += (ThresholdLimits / 12); //最大范围右移 1/12个阈值
    }

    //ThresholdDiff 阈值差异，计算阈值和灰度均值之间的差值
    //ThresholdDiff 被计算为 VMax - VMin + (ThresholdLimits / 6.0)
    //代表最高和最低灰度值范围之间的差距，再加上阈值的六分之一
    //ThresholdDiff 用于衡量最大最小灰度范围的宽度，以确定是否需要对像素进行进一步处理。
    double ThresholdDiff = VMax - VMin + (ThresholdLimits / 6.0);

    int LowThreshold = 0;
    if (AvgGray > (ThresholdDiff / 2.0)) 
    {
        //a. 如果 AvgGray 大于 ThresholdDiff / 2.0，则将 LowThreshold 的值设为 AvgGray - (ThresholdDiff / 2.0) 
        //的无符号整数部分。让 LowThreshold 在保证图像对比度的同时，尽可能地靠近平均灰度值 AvgGray。
        LowThreshold = (unsigned int)(AvgGray - (ThresholdDiff / 2.0));
    } 
    else 
    {
        //如果 AvgGray 小于等于 ThresholdDiff / 2.0，则将 LowThreshold 的值设为零。
        //避免 LowThreshold 取负值，确保不会对图像的过滤效果产生不良影响。
        LowThreshold = 0;
    }

    //重新计算阈值差值
    ThresholdDiff = VMax - LowThreshold;

    //避免阈值差值低于阈值限制，
    if (ThresholdDiff < ThresholdLimits) 
    {
        ThresholdDiff = ThresholdLimits;
        
        //根据新的阈值差值，重新计算 低阈值    
        LowThreshold = (unsigned int)(AvgGray - ThresholdDiff / 2.0);
    
        //最大灰度值与低阈值加上阈值限制之间的差异，如果仍然满足条件
        if (VMax > LowThreshold + ThresholdLimits) 
        {
            //重新计算阈值差值
            ThresholdDiff = VMax - LowThreshold;
        }
    }

    // 对输入向量进行直方图均衡化处理，并转换为8位灰度值
    for (int i = 0; i < dealInfo->PixelNum; ++i) 
    {
        //如果该像素点的灰度值小于最小阈值，使其等于最小阈值
        //确保直方图均衡化的值不会低于设定的阈值，从而保证图像的对比度和亮度的均衡。
        if (in_str[i] < LowThreshold) 
        {
            in_str[i] = LowThreshold;
        }

        //原始直方图值in_str[i]减去低阈值LowThreshold
        //然后乘以一个缩放系数(dealInfo->ExpectedMax / (ThresholdDiff * 1.0))，将结果赋值回in_str[i]。
        //目的将直方图的灰度值映射到更广的范围，以增强图像的对比度和细节。
        in_str[i] = (unsigned int)((in_str[i] - LowThreshold) * (dealInfo->ExpectedMax / (ThresholdDiff * 1.0)));

        //避免超出灰度最大值
        if (in_str[i] > dealInfo->ExpectedMax) 
        {
            in_str[i] = dealInfo->ExpectedMax;
        }
    }

    // 将均衡化后的灰度值转换为8位，并存储在输出向量中
    //直方图均衡化后的结果进行操作，将每个值转换为8位灰度值。具体操作是将in_str[i]中的值右移(InBits - 8)位
    //然后将结果转换为unsigned char类型，存储到输出向量对应的位置上。这样操作的目的是将原本可能不是8位的灰度值转换为8位灰度值，以便后续的处理和存储。
    for (int i = 0; i < dealInfo->PixelNum; i += 4) {
        (*out_str)[i]     = (unsigned char)(in_str[i] >> (dealInfo->ImgDataBits - 8));
        (*out_str)[i + 1] = (unsigned char)(in_str[i + 1] >> (dealInfo->ImgDataBits - 8));
        (*out_str)[i + 2] = (unsigned char)(in_str[i + 2] >> (dealInfo->ImgDataBits - 8));
        (*out_str)[i + 3] = (unsigned char)(in_str[i + 3] >> (dealInfo->ImgDataBits - 8));
    }

    *out_str_len = dealInfo->PixelNum;

    // 释放动态分配的内存空间
    free(ThisGrayAppendTime);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/*3. （组成RGB数组） static vector<unsigned char> supportFun_RGB(const vector<unsigned char> In) {}

// 	输入： vector<unsigned char>	即存有 8 位灰度值的容器
// 	输出： vector<unsigned char> 即可被转换的带有 RGB 值的容器，长度 245760 （81920 * 3）

// 	将输入数组的每个元素，扩展三倍，如：

// 	示例输入： 10 30 60 90 ...
// 	示例输出： 10 10 10 30 30 30 60 60 60 90 90 90 ...

// 	后续元素以此类推。
*/ 
T_JZsdkReturnCode Kt_Irc_GrayTo_RGB(U8_t *in_str, U8_t **out_str, unsigned int *out_str_len, struct Kt_Irc_deal *dealInfo) 
{
    *out_str_len = (dealInfo->PixelNum * 3);
    *out_str = (unsigned char*)malloc(*out_str_len * sizeof(unsigned char));
    if (out_str == NULL)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
    
    //这个会导致y轴倒置, 需要转码后才正常
    for (int i = 0; i < *out_str_len; i += 3) 
    {
        (*out_str)[i] = in_str[i / 3];
        (*out_str)[i + 1] = in_str[i / 3];
        (*out_str)[i + 2] = in_str[i / 3];
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/******
 * 
 *  盲元矫正
 *  输入变量，画面数据，处理地址
 * 
 * *****/
T_JZsdkReturnCode Kt_Irc_CutBlindPixel(U16_t *ImageData, struct Kt_Irc_deal *dealInfo) 
{  
    if (ImageData == NULL || dealInfo == NULL) 
    {  
        // 如果输入数据为空，则返回指针错误
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  
   
    // 遍历盲元数组
    for (int i = 0; i < (dealInfo->BlindNum)*2; i+=2)
    {
        int PosX = dealInfo->Blind[i]; //盲元在图像上的x轴坐标
        int PosY = dealInfo->Blind[i+1]; //盲元在图像上的y轴坐标
        int Pos  = PosY * dealInfo->Width + PosX; //盲元在图像一维数组中的位置

        //检查盲元的3*3的位置是否处于图像内
        if( (PosX > 0) && (PosX < (dealInfo->Width-1)) && (PosY > 0) && (PosY < (dealInfo->Height - 1)) ) 
        {
            // 计算3x3邻域的平均值
            int Avged = (   ImageData[Pos - dealInfo->Width - 1] + ImageData[Pos - dealInfo->Width] + ImageData[Pos - dealInfo->Width + 1] +
                            ImageData[Pos - 1]                   +                                  + ImageData[Pos + 1]+
                            ImageData[Pos + dealInfo->Width - 1] + ImageData[Pos + dealInfo->Width] + ImageData[Pos + dealInfo->Width + 1]) / 8;  

            // 如果得出的平均值小于纠正范围Extern，并且位置在图像内部有足够边距，则计算5x5邻域的平均值 
            if ( (fabs(ImageData[Pos] - Avged) < dealInfo->BlindExtern) && (PosX > 1) && (PosX < (dealInfo->Width - 2)) && (PosY > 1) && (PosY < (dealInfo->Height - 2)) ) 
            {  
                int Sum = 0;  
                // 计算5x5邻域的和  
                for (int y = -2; y <= 2; y++) {  
                    for (int x = -2; x <= 2; x++) {  
                        int index = (PosY + y) * dealInfo->Width + (PosX + x);  
                        Sum += ImageData[index];  
                    }  
                }  

                //除去中间块
                Sum -= ImageData[Pos];

                // 计算5x5邻域的平均值  
                Avged = Sum / 24;  
            }  
        }
    }
    
    // 返回处理后的图像数据  
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;  
}  

/******
 * 
 *  增加盲元
 *  输入变量，画面数据，左上角坐标，选取区域的右下角坐标，处理地址
 *  视频画面
 * *****/
T_JZsdkReturnCode Kt_Irc_AddBlind(U16_t *ImageData,struct Kt_Irc_deal *dealInfo, int topLeft_X, int topLeft_Y, int bottomRight_X, int bottomRight_Y, int blindIsMax) 
{  
    // 检查红外图像数据是否为空
    if (ImageData == NULL || dealInfo == NULL) 
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
  
    // 检查两点是否重合，至少是面，不是线
    if (topLeft_X == bottomRight_X || topLeft_Y == bottomRight_Y) 
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
  
    // 计算矩形区域的大小
    int areaWidth = bottomRight_X - topLeft_X + 1;
    int areaHeight = bottomRight_Y - topLeft_Y + 1;

    // 分配内存以存储矩形区域的数据
    U16_t *area = (U16_t *)malloc(areaWidth * areaHeight * sizeof(U16_t));
    if (area == NULL) 
    { 
        // 内存分配失败处理
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
  
    // 从画面数据中提取矩形区域的数据
    for (int y = 0; y < areaHeight; y++) 
    {
        memcpy(area + y * areaWidth, ImageData + (topLeft_Y + y) * dealInfo->Width + topLeft_X, areaWidth * sizeof(U16_t));
    }

    // 初始化盲元点的位置和灰度值
    // 更新盲元点数组
    int *newBlindPoints = (int *)realloc(dealInfo->Blind, (dealInfo->BlindNum + 1) * sizeof(int) * 2);
    if (newBlindPoints != NULL) 
    {  
        dealInfo->Blind = newBlindPoints;  
    } else {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    dealInfo->Blind[dealInfo->BlindNum*2] = 0; //x坐标
    dealInfo->Blind[dealInfo->BlindNum*2+1] = 0; //y坐标
    
    // 遍历矩形区域找到最大或最小灰度值的点
    int blindGray = area[0]; //比较用的基准灰度值
    for (int i = 0; i < areaWidth * areaHeight; i++) 
    {
        int gray = area[i];
        if ((gray > blindGray && blindIsMax) || (gray < blindGray && !blindIsMax)) 
        {
            blindGray = gray;
            dealInfo->Blind[dealInfo->BlindNum*2] = i % areaWidth + topLeft_X;
            dealInfo->Blind[dealInfo->BlindNum*2+1] = i / areaWidth + topLeft_Y;
        }
    }
    dealInfo->BlindNum++; //增加一个盲元点

    // 释放矩形区域数据的内存
    free(area);
}

/******
 * 
 *  删除某个盲元
 *  输入变量，处理地址
 *  
 * *****/
T_JZsdkReturnCode Kt_Irc_RemoveBlind(struct Kt_Irc_deal *dealInfo, int BlindNumindex) 
{  
    // 检查红外图像数据是否为空
    if (dealInfo == NULL) 
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
  
    // 检查是否存在盲元
    if (dealInfo->BlindNum == 0) 
    {
        JZSDK_LOG_ERROR("无盲元，不可删除");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    // 检查删除的盲元是否处理数组内
    if (dealInfo->BlindNum < BlindNumindex || BlindNumindex < 1)
    {
        JZSDK_LOG_ERROR("删除盲元不处于盲元范围内");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
  
    // 将要删除元素之后的元素向前移动一个位置  
    for (unsigned int i = BlindNumindex; i < dealInfo->BlindNum - 1; i++) {  
        dealInfo->Blind[i * 2] = dealInfo->Blind[(i + 1) * 2];  
        dealInfo->Blind[i * 2 + 1] = dealInfo->Blind[(i + 1) * 2 + 1];  
    }  
  
    // 减少盲元数量  
    dealInfo->BlindNum--;  
  
    // 如果需要，重新分配内存以缩小数组大小（注意：这可能会导致性能下降，因为频繁的内存分配/释放）  
    // 如果不重新分配，那么Blind数组将包含一些未使用的空间  
    if (dealInfo->BlindNum > 0) 
    {  
        // 重新分配内存  
        unsigned int newSize = dealInfo->BlindNum * 2 * sizeof(unsigned int);  
        unsigned int *newBlind = (unsigned int *)realloc(dealInfo->Blind, newSize);  
        if (newBlind != NULL) 
        {  
            dealInfo->Blind = newBlind;  
        } else {  
            // realloc失败，处理错误（例如，可能不需要处理，因为原始内存仍然有效）  
            return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
        }  
    } 
    else 
    {  
        // 如果没有盲元了，完全释放内存  
        free(dealInfo->Blind);  
        dealInfo->Blind = NULL;  
    }  

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/******
 * 
 *  删除所有盲元
 *  输入变量，处理地址
 *  
 * *****/
T_JZsdkReturnCode Kt_Irc_RemoveALLBlind(struct Kt_Irc_deal *dealInfo) 
{  
    // 释放盲元数组占用的内存  
    if (dealInfo->Blind != NULL) 
    {  
        free(dealInfo->Blind);  
    }  
  
    // 重置相关变量  
    dealInfo->Blind = NULL;  
    dealInfo->BlindNum = 0;  
}

/******
 * 
 *  增加屏蔽或标色区域  
 *  输入变量，处理地址
 *  
 * *****/
static T_JZsdkReturnCode Kt_Irc_AddShielding_or_ColorCoded_Areas(U16_t *ImageData,struct Kt_Irc_deal *dealInfo, int topLeft_X, int topLeft_Y, int bottomRight_X, int bottomRight_Y, int IsEnable) 
{  
    // 计算区域内的像素数  
    int AreaPixelNum = abs((bottomRight_X - topLeft_X) * (bottomRight_Y - topLeft_Y));  
      
    // 遍历区域内的每个像素并进行处理  
    for (int y = topLeft_Y; y < bottomRight_Y; y++) 
    {  
        for (int x = topLeft_X; x < bottomRight_X; x++) 
        {  
            int index = y * dealInfo->Width + x; // 计算一维数组中的索引  
              
            if (IsEnable) 
            {  
                // 如果是标色（IsEnable为true），将像素值从1改为0  
                dealInfo->DGCE_Area[index] = 0;   
            } 
            else 
            {  
                // 如果是屏蔽（IsEnable为false），将像素值从0改为1  
                dealInfo->DGCE_Area[index] = 1;   
            }  
        }  
    }  
}

/******
 * 
 *  低温循环标定
 *  手动划定区域屏蔽
 *  
 * *****/
static T_JZsdkReturnCode Kt_Irc_LowT_CycleCalibration(U16_t *ImageData,struct Kt_Irc_deal *dealInfo) 
{
    if (ImageData == NULL || dealInfo == NULL)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    //检测到开始获取标定温度，清空标定数组，并赋予第一组基准值
    if (dealInfo->LowT_flag == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_DEBUG("开始低温标定");
        memset(dealInfo->LowT_NineFrameAdd, 0, dealInfo->PixelNum);
        memcpy(dealInfo->LowT_NineFrameAdd, ImageData, dealInfo->PixelNum * sizeof(U16_t));
        dealInfo->LowT_flag++;
    }
    else if (dealInfo->LowT_flag == JZ_FLAGCODE_OFF)
    {
        //不是，你这不是都没打开吗
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else
    {
        //否则累加存储数组
        for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++)
        {
            dealInfo->LowT_NineFrameAdd[i] += ImageData[i];
        }
        dealInfo->LowT_flag++;
    }
    
    if (dealInfo->LowT_flag > 9) //已经存储了9组数据
    {
        for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++)
        {
            dealInfo->LowT_NineFrame_Avg[i] = dealInfo->LowT_NineFrameAdd[i] / 9;
        }   

        //存放到本地
        Kt_Irc_TempCalibrate_Save(1, dealInfo->LowT_NineFrame_Avg, dealInfo->PixelNum);

        dealInfo->LowT_flag = JZ_FLAGCODE_OFF; //将标志位归位

        JZSDK_LOG_DEBUG("低温数据记录完成");
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/******
 * 
 *  高温循环标定
 *  手动划定区域屏蔽
 *  
 * *****/
static T_JZsdkReturnCode Kt_Irc_HighT_CycleCalibration(U16_t *ImageData, struct Kt_Irc_deal *dealInfo) 
{
    if (ImageData == NULL || dealInfo == NULL)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    //检测到开始获取标定温度，清空标定数组，并赋予第一组基准值
    if (dealInfo->HighT_flag == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_DEBUG("开始高温标定");
        memset(dealInfo->HighT_NineFrameAdd, 0, dealInfo->PixelNum);
        memcpy(dealInfo->HighT_NineFrameAdd, ImageData, dealInfo->PixelNum * sizeof(U16_t));
        dealInfo->HighT_flag++;
    }
    else if (dealInfo->HighT_flag == JZ_FLAGCODE_OFF)
    {
        //不是，你这不是都没打开吗
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else
    {
        //否则累加存储数组
        for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++)
        {
            dealInfo->HighT_NineFrameAdd[i] += ImageData[i];
        }
        dealInfo->HighT_flag++;
    }
    
    if (dealInfo->HighT_flag > 9) //已经存储了9组数据
    {
        for (int i = 0; i < (dealInfo->Width * dealInfo->Height); i++)
        {
            dealInfo->HighT_NineFrame_Avg[i] = dealInfo->HighT_NineFrameAdd[i] / 9;
        }   

        Kt_Irc_TempCalibrate_Save(0, dealInfo->HighT_NineFrame_Avg, dealInfo->PixelNum);

        dealInfo->HighT_flag = JZ_FLAGCODE_OFF; //将标志位归位

        JZSDK_LOG_DEBUG("高温数据记录完成");
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/******
 * 
 *  两点矫正
 *  
 *  
 * *****/
T_JZsdkReturnCode Kt_Irc_TPC(U16_t *ImageData,struct Kt_Irc_deal *dealInfo) 
{
    //无图像
    if (ImageData == NULL || dealInfo == NULL) 
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    } 
  
    // 如果tpc的斜率和tpc的截距都为0，重新计算斜率与斜距
    int allZeroSlope_flag = 1, allZeroDiff_flag = 1;  
    for (int i = 0; i < dealInfo->PixelNum; i++) 
    {  
        if (dealInfo->TPC_Slope[i] != 0) 
        {  
            allZeroSlope_flag = 0;  
        }  
        if (dealInfo->TPC_Diff[i] != 0) {  
            allZeroDiff_flag = 0;  
        }  
    }  
  
    //如果出现tpc的斜率和tpc的截距都为0，重新计算斜率与斜距
    if (allZeroSlope_flag && allZeroDiff_flag) 
    {  
        double AvgSingleFrame_LowT = 0, AvgSingleFrame_HighT = 0;  

        for (int i = 0; i < dealInfo->PixelNum; i++) 
        {  
            AvgSingleFrame_LowT += dealInfo->LowT_NineFrame_Avg[i];  
            AvgSingleFrame_HighT += dealInfo->HighT_NineFrame_Avg[i];  
        }  

        AvgSingleFrame_LowT = AvgSingleFrame_LowT / dealInfo->PixelNum;  
        AvgSingleFrame_HighT = AvgSingleFrame_HighT / dealInfo->PixelNum;  
  
        for (int i = 0; i < dealInfo->PixelNum; i++) 
        {  
            if (dealInfo->HighT_NineFrame_Avg[i] > dealInfo->LowT_NineFrame_Avg[i]) 
            {  
                dealInfo->TPC_Slope[i] = (AvgSingleFrame_HighT - AvgSingleFrame_LowT) / (dealInfo->HighT_NineFrame_Avg[i] - dealInfo->LowT_NineFrame_Avg[i]);  
            } 
            else 
            {  
                dealInfo->TPC_Slope[i] = 0;  
            }  
            dealInfo->TPC_Diff[i] = AvgSingleFrame_LowT - dealInfo->TPC_Slope[i] * dealInfo->LowT_NineFrame_Avg[i];  
        }  
    }  
  
    // 应用两点校正公式  
    for (int i = 0; i < dealInfo->PixelNum; i++) 
    {  
        ImageData[i] = (int)(dealInfo->TPC_Slope[i] * ImageData[i] + dealInfo->TPC_Diff[i]);  
        if (ImageData[i] < 0) 
        {  
            ImageData[i] = 0;  
        } 
        else if (ImageData[i] > dealInfo->ExpectedMax) 
        {  
            ImageData[i] = dealInfo->ExpectedMax;  
        }  
    }  
  
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 返回校正后的灰度数组  
}


/****************
 * 
 *  单点纠正的画面获取/保存
 * 
 * ***************/
static T_JZsdkReturnCode Kt_Irc_SPC_FrameSaveOrRead(struct Kt_Irc_deal *dealInfo, int order, U16_t *MarkData)
{
    FILE  *fp = NULL;
    //order为0是获取
    if (order == 0)
    {
        fp = fopen(SPC_DATA_DIR, "rb"); 
        if (fp == NULL)
        {
            JZSDK_LOG_ERROR("spc 数据获取失败1");
            return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
        }

        // 从文件读取到数组  
        int read = fread(MarkData, sizeof(U16_t), dealInfo->PixelNum, fp);  
        if (read != dealInfo->PixelNum) { 
            if (feof(fp)) {  
                // 如果到达文件末尾且没有读取到足够的数据，可能是文件不完整  
                JZSDK_LOG_ERROR("Reached end of file before reading all data.\n");  
            } 
            else 
            { 
                JZSDK_LOG_ERROR("Failed to read data from file");  
            }
            fclose(fp);  
            JZSDK_LOG_ERROR("spc 数据获取失败2");
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }  
    }
    else if (order == 1)
    {
        // 打开文件以写入  
        fp = fopen(SPC_DATA_DIR, "wb");  
        if (fp == NULL) {  
            JZSDK_LOG_ERROR("Failed to open file for writing");  
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }  
    
        // 写入数据到文件  
        int write = fwrite(MarkData, sizeof(uint16_t), dealInfo->PixelNum, fp);
        if (write != dealInfo->PixelNum) {  
            JZSDK_LOG_ERROR("Failed to write data to file");  
            fclose(fp);  
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
        }  
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
        
    // 关闭文件  
    fclose(fp); 
    fp = NULL;
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/*************************
 * 
 *  单点纠正数值纠正
 * 
 * *************************/
static T_JZsdkReturnCode Kt_Irc_SPC_Param(struct Kt_Irc_deal *dealInfo, U16_t *MarkData)
{
    // 如果图像数据和Markdata完全相等，则计算校正参数  
    double Avg = 0.0;  
    for (int i = 0; i < dealInfo->PixelNum; i++) 
    {  
        Avg += MarkData[i]; 
    }  

    Avg /= dealInfo->PixelNum;  

    for (int i = 0; i < dealInfo->PixelNum; i++) 
    {  
        if (MarkData[i] <= 1) 
        {  
            // 处理除数为零的情况  
            // 可以设置一个默认值，比如斜率设为1（不进行斜率校正），或者设置为一个特定的错误码  
            dealInfo->SPC_Slope[i] = Avg / 1.0 ;  
            dealInfo->SPC_Diff[i] = Avg - MarkData[i];   
        } else {  
            dealInfo->SPC_Slope[i] = Avg / MarkData[i];  
            dealInfo->SPC_Diff[i] = Avg - MarkData[i];  
        }  
    }  

    JZSDK_LOG_INFO("重新计算IPC参数 Avg%f",Avg);
}

/******
 * 
 *  单点矫正
 *  
 * *****/
T_JZsdkReturnCode Kt_Irc_SPC(U16_t *ImageData,struct Kt_Irc_deal *dealInfo) 
{
    //无图像
    if (ImageData == NULL || dealInfo == NULL) 
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  

    // 应用校正参数 到图像数据
    for (int i = 0; i < dealInfo->PixelNum; i++) 
    {    
        double temp = ( ((dealInfo->SPC_Slope[i] * ImageData[i]) + (dealInfo->SPC_Diff[i] + ImageData[i])) / 2);
        if (temp <= dealInfo->ExpectedMax && temp >= 0)
        {
            ImageData[i] = (int)temp;
        }
        if (ImageData[i] < 0) 
        {  
            ImageData[i] = 0;  
        } 
        else if (ImageData[i] > dealInfo->ExpectedMax) 
        {  
            ImageData[i] = dealInfo->ExpectedMax;  
        }  
    }  

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/******
 * 
 *  动态气体色彩增强
 *  手动划定区域屏蔽
 *  Imagedata rgb过后的图像
 *  rawdata 未经过spc处理的原数据
 * *****/
T_JZsdkReturnCode Kt_Irc_DynamicGasesColorEnhance(U8_t *ImageData, U16_t *RawData, struct Kt_Irc_deal *dealInfo) 
{  

    //气体增强前，需要先经过一次spc单点矫正，然后，再vkt直方图处理 imageData 是已经处理得到的rgb图

    //无图像
    if (ImageData == NULL || dealInfo == NULL) 
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  

    // 遍历每个像素  
    for (int i = 0; i < dealInfo->PixelNum; i++) 
    {  
        int index = i * 3; // RGB值在一维数组中的索引  

        // 检查像素是否在指定区域内，并且差值在指定范围内  
        if (dealInfo->DGCE_Area[i] == 0
                && ( fabs(RawData[i] - dealInfo->DGCE_Mark_Data[i]) >= g_temp_GasValueMin )
                && (fabs(RawData[i] - dealInfo->DGCE_Mark_Data[i]) <= g_temp_GasValueMax) ) 
        {  
            // 根据标色类型设置RGB值  
            switch (dealInfo->DGCE_ColorType) {  
                case 0: // 红色  
                    ImageData[index + 0] = 255;  
                    ImageData[index + 1] = 0;  
                    ImageData[index + 2] = 0;  
                    break;  
                case 1: // 绿色  
                    ImageData[index + 0] = 0;  
                    ImageData[index + 1] = 255;  
                    ImageData[index + 2] = 0;
                case 2: // 蓝色
                    ImageData[index + 0] = 0;  
                    ImageData[index + 1] = 0;  
                    ImageData[index + 2] = 255;
                    break;
            }
        }
        
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}



/********************
 * 
 *  Kt_Irc_deal 结构体的初始化
 * 
 * 
 * ******************/
T_JZsdkReturnCode Kt_Irc_deal_Init(struct Kt_Irc_deal **index, int height, int width)
{
    T_JZsdkReturnCode ret;

    struct Kt_Irc_deal *IrcDealCfg = NULL;

    //为Kt_Irc_deal 结构体注册内存
    IrcDealCfg = (struct Kt_Irc_deal *)malloc(sizeof(struct Kt_Irc_deal));  
    if (IrcDealCfg == NULL) {  
        JZSDK_LOG_ERROR("Kt_Irc_deal 结构体的初始化内存分配失败");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }

    IrcDealCfg->ImgDataBits = 14; //图像为14位图像
    IrcDealCfg->Height = height;
    IrcDealCfg->Width  = width;
    IrcDealCfg->PixelNum = IrcDealCfg->Height * IrcDealCfg->Width;
    IrcDealCfg->ExpectedMax = (1 << IrcDealCfg->ImgDataBits) - 1;

    IrcDealCfg->DGCE_CurSubMarkedMin = 60;
    IrcDealCfg->DGCE_CurSubMarkedMax = 240; //240

    IrcDealCfg->Gain = 11;		//对比度，这里设为 11
    IrcDealCfg->LeftDrop = 5000;	//低灰度舍弃点数，这里设为 5000
    IrcDealCfg->RightDrop = 5000;	//高灰度舍弃点数，这里设为 5000

    IrcDealCfg->OutputPixelColorMode = 0;
    IrcDealCfg->First_DGCE_flag = JZ_FLAGCODE_ON;
    IrcDealCfg->SPC_flag = JZ_FLAGCODE_ON;

    IrcDealCfg->LowT_flag = JZ_FLAGCODE_OFF;
    IrcDealCfg->HighT_flag = JZ_FLAGCODE_OFF;
    IrcDealCfg->TPC_flag = JZ_FLAGCODE_OFF;

    IrcDealCfg->TPC_Diff = (double *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(double));  
    if (IrcDealCfg->TPC_Diff == NULL)
    {
        JZSDK_LOG_ERROR("TPC_Diff注册失败");
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
    
    IrcDealCfg->TPC_Slope = (double *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(double));  
    if (IrcDealCfg->TPC_Slope == NULL)
    {
        JZSDK_LOG_ERROR("TPC_Slope注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    IrcDealCfg->HighT_NineFrameAdd = (U16_t *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(U16_t));  
    if (IrcDealCfg->HighT_NineFrameAdd == NULL)
    {
        JZSDK_LOG_ERROR("HighT_NineFrameAdd注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    IrcDealCfg->LowT_NineFrameAdd = (U16_t *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(U16_t));  
    if (IrcDealCfg->LowT_NineFrameAdd == NULL)
    {
        JZSDK_LOG_ERROR("LowT_NineFrameAdd注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg->HighT_NineFrameAdd);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
    
    IrcDealCfg->HighT_NineFrame_Avg = (U16_t *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(U16_t));  
    if (IrcDealCfg->HighT_NineFrame_Avg == NULL)
    {
        JZSDK_LOG_ERROR("HighT_NineFrame_Avg注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg->HighT_NineFrameAdd);
        free(IrcDealCfg->LowT_NineFrameAdd);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
    
    IrcDealCfg->LowT_NineFrame_Avg = (U16_t *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(U16_t));  
    if (IrcDealCfg->LowT_NineFrame_Avg == NULL)
    {
        JZSDK_LOG_ERROR("LowT_NineFrame_Avg注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg->HighT_NineFrameAdd);
        free(IrcDealCfg->LowT_NineFrameAdd);
        free(IrcDealCfg->HighT_NineFrame_Avg);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    IrcDealCfg->SPC_Diff = (double *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(double));  
    if (IrcDealCfg->SPC_Diff == NULL)
    {
        JZSDK_LOG_ERROR("SPC_Diff注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg->HighT_NineFrameAdd);
        free(IrcDealCfg->LowT_NineFrameAdd);
        free(IrcDealCfg->HighT_NineFrame_Avg);
        free(IrcDealCfg->LowT_NineFrame_Avg);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    IrcDealCfg->SPC_Slope = (double *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(double));  
    if (IrcDealCfg->SPC_Slope == NULL)
    {
        JZSDK_LOG_ERROR("SPC_Slope注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg->HighT_NineFrameAdd);
        free(IrcDealCfg->LowT_NineFrameAdd);
        free(IrcDealCfg->HighT_NineFrame_Avg);
        free(IrcDealCfg->LowT_NineFrame_Avg);
        free(IrcDealCfg->SPC_Diff);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    IrcDealCfg->DGCE_Area = (U16_t *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(U16_t));  
    if (IrcDealCfg->DGCE_Area == NULL)
    {
        JZSDK_LOG_ERROR("DGCE_Area注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg->HighT_NineFrameAdd);
        free(IrcDealCfg->LowT_NineFrameAdd);
        free(IrcDealCfg->HighT_NineFrame_Avg);
        free(IrcDealCfg->LowT_NineFrame_Avg);
        free(IrcDealCfg->SPC_Diff);
        free(IrcDealCfg->SPC_Slope);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    IrcDealCfg->DGCE_Mark_Data = (U16_t *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(U16_t));  
    if (IrcDealCfg->DGCE_Mark_Data == NULL)
    {
        JZSDK_LOG_ERROR("DGCE_Mark_Data注册失败");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg->HighT_NineFrameAdd);
        free(IrcDealCfg->LowT_NineFrameAdd);
        free(IrcDealCfg->HighT_NineFrame_Avg);
        free(IrcDealCfg->LowT_NineFrame_Avg);
        free(IrcDealCfg->SPC_Diff);
        free(IrcDealCfg->SPC_Slope);
        free(IrcDealCfg->DGCE_Area);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    IrcDealCfg->SPC_Mark_Data = (U16_t *)malloc(IrcDealCfg->Height * IrcDealCfg->Width * sizeof(U16_t));  
    if (IrcDealCfg->SPC_Mark_Data == NULL)
    {
        JZSDK_LOG_ERROR("SPC_Mark_Data");
        free(IrcDealCfg->TPC_Diff);
        free(IrcDealCfg->TPC_Slope);
        free(IrcDealCfg->HighT_NineFrameAdd);
        free(IrcDealCfg->LowT_NineFrameAdd);
        free(IrcDealCfg->HighT_NineFrame_Avg);
        free(IrcDealCfg->LowT_NineFrame_Avg);
        free(IrcDealCfg->SPC_Diff);
        free(IrcDealCfg->SPC_Slope);
        free(IrcDealCfg->DGCE_Area);
        free(IrcDealCfg->DGCE_Mark_Data);
        free(IrcDealCfg);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    //尝试往markdata中填入数据
    ret = Kt_Irc_SPC_FrameSaveOrRead(IrcDealCfg, 0, IrcDealCfg->SPC_Mark_Data);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        IrcDealCfg->FirstSPC_flag = JZ_FLAGCODE_ON;
    }
    else
    {
        JZSDK_LOG_INFO("存在本地的spc数据");

        //计算一次spc参数
        Kt_Irc_SPC_Param(IrcDealCfg, IrcDealCfg->SPC_Mark_Data);
    }

    //加载坏点与灰坏点纠正
    IrcDealCfg->BadPixel = (unsigned int *)malloc(sizeof(unsigned int) * IrcDealCfg->Width * IrcDealCfg->Height);
    IrcDealCfg->GrayPixel = (unsigned int *)malloc(sizeof(unsigned int) * IrcDealCfg->Width * IrcDealCfg->Height);
    JZsdk_RawGetBadPixel_U16(IrcDealCfg->BadPixel, &IrcDealCfg->BadPixelNum, IrcDealCfg->Height*IrcDealCfg->Width);
    JZsdk_GrayGetBadPixel_U8(IrcDealCfg->GrayPixel, &IrcDealCfg->GrayPixelNum, IrcDealCfg->Height*IrcDealCfg->Width);
    IrcDealCfg->BadPixelExtern = 1000;
    IrcDealCfg->GrayPixelExtern = 100;

    //加载高低温
    ret = Kt_Irc_TempCalibrate_Read(0, IrcDealCfg->HighT_NineFrame_Avg, IrcDealCfg->Width * IrcDealCfg->Height);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("没有高温数据");
    }
    ret = Kt_Irc_TempCalibrate_Read(1, IrcDealCfg->LowT_NineFrame_Avg, IrcDealCfg->Width * IrcDealCfg->Height);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("没有低温数据");
    }

    //加载气体阈值
    Kt_Irc_ReadAndSave_threshold(0, JZ_FLAGCODE_GET, &g_temp_GasValueMax);
    Kt_Irc_ReadAndSave_threshold(1, JZ_FLAGCODE_GET, &g_temp_GasValueMin);

    *index = IrcDealCfg;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode Kt_Irc_WriteGraphical(U8_t *rgb_data, struct Kt_Irc_deal *dealInfo)
{
    //不画
    if (g_CameraRegionBox_ClickTime == 0)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    //画十字
    if (g_CameraRegionBox_ClickTime == 1)
    {
        Stream_rgb888_WriteCross(rgb_data, 
                            dealInfo->Width, dealInfo->Height, 
                            g_CameraRegionBox_FirstPixel[0],
                            g_CameraRegionBox_FirstPixel[1],
                            255, 215, 0, 20, 20);

        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    
    //画十字
    if (g_CameraRegionBox_ClickTime == 2)
    {
        Stream_rgb888_WriteRectangle(rgb_data,
                                dealInfo->Width, dealInfo->Height,
                                g_CameraRegionBox_FirstPixel[0],
                                g_CameraRegionBox_FirstPixel[1],
                                g_CameraRegionBox_SecondPixel[0],
                                g_CameraRegionBox_SecondPixel[1], 
                                255, 215, 0, 1);

        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}

//将14位灰度图数据转换为原始码流
T_JZsdkReturnCode Kt_Irc_14bitGrayData_to_RawData(U8_t *data, int data_len, U8_t **raw_data, int *raw_data_len, struct Kt_Irc_deal *dealInfo, int rawType)
{
    T_JZsdkReturnCode ret;

    //无图像
    if (data == NULL || dealInfo == NULL) 
    {  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  

    U16_t u16_RawData[dealInfo->PixelNum];     //原始16位码流
    U16_t u16_CorrentData[dealInfo->PixelNum];
    unsigned int u16_data_len; //16位码流的数据长度

    //1、合成像素，u8转换合并成u16
    JZsdk_Merge_U8_to_U16_byReverse(data, data_len,u16_RawData, &u16_data_len);
    if (u16_data_len != dealInfo->PixelNum)
    {
        JZSDK_LOG_ERROR("像素合成失败");
    }
    
    //2、数据检查
    for (int i = 0; i < dealInfo->PixelNum; i++)
    {
        if (u16_RawData[i] > dealInfo->ExpectedMax)
        {
            u16_RawData[i] = dealInfo->ExpectedMax;
        }
    }   

    //3、如果开启了原始流坏点寻找
    if (JZsdk_RawBadPixelCheck_Flag == JZ_FLAGCODE_ON)
    {
        JZsdk_RawCheckisBadPixel_U16(u16_RawData, dealInfo->Width, dealInfo->Height, dealInfo->BadPixel, &dealInfo->BadPixelNum);
        JZsdk_RawBadPixelCheck_Flag = JZ_FLAGCODE_OFF;
    }
    //盲元纠正
    JZsdk_CutBadPixel_U16(u16_RawData, dealInfo->Width, dealInfo->Height, dealInfo->BadPixel, dealInfo->BadPixelNum,dealInfo->BadPixelExtern, 1);


/***************************************************************************
 * 
 *  图像标定记录
 * 
 * 
 * *******************************************************************/
    //3、如果开启了低温循环标定
    if (dealInfo->LowT_flag != JZ_FLAGCODE_OFF)
    {
        Kt_Irc_LowT_CycleCalibration(u16_RawData, dealInfo);
    }
    
    //4、如果开启了高温循环标定
    if (dealInfo->HighT_flag != JZ_FLAGCODE_OFF)
    {
        Kt_Irc_HighT_CycleCalibration(u16_RawData, dealInfo);
    }


    //单点校正spc如果未进行过数据的标定，则进行一次
    if (dealInfo->FirstSPC_flag == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_INFO("未进行过数据标定");
        memcpy(dealInfo->SPC_Mark_Data, u16_RawData, dealInfo->PixelNum * sizeof(U16_t));
        Kt_Irc_SPC_FrameSaveOrRead(dealInfo, 1, dealInfo->SPC_Mark_Data);
        Kt_Irc_SPC_Param(dealInfo, dealInfo->SPC_Mark_Data);
        dealInfo->FirstSPC_flag = JZ_FLAGCODE_OFF;
    }
    //如果开启spc重置标定
    if (JZsdk_SPCCheck_flag == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_INFO("SPC重置标定");
        memcpy(dealInfo->SPC_Mark_Data, u16_RawData, dealInfo->PixelNum * sizeof(U16_t));
        Kt_Irc_SPC_FrameSaveOrRead(dealInfo, 1, dealInfo->SPC_Mark_Data);
        Kt_Irc_SPC_Param(dealInfo, dealInfo->SPC_Mark_Data);
        JZsdk_SPCCheck_flag = JZ_FLAGCODE_OFF;
    }

    //标记气体增图像图像
    //如果开启气体增强时，未标记过
    if (dealInfo->OutputPixelColorMode == 2 && dealInfo->First_DGCE_flag == JZ_FLAGCODE_ON)
    {
        memcpy(dealInfo->DGCE_Mark_Data, u16_RawData, dealInfo->PixelNum * sizeof(U16_t) );
        dealInfo->First_DGCE_flag = JZ_FLAGCODE_OFF;
    }
    //如果开启气体增强重置标定
    if (JZsdk_GasEnhancementCorrect_flag == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_INFO("气体增强重置标定");
        memcpy(dealInfo->DGCE_Mark_Data, u16_RawData, dealInfo->PixelNum * sizeof(U16_t));
        JZsdk_GasEnhancementCorrect_flag = JZ_FLAGCODE_OFF;
    }

/***************************************************************************
 * 
 *  校正
 * 
 * 
 * *******************************************************************/
    //5、校正
    //先复制一份纠正用数据
    memcpy(u16_CorrentData, u16_RawData, dealInfo->PixelNum * sizeof(U16_t));


    //如果打开了两点校正
    if (dealInfo->TPC_flag == JZ_FLAGCODE_ON)
    {
        Kt_Irc_TPC(u16_CorrentData, dealInfo);
    }

    
    //如果打开了单点校正
    if (dealInfo->SPC_flag == JZ_FLAGCODE_ON)
    {
        Kt_Irc_SPC(u16_CorrentData, dealInfo);
    }

    //7、图像输出模式
    U8_t *GrayImage = NULL; //灰度图数组
    unsigned int GrayImageLen = 0; //灰度图长度
    U8_t *RgbImage = NULL; //rgb888的图像数组
    unsigned int RgbImageLen = 0; //rgb数组的长度

    switch (dealInfo->OutputPixelColorMode)
    {
        case 0: //默认输出模式
        {
            //u16转换为灰度图
            //Kt_Irc_Histogram_vKT(u16_CorrentData, &GrayImage, &GrayImageLen, dealInfo);
            JZsdk_vKT(u16_CorrentData, &GrayImage, &GrayImageLen, dealInfo);
            
            if (JZsdk_GrayBadPixelCheck_flag == JZ_FLAGCODE_ON)
            {
                JZsdk_GrayCheckisBadPixel_U8(GrayImage, dealInfo->Width, dealInfo->Height, dealInfo->GrayPixel, &dealInfo->GrayPixelNum);
                JZsdk_GrayBadPixelCheck_flag = JZ_FLAGCODE_OFF;
            }
                
            //JZsdk_CutBadPixel_U8(GrayImage, dealInfo->Width, dealInfo->Height, dealInfo->GrayPixel, dealInfo->GrayPixelNum,dealInfo->GrayPixelExtern, 1);
            
            //灰度图转rgb888
            Kt_Irc_GrayTo_RGB(GrayImage, &RgbImage, &RgbImageLen,dealInfo);
        }
        break;

        case 1: //伪彩输出模式
        {
            //u16转换为灰度图
            //Kt_Irc_Histogram_vKT(u16_CorrentData, &GrayImage, &GrayImageLen, dealInfo);
            JZsdk_vKT(u16_CorrentData, &GrayImage, &GrayImageLen, dealInfo);

            if (JZsdk_GrayBadPixelCheck_flag == JZ_FLAGCODE_ON)
            {
                JZsdk_GrayCheckisBadPixel_U8(GrayImage, dealInfo->Width, dealInfo->Height, dealInfo->GrayPixel, &dealInfo->GrayPixelNum);
                JZsdk_GrayBadPixelCheck_flag = JZ_FLAGCODE_OFF;
            }

            //JZsdk_CutBadPixel_U8(GrayImage, dealInfo->Width, dealInfo->Height, dealInfo->GrayPixel, dealInfo->GrayPixelNum,dealInfo->GrayPixelExtern, 1);

            //灰度图转伪彩rgb888
            ret = PseudoColor_Gray2Rgb(GrayImage, &RgbImage, &RgbImageLen, dealInfo->PixelNum);
            if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
            {
                Kt_Irc_GrayTo_RGB(GrayImage, &RgbImage, &RgbImageLen,dealInfo);
            }
            
        }
        break;

        case 2: //气体色彩增强输出模式
        {            
            //进行前需要自动打开单点纠正模式
            //u16转换为灰度图
            //Kt_Irc_Histogram_vKT(u16_CorrentData, &GrayImage, &GrayImageLen, dealInfo);
            JZsdk_vKT(u16_CorrentData, &GrayImage, &GrayImageLen, dealInfo); 

            // if (JZsdk_GrayBadPixelCheck_flag == JZ_FLAGCODE_ON)
            // {
            //     JZsdk_GrayCheckisBadPixel_U8(GrayImage, dealInfo->Width, dealInfo->Height, dealInfo->GrayPixel, &dealInfo->GrayPixelNum);
            //     JZsdk_GrayBadPixelCheck_flag = JZ_FLAGCODE_OFF;
            // }
            // JZsdk_CutBadPixel_U8(GrayImage, dealInfo->Width, dealInfo->Height, dealInfo->GrayPixel, dealInfo->GrayPixelNum,dealInfo->GrayPixelExtern, 1);
            
            //转为rgb
            Kt_Irc_GrayTo_RGB(GrayImage, &RgbImage, &RgbImageLen,dealInfo);

            //灰度图转气体增强rgb888
            Kt_Irc_DynamicGasesColorEnhance(RgbImage, u16_RawData, dealInfo);
        }
        break;
    
        default:
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        break;
    }

    // 在rgb图上画图形
    Kt_Irc_WriteGraphical(RgbImage, dealInfo);

/*****************
 * 
 * 
 *  如果码流类型要求为yuv420p
 * 
 * **********************/
    if (rawType == 0)
    {
        //rgb888转yuv
        U8_t *yuv_frame = (U8_t *)malloc(dealInfo->Width*dealInfo->Height*3/2 ); 
        if (yuv_frame == NULL)
        {
            printf("内存注册失败\n");
            if (GrayImage != NULL)
            {
                free(GrayImage);
                GrayImage = NULL;
            }
            if (RgbImage != NULL)
            {
                free(RgbImage);
                RgbImage = NULL;
            }
            return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
        }

        // 调用转换函数 
        Stream_rgb888_to_yuv420p(RgbImage,dealInfo->Width,dealInfo->Height,yuv_frame);
        
        // 释放临时缓冲区，保留yuv_frame  
        if (GrayImage != NULL)
        {
            free(GrayImage);
            GrayImage = NULL;
        }
        if (RgbImage != NULL)
        {
            free(RgbImage);
            RgbImage = NULL;
        }

        *raw_data = yuv_frame;
        *raw_data_len = dealInfo->Width*dealInfo->Height*3/2;
    }

/*****************
 * 
 * 
 *  如果码流类型要求为rgb888
 * 
 * **********************/
    if (rawType == 1)
    {
        // 释放临时缓冲区
        if (GrayImage != NULL)
        {
            free(GrayImage);
            GrayImage = NULL;
        }

        *raw_data = RgbImage;
        *raw_data_len = dealInfo->Width*dealInfo->Height*3;
    }
    
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


#define TEMP_CALIBRATE_SAVE_DIR "/root/TempCalibrate"
#define TEMP_CALIBRATE_HIGH_PIXEL_DIR "tempCalibrateHigh.txt"
#define TEMP_CALIBRATE_LOW_PIXEL_DIR "tempCalibrateLow.txt"

/**********************************
 * 
 *  高低温参数的标定值读取
 *  flag == 0 为高温标定
 *  flag == 1 为低温标定
 * ********************************/
static T_JZsdkReturnCode Kt_Irc_TempCalibrate_Read(int flag, U16_t *Image, unsigned int maxLen)
{
    unsigned char str[256];
    if (flag == 0)
    {
        snprintf(str, sizeof(str), "%s/%s",TEMP_CALIBRATE_SAVE_DIR, TEMP_CALIBRATE_HIGH_PIXEL_DIR);
    }
    else if (flag == 1)
    {
        snprintf(str, sizeof(str), "%s/%s",TEMP_CALIBRATE_SAVE_DIR, TEMP_CALIBRATE_LOW_PIXEL_DIR);
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
    
    JZSDK_LOG_INFO("get_to%s",str);
    FILE  *Save_fp = fopen(str, "r");
    if (Save_fp == NULL)
    {
        JZSDK_LOG_ERROR("高低温参数的标定值打开失败"); 
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    if(fread(Image, sizeof(U16_t), maxLen,Save_fp) != maxLen)
    {
        JZSDK_LOG_ERROR("高低温参数的标定值读取失败"); 
        fclose(Save_fp);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    fclose(Save_fp);
}

/**********************************
 * 
 *  高低温参数的标定值存储
 * 
 * 
 * ********************************/
static T_JZsdkReturnCode Kt_Irc_TempCalibrate_Save(int flag, U16_t *Image, unsigned int maxLen)
{
    T_JZsdkReturnCode ret;
    //2、保存
    //检查文件夹
    ret = JZsdk_check_directory_exists_posix(TEMP_CALIBRATE_SAVE_DIR); 
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {

        JZSDK_LOG_ERROR("不存在高低温参数文件夹，建立一个");
        ret = JZsdk_Osal_Mkdir(TEMP_CALIBRATE_SAVE_DIR);
        if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE)
        {
            JZSDK_LOG_ERROR("高低温参数文件夹建立失败");         
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }
    }
    
    //写入文件
    unsigned char str[256];
    if (flag == 0)
    {
        snprintf(str, sizeof(str), "%s/%s",TEMP_CALIBRATE_SAVE_DIR, TEMP_CALIBRATE_HIGH_PIXEL_DIR);
    }
    else if (flag == 1)
    {
        snprintf(str, sizeof(str), "%s/%s",TEMP_CALIBRATE_SAVE_DIR, TEMP_CALIBRATE_LOW_PIXEL_DIR);
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    JZSDK_LOG_INFO("save_to%s",str);
    FILE  *Save_fp = fopen(str, "w");
    if (Save_fp == NULL)
    {
        JZSDK_LOG_ERROR("高低温文件建立失败"); 
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    if(fwrite(Image, sizeof(U16_t), maxLen,Save_fp) != maxLen)
    {
        JZSDK_LOG_ERROR("高低温参数的标定值保存失败"); 
        fclose(Save_fp);
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }
  
    fclose(Save_fp); // 关闭文件  
  
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 返回成功代码  

}



/***********************
 * 
 *  气体阈值
 *  flag 0指高阈值 1低阈值
 *  
 * ************************/
#define HIGH_THRESHOLD_DIR "/root/highThreshold.txt"
#define LOW_THRESHOLD_DIR "/root/lowThreshold.txt"

static T_JZsdkReturnCode Kt_Irc_ReadAndSave_threshold(int flag, int order,unsigned int *num)
{
    //写入文件	
    FILE *fp = NULL;

    if (flag == 0)
    {
        if (order == JZ_FLAGCODE_SET)
        {      
            fp = fopen(HIGH_THRESHOLD_DIR, "wb+");
            if (fp == NULL) {  
                JZSDK_LOG_ERROR("Failed to open highThreshold file for writing.\r\n");  
                return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 替换为合适的错误码  
            }  
            
            int ret = fwrite((unsigned int *)num, sizeof(unsigned int), 1,fp);
            if (ret != sizeof(unsigned int)) 
            {
                JZSDK_LOG_ERROR("Write highThreshold error.\r\n");
            }
            else{
                JZSDK_LOG_INFO("Write highThreshold=%d\n",*num);
            }

            fclose(fp);
        }
        else if (order == JZ_FLAGCODE_GET)
        {
            *num = g_temp_GasValueMax;
            fp = fopen(HIGH_THRESHOLD_DIR, "rb+");
            if (fp == NULL) 
            {
                fp = fopen(HIGH_THRESHOLD_DIR, "wb+");
                if (fp == NULL) 
                {
                    JZSDK_LOG_ERROR("threshold创建失败");
                    JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
                }
                *num = g_temp_GasValueMax;
            } 
            else 
            {
                int ret = fseek(fp, 0, SEEK_SET);
                if (ret != 0) {
                    printf("Seek log count file error, ret: %d.\r\n", ret);
                }

                ret = fread((unsigned int *)num, sizeof(unsigned int), 1,fp);
                if (ret != 1) 
                {
                    printf("Read highThreshold error.\r\n");
                }
                else{
                    printf("Read highThreshold=%d\n",*num);
                }
            }
            fclose(fp);    
        }
    }
    else if (flag == 1)
    {
        if (order == JZ_FLAGCODE_SET)
        {      
            fp = fopen(LOW_THRESHOLD_DIR, "wb+");
            if (fp == NULL) {  
                JZSDK_LOG_ERROR("Failed to open lowThreshold file for writing.\r\n");  
                return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE; // 替换为合适的错误码  
            }  
            
            int ret = fwrite((unsigned int *)num, sizeof(unsigned int), 1,fp);
            if (ret != sizeof(unsigned int)) 
            {
                JZSDK_LOG_ERROR("Write lowThreshold error.\r\n");
            }
            else{
                JZSDK_LOG_INFO("Write lowThreshold=%d\n",*num);
            }

            fclose(fp);
        }
        else if (order == JZ_FLAGCODE_GET)
        {
            *num = g_temp_GasValueMin;
            fp = fopen(LOW_THRESHOLD_DIR, "rb+");
            if (fp == NULL) 
            {
                fp = fopen(LOW_THRESHOLD_DIR, "wb+");
                if (fp == NULL) 
                {
                    JZSDK_LOG_ERROR("threshold创建失败");
                    JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
                }
                *num = g_temp_GasValueMin;
            } 
            else 
            {
                int ret = fseek(fp, 0, SEEK_SET);
                if (ret != 0) {
                    printf("Seek log count file error, ret: %d.\r\n", ret);
                }

                ret = fread((unsigned int *)num, sizeof(unsigned int), 1, fp);
                if (ret != 1) 
                {
                    printf("Read lowThreshold error.\r\n");
                }
                else{
                    printf("Read lowThreshold=%d\n",*num);
                }
            }
            fclose(fp);    
        }
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/***********************
 * 
 *  气体阈值
 *  flag 0指高阈值 1低阈值
 *  
 * ************************/
T_JZsdkReturnCode Set_GasThreshold(int flag, int num)
{
    int temp = 0;
    if (flag == 0)
    {
        temp = g_temp_GasValueMax + num;
        if (temp <= 0)
        {
            temp = 0;
        }
        g_temp_GasValueMax = temp;
        Kt_Irc_ReadAndSave_threshold(flag, JZ_FLAGCODE_SET, &temp);
    }
    else if (flag == 1)
    {
        temp = g_temp_GasValueMin + num;
        if (temp <= 0)
        {
            temp = 0;
        }
        g_temp_GasValueMin = temp;
        Kt_Irc_ReadAndSave_threshold(flag, JZ_FLAGCODE_SET, &temp);
    }
    
}