IRC_funtion.c 44.1 KB

原文件审查历史永久链接

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "JZsdkLib.h"

#include "./KtLibProc/KtLibProc.h"
#include "./IRC_data_deal/IRC_data_deal.h"
#include "./IRC_Param.h"
#include "../MultProc/MultProc.h"
#include "../ImageProc/BadPixelProc/BadPixelProc.h"

#include "MediaProc/MediaProc_Param.h"
#include "./IRC_funtion.h"
#include "MediaProc/IRC_funtion/JZIRC_LibProc/JZIRC_Lib.h"

#define IRC_DEALMODE_JZSDK 0
#define IRC_DEALMODE_KTLIB 1

int g_temp_GasValueMax = 160;
int g_temp_GasValueMin = 30;

struct IRC_param *g_IRC_Param = NULL;
static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, int width, int frameRate);
static int lastSPCMode = -1; //0低温数据 1手动打档 2自动打档
static int lastTPCMode = -1;

static FILE *temp_fp = NULL;

/*

功能：初始化IRC参数
参数：无
返回值：T_JZsdkReturnCode
备注：

*/
T_JZsdkReturnCode IRC_ParamInit(int height, int width, int frameRate)
{
    T_JZsdkReturnCode ret;

    ret = IRC_param_Init(&g_IRC_Param, height, width, frameRate);

    if (g_IRC_Param->DealWay == IRC_DEALMODE_KTLIB)
    {
        KtLib_Init(g_IRC_Param);
    }

    temp_fp = fopen("IRC_temp.raw", "w");
    if (temp_fp == NULL)
    {
        JZSDK_LOG_ERROR("IRC_temp.raw文件打开失败");
    }

    return ret;
}


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

    功能：IRC 预处理
    参数：
    返回值：T_JZsdkReturnCode
    备注：

 * *************/
