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

#define PIXEL_SAVE_DIR "/root/PixelSave"
#define RAW_BAD_PIXEL_DIR "RawBadPixel.txt"
#define GRAY_BAD_PIXEL_DIR "GrayBadPixel.txt"

#define FIRST_WINDOW_SIZE 3 // 第一窗口和第二窗口的大小（简化为3x3）
#define SECOND_WINDOW_SIZE 5 // 第一窗口和第二窗口的大小（简化为5x5）  

#define RAW_VARINANCE_RANK (100000.0)
#define GRAY_VARINANCE_RANK (600.0)

/***************
 * 
 *  计算方差值
 * 
 * 
 * ****************/
static T_JZsdkReturnCode JZsdk_CalulateLocalVarinance_Int(unsigned int *array, int size, double *variance)
{
    double sum = 0.0, mean = 0.0;
    *variance = 0.0;    
    for (int i = 0; i < size; ++i)   
    {    
        sum += array[i];    
    }  

    // 计算均值  
    mean = sum / (double)size;

    // 计算方差  
    for (int i = 0; i < size; ++i)   
    {    
        *variance += pow(array[i] - mean, 2);    
    } 
    *variance /= (double)(size);    

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}
static T_JZsdkReturnCode JZsdk_CalulateLocalVarinance_Char(unsigned char *array, int size, double *variance)
{
    double sum = 0.0, mean = 0.0;
    *variance = 0.0;    
    for (int i = 0; i < size; ++i)   
    {    
        sum += array[i];    
    }  

    // 计算均值  
    mean = sum / (double)size;

    // 计算方差  
    for (int i = 0; i < size; ++i)   
    {    
        *variance += pow(array[i] - mean, 2);    
    } 
    *variance /= (double)(size);    

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/***************
 * 
 *  判断是否为坏点
 *  并记录到数组中
 * ****************/  
static T_JZsdkReturnCode CheckisBadPixel_U16(U16_t* image, int width, int height, unsigned int *Blind, int *Blind_num)
{
    //3*3和5*5来获取点判断
    memset(Blind, 0, *Blind_num);
    *Blind_num = 0;
    
    //先检查足够拥有5*5范围的
    int PointX = 0;
    int PointY = 0;

    int Len = height*width;
    int BadNum = 0;

    unsigned int firstWindow[FIRST_WINDOW_SIZE*FIRST_WINDOW_SIZE];
    unsigned int secondWindow[SECOND_WINDOW_SIZE*SECOND_WINDOW_SIZE];

    for (int i = 0; i < Len; i++)
    {
        PointY = i/width;
        PointX = i%width;

        //检查边界
        if (PointX < 2 || PointX >= (width - 2) || PointY < 2 || PointY >= (height - 2))  
        {  
            // 如果当前点不在5x5窗口的有效范围内，则跳过  
            continue;  
        }    
        
        // 写入小窗口（3x3）  
        int index = 0; // firstWindow的索引  
        for (int dy = -1; dy <= 1; dy++)  
        {  
            for (int dx = -1; dx <= 1; dx++)  
            {  
                // 计算3x3窗口中当前元素的索引  
                int newY = PointY + dy;  
                int newX = PointX + dx;  
                firstWindow[index++] = image[newY * width + newX]; // 假设image是二维数组的一维表示  
            }  
        }  
        
        // 写入大窗口（5x5）  
        index = 0; // firstWindow的索引  
        for (int dy = -2; dy <= 2; dy++)  
        {  
            for (int dx = -2; dx <= 2; dx++)  
            {  
                // 计算3x3窗口中当前元素的索引  
                int newY = PointY + dy;  
                int newX = PointX + dx;  
                secondWindow[index++] = image[newY * width + newX]; // 假设image是二维数组的一维表示  
            }  
        }  

        //计算方差
        double first_variance;
        JZsdk_CalulateLocalVarinance_Int(firstWindow, FIRST_WINDOW_SIZE*FIRST_WINDOW_SIZE, &first_variance); 
        double second_variance;
        JZsdk_CalulateLocalVarinance_Int(secondWindow, SECOND_WINDOW_SIZE*SECOND_WINDOW_SIZE, &second_variance); 

        if ( (first_variance-second_variance) > RAW_VARINANCE_RANK || (first_variance-second_variance) < -RAW_VARINANCE_RANK)
        {
            //JZSDK_LOG_INFO("记录坏点(%d, %d)",PointX,PointY);
            Blind[*Blind_num] = (PointY*width + PointX);
            
            //JZSDK_LOG_INFO("记录坏点(%d, %d) len:%d",PointX,PointY,Blind[*Blind_num]);
            (*Blind_num)++;
        }
        
    }
    
    JZSDK_LOG_INFO("一共%d个坏点",*Blind_num);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}  

/***************
 * 
 *  判断是否为坏点
 *  并记录到文件中
 * ****************/  
T_JZsdkReturnCode JZsdk_RawCheckisBadPixel_U16(U16_t* image, int width, int height, unsigned int *Blind, int *Blind_num)
{
    T_JZsdkReturnCode ret;

    //1、获取错误点
    CheckisBadPixel_U16(image, width, height, Blind, Blind_num);

    //2、保存
    //检查文件夹
    ret = JZsdk_check_directory_exists_posix(PIXEL_SAVE_DIR); 
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {

        JZSDK_LOG_ERROR("不存在坏点文件夹，建立一个");
        ret = JZsdk_Osal_Mkdir(PIXEL_SAVE_DIR);
        if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE)
        {
            JZSDK_LOG_ERROR("坏点文件夹建立失败");         
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }
    }
    
    //写入文件
    unsigned char str[256];
    snprintf(str, sizeof(str), "%s/%s",PIXEL_SAVE_DIR, RAW_BAD_PIXEL_DIR);
    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;
    }

    // 假设Blind_num包含数组中元素的数量  
    for (int i = 0; i < *Blind_num; ++i) {  
        fprintf(Save_fp, "%u\n", Blind[i]); // 将每个元素写入文件，每行一个  
    }  
  
    fclose(Save_fp); // 关闭文件  
  
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 返回成功代码  

}

