#include "CorrectParam.h"
#include <iostream>
#include <fstream>
#include <sys/stat.h>
#include <sstream>
#include <iomanip>
#include "commondef.h"


using namespace std;

#define JSONPATH "/usr/local/huago/cameraparam.json"
#define JSONPATH_8478 "/usr/local/huago/cameraparam_8478.json"
#define JSONPATH_8458_COLOR_LVDS "/usr/local/huago/cameraparam_8458_color_lvds.json"
#define JSONPATH_8478_HL_LVDS "/usr/local/huago/cameraparam_8478_HL_lvds.json"

#define TEXTLUT200COLORPATH "/usr/local/huago/Textlut200clr.bmp"
#define LUT200COLORPATH "/usr/local/huago/lut200clr.bmp"
#define LUT200_COLOR_BLACKPATH "/usr/local/huago/lut200clrbw.bmp"
#define LUT200_COLOR_WHITEPATH "/usr/local/huago/lut200clrwhite.bmp"

#define TEXTLUT200GRAYPATH "/usr/local/huago/Textlut200gray.bmp"
#define LUT200GRAYPATH "/usr/local/huago/lut200gray.bmp"
#define LUT200_GRAY_BLACKPATH "/usr/local/huago/lut200graybw.bmp"
#define LUT200_GRAY_WHITEPATH "/usr/local/huago/lut200graywhite.bmp"

#define TEXTLUT300COLORPATH "/usr/local/huago/Textlut300clr.bmp"
#define LUT300COLORPATH "/usr/local/huago/lut300clr.bmp"
#define LUT300_COLOR_BLACKPATH "/usr/local/huago/lut300clrbw.bmp"
#define LUT300_COLOR_WHITEPATH "/usr/local/huago/lut300clrwhite.bmp"

#define TEXTLUT300GRAYPATH "/usr/local/huago/Textlut300gray.bmp"
#define LUT300GRAYPATH "/usr/local/huago/lut300gray.bmp"
#define LUT300_GRAY_BLACKPATH "/usr/local/huago/lut300graybw.bmp"
#define LUT300_GRAY_WHITEPATH "/usr/local/huago/lut300graywhite.bmp"

#define LUT600COLORPATH "/usr/local/huago/lut600clr.bmp"
#define TEXTLUT600COLORPATH "/usr/local/huago/Textlut600clr.bmp"
#define LUT600_COLOR_BLACKPATH "/usr/local/huago/lut600clrbw.bmp"
#define LUT600_COLOR_WHITEPATH "/usr/local/huago/lut600clrwhite.bmp"

#define LUT600GRAYPATH "/usr/local/huago/lut600gray.bmp"
#define TEXTLUT600GRAYPATH "/usr/local/huago/Textlut600gray.bmp"
#define LUT600_GRAY_BLACKPATH "/usr/local/huago/lut600graybw.bmp"
#define LUT600_GRAY_WHITEPATH "/usr/local/huago/lut600graywhite.bmp"

#define LUTslow_moireCOLORPATH "/usr/local/huago/lutslow_moireclr.bmp"
#define TEXTLUTslow_moireCOLORPATH "/usr/local/huago/Textlutslow_moireclr.bmp"
#define LUTslow_moire_COLOR_BLACKPATH "/usr/local/huago/lutslow_moireclrbw.bmp"
#define LUTslow_moire_COLOR_WHITEPATH "/usr/local/huago/lutslow_moireclrwhite.bmp"

#define LUTslow_moireGRAYPATH "/usr/local/huago/lutslow_moiregray.bmp"
#define TEXTLUTslow_moireGRAYPATH "/usr/local/huago/Textlutslow_moiregray.bmp"
#define LUTslow_moire_GRAY_BLACKPATH "/usr/local/huago/lutslow_moiregraybw.bmp"
#define LUTslow_moire_GRAY_WHITEPATH "/usr/local/huago/lutslow_moiregraywhite.bmp"

#define LUTslow_moire_300_COLORPATH "/usr/local/huago/lutslow_moire300clr.bmp"
#define TEXTLUTslow_moire_300_COLORPATH "/usr/local/huago/Textlutslow_moire300clr.bmp"
#define LUTslow_moire_300_COLOR_BLACKPATH "/usr/local/huago/lutslow_moire300clrbw.bmp"
#define LUTslow_moire_300_COLOR_WHITEPATH "/usr/local/huago/lutslow_moire300clrwhite.bmp"

#define LUTslow_moire_300_GRAYPATH "/usr/local/huago/lutslow_moire300gray.bmp"
#define TEXTLUTslow_moire_300_GRAYPATH "/usr/local/huago/Textlutslow_moire300gray.bmp"
#define LUTslow_moire_300_GRAY_BLACKPATH "/usr/local/huago/lutslow_moire300graybw.bmp"
#define LUTslow_moire_300_GRAY_WHITEPATH "/usr/local/huago/lutslow_moire300graywhite.bmp"

#define LUTLong_Manuscript_200_COLORPATH "/usr/local/huago/lutLong_Manuscript200clr.bmp"
#define TEXTLUTLong_Manuscript_200_COLORPATH "/usr/local/huago/TextlutLong_Manuscript200clr.bmp"
#define LUTLong_Manuscript_200_COLOR_BLACKPATH "/usr/local/huago/lutLong_Manuscript200clrbw.bmp"
#define LUTLong_Manuscript_200_COLOR_WHITEPATH "/usr/local/huago/lutLong_Manuscript200clrwhite.bmp"

