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


#include "../IRC_data_deal/IRC_data_deal.h"

#include "MediaProc/IRC_funtion/IRC_param.h"
#include "MediaProc/ImageProc/PseudoColor/PseudoColor.h"

#include "MediaProc/ImageProc/BadPixelProc/BadPixelProc.h"
#include "MediaProc/MediaProc_Param.h"
#include "MediaProc/IRC_funtion/IRC_data_deal/IRC_data_deal.h"

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



// //将14位灰度图数据转换为原始码流
// T_JZsdkReturnCode IRC_14bitGrayData_to_RawData(U8_t *data, int data_len, U8_t **raw_data, int *raw_data_len, struct IRC_param *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 (dealInfo->AutoBadPixelReset == JZ_FLAGCODE_ON)
//     {
//         JZsdk_RawCheckisBadPixel_U16(u16_RawData, dealInfo->Width, dealInfo->Height, dealInfo->BadPixel, &dealInfo->BadPixelNum);
//         dealInfo->AutoBadPixelReset = 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)
//     {
//         IRC_LowT_CycleCalibration(u16_RawData, dealInfo);
//     }
    
//     //4、如果开启了高温循环标定
//     if (dealInfo->HighT_flag != JZ_FLAGCODE_OFF)
//     {
//         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));
//         IRC_SPC_FrameSaveOrRead(dealInfo, 1, dealInfo->SPC_Mark_Data);
//         IRC_SPC_ParamCorrect(dealInfo, dealInfo->SPC_Mark_Data);
//         dealInfo->FirstSPC_flag = JZ_FLAGCODE_OFF;
//     }
    
//     //如果开启spc重置标定
//     if (dealInfo->SPC_ResetFlag == JZ_FLAGCODE_ON)
//     {
//         JZSDK_LOG_INFO("SPC重置标定");
//         memcpy(dealInfo->SPC_Mark_Data, u16_RawData, dealInfo->PixelNum * sizeof(U16_t));
//         IRC_SPC_FrameSaveOrRead(dealInfo, 1, dealInfo->SPC_Mark_Data);
//         IRC_SPC_ParamCorrect(dealInfo, dealInfo->SPC_Mark_Data);
//         dealInfo->SPC_ResetFlag = 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 (dealInfo->DGCE_ResetFlag == JZ_FLAGCODE_ON)
//     {
//         JZSDK_LOG_INFO("气体增强重置标定");
//         memcpy(dealInfo->DGCE_Mark_Data, u16_RawData, dealInfo->PixelNum * sizeof(U16_t));
//         dealInfo->DGCE_ResetFlag = JZ_FLAGCODE_OFF;
//     }

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


//     //如果打开了两点校正
//     if (dealInfo->FrameCorrectMode == IRC_CORRCTION_TPC)
//     {
//         IRC_TPC(u16_CorrentData, dealInfo);
//     }

//     if (dealInfo->FrameCorrectMode == IRC_CORRCTION_SPC)
//     {
//         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转换为灰度图
//             //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
//             IRC_GrayTo_RGB(GrayImage, &RgbImage, &RgbImageLen,dealInfo);
//         }
//         break;

//         case 1: //伪彩输出模式
//         {
//             //u16转换为灰度图
//             //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)
//             {
//                 IRC_GrayTo_RGB(GrayImage, &RgbImage, &RgbImageLen,dealInfo);
//             }
            
//         }
//         break;

//         case 2: //气体色彩增强输出模式
//         {            
//             //进行前需要自动打开单点纠正模式
//             //u16转换为灰度图
//             //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
//             IRC_GrayTo_RGB(GrayImage, &RgbImage, &RgbImageLen,dealInfo);

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

//     // 在rgb图上画图形
//     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;
// }



/******
 * 
 *  单点矫正
 *  
 * *****/
static T_JZsdkReturnCode JZIrcLib_SPC(U16_t *ImageData,struct IRC_param *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;
}




T_JZsdkReturnCode JZIrcLib_DataDeal(U16_t* U16_data, unsigned int U16_dataSize, 
                                U8_t **RGB_data, unsigned int *RGB_dataSize,      
                                struct IRC_param *dealInfo)
{
    T_JZsdkReturnCode ret;

    //注册一个处理用的16位数据
    U16_t *u16_CorrentData = (U16_t *)malloc(dealInfo->PixelNum * sizeof(U16_t));
    if (u16_CorrentData == NULL)
    {
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;
    }

    //将16位数据拷贝到处理用的16位数据
    memcpy(u16_CorrentData, U16_data, dealInfo->PixelNum * sizeof(U16_t));

    //如果打开了单点纠正模式
    if (dealInfo->FrameCorrectMode == IRC_CORRCTION_SPC)
    {
        JZIrcLib_SPC(u16_CorrentData, dealInfo);
    }

    // 如果打开了两点校正
    if (dealInfo->FrameCorrectMode == IRC_CORRCTION_TPC)
    {
        
    }

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}