T_JZsdkReturnCode JZsdk_RawGetBadPixel_U16(unsigned int *Blind, int *Blind_num, int max_num)
{
    unsigned char str[256];
    snprintf(str, sizeof(str), "%s/%s",PIXEL_SAVE_DIR, RAW_BAD_PIXEL_DIR);
    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;
    }

    int count = 0;
    unsigned int temp;  
    while (fscanf(Save_fp, "%u", &temp) == 1 && count < max_num) 
    {  
        // // 动态增加数组大小  
        // blind = realloc(blind, (count + 1) * sizeof(unsigned int));  
        // if (blind == NULL) {  
        //     perror("内存分配失败");  
        //     fclose(fp);  
        //     return 1;  
        // }  
  
        Blind[count++] = temp;  
    }  

    *Blind_num = count;
    fclose(Save_fp);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}



/***************
 * 
 *  坏点纠正
 *  输入参数 图像数据 图像宽高 坏点与数量 坏点界限 纠正方式
 * ****************/  
T_JZsdkReturnCode JZsdk_CutBadPixel_U16(U16_t *image, int width, int height, unsigned int *Blind, int Blind_num, unsigned Buildextern,int order)
{
    //平均值取值法
    if (order == 0)
    {
        for (int i = 0; i < Blind_num; i++)
        {
            int PointX = 0;
            int PointY = 0;

            unsigned int newPixel = 0;

            int tempLen = Blind[i];
            PointY = tempLen/width;
            PointX = tempLen%width;
            int index=0;

            for (int dy = -1; dy <= 1; dy++)  
            {  
                for (int dx = -1; dx <= 1; dx++)  
                {  
                    // 计算3x3窗口中当前元素的索引  
                    int newY = PointY + dy;  
                    int newX = PointX + dx;  
                    newPixel += image[newY * width + newX]; // 假设image是二维数组的一维表示  
                }  
            }  
            
            int Avged = (newPixel-image[tempLen])/8;
            if ((fabs(image[tempLen] - Avged) < Buildextern))
            {
                newPixel = 0;
                for (int dy = -2; dy <= 2; dy++)  
                {  
                    for (int dx = -2; dx <= 2; dx++)  
                    {  
                        // 计算5x5窗口中当前元素的索引  
                        int newY = PointY + dy;  
                        int newX = PointX + dx;  
                        newPixel += image[newY * width + newX]; // 假设image是二维数组的一维表示  
                    }  
                }  
                Avged = (newPixel-image[tempLen])/24;
            }
            

            image[tempLen] = Avged;
            //JZSDK_LOG_INFO("切除位置(%d,%d) %d",PointX,PointY,Blind[Blind_num]);
        }
    }
    //二分取值法
    if (order == 1)
    {
        for (int i = Blind_num-1; i  >= 0; i--)
        {
            int PointX = 0;
            int PointY = 0;

            unsigned int newPixel = 0;

            //把盲点长度坐标转化为xy坐标
            int tempLen = Blind[i];
            PointY = tempLen/width;
            PointX = tempLen%width;

            int index=0; //索引值
            int Avged=0; //平均值

            int tempPixel[25];

            for (int dy = -2; dy <= 2; dy++)  
            {  
                for (int dx = -2; dx <= 2; dx++)  
                {  
                    
                    // 计算5x5窗口中当前元素的索引  
                    int newY = PointY + dy;  
                    int newX = PointX + dx;                      
                    tempPixel[index] = image[newY * width + newX];


                    newPixel += tempPixel[index];
                    index++;
                }  
            }  

            //移除中心点
            newPixel -= image[tempLen];

            //计算周围24个点的平均值
            Avged = newPixel/24;

            int MaxAvgd = 0;
            int MinAvgd = 0;
            int MaxNum = 0;
            int MinNum = 0;
            
            for (int i = 0; i < 25; i++)
            {
                if (i==12)
                {
                    continue;
                }
                
                if (tempPixel[i] < Avged)
                {
                    MinAvgd++;
                    MinNum+=tempPixel[i];
                }
                else
                {
                    MaxAvgd++;
                    MaxNum+=tempPixel[i];
                }
            }
            
            int NewAvgd = 0;
            if (MaxAvgd >= MinAvgd)
            {
                NewAvgd = MaxNum/MaxAvgd;
            }
            else
            {
                NewAvgd = MinNum/MinAvgd;
            }    

            image[tempLen] = NewAvgd;
            //JZSDK_LOG_INFO("切除位置(%d,%d) %d",PointX,PointY,Blind[Blind_num]);
        }
    }
     
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

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



/***************
 * 
 *  判断是否为坏点
 *  并记录到数组中
 * ****************/  
static T_JZsdkReturnCode CheckisBadPixel_U8(unsigned char* image, int width, int height, unsigned int *Blind, int *Blind_num)
{
    //3*3和5*5来获取点判断
    memset(Blind, 0, *Blind_num);
    *Blind_num = 0;

    //先检查足够拥有5*5范围的
    int PointX = 0;
    int PointY = 0;

    int Len = height*width;
    int BadNum = 0;

    unsigned char firstWindow[FIRST_WINDOW_SIZE*FIRST_WINDOW_SIZE];
    unsigned char secondWindow[SECOND_WINDOW_SIZE*SECOND_WINDOW_SIZE];

    for (int i = 0; i < Len; i++)
    {
        PointY = i/width;
        PointX = i%width;

        //检查边界
        if (PointX < 2 || PointX >= (width - 2) || PointY < 2 || PointY >= (height - 2))  
        {  
            // 如果当前点不在5x5窗口的有效范围内，则跳过  
            continue;  
        }    
        
        // 写入小窗口（3x3）  
        int index = 0; // firstWindow的索引  
        for (int dy = -1; dy <= 1; dy++)  
        {  
            for (int dx = -1; dx <= 1; dx++)  
            {  
                // 计算3x3窗口中当前元素的索引  
                int newY = PointY + dy;  
                int newX = PointX + dx;  
                firstWindow[index++] = image[newY * width + newX]; // 假设image是二维数组的一维表示  
            }  
        }  
        
        // 写入大窗口（5x5）  
        index = 0; // firstWindow的索引  
        for (int dy = -2; dy <= 2; dy++)  
        {  
            for (int dx = -2; dx <= 2; dx++)  
            {  
                // 计算3x3窗口中当前元素的索引  
                int newY = PointY + dy;  
                int newX = PointX + dx;  
                secondWindow[index++] = image[newY * width + newX]; // 假设image是二维数组的一维表示  
            }  
        }  

        //计算方差
        double first_variance;
        JZsdk_CalulateLocalVarinance_Char(firstWindow, FIRST_WINDOW_SIZE*FIRST_WINDOW_SIZE, &first_variance); 
        double second_variance;
        JZsdk_CalulateLocalVarinance_Char(secondWindow, SECOND_WINDOW_SIZE*SECOND_WINDOW_SIZE, &second_variance); 

        if ( (first_variance-second_variance) > GRAY_VARINANCE_RANK || (first_variance-second_variance) < -GRAY_VARINANCE_RANK)
        {
            //JZSDK_LOG_INFO("记录坏点(%d, %d)",PointX,PointY);
            Blind[*Blind_num] = (PointY*width + PointX);
            
            //JZSDK_LOG_INFO("记录坏点(%d, %d) len:%d",PointX,PointY,Blind[*Blind_num]);
            (*Blind_num)++;
        }
        
    }
    
    JZSDK_LOG_INFO("一共%d个灰点",*Blind_num);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}  

/***************
 * 
 *  判断是否为坏点
 *  并记录到文件中
 * ****************/  
T_JZsdkReturnCode JZsdk_GrayCheckisBadPixel_U8(unsigned char* image, int width, int height, unsigned int *Blind, int *Blind_num)
{
    T_JZsdkReturnCode ret;

    //1、获取错误点
    CheckisBadPixel_U8(image, width, height, Blind, Blind_num);

    //2、保存
    //检查文件夹
    ret = JZsdk_check_directory_exists_posix(PIXEL_SAVE_DIR); 
    if (ret != JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS)
    {

        JZSDK_LOG_ERROR("不存在坏点文件夹，建立一个");
        ret = JZsdk_Osal_Mkdir(PIXEL_SAVE_DIR);
        if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE)
        {
            JZSDK_LOG_ERROR("坏点文件夹建立失败");         
            return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
        }
    }
    
    //写入文件
    unsigned char str[256];
    snprintf(str, sizeof(str), "%s/%s",PIXEL_SAVE_DIR, GRAY_BAD_PIXEL_DIR);
    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;
    }

    // 假设Blind_num包含数组中元素的数量  
    for (int i = 0; i < *Blind_num; ++i) {  
        fprintf(Save_fp, "%u\n", Blind[i]); // 将每个元素写入文件，每行一个  
    }  
  
    fclose(Save_fp); // 关闭文件  
  
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS; // 返回成功代码  

}