#define LUTLong_Manuscript_200_GRAYPATH "/usr/local/huago/lutLong_Manuscript200gray.bmp"
#define TEXTLUTLong_Manuscript_200_GRAYPATH "/usr/local/huago/TextlutLong_Manuscript200gray.bmp"
#define LUTLong_Manuscript_200_GRAY_BLACKPATH "/usr/local/huago/lutLong_Manuscript200graybw.bmp"
#define LUTLong_Manuscript_200_GRAY_WHITEPATH "/usr/local/huago/lutLong_Manuscript200graywhite.bmp"

#define LUTLong_Manuscript_300_COLORPATH "/usr/local/huago/lutLong_Manuscript300clr.bmp"
#define TEXTLUTLong_Manuscript_300_COLORPATH "/usr/local/huago/TextlutLong_Manuscript300clr.bmp"
#define LUTLong_Manuscript_300_COLOR_BLACKPATH "/usr/local/huago/lutLong_Manuscript300clrbw.bmp"
#define LUTLong_Manuscript_300_COLOR_WHITEPATH "/usr/local/huago/lutLong_Manuscript300clrwhite.bmp"

#define LUTLong_Manuscript_300_GRAYPATH "/usr/local/huago/lutLong_Manuscript300gray.bmp"
#define TEXTLUTLong_Manuscript_300_GRAYPATH "/usr/local/huago/TextlutLong_Manuscript300gray.bmp"
#define LUTLong_Manuscript_300_GRAY_BLACKPATH "/usr/local/huago/lutLong_Manuscript300graybw.bmp"
#define LUTLong_Manuscript_300_GRAY_WHITEPATH "/usr/local/huago/lutLong_Manuscript300graywhite.bmp"


CorrectParam::CorrectParam()
{
	initdefaultpapram();
}

CorrectParam::~CorrectParam()
{
}

std::vector<FPGAConfigParam> CorrectParam::GetCorrectParams()
{
	std::ifstream i(JSONPATH);
	json j;
	i >> j;
	i.close();
	std::vector<FPGAConfigParam> vct_param;
	for (json::iterator it = j.begin(); it != j.end(); ++it)
	{
		auto tmv = it.value();
		FPGAConfigParam param;
		from_json(tmv, param);
		vct_param.push_back(param);
	}
	return vct_param;
}


std::vector<FPGAConfigParam> CorrectParam::GetCorrectParams_8458_Color_Lvds()
{
	std::ifstream i(JSONPATH_8458_COLOR_LVDS);
	json j;
	i >> j;
	i.close();
	std::vector<FPGAConfigParam> vct_param;
	for (json::iterator it = j.begin(); it != j.end(); ++it)
	{
		auto tmv = it.value();
		FPGAConfigParam param;
		from_json(tmv, param);
		vct_param.push_back(param);
	}
	return vct_param;
}

FPGAConfigParam CorrectParam::GetFpgaparam_8458_color_Lvds(int dpi, int mode){
	std::lock_guard<std::mutex> lc(m_lock);
	FPGAConfigParam param;
	auto filejson = GetCorrectParams_8458_Color_Lvds();
	bool isfind = false;
	for (size_t i = 0; i < filejson.size(); i++)
	{
		if ((filejson[i].ColorMode == mode) &&
			(filejson[i].DpiMode == dpi))
		{
			param = filejson[i];
			isfind = true;
			break;
		}
	}
	return param;
}


FPGAConfigParam CorrectParam::GetFpgaparam(int dpi, int mode)
{
	std::lock_guard<std::mutex> lc(m_lock);
	FPGAConfigParam param;
	auto filejson = GetCorrectParams();
	bool isfind = false;
	for (size_t i = 0; i < filejson.size(); i++)
	{
		if ((filejson[i].ColorMode == mode) &&
			(filejson[i].DpiMode == dpi))
		{
			param = filejson[i];
			isfind = true;
			break;
		}
	}
	if (isfind == false && dpi == 0x10)
	{
		FPGAConfigParam nodeparam;
		json t_j;
		nodeparam.ColorMode = 1; // 彩色
		nodeparam.DpiMode = 2;	 // 300 dpi
		nodeparam.MaxBright = 200;
		nodeparam.MaxExp = 1100;
		nodeparam.HRatio = 1065353216;
		nodeparam.VRatio = 1065353216;
		// 慢速摩尔纹 彩色
		nodeparam.MaxBright = 200;
		nodeparam.ColorMode = 1;  // 彩色
		nodeparam.DpiMode = 0x10; // 200 dpi
		nodeparam.LutPath = LUTslow_moireCOLORPATH;
		nodeparam.TextLutPath = TEXTLUTslow_moireCOLORPATH;
		nodeparam.Flat_BwPath = LUTslow_moire_COLOR_BLACKPATH;
		nodeparam.Flat_WhitePath = LUTslow_moire_COLOR_WHITEPATH;
#ifdef G100
		nodeparam.Sp = 875;
#else
		nodeparam.Sp = 878;
#endif
		for (size_t i = 0; i < 6; i++)
		{
			if (i < 3)
				nodeparam.ExposureB[i] = nodeparam.ExposureF[i] = 650; // 1500
			nodeparam.GainF[i] = nodeparam.GainB[i] = 170;
			nodeparam.OffsetF[i] = nodeparam.OffsetB[i] = 125;
		}
		filejson.push_back(nodeparam);
		param = nodeparam;
		// 慢速摩尔纹 灰度
		nodeparam.MaxBright = 220;
		nodeparam.ColorMode = 0; // 灰度
		nodeparam.LutPath = LUTslow_moireGRAYPATH;
		nodeparam.TextLutPath = TEXTLUTslow_moireGRAYPATH;
		nodeparam.Flat_BwPath = LUTslow_moire_GRAY_BLACKPATH;
		nodeparam.Flat_WhitePath = LUTslow_moire_GRAY_WHITEPATH;
#ifdef G100
		nodeparam.Sp = 2626;
#else
		nodeparam.Sp = 2637;
#endif
		filejson.push_back(nodeparam);
		if (mode == 0)
			param = nodeparam;
		json j = json::array();
		for (size_t i = 0; i < filejson.size(); i++)
		{
			json t_j;
			to_json(t_j, filejson[i]);
			j.push_back(t_j);
		}
		ofstream ofs(JSONPATH);
		ofs << std::setw(4) << j << std::endl;
		ofs.close();
	}
	return param;
}