static T_JZsdkReturnCode IRC_data_PreliminaryDeal(U16_t *rawData ,unsigned int *rawSize, struct IRC_param *dealInfo)
{
    T_JZsdkReturnCode ret;

    //无图像
    if (rawData == NULL || dealInfo == NULL)
    {
        JZSDK_LOG_ERROR("irc数据预处理失败，参数错误");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    //数据检查
    for (int i = 0; i < *rawSize; i++)
    {
        if (rawData[i] > dealInfo->ExpectedMax)
        {
            rawData[i] = dealInfo->ExpectedMax;
        }
    }

/*************************************手动盲点部分******************************************************************/

    //手动盲点处理
    if (dealInfo->BlindNum > 0)
    {
        JZsdk_CutBadPixel_U16(rawData, dealInfo->Width, dealInfo->Height, dealInfo->Blind, dealInfo->BlindNum,dealInfo->BadPixelExtern, 1);
    }

/*************************************自动盲点部分******************************************************************/
    //如果自动盲点纠正已打开
    if (dealInfo->AutoBadPixelReset == JZ_FLAGCODE_ON)
    {
        //检查自动盲点的位置
        JZsdk_RawCheckisBadPixel_U16(rawData, dealInfo->Width, dealInfo->Height, dealInfo->BadPixel, &dealInfo->BadPixelNum);

        //关闭自动盲点校正
        dealInfo->AutoBadPixelReset = JZ_FLAGCODE_OFF;
    }

    //如果自动盲点校正已打开
    if (dealInfo->AutoBadPixel_flag == JZ_FLAGCODE_ON)
    {
        //对数据进行自动盲点校正
        JZsdk_CutBadPixel_U16(rawData, dealInfo->Width, dealInfo->Height, dealInfo->BadPixel, dealInfo->BadPixelNum,dealInfo->BadPixelExtern, 1);
    }

    // //盲点过后进行数据复查
    // for (int i = 0; i < *rawSize; i++)
    // {
    //     if (rawData[i] > dealInfo->ExpectedMax)
    //     {
    //         rawData[i] = dealInfo->ExpectedMax;
    //     }
    // }

/*************************************两点纠正部分******************************************************************/

    //判断两点的数据模式是否有改变
    //注：该判断默认拥有出厂的数据
    if (dealInfo->TPC_mode != dealInfo->TPC_LastTPCMode)
    {
        /********读取高温数据**********************************************************/
        switch (dealInfo->TPC_mode)
        {
            //读取出厂的高温数据
            case 0:
                ret = IRC_LocalFrame_DataRead(FACTORY_HIGH_TEMP, dealInfo);
            break;

            //读取手动数据1
            case 1:
                ret = IRC_LocalFrame_DataRead(LOCAL_HIGH_TEMP_1, dealInfo);
            break;

            //读取手动数据2
            case 2:
                ret = IRC_LocalFrame_DataRead(LOCAL_HIGH_TEMP_2, dealInfo);
            break;

            //读取手动数据3
            case 3:
                ret = IRC_LocalFrame_DataRead(LOCAL_HIGH_TEMP_3, dealInfo);
            break;

            //读取手动数据4
            case 4:
                ret = IRC_LocalFrame_DataRead(LOCAL_HIGH_TEMP_4, dealInfo);
            break;

            //其余读取出厂数据
            default:
                ret = IRC_LocalFrame_DataRead(FACTORY_HIGH_TEMP, dealInfo);
            break;
        }

        //如果读取数据失败，则当场开启录入标志位
        if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
        {
            JZSDK_LOG_ERROR("数据读取失败");

            //先填入出厂数据
            IRC_LocalFrame_DataRead(FACTORY_HIGH_TEMP, dealInfo);

            //且开启数据录入标志位
            dealInfo->HighT_flag = JZ_FLAGCODE_ON;
        }

        /********读取低温数据**********************************************************/
        switch (dealInfo->TPC_mode)
        {
            //读取出厂的低温数据
            case 0:
                ret = IRC_LocalFrame_DataRead(FACTORY_LOW_TEMP, dealInfo);
                break;

            //读取手动数据1
            case 1:
                ret = IRC_LocalFrame_DataRead(LOCAL_LOW_TEMP_1, dealInfo);
                break;

            //读取手动数据2
            case 2:
                ret = IRC_LocalFrame_DataRead(LOCAL_LOW_TEMP_2, dealInfo);
                break;

            //读取手动数据3
            case 3:
                ret = IRC_LocalFrame_DataRead(LOCAL_LOW_TEMP_3, dealInfo);
                break;

            //读取手动数据4
            case 4:
                ret = IRC_LocalFrame_DataRead(LOCAL_LOW_TEMP_4, dealInfo);
                break;

            //其余读取出厂数据
            default:
                ret = IRC_LocalFrame_DataRead(FACTORY_LOW_TEMP, dealInfo);
                break;
        }

        //如果读取数据失败，则当场开启录入标志位
        if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
        {
            JZSDK_LOG_ERROR("数据读取失败");

            //先填入出厂数据
            IRC_LocalFrame_DataRead(FACTORY_LOW_TEMP, dealInfo);

            //且开启数据录入标志位
            dealInfo->LowT_flag = JZ_FLAGCODE_ON;
        }


        //***********重新计算两点校正的斜率**************************************/

        //如果开启开启的昆腾库，则载入昆腾数据
        if (g_IRC_Param->DealWay == IRC_DEALMODE_KTLIB)
        {
            KtLib_writeMarkData(HIGH_TEMP_DATA ,dealInfo->HighT_NineFrame_Avg, dealInfo->PixelNum);
            KtLib_writeMarkData(LOW_TEMP_DATA ,dealInfo->LowT_NineFrame_Avg, dealInfo->PixelNum);
        }
        else
        {
            //使用本地库计算斜率
            JZIrcLib_TPC_Slope_Calculation2(dealInfo);
        }

    }

    //如果开启了低温循环标定，计算低温循环数据
    if (dealInfo->LowT_flag != JZ_FLAGCODE_OFF)
    {
        //将数据写入缓冲区
        IRC_LowT_CycleCalibration(rawData, dealInfo);

        //数据重新缓存完毕，将缓存保存到本地
        if (dealInfo->LowT_flag == JZ_FLAGCODE_OFF)
        {

            switch (dealInfo->TPC_mode)
            {
                //写入出厂的低温数据
                case 0:
                    JZSDK_LOG_DEBUG("无法覆盖出厂的低温数据");
                break;

                //写入手动数据1
                case 1:
                    IRC_LocalFrame_DataWrite(LOCAL_LOW_TEMP_1,dealInfo, dealInfo->LowT_NineFrame_Avg, dealInfo->PixelNum);
                break;

                //写入手动数据2
                case 2:
                    IRC_LocalFrame_DataWrite(LOCAL_LOW_TEMP_2,dealInfo, dealInfo->LowT_NineFrame_Avg, dealInfo->PixelNum);
                break;

                //写入手动数据3
                case 3:
                    IRC_LocalFrame_DataWrite(LOCAL_LOW_TEMP_3,dealInfo, dealInfo->LowT_NineFrame_Avg, dealInfo->PixelNum);
                break;

                //写入手动数据4
                case 4:
                    IRC_LocalFrame_DataWrite(LOCAL_LOW_TEMP_4,dealInfo, dealInfo->LowT_NineFrame_Avg, dealInfo->PixelNum);
                break;

                default:
                    JZSDK_LOG_DEBUG("无法覆盖出厂的低温数据");
                break;
            }
        }

        //***********重新计算两点校正的斜率**************************************/
        //如果开启开启的昆腾库，则载入昆腾数据
        if (g_IRC_Param->DealWay == IRC_DEALMODE_KTLIB)
        {
            KtLib_writeMarkData(LOW_TEMP_DATA ,dealInfo->LowT_NineFrame_Avg, dealInfo->PixelNum);
        }
        else
        {
            //使用本地库计算斜率
            JZIrcLib_TPC_Slope_Calculation2(dealInfo);
        }
    }

    //如果开启了高温循环标定,计算高温循环数据
    if (dealInfo->HighT_flag != JZ_FLAGCODE_OFF)
    {
        //将数据写入缓冲区
        IRC_HighT_CycleCalibration(rawData, dealInfo);

        //数据重新缓存完毕，将缓存保存到本地
        if (dealInfo->HighT_flag == JZ_FLAGCODE_OFF)
        {
            switch (dealInfo->TPC_mode)
            {
                //写入出厂的高温数据
                case 0:
                    JZSDK_LOG_DEBUG("无法覆盖出厂的高温数据");
                break;

                //写入手动数据1
                case 1:
                    IRC_LocalFrame_DataWrite(LOCAL_HIGH_TEMP_1,dealInfo, dealInfo->HighT_NineFrame_Avg, dealInfo->PixelNum);
                break;

                //写入手动数据2
                case 2:
                    IRC_LocalFrame_DataWrite(LOCAL_HIGH_TEMP_2,dealInfo, dealInfo->HighT_NineFrame_Avg, dealInfo->PixelNum);
                break;

                //写入手动数据3
                case 3:
                    IRC_LocalFrame_DataWrite(LOCAL_HIGH_TEMP_3,dealInfo, dealInfo->HighT_NineFrame_Avg, dealInfo->PixelNum);
                break;

                //写入手动数据4
                case 4:
                    IRC_LocalFrame_DataWrite(LOCAL_HIGH_TEMP_4,dealInfo, dealInfo->HighT_NineFrame_Avg, dealInfo->PixelNum);
                break;

                default:
                    JZSDK_LOG_DEBUG("无法覆盖出厂的高温数据");
                break;
            }
        }

        //***********重新计算两点校正的斜率**************************************/
        //如果开启开启的昆腾库，则载入昆腾数据
        if (g_IRC_Param->DealWay == IRC_DEALMODE_KTLIB)
        {
            KtLib_writeMarkData(HIGH_TEMP_DATA ,dealInfo->HighT_NineFrame_Avg, dealInfo->PixelNum);
        }
        else
        {
            //使用本地库计算斜率
            JZIrcLib_TPC_Slope_Calculation2(dealInfo);
        }
    }

    //两点校正模式
    dealInfo->TPC_LastTPCMode = dealInfo->TPC_mode;

/*************************************单点纠正部分******************************************************************/
    //单点校正spc如果未进行过数据的标定，则进行一次
    if (dealInfo->FirstSPC_flag == JZ_FLAGCODE_OFF)
    {
        JZSDK_LOG_INFO("未进行过数据标定");
        dealInfo->SPC_ResetFlag = JZ_FLAGCODE_ON;
        dealInfo->FirstSPC_flag = JZ_FLAGCODE_ON;
    }

    //判断单点下石佛切换过单点模式（切换低温数据 或 手动打挡），如果切换过，鲲腾要重新注入spc数据
    if ( (dealInfo->SPC_mode == 0 && lastSPCMode != 0 ) || (dealInfo->SPC_mode == 1 && lastSPCMode != 1))
    {
#ifdef KTIRC_LIB_STATUS_ON
        if (dealInfo->SPC_mode == 0)
        {
            KtLib_writeMarkData(SPC_MARK_DATA, dealInfo->LowT_NineFrame_Avg ,dealInfo->PixelNum);
        }

        if (dealInfo->SPC_mode == 1)
        {
            //此时spc数据应该是换过的
            KtLib_writeMarkData(SPC_MARK_DATA, dealInfo->SPC_Mark_Data ,dealInfo->PixelNum);
        }
#endif
    }

    lastSPCMode = dealInfo->SPC_mode;

    //判断单点模式 选择了低温数据的情况下，是否切换过低温数据组
    if (dealInfo->SPC_mode == 0)
    {
        if (lastTPCMode != dealInfo->TPC_mode)
        {
            KtLib_writeMarkData(SPC_MARK_DATA, dealInfo->LowT_NineFrame_Avg ,dealInfo->PixelNum);
            lastTPCMode = dealInfo->TPC_mode;
        }
    }

    //如果处于自动打档模式
    if (dealInfo->SPC_mode == 2)
    {
        dealInfo->SPC_auto_time_flag++;

        //计算经过时间 以ms为单位
        int base = 1000/dealInfo->frameRate; //时间基数
        int time = dealInfo->SPC_auto_time_flag * base; //经过时间

        //如果经过时间大于设定时间，则进行一次spc标定
        if (time >= dealInfo->SPC_auto_time)
        {
            JZSDK_LOG_DEBUG("自动打档模式,进行一次spc标定");
            dealInfo->SPC_ResetFlag = JZ_FLAGCODE_ON;
            dealInfo->SPC_auto_time_flag = 0;
        }
    }

    //如果开了spc重置标定
    if (dealInfo->SPC_ResetFlag == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_INFO("SPC重置标定");

        memcpy(dealInfo->SPC_Mark_Data, rawData, dealInfo->PixelNum * sizeof(U16_t));

        //保存spc标定点
        IRC_LocalFrame_DataWrite(SPC_MARK_DATA, dealInfo, (U16_t *)dealInfo->SPC_Mark_Data, dealInfo->PixelNum);

        //如果开启开启的昆腾库，则载入昆腾数据
        if (g_IRC_Param->DealWay == IRC_DEALMODE_KTLIB && dealInfo->SPC_mode == 1)
        {
#ifdef KTIRC_LIB_STATUS_ON
            KtLib_writeMarkData(SPC_MARK_DATA ,dealInfo->SPC_Mark_Data, dealInfo->PixelNum);
#endif
        }

        dealInfo->SPC_ResetFlag = JZ_FLAGCODE_OFF;
    }

/*************************************气体增强部分，标记气体增图像图像******************************************************************/

    //如果开启气体增强时，未标记过气体画面，则标记
    if (dealInfo->OutputPixelColorMode == 2 && dealInfo->First_DGCE_flag == JZ_FLAGCODE_OFF)
    {
        JZSDK_LOG_INFO("未标记过气体画面");
        dealInfo->First_DGCE_flag = JZ_FLAGCODE_ON;
        dealInfo->DGCE_ResetFlag = JZ_FLAGCODE_ON;
    }

    //如果开启气体增强重置标定
    if (dealInfo->DGCE_ResetFlag == JZ_FLAGCODE_ON)
    {
        JZSDK_LOG_INFO("气体增强重置标定");
        memcpy(dealInfo->DGCE_Mark_Data, rawData, dealInfo->PixelNum * sizeof(U16_t));
        dealInfo->DGCE_ResetFlag = JZ_FLAGCODE_OFF;
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

unsigned int Get_2DImage_PointToArray(int x, int y, int width, int height)
{
    return (x + y*width);
}


/*
功能：IRC后处理

*/
static T_JZsdkReturnCode IRC_Postdeal(unsigned char *rgb_data, struct IRC_param *dealInfo)
{
    //将rgb图形镜像
    //水平镜像
    if (dealInfo->Filp_H == JZ_FLAGCODE_ON)
    {
        int x, y = 0;

        int bytes_per_row = dealInfo->Width * 3; // 每行的字节数
        unsigned char *temp_row = (unsigned char *)malloc(bytes_per_row); // 临时缓冲区，用于存储一行的像素数据

        if (temp_row == NULL) {
            // 内存分配失败处理
            return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
        }

        // 遍历图像的每一行
        for (y = 0; y < dealInfo->Height; y++)
        {
            // 复制当前行到临时缓冲区
            memcpy(temp_row, rgb_data + (y * bytes_per_row), bytes_per_row);

            // 从右向左（即反向）复制临时缓冲区的数据回原位置
            for (x = 0; x < dealInfo->Width; x++) {
                int source_index = (dealInfo->Width - 1 - x) * 3; // 计算源像素的索引
                int dest_index = x * 3; // 计算目标像素的索引

                // 复制RGB三个字节
                rgb_data[y * bytes_per_row + dest_index] = temp_row[source_index];
                rgb_data[y * bytes_per_row + dest_index + 1] = temp_row[source_index + 1];
                rgb_data[y * bytes_per_row + dest_index + 2] = temp_row[source_index + 2];
            }
        }

        free(temp_row); // 释放临时缓冲区
    }

    //垂直镜像
    if (dealInfo->Filp_V == JZ_FLAGCODE_ON) // 假设Filp_V是控制垂直翻转的标志
    {
        int x, y = 0;
        int bytes_per_row = dealInfo->Width * 3; // 每行的字节数，假设图像是RGB格式
        unsigned char *temp_image = (unsigned char *)malloc(dealInfo->Height * bytes_per_row); // 临时缓冲区，用于存储整个图像的像素数据

        if (temp_image == NULL) {
            // 内存分配失败处理
            return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
        }

        // 复制整个图像到临时缓冲区
        memcpy(temp_image, rgb_data, dealInfo->Height * bytes_per_row);

        // 遍历图像的每一行
        for (y = 0; y < dealInfo->Height; y++) {
            // 从临时缓冲区中复制对应行的数据回原图像，但是是从底部向上（即反向）复制
            memcpy(rgb_data + (dealInfo->Height - 1 - y) * bytes_per_row,
                temp_image + y * bytes_per_row,
                bytes_per_row);
        }

        free(temp_image); // 释放临时缓冲区
    }

    //修复外圈图像
    if (dealInfo->RingRepair == JZ_FLAGCODE_ON)
    {
        int x, y = 0;

        //修复上边
        for (x = 2; x <= dealInfo->Width - 2; x++)
        {
            int SourceIndex = Get_2DImage_PointToArray(x, 3, dealInfo->Width, dealInfo->Height) * 3;

            int FirstIndex = Get_2DImage_PointToArray(x, 0, dealInfo->Width, dealInfo->Height) * 3;
            int SecondIndex = Get_2DImage_PointToArray(x, 1, dealInfo->Width, dealInfo->Height) * 3;

            rgb_data[FirstIndex] = rgb_data[SourceIndex];
            rgb_data[FirstIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[FirstIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[SecondIndex] = rgb_data[SourceIndex];
            rgb_data[SecondIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[SecondIndex + 2] = rgb_data[SourceIndex + 2];
        }

        //修复下边
        for (x = 2; x <= dealInfo->Width - 2; x++)
        {
            int SourceIndex = Get_2DImage_PointToArray(x, dealInfo->Height - 3, dealInfo->Width, dealInfo->Height) * 3;

            int FirstIndex = Get_2DImage_PointToArray(x, dealInfo->Height - 1, dealInfo->Width, dealInfo->Height) * 3;
            int SecondIndex = Get_2DImage_PointToArray(x, dealInfo->Height - 2, dealInfo->Width, dealInfo->Height) * 3;

            rgb_data[FirstIndex] = rgb_data[SourceIndex];
            rgb_data[FirstIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[FirstIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[SecondIndex] = rgb_data[SourceIndex];
            rgb_data[SecondIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[SecondIndex + 2] = rgb_data[SourceIndex + 2];
        }

        //修复左边
        for (int y = 0; y < dealInfo->Height; y++)
        {
            int SourceIndex = Get_2DImage_PointToArray(3, y, dealInfo->Width, dealInfo->Height) * 3;

            int FirstIndex = Get_2DImage_PointToArray(0, y, dealInfo->Width, dealInfo->Height) * 3;
            int SecondIndex = Get_2DImage_PointToArray(1, y, dealInfo->Width, dealInfo->Height) * 3;
            int ThirdIndex = Get_2DImage_PointToArray(2, y, dealInfo->Width, dealInfo->Height) * 3;

            rgb_data[FirstIndex] = rgb_data[SourceIndex];
            rgb_data[FirstIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[FirstIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[SecondIndex] = rgb_data[SourceIndex];
            rgb_data[SecondIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[SecondIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[ThirdIndex] = rgb_data[SourceIndex];
            rgb_data[ThirdIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[ThirdIndex + 2] = rgb_data[SourceIndex + 2];
        }

        // 修复右边
        for (int y = 0; y < dealInfo->Height; y++)
        {
            int SourceIndex = Get_2DImage_PointToArray(dealInfo->Width - 7, y, dealInfo->Width, dealInfo->Height) * 3;

            int FirstIndex = Get_2DImage_PointToArray(dealInfo->Width - 1, y, dealInfo->Width, dealInfo->Height) * 3;
            int SecondIndex = Get_2DImage_PointToArray(dealInfo->Width - 2, y, dealInfo->Width, dealInfo->Height) * 3;
            int ThirdIndex = Get_2DImage_PointToArray(dealInfo->Width - 3, y, dealInfo->Width, dealInfo->Height) * 3;
            int FourthIndex = Get_2DImage_PointToArray(dealInfo->Width - 4, y, dealInfo->Width, dealInfo->Height) * 3;
            int FifthIndex = Get_2DImage_PointToArray(dealInfo->Width - 5, y, dealInfo->Width, dealInfo->Height) * 3;
            int SixthIndex = Get_2DImage_PointToArray(dealInfo->Width - 6, y, dealInfo->Width, dealInfo->Height) * 3;
            int SeventhIndex = Get_2DImage_PointToArray(dealInfo->Width - 7, y, dealInfo->Width, dealInfo->Height) * 3;

            rgb_data[FirstIndex] = rgb_data[SourceIndex];
            rgb_data[FirstIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[FirstIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[SecondIndex] = rgb_data[SourceIndex];
            rgb_data[SecondIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[SecondIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[ThirdIndex] = rgb_data[SourceIndex];
            rgb_data[ThirdIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[ThirdIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[FourthIndex] = rgb_data[SourceIndex];
            rgb_data[FourthIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[FourthIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[FifthIndex] = rgb_data[SourceIndex];
            rgb_data[FifthIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[FifthIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[SixthIndex] = rgb_data[SourceIndex];
            rgb_data[SixthIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[SixthIndex + 2] = rgb_data[SourceIndex + 2];

            rgb_data[SeventhIndex] = rgb_data[SourceIndex];
            rgb_data[SeventhIndex + 1] = rgb_data[SourceIndex + 1];
            rgb_data[SeventhIndex + 2] = rgb_data[SourceIndex + 2];
        }

    }


    // 在rgb图上画图形

    // //不画
    // if (dealInfo->RegionMode == 0)
    // {
    //     return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    // }

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

    //     return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    // }

    // //画十字
    // if (dealInfo->RegionMode == 2)
    // {
    //     Stream_rgb888_WriteRectangle(rgb_data,
    //                             dealInfo->Width, dealInfo->Height,
    //                             dealInfo->RegionBox[0],
    //                             dealInfo->RegionBox[1],
    //                             dealInfo->RegionBox[2],
    //                             dealInfo->RegionBox[3],
    //                             255, 215, 0, 1);

    //     return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    // }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


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

    功能：IRC 帧处理
    参数：
    返回值：T_JZsdkReturnCode
    备注：

 * *************/
T_JZsdkReturnCode IRC_FrameDeal(U16_t *rawData ,unsigned int dataSize, unsigned char **outData, unsigned int *outDataSize)
{
    //1、数据预处理(移除数据的盲点，并记录标定数据)
    IRC_data_PreliminaryDeal(rawData , &dataSize, g_IRC_Param);

    //JZSDK_LOG_DEBUG("数据预处理完成");

    // if (temp_fp != NULL)
    // {
    //     fwrite(rawData, sizeof(U16_t), dataSize, temp_fp);

    //     fflush(temp_fp);
    // }


    //2、数据前处理，将原始数据和16位数据 合成为rgb数据
    U8_t *RGB_data = NULL;
    unsigned int RGB_dataSize = 0;

    //选择前处理的方式
    switch (g_IRC_Param->DealWay)
    {
        case IRC_DEALMODE_KTLIB:
            KtLib_DataDeal(rawData, dataSize, &RGB_data, &RGB_dataSize,g_IRC_Param);
        break;

        case IRC_DEALMODE_JZSDK:
            JZIrcLib_DataDeal(rawData, dataSize, &RGB_data, &RGB_dataSize,g_IRC_Param);
        break;

        default:
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        break;
    }

    //JZSDK_LOG_DEBUG("数据抽查 1000:%d %d %d 10000:%d %d %d 20000:%d %d %d",RGB_data[1000*3],RGB_data[1000*3+1],RGB_data[1000*3+2],RGB_data[10000*3],RGB_data[10000*3+1],RGB_data[10000*3+2],RGB_data[20000*3],RGB_data[20000*3+1],RGB_data[20000*3+2]);

    //JZSDK_LOG_DEBUG("数据前处理完成");

    //3、数据后处理，在rgb数据上，进行图像处理
    IRC_Postdeal(RGB_data, g_IRC_Param);

    //JZSDK_LOG_DEBUG("数据后处理完成");

    //4、数据转换，将rgb数据，转换为yuv数据
    if (g_IRC_Param->IRC_outPixelMode == PIXEL_MODE_YUV420)
    {
        U8_t *yuv_frame = (U8_t *)malloc(g_IRC_Param->Width*g_IRC_Param->Height*3/2 *sizeof(U8_t));

        // 调用转换函数
        //Stream_rgb888_to_yuv420p(RGB_data,g_IRC_Param->Width,g_IRC_Param->Height, yuv_frame);
        Stream_rgb888_to_yuv420sp(RGB_data,g_IRC_Param->Width,g_IRC_Param->Height, yuv_frame);

        *outData = yuv_frame;
        *outDataSize = g_IRC_Param->Width*g_IRC_Param->Height*3/2;

        if (RGB_data != NULL)
        {
            JZsdk_Free((void *)RGB_data);
        }

        //printf("输出yuv\n");
    }

/*****************
 *
 *
 *  如果码流类型要求为rgb888
 *
 * **********************/
    else if (g_IRC_Param->IRC_outPixelMode == PIXEL_MODE_RGB888)
    {
        *outData = RGB_data;
        *outDataSize = g_IRC_Param->Width*g_IRC_Param->Height*3;
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/***********************************
 *
 * 红外相机的气体增强模式颜色
 *
 * ***************************************/
T_JZsdkReturnCode IRC_Set_GasEnhancementColor(int mode)
{
    if (g_IRC_Param == NULL)
    {
        JZSDK_LOG_ERROR("气体增强模式颜色出错");
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    //关闭纠正
    if (mode == IRC_GAS_ENHANCEMENT_RED)
    {
        g_IRC_Param->DGCE_ColorType = IRC_GAS_ENHANCEMENT_RED;
    }

    else if (mode == IRC_GAS_ENHANCEMENT_GREEN)
    {
        g_IRC_Param->DGCE_ColorType = IRC_GAS_ENHANCEMENT_GREEN;
    }

    else if (mode == IRC_GAS_ENHANCEMENT_BLUE)
    {
        g_IRC_Param->DGCE_ColorType = IRC_GAS_ENHANCEMENT_BLUE;
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/**********************
 *
 *  设置高低温标定
 *  0为高 1为低
 *
 * *****************************/
T_JZsdkReturnCode LowAndHigh_MarkRest(int mode)
{
    if (g_IRC_Param == NULL)
    {
        JZSDK_LOG_ERROR("高低温标定出错");
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    if (mode == 0)
    {
        JZSDK_LOG_INFO("高温标定");
        g_IRC_Param->HighT_flag = JZ_FLAGCODE_ON;
    }
    else if (mode == 1)
    {
        JZSDK_LOG_INFO("低温标定");
        g_IRC_Param->LowT_flag = JZ_FLAGCODE_ON;
    }
}


/****************************************************************************************************************************************************
 *
 *  ui功能
 *
 *
 *
 * ****************************************************************************************************************************************************/
T_JZsdkReturnCode IRC_SetRawPixel_ResetFlag()
{
    g_IRC_Param->AutoBadPixelReset = JZ_FLAGCODE_ON;
}

T_JZsdkReturnCode IRC_SetGrayPixel_ResetFlag()
{
    g_IRC_Param->AutoBadPixelReset = JZ_FLAGCODE_ON;
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode IRC_SetSPC_ResetFlag()
{
    g_IRC_Param->SPC_ResetFlag = JZ_FLAGCODE_ON;
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode IRC_SetDGCE_ResetFlag()
{
    g_IRC_Param->DGCE_ResetFlag = JZ_FLAGCODE_ON;
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/***********************************
 *
 * 红外相机的像素输出模式修改
 *
 * ***************************************/
T_JZsdkReturnCode IRC_Set_OutputPixelColorMode(int value)
{
    T_JZsdkReturnCode ret;

    if (value < 0 || value > 2)
    {
        JZSDK_LOG_ERROR("像素输出模式出错1");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    if (g_IRC_Param == NULL)
    {
        JZSDK_LOG_ERROR("像素输出模式出错2");
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    if (value == 1 || value == 0)
    {
        //切换模式后要重新设置气体增强
        g_IRC_Param->First_DGCE_flag = JZ_FLAGCODE_OFF;
    }


    g_IRC_Param->OutputPixelColorMode = value;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/***********************************
 *
 * 红外相机的纠正模式修改
 *
 * ***************************************/
T_JZsdkReturnCode IRC_Set_CorrectionMode(int mode)
{
    if (g_IRC_Param == NULL)
    {
        JZSDK_LOG_ERROR("纠正模式修改出错");
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    //关闭纠正
    if (mode == JZ_FLAGCODE_OFF)
    {
        g_IRC_Param->FrameCorrectMode = JZ_FLAGCODE_OFF;
    }

    else if (mode == IRC_CORRCTION_SPC)
    {
        g_IRC_Param->FrameCorrectMode = IRC_CORRCTION_SPC;
    }

    else if (mode == IRC_CORRCTION_TPC)
    {
        g_IRC_Param->FrameCorrectMode = IRC_CORRCTION_TPC;
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode IRC_Set_RegionBox(int PointNum, int x, int y)
{
    if (PointNum = 0)
    {
        g_IRC_Param->RegionBox[0] = x;
        g_IRC_Param->RegionBox[1] = y;
    }

    else if (PointNum = 1)
    {
        g_IRC_Param->RegionBox[2] = x;
        g_IRC_Param->RegionBox[3] = y;
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode IRC_Set_RegionMode(int mode)
{
    g_IRC_Param->RegionMode = mode;
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/***********
 *
 *  红外气体上下限调整
 *
 * ******/
T_JZsdkReturnCode IRC_Set_GasRange(int flag, int value)
{
    int temp = 0;
    if (flag == IRC_GasMax)
    {
        temp = g_temp_GasValueMax + value;
        if (temp <= 0)
        {
            temp = 0;
        }
        g_temp_GasValueMax = temp;
        IRC_ReadAndSave_DGCE_threshold(HIGH_DGCE_THRESHOLD, JZ_FLAGCODE_SET, &temp);
    }
    else if (flag == IRC_GasMin)
    {
        temp = g_temp_GasValueMin + value;
        if (temp <= 0)
        {
            temp = 0;
        }
        g_temp_GasValueMin = temp;
        IRC_ReadAndSave_DGCE_threshold(LOW_DGCE_THRESHOLD, JZ_FLAGCODE_SET, &temp);
    }
    else
    {
        JZSDK_LOG_ERROR("气体上下限调整出错");
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/********************************************
 *
 *  设置单体纠正模式
 *  0 采用tpc的低温画面进行纠正 1手动打档 2定时打档
 *
 * *****************************************/
static T_JZsdkReturnCode IRC_Set_SpcMode(int mode)
{
    if (mode == 0)
    {
        JZSDK_LOG_INFO("开启低温画面打档");
    }
    else if (mode == 1)
    {
        JZSDK_LOG_INFO("开启手动打档");
    }
    else if (mode == 2)
    {
        JZSDK_LOG_INFO("开启自动打档");
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    g_IRC_Param->SPC_mode = mode;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/********************************************
 *
 *  设置单体纠正时间间隔
 *  0 采用tpc的低温画面进行纠正 1手动打档 2定时打档
 *
 * *****************************************/
static T_JZsdkReturnCode IRC_Set_SpcTime(int timebase)
{
    int time = 0; //ms单位
    if (timebase == 0)
    {
        time = 1000;
    }
    else if (timebase == 1)
    {
        time = 2000;
    }
    else if (timebase == 2)
    {
        time = 3000;
    }

    g_IRC_Param->SPC_auto_time_tpye = timebase;
    g_IRC_Param->SPC_auto_time = time;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/********************************************
 *
 *  设置两点纠正模式
 *  0 为出厂默认的高低温纠正 1为手动高低温的数据
 *
 * *****************************************/
static T_JZsdkReturnCode IRC_Set_TpcMode(int mode)
{
    T_JZsdkReturnCode ret;

    if (mode == 0)
    {
        JZSDK_LOG_INFO("出厂高低温模式");
    }
    else if (mode == 1 || mode == 2 || mode == 3 || mode == 4)
    {
        JZSDK_LOG_INFO("手动高低温模式 %d", mode);
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    g_IRC_Param->TPC_mode = mode;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

/********************************************
 *
 *  是否开启自动坏点纠正
 *  0 关闭 1 开启
 *
 * *****************************************/
static T_JZsdkReturnCode IRC_Set_AutoBadPixelCorrect(int mode)
{
    if (mode == 0)
    {
        JZSDK_LOG_INFO("关闭自动坏点纠正");
    }
    else if (mode == 1)
    {
        JZSDK_LOG_INFO("开启自动坏点纠正");
    }
    else
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    g_IRC_Param->AutoBadPixel_flag = mode;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/*******************************
 *
 *  设置IRC参数
 *
 *
 * *****************************/
T_JZsdkReturnCode Proc_IRC_param(int flagcode, enum JZsdk_Widget_Control paramflag, int *value)
{
    T_JZsdkReturnCode ret;

    if (g_IRC_Param == NULL || value == NULL)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    if (flagcode == JZ_FLAGCODE_GET)
    {
        switch (paramflag)
        {
            case JZSDK_WIDGET_SPC_MODE:
            {
               *value = g_IRC_Param->SPC_mode;
            }
            break;

            case JZSDK_WIDGET_SPC_AUTO_TIME:
            {
                *value = g_IRC_Param->SPC_auto_time_tpye;
            }
            break;

            case JZSDK_WIDGET_TPC_MODE:
            {
                *value = g_IRC_Param->TPC_mode;
            }
            break;

            case JZSDK_WIDGET_BAD_PIXEL_CORRECT_MODE:
            {
                *value = g_IRC_Param->AutoGrayPixel_flag;
            }
            break;

            default:
            {
                *value = JZ_FLAGCODE_OFF;
            }
            break;
        }

        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }
    else if (flagcode == JZ_FLAGCODE_SET)
    {
        switch (paramflag)
        {
            case JZSDK_WIDGET_SPC_MODE:
            {
                ret = IRC_Set_SpcMode(*value);
                if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
                {
                    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
                }
            }
            break;

            case JZSDK_WIDGET_SPC_AUTO_TIME:
            {
                ret = IRC_Set_SpcTime(*value);
                if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
                {
                    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
                }
            }
            break;

            case JZSDK_WIDGET_TPC_MODE:
            {
                ret = IRC_Set_TpcMode(*value);
                if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
                {
                    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
                }
            }
            break;

            case JZSDK_WIDGET_BAD_PIXEL_CORRECT_MODE:
            {
                ret = IRC_Set_AutoBadPixelCorrect(*value);
                if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
                {
                    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
                }
            }
            break;

            default:
            {
                *value = JZ_FLAGCODE_OFF;
            }
            break;
        }

        return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
    }

    JZSDK_LOG_ERROR("参数获取出错");
    return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
}


/************************************************************************************************
 *
 *  IRC_param 结构体的初始化
 *
 *
 * ************************************************************************************************/
static T_JZsdkReturnCode IRC_param_Init(struct IRC_param **index, int height, int width, int frameRate)
{
    T_JZsdkReturnCode ret;

    struct IRC_param *IrcDealCfg = NULL;

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

    //IrcDealCfg->DealWay = IRC_DEALMODE_JZSDK;
    IrcDealCfg->DealWay = IRC_DEALMODE_KTLIB;

    //我们自己库要水平翻转
    if (IrcDealCfg->DealWay == IRC_DEALMODE_JZSDK)
    {
        IrcDealCfg->Filp_H = JZ_FLAGCODE_ON;
    }
    //鲲腾的库要垂直翻转
    else if (IrcDealCfg->DealWay == IRC_DEALMODE_KTLIB)
    {
        IrcDealCfg->Filp_V = JZ_FLAGCODE_ON;
    }
    //否则都不翻转
    else
    {
        IrcDealCfg->Filp_H = JZ_FLAGCODE_OFF;
        IrcDealCfg->Filp_V = JZ_FLAGCODE_OFF;
    }


    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->frameRate = frameRate;
    IrcDealCfg->IRC_outPixelMode = PIXEL_MODE_YUV420;
    IrcDealCfg->FrameCorrectMode = IRC_CORRCTION_SPC; //默认单点校正
    IrcDealCfg->SPC_mode = 0;
    IrcDealCfg->SPC_auto_time = 1000;//默认自动单点校正时间

    IrcDealCfg->OutputPixelColorMode = 0;

    IrcDealCfg->RingRepair = JZ_FLAGCODE_ON;

    //单点部分
    IrcDealCfg->FirstSPC_flag = JZ_FLAGCODE_OFF;
    IrcDealCfg->SPC_ResetFlag = JZ_FLAGCODE_OFF;


    IrcDealCfg->First_DGCE_flag = JZ_FLAGCODE_OFF;

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

    IrcDealCfg->TPC_Offset = (double *)malloc(IrcDealCfg->PixelNum * sizeof(double));
    if (IrcDealCfg->TPC_Offset == NULL)
    {
        JZSDK_LOG_ERROR("TPC_Offset注册失败");
    }

    IrcDealCfg->TPC_Gain = (double *)malloc(IrcDealCfg->PixelNum * sizeof(double));
    if (IrcDealCfg->TPC_Gain == NULL)
    {
        JZSDK_LOG_ERROR("TPC_Gain注册失败");
    }

    IrcDealCfg->HighT_NineFrameAdd = (int *)malloc(IrcDealCfg->PixelNum * sizeof(int));
    if (IrcDealCfg->HighT_NineFrameAdd == NULL)
    {
        JZSDK_LOG_ERROR("HighT_NineFrameAdd注册失败");
    }

    IrcDealCfg->LowT_NineFrameAdd = (int *)malloc(IrcDealCfg->PixelNum * sizeof(int));
    if (IrcDealCfg->LowT_NineFrameAdd == NULL)
    {
        JZSDK_LOG_ERROR("LowT_NineFrameAdd注册失败");
    }

    IrcDealCfg->HighT_NineFrame_Avg = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t));
    if (IrcDealCfg->HighT_NineFrame_Avg == NULL)
    {
        JZSDK_LOG_ERROR("HighT_NineFrame_Avg注册失败");
    }

    IrcDealCfg->LowT_NineFrame_Avg = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t));
    if (IrcDealCfg->LowT_NineFrame_Avg == NULL)
    {
        JZSDK_LOG_ERROR("LowT_NineFrame_Avg注册失败");
    }

    IrcDealCfg->SPC_Diff = (double *)malloc(IrcDealCfg->PixelNum * sizeof(double));
    if (IrcDealCfg->SPC_Diff == NULL)
    {
        JZSDK_LOG_ERROR("SPC_Diff注册失败");
    }

    IrcDealCfg->SPC_Slope = (double *)malloc(IrcDealCfg->PixelNum * sizeof(double));
    if (IrcDealCfg->SPC_Slope == NULL)
    {
        JZSDK_LOG_ERROR("SPC_Slope注册失败");
    }

    IrcDealCfg->DGCE_Area = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t));
    if (IrcDealCfg->DGCE_Area == NULL)
    {
        JZSDK_LOG_ERROR("DGCE_Area注册失败");
    }

    IrcDealCfg->DGCE_Mark_Data = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t));
    if (IrcDealCfg->DGCE_Mark_Data == NULL)
    {
        JZSDK_LOG_ERROR("DGCE_Mark_Data注册失败");
    }

    IrcDealCfg->SPC_Mark_Data = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t));
    if (IrcDealCfg->SPC_Mark_Data == NULL)
    {
        JZSDK_LOG_ERROR("SPC_Mark_Data注册失败");
    }

    IrcDealCfg->Factory_HighT_Mark_Data = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t));
    if (IrcDealCfg->Factory_HighT_Mark_Data == NULL)
    {
        JZSDK_LOG_ERROR("Factory_HighT_Mark_Data注册失败");
    }
    IrcDealCfg->Factory_HighT_Mark_Data_flag = JZ_FLAGCODE_OFF;

    IrcDealCfg->Factory_LowT_Mark_Data = (U16_t *)malloc(IrcDealCfg->PixelNum * sizeof(U16_t));
    if (IrcDealCfg->Factory_LowT_Mark_Data == NULL)
    {
        JZSDK_LOG_ERROR("Factory_LowT_Mark_Data注册失败");
    }
    IrcDealCfg->Factory_LowT_Mark_Data_flag = JZ_FLAGCODE_OFF;

/*******************************************************************************************
 *
 *  加载文件数据
 *
 *
**********************************************************************************************/

    //填入出厂的高温数据
    IRC_LocalFrame_DataRead(FACTORY_HIGH_TEMP, IrcDealCfg);

    //填入低温数据
    IRC_LocalFrame_DataRead(FACTORY_LOW_TEMP, IrcDealCfg);

    //计算两点系数***********重新计算两点校正的斜率**************************************/
    JZIrcLib_TPC_Slope_Calculation2(IrcDealCfg);

    //开启tpc校验标志
    IrcDealCfg->TPC_ResetFlag = JZ_FLAGCODE_ON;

    //获取markdata的本地数据
    ret = IRC_LocalFrame_DataRead(SPC_MARK_DATA, IrcDealCfg);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("没有spc数据数据");
        IrcDealCfg->FirstSPC_flag = JZ_FLAGCODE_OFF; //打开录入标志
    }
    else if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_INFO("读入spc数据数据 0:%d 1:%d 2:%d", IrcDealCfg->SPC_Mark_Data[2550], IrcDealCfg->SPC_Mark_Data[2551], IrcDealCfg->SPC_Mark_Data[2552]);
        IrcDealCfg->FirstSPC_flag = JZ_FLAGCODE_ON; //打开录入标志
    }

    //加载气体阈值
    IRC_ReadAndSave_DGCE_threshold(HIGH_DGCE_THRESHOLD, JZ_FLAGCODE_GET, &g_temp_GasValueMax);
    IRC_ReadAndSave_DGCE_threshold(LOW_DGCE_THRESHOLD, JZ_FLAGCODE_GET, &g_temp_GasValueMin);

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

    //加载手动点击的盲点（手选的坏点）
    IrcDealCfg->Blind = (unsigned int *)malloc(sizeof(unsigned int) * IrcDealCfg->PixelNum);
    ret = JZsdkBadPixelProcManualLoad(IrcDealCfg->Blind, &IrcDealCfg->BlindNum, IrcDealCfg->Width);
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {
        JZSDK_LOG_ERROR("没有手动点击的坏点");
    }

    *index = IrcDealCfg;

    JZSDK_LOG_INFO("IRC funtion Init success");

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}