T_JZsdkReturnCode JZsdk_GrayGetBadPixel_U8(unsigned int *Blind, int *Blind_num, int max_num)
{
    unsigned char str[256];
    snprintf(str, sizeof(str), "%s/%s",PIXEL_SAVE_DIR, GRAY_BAD_PIXEL_DIR);
    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;
    }

    int count = 0;
    unsigned int temp;  
    while (fscanf(Save_fp, "%u", &temp) == 1 && count < max_num) 
    {  
        // // 动态增加数组大小  
        // blind = realloc(blind, (count + 1) * sizeof(unsigned int));  
        // if (blind == NULL) {  
        //     perror("内存分配失败");  
        //     fclose(fp);  
        //     return 1;  
        // }  
  
        Blind[count++] = temp;  
    }  

    *Blind_num = count;
    fclose(Save_fp);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}



/***************
 * 
 *  坏点纠正
 *  输入参数 图像数据 图像宽高 坏点与数量 坏点界限 纠正方式
 * ****************/  
T_JZsdkReturnCode JZsdk_CutBadPixel_U8(U8_t *image, int width, int height, unsigned int *Blind, int Blind_num, unsigned Buildextern,int order)
{
    //平均值取值法
    if (order == 0)
    {
        for (int i = 0; i < Blind_num; i++)
        {
            int PointX = 0;
            int PointY = 0;

            unsigned int newPixel = 0;

            int tempLen = Blind[i];
            PointY = tempLen/width;
            PointX = tempLen%width;
            int index=0;

            for (int dy = -1; dy <= 1; dy++)  
            {  
                for (int dx = -1; dx <= 1; dx++)  
                {  
                    // 计算3x3窗口中当前元素的索引  
                    int newY = PointY + dy;  
                    int newX = PointX + dx;  
                    newPixel += image[newY * width + newX]; // 假设image是二维数组的一维表示  
                }  
            }  
            
            int Avged = (newPixel-image[tempLen])/8;
            if ((fabs(image[tempLen] - Avged) < Buildextern))
            {
    
                for (int dy = -2; dy <= 2; dy++)  
                {  
                    for (int dx = -2; dx <= 2; dx++)  
                    {  
                        // 计算5x5窗口中当前元素的索引  
                        int newY = PointY + dy;  
                        int newX = PointX + dx;  
                        newPixel += image[newY * width + newX]; // 假设image是二维数组的一维表示  
                    }  
                }  
                Avged = (newPixel-image[tempLen])/24;
            }
            

            image[tempLen] = Avged;
            //JZSDK_LOG_INFO("切除位置(%d,%d) %d",PointX,PointY,Blind[Blind_num]);
        }
    }
    //二分取值法
    if (order == 1)
    {
        for (int i = Blind_num-1; i  >= 0; i--)
        {
            int PointX = 0;
            int PointY = 0;

            unsigned int newPixel = 0;

            //获取xy轴坐标
            int tempLen = Blind[i];
            PointY = tempLen/width;
            PointX = tempLen%width;
            int index=0; 
            int Avged=0;

            int tempPixel[25];

            for (int dy = -2; dy <= 2; dy++)  
            {  
                for (int dx = -2; dx <= 2; dx++)  
                {  
                    // 计算5x5窗口中当前元素的索引  
                    int newY = PointY + dy;  
                    int newX = PointX + dx;                      
                    tempPixel[index] = image[newY * width + newX];
                    newPixel += tempPixel[index];
                    index++;
                }  
            }  

            Avged = (newPixel-image[tempLen])/24;

            int MaxAvgd = 0;
            int MinAvgd = 0;
            int MaxNum = 0;
            int MinNum = 0;
            
            for (int i = 0; i < 25; i++)
            {
                if (i==12)
                {
                    continue;
                }
                
                if (tempPixel[i] < Avged)
                {
                    MinAvgd++;
                    MinNum+=tempPixel[i];
                }
                else
                {
                    MaxAvgd++;
                    MaxNum+=tempPixel[i];
                }
            }
            
            int NewAvgd = 0;
            if (MaxAvgd >= MinAvgd)
            {
                NewAvgd = MaxNum/MaxAvgd;
            }
            else
            {
                NewAvgd = MinNum/MinAvgd;
            }    

            image[tempLen] = NewAvgd;
            //JZSDK_LOG_INFO("切除位置(%d,%d) %d",PointX,PointY,Blind[Blind_num]);
        }
    }
     
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// 定义一个结构体来存储点的坐标  
typedef struct BlindPoint{  
    int x;  
    int y;  
} BlindPoint;  

//手动盲点加载
T_JZsdkReturnCode JZsdkBadPixelProcManualLoad(unsigned int *blind, unsigned int *blindNum,int  witdh)
{
    FILE *fp = fopen("/root/IRC_File/BlindPixels.txt", "r"); // 假设文件已打开，并且路径正确  
    if (!fp) {  
        // 错误处理：文件打开失败  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  
  
    BlindPoint *points = NULL; // 用于存储已读取的整数对（即点的坐标）  
    int count = 0; // 用于记录已读取的点的个数  
    int capacity = 0; // 用于记录当前分配的内存容量（以点的个数计）  
  
    // 读取数据，每两个整数表示一个点的x和y坐标  
    int x, y;  
    while (fscanf(fp, "%d %d", &x, &y) == 2) { // 确保一次读取两个整数  
        // 如果当前容量不足以存储新点，则增加容量  
        if (count >= capacity) {  
            capacity = (capacity == 0) ? 10 : capacity * 2; // 初始容量为10，之后每次翻倍  
            points = realloc(points, capacity * sizeof(BlindPoint));  
            if (points == NULL) {  
                // 如果内存分配失败，则释放已分配的内存并退出  
                free(points);  
                fclose(fp);  
                // 这里可以添加适当的错误日志或处理  
                return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER; // 或其他错误代码  
            }  
        }  
        points[count].x = x; // 存储x坐标  
        points[count].y = y; // 存储y坐标  
        count++; // 增加计数器  
    }  
  
    //将point数组放入dealInfo中
    for (int i = 0; i < count; i++)
    {
        blind[i] = points[i].x + points[i].y * witdh;
    }

    *blindNum = count;

    JZSDK_LOG_INFO("加载了%d个盲点",count);
  
    // 释放分配的内存  
    free(points);  
    fclose(fp);  

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

//手动盲点保存
T_JZsdkReturnCode JZsdkBadPixelProcManualSave(unsigned int *blind, unsigned int blindNum,int  witdh)
{

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;

}