void CorrectParam::SaveCorrectParam(FPGAConfigParam &parms)
{
	std::lock_guard<std::mutex> lc(m_lock);
	auto filejson = GetCorrectParams();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		if ((filejson[i].ColorMode == parms.ColorMode) &&
			(filejson[i].DpiMode == parms.DpiMode))
		{
			memcpy(filejson[i].ExposureB, parms.ExposureB, sizeof(parms.ExposureB));
			memcpy(filejson[i].ExposureF, parms.ExposureF, sizeof(parms.ExposureF));
			memcpy(filejson[i].GainB, parms.GainB, sizeof(parms.GainB));
			memcpy(filejson[i].GainF, parms.GainF, sizeof(parms.GainF));
			memcpy(filejson[i].OffsetB, parms.OffsetB, sizeof(parms.OffsetB));
			memcpy(filejson[i].OffsetF, parms.OffsetF, sizeof(parms.OffsetF));
			filejson[i].LutPath = parms.LutPath;
			filejson[i].TextLutPath = parms.TextLutPath;
			filejson[i].Flat_BwPath = parms.Flat_BwPath;
			filejson[i].Flat_WhitePath = parms.Flat_WhitePath;
			filejson[i].Sp = parms.Sp;
			filejson[i].HRatio = parms.HRatio;
			filejson[i].VRatio = parms.VRatio;
			break;
		}
	}
	json j = json::array();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		json t_j;
		to_json(t_j, filejson[i]);
		j.push_back(t_j);
	}
	ofstream ofs(JSONPATH);
	ofs << std::setw(4) << j << std::endl;
	ofs.close();
}

void CorrectParam::initdefaultpapram()
{

	json js = json::array();
	json js_8478 = json::array();
	{
		FPGAConfigParam param;
		FPGAConfigParam_8478 param_8478;
		json t_j, t_j_8478;

		// 彩色 300 dpi
		param_8478.ColorMode = param.ColorMode = 1; // 彩色
		param_8478.DpiMode = param.DpiMode = 2;		// 300 dpi
		param_8478.MaxBright = param.MaxBright = 200;
		param_8478.MaxExp = param.MaxExp = 1100;
		param_8478.HRatio = param.HRatio = 1065353216;
		param_8478.VRatio = param.VRatio = 1065353216;
		param_8478.LutPath = param.LutPath = LUT300COLORPATH;
		param_8478.TextLutPath = param.TextLutPath = TEXTLUT300COLORPATH;
		param_8478.Flat_BwPath = param.Flat_BwPath = LUT300_COLOR_BLACKPATH;
		param_8478.Flat_WhitePath = param.Flat_WhitePath = LUT300_COLOR_WHITEPATH;
		param_8478.Sp = 4680;
		param.Sp = 1200;
		for (size_t i = 0; i < 9; i++)
		{
			if (i < 6)
			{
				if (i < 3)
					param.ExposureB[i] = param.ExposureF[i] = 700; // 1500
				param.GainF[i] = param.GainB[i] = 170;
				param.OffsetF[i] = param.OffsetB[i] = 125;
			}
			if (i < 3)
				param_8478.ExposureB[i] = param_8478.ExposureF[i] = 200; // 1500
			param_8478.GainF_R[i] = param_8478.GainB_R[i] = param_8478.GainF_G[i] = param_8478.GainB_G[i] =
				param_8478.GainF_B[i] = param_8478.GainB_B[i] = 80;
			param_8478.OffsetF_R[i] = param_8478.OffsetB_R[i] = param_8478.OffsetF_G[i] = param_8478.OffsetB_G[i] =
				param_8478.OffsetF_B[i] = param_8478.OffsetB_B[i] = 180;
		}
		to_json(t_j, param);
		to_json(t_j_8478, param_8478);
		js.push_back(t_j);
		js_8478.push_back(t_j_8478);

		// 灰度 300 dpi
		param_8478.ColorMode = param.ColorMode = 0; // 灰度
		param_8478.MaxBright = param.MaxBright = 200;
		param_8478.LutPath = param.LutPath = LUT300GRAYPATH;
		param_8478.TextLutPath = param.TextLutPath = TEXTLUT300GRAYPATH;
		param_8478.Flat_BwPath = param.Flat_BwPath = LUT300_GRAY_BLACKPATH;
		param_8478.Flat_WhitePath = param.Flat_WhitePath = LUT300_GRAY_WHITEPATH;
		to_json(t_j, param);
		to_json(t_j_8478, param_8478);
		js.push_back(t_j);
		js_8478.push_back(t_j_8478);

		// 彩色 200 dpi
		param_8478.MaxBright = param.MaxBright = 200;
		param_8478.ColorMode = param.ColorMode = 1; // 彩色
		param_8478.DpiMode = param.DpiMode = 1;		// 200 dpi
		param_8478.LutPath = param.LutPath = LUT200COLORPATH;
		param_8478.TextLutPath = param.TextLutPath = TEXTLUT200COLORPATH;
		param_8478.Flat_BwPath = param.Flat_BwPath = LUT200_COLOR_BLACKPATH;
		param_8478.Flat_WhitePath = param.Flat_WhitePath = LUT200_COLOR_WHITEPATH;
		for (size_t i = 0; i < 9; i++)
		{
			if (i < 6)
			{
				if (i < 3)
					param.ExposureB[i] = param.ExposureF[i] = 650; // 1500
				param.GainF[i] = param.GainB[i] = 170;
				param.OffsetF[i] = param.OffsetB[i] = 125;
			}
			if (i < 3)
				param_8478.ExposureB[i] = param_8478.ExposureF[i] = 200; // 1500
			param_8478.GainF_R[i] = param_8478.GainB_R[i] = param_8478.GainF_G[i] = param_8478.GainB_G[i] =
				param_8478.GainF_B[i] = param_8478.GainB_B[i] = 80;
			param_8478.OffsetF_R[i] = param_8478.OffsetB_R[i] = param_8478.OffsetF_G[i] = param_8478.OffsetB_G[i] =
				param_8478.OffsetF_B[i] = param_8478.OffsetB_B[i] = 180;
		}
		to_json(t_j, param);
		to_json(t_j_8478, param_8478);
		js.push_back(t_j);
		js_8478.push_back(t_j_8478);

		// 灰度 200dpi
		param_8478.MaxBright = param.MaxBright = 200;
		param_8478.ColorMode = param.ColorMode = 0; // 灰度
		param_8478.LutPath = param.LutPath = LUT200GRAYPATH;
		param_8478.TextLutPath = param.TextLutPath = TEXTLUT200GRAYPATH;
		param_8478.Flat_BwPath = param.Flat_BwPath = LUT200_GRAY_BLACKPATH;
		param_8478.Flat_WhitePath = param.Flat_WhitePath = LUT200_GRAY_WHITEPATH;
		to_json(t_j, param);
		to_json(t_j_8478, param_8478);
		js.push_back(t_j);
		js_8478.push_back(t_j_8478);

		// 彩色 600 dpi
		param_8478.MaxBright = param.MaxBright = 200;
		param_8478.ColorMode = param.ColorMode = 1; // 彩色
		param_8478.DpiMode = param.DpiMode = 0x03;	// 200 dpi
		param_8478.LutPath = param.LutPath = LUT600COLORPATH;
		param_8478.TextLutPath = param.TextLutPath = TEXTLUT600COLORPATH;
		param_8478.Flat_BwPath = param.Flat_BwPath = LUT600_COLOR_BLACKPATH;
		param_8478.Flat_WhitePath = param.Flat_WhitePath = LUT600_COLOR_WHITEPATH;
		param_8478.Sp = 9000;
		param.Sp = 3000;
		for (size_t i = 0; i < 9; i++)
		{
			if (i < 6)
			{
				if (i < 3)
					param.ExposureB[i] = param.ExposureF[i] = 1350; // 1500
				param.GainF[i] = param.GainB[i] = 170;
				param.OffsetF[i] = param.OffsetB[i] = 125;
			}
			if (i < 3)
				param_8478.ExposureB[i] = param_8478.ExposureF[i] = 200; // 1500
			param_8478.GainF_R[i] = param_8478.GainB_R[i] = param_8478.GainF_G[i] = param_8478.GainB_G[i] =
				param_8478.GainF_B[i] = param_8478.GainB_B[i] = 80;
			param_8478.OffsetF_R[i] = param_8478.OffsetB_R[i] = param_8478.OffsetF_G[i] = param_8478.OffsetB_G[i] =
				param_8478.OffsetF_B[i] = param_8478.OffsetB_B[i] = 180;
		}
		to_json(t_j, param);
		to_json(t_j_8478, param_8478);
		js.push_back(t_j);
		js_8478.push_back(t_j_8478);

		// 灰度 600dpi
		param_8478.MaxBright = param.MaxBright = 200;
		param_8478.ColorMode = param.ColorMode = 0; // 灰度
		param_8478.LutPath = param.LutPath = LUT600GRAYPATH;
		param_8478.TextLutPath = param.TextLutPath = TEXTLUT600GRAYPATH;
		param_8478.Flat_BwPath = param.Flat_BwPath = LUT600_GRAY_BLACKPATH;
		param_8478.Flat_WhitePath = param.Flat_WhitePath = LUT600_GRAY_WHITEPATH;
		to_json(t_j, param);
		to_json(t_j_8478, param_8478);
		js.push_back(t_j);
		js_8478.push_back(t_j_8478);

		// 慢速摩尔纹 彩色
		param_8478.MaxBright = param.MaxBright = 200;
		param_8478.ColorMode = param.ColorMode = 1; // 彩色
		param_8478.DpiMode = param.DpiMode = 0x10;	// 200 dpi
		param_8478.LutPath = param.LutPath = LUTslow_moireCOLORPATH;
		param_8478.TextLutPath = param.TextLutPath = TEXTLUTslow_moireCOLORPATH;
		param_8478.Flat_BwPath = param.Flat_BwPath = LUTslow_moire_COLOR_BLACKPATH;
		param_8478.Flat_WhitePath = param.Flat_WhitePath = LUTslow_moire_COLOR_WHITEPATH;
#ifdef G100
		param_8478.Sp = 4680;
		param.Sp = 875;
#else
		param_8478.Sp = 4680;
		param.Sp = 878;
#endif
		for (size_t i = 0; i < 9; i++)
		{
			if (i < 6)
			{
				if (i < 3)
					param.ExposureB[i] = param.ExposureF[i] = 650; // 1500
				param.GainF[i] = param.GainB[i] = 170;
				param.OffsetF[i] = param.OffsetB[i] = 125;
			}
			if (i < 3)
				param_8478.ExposureB[i] = param_8478.ExposureF[i] = 200; // 1500
			param_8478.GainF_R[i] = param_8478.GainB_R[i] = param_8478.GainF_G[i] = param_8478.GainB_G[i] =
				param_8478.GainF_B[i] = param_8478.GainB_B[i] = 80;
			param_8478.OffsetF_R[i] = param_8478.OffsetB_R[i] = param_8478.OffsetF_G[i] = param_8478.OffsetB_G[i] =
				param_8478.OffsetF_B[i] = param_8478.OffsetB_B[i] = 180;
		}
		to_json(t_j, param);
		to_json(t_j_8478, param_8478);
		js.push_back(t_j);
		js_8478.push_back(t_j_8478);

		// 慢速摩尔纹 灰度
		param_8478.MaxBright = param.MaxBright = 200;
		param_8478.ColorMode = param.ColorMode = 0; // 灰度
		param_8478.LutPath = param.LutPath = LUTslow_moireGRAYPATH;
		param_8478.TextLutPath = param.TextLutPath = TEXTLUTslow_moireGRAYPATH;
		param_8478.Flat_BwPath = param.Flat_BwPath = LUTslow_moire_GRAY_BLACKPATH;
		param_8478.Flat_WhitePath = param.Flat_WhitePath = LUTslow_moire_GRAY_WHITEPATH;
#ifdef G100
		param_8478.Sp = 4680;
		param.Sp = 2626;
#else
		param_8478.Sp = 4680;
		param.Sp = 2637;
#endif
		to_json(t_j, param);
		to_json(t_j_8478, param_8478);
		js.push_back(t_j);
		js_8478.push_back(t_j_8478);

		// 慢速摩尔纹 300dpi 彩色
		param_8478.MaxBright = 200;
		param_8478.ColorMode = 1;  // 彩色
		param_8478.DpiMode = 0x11; // 200 dpi
		param_8478.LutPath = LUTslow_moire_300_COLORPATH;
		param_8478.TextLutPath = TEXTLUTslow_moire_300_COLORPATH;
		param_8478.Flat_BwPath = LUTslow_moire_300_COLOR_BLACKPATH;
		param_8478.Flat_WhitePath = LUTslow_moire_300_COLOR_WHITEPATH;
#ifdef G100
		param_8478.Sp = 6460;
#else
		param_8478.Sp = 6460;
#endif
		for (size_t i = 0; i < 9; i++)
		{
			if (i < 3)
				param_8478.ExposureB[i] = param_8478.ExposureF[i] = 200; // 1500
			param_8478.GainF_R[i] = param_8478.GainB_R[i] = param_8478.GainF_G[i] = param_8478.GainB_G[i] =
				param_8478.GainF_B[i] = param_8478.GainB_B[i] = 80;
			param_8478.OffsetF_R[i] = param_8478.OffsetB_R[i] = param_8478.OffsetF_G[i] = param_8478.OffsetB_G[i] =
				param_8478.OffsetF_B[i] = param_8478.OffsetB_B[i] = 180;
		}
		to_json(t_j_8478, param_8478);
		js_8478.push_back(t_j_8478);

		// 慢速摩尔纹 300dpi 灰度
		param_8478.MaxBright = 200;
		param_8478.ColorMode = 0; // 灰度
		param_8478.LutPath = LUTslow_moire_300_GRAYPATH;
		param_8478.TextLutPath = TEXTLUTslow_moire_300_GRAYPATH;
		param_8478.Flat_BwPath = LUTslow_moire_300_GRAY_BLACKPATH;
		param_8478.Flat_WhitePath = LUTslow_moire_300_GRAY_WHITEPATH;
#ifdef G100
		param_8478.Sp = 6460;
#else
		param_8478.Sp = 6460;
#endif
		to_json(t_j_8478, param_8478);
		js_8478.push_back(t_j_8478);


		// 长文稿 200dpi 彩色
		param_8478.MaxBright = 200;
		param_8478.ColorMode = 1;  // 彩色
		param_8478.DpiMode = 0x20; // 200 dpi
		param_8478.LutPath = LUTLong_Manuscript_200_COLORPATH;;
		param_8478.TextLutPath = TEXTLUTLong_Manuscript_200_COLORPATH;
		param_8478.Flat_BwPath = LUTLong_Manuscript_200_COLOR_BLACKPATH;
		param_8478.Flat_WhitePath = LUTLong_Manuscript_200_COLOR_WHITEPATH;
#ifdef G100
		param_8478.Sp = 6460;
#else
		param_8478.Sp = 30627;
#endif
		for (size_t i = 0; i < 9; i++)
		{
			if (i < 3)
				param_8478.ExposureB[i] = param_8478.ExposureF[i] = 200; // 1500
			param_8478.GainF_R[i] = param_8478.GainB_R[i] = param_8478.GainF_G[i] = param_8478.GainB_G[i] =
				param_8478.GainF_B[i] = param_8478.GainB_B[i] = 80;
			param_8478.OffsetF_R[i] = param_8478.OffsetB_R[i] = param_8478.OffsetF_G[i] = param_8478.OffsetB_G[i] =
				param_8478.OffsetF_B[i] = param_8478.OffsetB_B[i] = 180;
		}
		to_json(t_j_8478, param_8478);
		js_8478.push_back(t_j_8478);

		// 长文稿 200dpi 灰度
		param_8478.MaxBright = 200;
		param_8478.ColorMode = 0; // 灰度
		param_8478.LutPath = LUTLong_Manuscript_200_GRAYPATH;;
		param_8478.TextLutPath = TEXTLUTLong_Manuscript_200_GRAYPATH;
		param_8478.Flat_BwPath = LUTLong_Manuscript_200_GRAY_BLACKPATH;
		param_8478.Flat_WhitePath = LUTLong_Manuscript_200_GRAY_WHITEPATH;
#ifdef G100
		param_8478.Sp = 6460;
#else
		param_8478.Sp = 30627;
#endif
		to_json(t_j_8478, param_8478);
		js_8478.push_back(t_j_8478);



		// 长文稿 300dpi 彩色
		param_8478.MaxBright = 200;
		param_8478.ColorMode = 1;  // 彩色
		param_8478.DpiMode = 0x21; // 200 dpi
		param_8478.LutPath = LUTLong_Manuscript_300_COLORPATH;;
		param_8478.TextLutPath = TEXTLUTLong_Manuscript_300_COLORPATH;
		param_8478.Flat_BwPath = LUTLong_Manuscript_300_COLOR_BLACKPATH;
		param_8478.Flat_WhitePath = LUTLong_Manuscript_300_COLOR_WHITEPATH;
#ifdef G100
		param_8478.Sp = 6460;
#else
		param_8478.Sp = 20436;
#endif
		for (size_t i = 0; i < 9; i++)
		{
			if (i < 3)
				param_8478.ExposureB[i] = param_8478.ExposureF[i] = 200; // 1500
			param_8478.GainF_R[i] = param_8478.GainB_R[i] = param_8478.GainF_G[i] = param_8478.GainB_G[i] =
				param_8478.GainF_B[i] = param_8478.GainB_B[i] = 80;
			param_8478.OffsetF_R[i] = param_8478.OffsetB_R[i] = param_8478.OffsetF_G[i] = param_8478.OffsetB_G[i] =
				param_8478.OffsetF_B[i] = param_8478.OffsetB_B[i] = 180;
		}
		to_json(t_j_8478, param_8478);
		js_8478.push_back(t_j_8478);

		// 长文稿 300dpi 灰度
		param_8478.MaxBright = 200;
		param_8478.ColorMode = 0; // 灰度
		param_8478.LutPath = LUTLong_Manuscript_300_GRAYPATH;;
		param_8478.TextLutPath = TEXTLUTLong_Manuscript_300_GRAYPATH;
		param_8478.Flat_BwPath = LUTLong_Manuscript_300_GRAY_BLACKPATH;
		param_8478.Flat_WhitePath = LUTLong_Manuscript_300_GRAY_WHITEPATH;
#ifdef G100
		param_8478.Sp = 6460;
#else
		param_8478.Sp = 20436;
#endif
		to_json(t_j_8478, param_8478);
		js_8478.push_back(t_j_8478);
	}

	struct stat buff;
	if (stat(JSONPATH, &buff) != 0) // 存在
	{
		std::ofstream ofs(JSONPATH);
		ofs << std::setw(4) << js << std::endl;
		ofs.close();
	}
	if (stat(JSONPATH_8478, &buff) != 0) // 存在
	{
		std::ofstream ofs(JSONPATH_8478);
		ofs << std::setw(4) << js_8478 << std::endl;
		ofs.close();
	}
	if (stat(JSONPATH_8458_COLOR_LVDS, &buff) != 0) // 存在
	{
		std::ofstream ofs(JSONPATH_8458_COLOR_LVDS);
		ofs << std::setw(4) << js << std::endl;
		ofs.close();
	}
	if (stat(JSONPATH_8478_HL_LVDS, &buff) != 0) // 存在
	{
		std::ofstream ofs(JSONPATH_8478_HL_LVDS);
		ofs << std::setw(4) << js_8478 << std::endl;
		ofs.close();
	}
}

void CorrectParam::to_json(json &j, FPGAConfigParam &param)
{
	j = json{{"ExposureF", param.ExposureF},
			 {"GainF", param.GainF},
			 {"OffsetF", param.OffsetF},
			 {"ExposureB", param.ExposureB},
			 {"GainB", param.GainB},
			 {"OffsetB", param.OffsetB},
			 {"DpiMode", param.DpiMode},
			 {"ColorMode", param.ColorMode},
			 {"MaxBright", param.MaxBright},
			 {"MaxExp", param.MaxExp},
			 {"Sp", param.Sp},
			 {"HRatio", param.HRatio},
			 {"VRatio", param.VRatio},
			 {"LutPath", param.LutPath},
			 {"TextLutPath", param.TextLutPath},
			 {"FlatBlackPath", param.Flat_BwPath},
			 {"FlatWhitePath", param.Flat_WhitePath}};
}

void CorrectParam::from_json(json &j, FPGAConfigParam &param)
{
	j.at("ExposureF").get_to(param.ExposureF);
	j.at("GainF").get_to(param.GainF);
	j.at("OffsetF").get_to(param.OffsetF);
	j.at("ExposureB").get_to(param.ExposureB);
	j.at("GainB").get_to(param.GainB);
	j.at("OffsetB").get_to(param.OffsetB);
	j.at("DpiMode").get_to(param.DpiMode);
	j.at("ColorMode").get_to(param.ColorMode);
	j.at("MaxBright").get_to(param.MaxBright);
	j.at("MaxExp").get_to(param.MaxExp);
	j.at("Sp").get_to(param.Sp);
	j.at("HRatio").get_to(param.HRatio);
	j.at("VRatio").get_to(param.VRatio);
	j.at("LutPath").get_to(param.LutPath);
	j.at("TextLutPath").get_to(param.TextLutPath);
	j.at("FlatBlackPath").get_to(param.Flat_BwPath);
	j.at("FlatWhitePath").get_to(param.Flat_WhitePath);
}

std::vector<FPGAConfigParam_8478> CorrectParam::GetCorrectParams_8478()
{
	std::ifstream i(JSONPATH_8478);
	json j;
	i >> j;
	i.close();
	std::vector<FPGAConfigParam_8478> vct_param;
	for (json::iterator it = j.begin(); it != j.end(); ++it)
	{
		auto tmv = it.value();
		FPGAConfigParam_8478 param;
		from_json(tmv, param);
		vct_param.push_back(param);
	}
	return vct_param;
}

std::vector<FPGAConfigParam_8478> CorrectParam::GetCorrectParams_8478_HL_Lvds()
{
	std::ifstream i(JSONPATH_8478_HL_LVDS);
	json j;
	i >> j;
	i.close();
	std::vector<FPGAConfigParam_8478> vct_param;
	for (json::iterator it = j.begin(); it != j.end(); ++it)
	{
		auto tmv = it.value();
		FPGAConfigParam_8478 param;
		from_json(tmv, param);
		vct_param.push_back(param);
	}
	return vct_param;
}


void CorrectParam::to_json(json &j, FPGAConfigParam_8478 &param)
{
	j = json{{"ExposureF", param.ExposureF},
			 {"GainF_R", param.GainF_R},
			 {"OffsetF_R", param.OffsetF_R},
			 {"GainF_G", param.GainF_G},
			 {"OffsetF_G", param.OffsetF_G},
			 {"GainF_B", param.GainF_B},
			 {"OffsetF_B", param.OffsetF_B},
			 {"ExposureB", param.ExposureB},
			 {"GainB_R", param.GainB_R},
			 {"OffsetB_R", param.OffsetB_R},
			 {"GainB_G", param.GainB_G},
			 {"OffsetB_G", param.OffsetB_G},
			 {"GainB_B", param.GainB_B},
			 {"OffsetB_B", param.OffsetB_B},
			 {"DpiMode", param.DpiMode},
			 {"ColorMode", param.ColorMode},
			 {"MaxBright", param.MaxBright},
			 {"MaxExp", param.MaxExp},
			 {"Sp", param.Sp},
			 {"HRatio", param.HRatio},
			 {"VRatio", param.VRatio},
			 {"LutPath", param.LutPath},
			 {"TextLutPath", param.TextLutPath},
			 {"FlatBlackPath", param.Flat_BwPath},
			 {"FlatWhitePath", param.Flat_WhitePath}};
}

void CorrectParam::from_json(json &j, FPGAConfigParam_8478 &param)
{
	j.at("ExposureF").get_to(param.ExposureF);
	j.at("GainF_R").get_to(param.GainF_R);
	j.at("OffsetF_R").get_to(param.OffsetF_R);
	j.at("GainF_G").get_to(param.GainF_G);
	j.at("OffsetF_G").get_to(param.OffsetF_G);
	j.at("GainF_B").get_to(param.GainF_B);
	j.at("OffsetF_B").get_to(param.OffsetF_B);
	j.at("ExposureB").get_to(param.ExposureB);
	j.at("GainB_R").get_to(param.GainB_R);
	j.at("OffsetB_R").get_to(param.OffsetB_R);
	j.at("GainB_G").get_to(param.GainB_G);
	j.at("OffsetB_G").get_to(param.OffsetB_G);
	j.at("GainB_B").get_to(param.GainB_B);
	j.at("OffsetB_B").get_to(param.OffsetB_B);
	j.at("DpiMode").get_to(param.DpiMode);
	j.at("ColorMode").get_to(param.ColorMode);
	j.at("MaxBright").get_to(param.MaxBright);
	j.at("MaxExp").get_to(param.MaxExp);
	j.at("Sp").get_to(param.Sp);
	j.at("HRatio").get_to(param.HRatio);
	j.at("VRatio").get_to(param.VRatio);
	j.at("LutPath").get_to(param.LutPath);
	j.at("TextLutPath").get_to(param.TextLutPath);
	j.at("FlatBlackPath").get_to(param.Flat_BwPath);
	j.at("FlatWhitePath").get_to(param.Flat_WhitePath);
}

void CorrectParam::SaveCorrectParam(FPGAConfigParam_8478 &parms)
{
	std::lock_guard<std::mutex> lc(m_lock);
	auto filejson = GetCorrectParams_8478();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		if ((filejson[i].ColorMode == parms.ColorMode) &&
			(filejson[i].DpiMode == parms.DpiMode))
		{
			memcpy(filejson[i].ExposureB, parms.ExposureB, sizeof(parms.ExposureB));
			memcpy(filejson[i].ExposureF, parms.ExposureF, sizeof(parms.ExposureF));
			memcpy(filejson[i].GainB_R, parms.GainB_R, sizeof(parms.GainB_R));
			memcpy(filejson[i].GainF_R, parms.GainF_R, sizeof(parms.GainF_R));
			memcpy(filejson[i].OffsetB_R, parms.OffsetB_R, sizeof(parms.OffsetB_R));
			memcpy(filejson[i].OffsetF_R, parms.OffsetF_R, sizeof(parms.OffsetF_R));

			memcpy(filejson[i].GainB_G, parms.GainB_G, sizeof(parms.GainB_G));
			memcpy(filejson[i].GainF_G, parms.GainF_G, sizeof(parms.GainF_G));
			memcpy(filejson[i].OffsetB_G, parms.OffsetB_G, sizeof(parms.OffsetB_G));
			memcpy(filejson[i].OffsetF_G, parms.OffsetF_G, sizeof(parms.OffsetF_G));

			memcpy(filejson[i].GainB_B, parms.GainB_B, sizeof(parms.GainB_B));
			memcpy(filejson[i].GainF_B, parms.GainF_B, sizeof(parms.GainF_B));
			memcpy(filejson[i].OffsetB_B, parms.OffsetB_B, sizeof(parms.OffsetB_B));
			memcpy(filejson[i].OffsetF_B, parms.OffsetF_B, sizeof(parms.OffsetF_B));
			filejson[i].LutPath = parms.LutPath;
			filejson[i].TextLutPath = parms.TextLutPath;
			filejson[i].Flat_BwPath = parms.Flat_BwPath;
			filejson[i].Flat_WhitePath = parms.Flat_WhitePath;
			filejson[i].Sp = parms.Sp;
			filejson[i].HRatio = parms.HRatio;
			filejson[i].VRatio = parms.VRatio;
			break;
		}
	}
	json j = json::array();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		json t_j;
		to_json(t_j, filejson[i]);
		j.push_back(t_j);
	}
	ofstream ofs(JSONPATH_8478);
	ofs << std::setw(4) << j << std::endl;
	ofs.close();
}

FPGAConfigParam_8478 CorrectParam::GetFpgaparam_8478(int dpi, int mode)
{
	std::lock_guard<std::mutex> lc(m_lock);
	FPGAConfigParam_8478 param;
	auto filejson = GetCorrectParams_8478();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		if ((filejson[i].ColorMode == mode) &&
			(filejson[i].DpiMode == dpi))
		{
			param = filejson[i];
			break;
		}
	}
	return param;
}

FPGAConfigParam_8478 CorrectParam::GetFpgaparam_8478_HL_Lvds(int dpi, int mode)
{
	std::lock_guard<std::mutex> lc(m_lock);
	FPGAConfigParam_8478 param;
	auto filejson = GetCorrectParams_8478_HL_Lvds();
	for (size_t i = 0; i < filejson.size(); i++)
	{
		if ((filejson[i].ColorMode == mode) &&
			(filejson[i].DpiMode == dpi))
		{
			param = filejson[i];
			break;
		}
	}
	return param;
}


void CorrectParam::set_sp(int dpi, int mode,uint32_t sp)
{
	auto param = GetFpgaparam(dpi,mode);
    param.Sp = sp;
    SaveCorrectParam(param);
}
void CorrectParam::set_sp_8478(int dpi, int mode,uint32_t sp)
{
	auto param = GetFpgaparam_8478(dpi,mode);
    param.Sp = sp;
    SaveCorrectParam(param);
}

void CorrectParam::set_sp_8458_color_lvds(int dpi,int mode,uint32_t sp)
{
	auto param = GetFpgaparam_8458_color_Lvds(dpi,mode);
    param.Sp = sp;
    SaveCorrectParam(param);
}

void CorrectParam::set_sp_8748_HL_lvds(int dpi,int mode,uint32_t sp)
{
	auto param = GetFpgaparam_8478_HL_Lvds(dpi,mode);
    param.Sp = sp;
    SaveCorrectParam(param);
}


CorrectParam m_static_correctparam;