#include "GF3CalibrationAndGeocodingClass.h"
#include "SatelliteGF3xmlParser.h"
#include <QRegularExpression>
#include <QMessageBox>
#include "GF3PSTNClass.h"
#include "boost/asio.hpp"
#include <boost/thread.hpp>
#include <thread>
#include <qprogressdialog.h>
#include "BaseTool.h"
#include "GeoOperator.h"
#include "ImageOperatorBase.h"
#include "FileOperator.h"
#include "GF3Util.h"
#include "GF3CalibrationAndOrthLib.h"

ErrorCode GF3CalibrationRaster(QString inRasterPath, QString outRasterPath, double Qualifyvalue, double calibrationConst)
{
	gdalImage imgraster(inRasterPath.toUtf8().constData());

	if (!isExists(outRasterPath)) {
		gdalImageComplex outraster = CreategdalImageComplex(outRasterPath, imgraster.height, imgraster.width, 1, imgraster.gt, imgraster.projection, false, true);
	}
	gdalImageComplex outraster(outRasterPath);


	long blocklines = Memory1MB  / 8 / imgraster.width*200;
	blocklines = blocklines < 100 ? 100 : blocklines;

	double quayCoff = Qualifyvalue * 1.0 / 32767;
	double caliCoff = std::pow(10.0, (calibrationConst * 1.0 / 20));
	qDebug() << u8"定标系数:\t" << quayCoff / caliCoff;
 

	omp_lock_t lock;
	omp_init_lock(&lock);
#pragma omp parallel for
	for (int64_t startrow = 0; startrow < imgraster.height; startrow = startrow + blocklines) {

		Eigen::MatrixXd  imgArrb1 = imgraster.getData(startrow, 0, blocklines, imgraster.width, 1);
		Eigen::MatrixXd  imgArrb2 = imgraster.getData(startrow, 0, blocklines, imgraster.width, 2);
		Eigen::MatrixXcd imgArr = outraster.getDataComplex(startrow, 0, blocklines, outraster.width, 1);
		imgArr.real() = imgArrb1.array() * quayCoff / caliCoff;
		imgArr.imag() = imgArrb2.array() * quayCoff / caliCoff;
		omp_set_lock(&lock);
		outraster.saveImage(imgArr, startrow, 0, 1);
		omp_unset_lock(&lock);	 //
	}
	omp_destroy_lock(&lock); //  
	qDebug() << u8"影像写入到：" << outRasterPath;
	return ErrorCode::SUCCESS;
}

ErrorCode ImportGF3L1ARasterToWorkspace(QString inMetaxmlPath, QString inRasterPath, QString outWorkDirPath, POLARTYPEENUM polsartype)
{
	SatelliteGF3xmlParser gf3xml;
	gf3xml.loadFile(inMetaxmlPath);
	QString filename = getFileNameWidthoutExtend(inRasterPath);
	SARSimulationImageL1Dataset l1dataset;
	l1dataset.OpenOrNew(outWorkDirPath, filename, gf3xml.height, gf3xml.width);
	l1dataset.setSateAntPos(SatellitePos2SatelliteAntPos(gf3xml.antposs));
	l1dataset.setCenterFreq(gf3xml.RadarCenterFrequency);
	l1dataset.setcolCount(gf3xml.width);
	l1dataset.setrowCount(gf3xml.height);
	l1dataset.setNearRange(gf3xml.nearRange);
	l1dataset.setRefRange(gf3xml.refRange);
	l1dataset.setFs(gf3xml.eqvFs);
	l1dataset.setPRF(gf3xml.eqvPRF);
	l1dataset.setCenterAngle((gf3xml.incidenceAngleNearRange + gf3xml.incidenceAngleFarRange) / 2.0); // 入射角
	l1dataset.setDopplerParametersReferenceTime(gf3xml.DopplerParametersReferenceTime);
	l1dataset.setTotalProcessedAzimuthBandWidth(gf3xml.TotalProcessedAzimuthBandWidth);
	l1dataset.setIncidenceAngleFarRange(gf3xml.incidenceAngleFarRange);
	l1dataset.setIncidenceAngleNearRangeet(gf3xml.incidenceAngleNearRange);
	l1dataset.setDopplerParams(gf3xml.d0, gf3xml.d1, gf3xml.d2, gf3xml.d3, gf3xml.d4);
	l1dataset.setDopplerCenterCoff(gf3xml.r0, gf3xml.r1, gf3xml.r2, gf3xml.r3, gf3xml.r4);
	l1dataset.setLatitudeCenter(gf3xml.latitude_center);
	l1dataset.setLongitudeCenter(gf3xml.longitude_center);
	l1dataset.setLatitudeTopLeft(gf3xml.latitude_topLeft);
	l1dataset.setLongitudeTopLeft(gf3xml.longitude_topLeft);
	l1dataset.setLatitudeTopRight(gf3xml.latitude_topRight);
	l1dataset.setLongitudeTopRight(gf3xml.longitude_topRight);
	l1dataset.setLatitudeBottomLeft(gf3xml.latitude_bottomLeft);
	l1dataset.setLongitudeBottomLeft(gf3xml.longitude_bottomLeft);
	l1dataset.setLatitudeBottomRight(gf3xml.latitude_bottomRight);
	l1dataset.setLongitudeBottomRight(gf3xml.longitude_bottomRight);
	l1dataset.setStartImageTime(gf3xml.start);
	l1dataset.setEndImageTime(gf3xml.end);
	l1dataset.saveToXml();

	QString outRasterpath = l1dataset.getImageRasterPath();

	ErrorCode errorcode = ErrorCode::SUCCESS;
	qDebug() << u8"导入数据:\t" << inRasterPath;
	switch (polsartype)
	{
	case POLARHH:
		qDebug() << u8"极化：HH";
		errorcode = GF3CalibrationRaster(inRasterPath, outRasterpath, gf3xml.HH_QualifyValue, gf3xml.HH_CalibrationConst);
		break;
	case POLARHV:
		qDebug() << u8"极化：HH";
		errorcode = GF3CalibrationRaster(inRasterPath, outRasterpath, gf3xml.HV_QualifyValue, gf3xml.HV_CalibrationConst);
		break;
	case POLARVH:
		qDebug() << u8"极化：VH";
		errorcode = GF3CalibrationRaster(inRasterPath, outRasterpath, gf3xml.VH_QualifyValue, gf3xml.VH_CalibrationConst);
		break;
	case POLARVV:
		qDebug() << u8"极化：VV";
		errorcode = GF3CalibrationRaster(inRasterPath, outRasterpath, gf3xml.VV_QualifyValue, gf3xml.VV_CalibrationConst);
		break;
	default:
		break;
	}
	qDebug() << u8"导入数据状态：\t" << QString::fromStdString(errorCode2errInfo(errorcode));

	return errorcode;
}

QVector<QString> SearchGF3DataTiff(QString inMetaxmlPath)
{
	// 指定路径
	QString xmlpath = inMetaxmlPath; // 替换为你的实际路径
	QString absPath = QFileInfo(xmlpath).absolutePath();
	// 获取路径所在的目录
	QDir directory(absPath);
	if (!directory.exists()) {
		qDebug() << u8"Directory does not exist:" << directory.absolutePath();
		return QVector<QString>(0);
	}

	// 设置过滤器以仅列出 .tif 文件
	QStringList filters;
	filters << "*.tif" << "*.TIF" << "*.tiff" << "*.TIFF";
	QStringList files = directory.entryList(filters, QDir::Files);

	qDebug() << u8"TIFF Files in the directory" << directory.absolutePath() << ":";
	QVector<QString> filepath(0);

	for (long i = 0; i < files.count(); i++) {
		filepath.append(JoinPath(absPath, files[i]));
	}

	return filepath;
}

POLARTYPEENUM getDatasetGF3FilePolsarType(QString fileName)
{

	// 提取极化情况
	QRegularExpression re("_([A-Z]{2})_");
	QRegularExpressionMatch match = re.match(fileName);
	QString polarization = "";
	if (match.hasMatch()) {
		polarization = match.captured(1);
		polarization = polarization.toLower().replace("_", "");
		qDebug() << u8"Polarization extracted:" << polarization;
		if (polarization == "hh") {
			return POLARTYPEENUM::POLARHH;
		}
		else if (polarization == "hv") {
			return POLARTYPEENUM::POLARHV;
		}
		else if (polarization == "vh") {
			return POLARTYPEENUM::POLARVH;
		}
		else if (polarization == "vv") {
			return POLARTYPEENUM::POLARVV;
		}
		else {
			return POLARTYPEENUM::POLARUNKOWN;
		}
	}
	else {
		qDebug() << u8"No polarization found in the path.";
		return POLARTYPEENUM::POLARUNKOWN;
	}

	return POLARTYPEENUM::POLARUNKOWN;
}

ErrorCode ImportGF3L1AProcess(QString inMetaxmlPath, QString outWorkDirPath)
{
	QVector<QString> tiffpaths = SearchGF3DataTiff(inMetaxmlPath);
	ErrorCode errorcode = ErrorCode::SUCCESS;
	for (long i = 0; i < tiffpaths.count(); i++) {
		QString tiffpath = tiffpaths[i];
		QString filenamewithoutextern = getFileNameWidthoutExtend(tiffpath);
		QString filename = getFileNameFromPath(tiffpath);
		POLARTYPEENUM poltype = getDatasetGF3FilePolsarType(filename);

		switch (poltype)
		{
		case POLARHH:
			errorcode = ImportGF3L1ARasterToWorkspace(inMetaxmlPath, tiffpath, outWorkDirPath, POLARTYPEENUM::POLARHH);
			break;
		case POLARHV:
			errorcode = ImportGF3L1ARasterToWorkspace(inMetaxmlPath, tiffpath, outWorkDirPath, POLARTYPEENUM::POLARHV);
			break;
		case POLARVH:
			errorcode = ImportGF3L1ARasterToWorkspace(inMetaxmlPath, tiffpath, outWorkDirPath, POLARTYPEENUM::POLARVH);
			break;
		case POLARVV:
			errorcode = ImportGF3L1ARasterToWorkspace(inMetaxmlPath, tiffpath, outWorkDirPath, POLARTYPEENUM::POLARVV);
			break;
		case POLARUNKOWN:
			break;
		default:
			break;
		}
		if (errorcode == ErrorCode::SUCCESS) {
			continue;
		}
		else {
			QMessageBox::warning(nullptr, u8"错误", u8"数据导入错误");
			break;
		}
	}
	return errorcode;
}


ErrorCode RD_PSTN(double& refrange, double& lamda, double& timeR, double& R, double& tx, double& ty, double& tz, double& slopex, double& slopey, double& slopez, GF3PolyfitSatelliteOribtModel& polyfitmodel, SatelliteOribtNode& node, double& d0, double& d1, double& d2, double& d3, double& d4)
{
	double dt = 1e-4;
	double inct = 0;
	bool antfalg = false;
	double timeR2 = 0;
	//return ((R_s1.array() * V_s1.array()).rowwise().sum().array() * (-2) / (R * this->lamda))[0];
	//double t = (R - this->refrange) * (1e6 / LIGHTSPEED);
	//return this->doppler_paras(0) + this->doppler_paras(1) * t + this->doppler_paras(2) * t * t + this->doppler_paras(3) * t * t * t + this->doppler_paras(4) * t * t * t * t;
	double R1 = 0;
	double R2 = 0;
	double dplerTheory1 = 0;
	double dplerTheory2 = 0;
	double dplerNumber1 = 0;
	double dplerNumber2 = 0;
	double dplerR = 0;
	// Rst=Rs-Rt;

	for (int i = 0; i < 50; i++) {
		polyfitmodel.getSatelliteOribtNode(timeR, node, antfalg);
		R1 = std::sqrt(std::pow(node.Px - tx, 2) + std::pow(node.Py - ty, 2) + std::pow(node.Pz - tz, 2));
		//dplerTheory1 = (-2 / lamda / R1) * ((node.Px - tx) * (node.Vx + EARTHWE * ty) + (node.Py - ty) * (node.Vy - EARTHWE * tx) + (node.Pz - tz) * (node.Vz - 0));
		dplerTheory1 = (-2 / lamda / R1) * ((node.Px - tx) * (node.Vx + 0) + (node.Py - ty) * (node.Vy -0) + (node.Pz - tz) * (node.Vz - 0));
		dplerR = (R1 - refrange) * 1e6 / LIGHTSPEED; // GF3 计算公式
		dplerNumber1 = d0 + dplerR * d1 + std::pow(dplerR, 2) * d2 + std::pow(dplerR, 3) * d3 + std::pow(dplerR, 4) * d4;

		timeR2 = timeR + dt;
		polyfitmodel.getSatelliteOribtNode(timeR2, node, antfalg);
		R2 = std::sqrt(std::pow(node.Px - tx, 2) + std::pow(node.Py - ty, 2) + std::pow(node.Pz - tz, 2));
		//dplerTheory2 = (-2 / lamda/R2) * ((node.Px - tx) * (node.Vx + EARTHWE * ty) + (node.Py - ty) * (node.Vy - EARTHWE * tx) + (node.Pz - tz) * (node.Vz - 0));
		dplerTheory2 = (-2 / lamda/R2) * ((node.Px - tx) * (node.Vx +0) + (node.Py - ty) * (node.Vy -0) + (node.Pz - tz) * (node.Vz - 0));
		//dplerR = (R2 - refrange) * 1e6 / LIGHTSPEED; // GF3 计算公式
		//dplerNumber2 = d0 + dplerR * d1 + std::pow(dplerR, 2) * d2 + std::pow(dplerR, 3) * d3 + std::pow(dplerR, 4) * d4;
 
		inct =  dt*(dplerTheory2-dplerNumber1) / (dplerTheory2 - dplerTheory1);
		if (std::abs(dplerNumber1 - dplerTheory2) < 1e-6 || std::abs(inct) < 1.0e-4) {
			R = R1; // 斜距
			return ErrorCode::SUCCESS;
			break;
		}
		inct = std::abs(inct) < 10 ?inct:inct*1e-2;
		timeR = timeR - inct;
	}
	return ErrorCode::FAIL;
	
}

ErrorCode GF3RDCreateLookTable(QString inxmlPath, QString indemPath, QString outworkdir, QString outlooktablePath,QString outLocalIncidenceAnglePath,bool localincAngleFlag)
{
	QString indemfilename = getFileNameWidthoutExtend(indemPath);

	QString resampleDEMXYZPath = JoinPath(outworkdir, indemfilename + "_XYZ.tif");
	QString resampleDEMSLOPEPath = JoinPath(outworkdir, indemfilename + "_slopevector.tif");
	DEM2XYZRasterAndSlopRaster(indemPath, resampleDEMXYZPath, resampleDEMSLOPEPath);

	gdalImage demxyz(resampleDEMXYZPath);// X,Y,Z
	gdalImage demslope(resampleDEMSLOPEPath);// X,Y,Z
	gdalImage rasterRC = CreategdalImage(outlooktablePath, demxyz.height, demxyz.width, 2, demxyz.gt, demxyz.projection, true, true);// X,Y,Z
	gdalImage localincangleRaster;
	if (localincAngleFlag) {
		localincangleRaster = CreategdalImage(outLocalIncidenceAnglePath, demxyz.height, demxyz.width, 1, demxyz.gt, demxyz.projection, true, true);// X,Y,Z
	}
	

	SARSimulationImageL1Dataset l1dataset;
	l1dataset.Open(inxmlPath);
	// RD 相关参数
	QVector<double> dopplers = l1dataset.getDopplerParams(); // 多普勒参数
	double d0 = dopplers[0];
	double d1 = dopplers[1];
	double d2 = dopplers[2];
	double d3 = dopplers[3];
	double d4 = dopplers[4];

	double fs = l1dataset.getFs()*1e6;// Fs采样
	double prf = l1dataset.getPRF();// PRF 采样

	double nearRange = l1dataset.getNearRange();
	double imagestarttime = l1dataset.getStartImageTime();
	double imageendtime = l1dataset.getEndImageTime();
	double refrange = l1dataset.getRefRange();
	double lamda = (LIGHTSPEED*1.0e-9)/ l1dataset.getCenterFreq();
	// 打印参数
	qDebug() << "Fs:\t" << fs;
	qDebug() << "prf:\t" << prf;
	qDebug() << "nearRange:\t" << nearRange;
	qDebug() << "imagestarttime:\t" << imagestarttime;
	qDebug() << "imageendtime:\t" << imageendtime;
	qDebug() << "refrange:\t" << refrange;
	qDebug() << "lamda:\t" << lamda;
	//打印多普累参数
	qDebug() << u8"-----------------------------------";
	qDebug() << u8"多普勒参数：\n";
	qDebug() << u8"d0:\t" << d0;
	qDebug() << u8"d1:\t" << d1;
	qDebug() << u8"d2:\t" << d2;
	qDebug() << u8"d3:\t" << d3;
	qDebug() << u8"d4:\t" << d4;
	qDebug() << u8"-----------------------------------";

	// 构建轨道模型
	GF3PolyfitSatelliteOribtModel polyfitmodel;
	QVector < SatelliteAntPos > antposes = l1dataset.getXmlSateAntPos();
	polyfitmodel.setSatelliteOribtStartTime((imagestarttime+imageendtime)/2);
	for (long i = 0; i < antposes.size(); i++) {
		if (antposes[i].time > imagestarttime - 5 && antposes[i].time < imageendtime + 5) {
			SatelliteOribtNode node;
			node.time = antposes[i].time;
			node.Px = antposes[i].Px;
			node.Py = antposes[i].Py;
			node.Pz = antposes[i].Pz;
			node.Vx = antposes[i].Vx;
			node.Vy = antposes[i].Vy;
			node.Vz = antposes[i].Vz;
			polyfitmodel.addOribtNode(node);
		}
	}
	polyfitmodel.polyFit(3, false);

	qDebug() << "-----------------------------------";
	qDebug() << u8"satellite polyfit model params:\n";
	qDebug() << polyfitmodel.getSatelliteOribtModelParamsString();
	qDebug() << "-----------------------------------";

	// 开始计算查找表
	//1.计算分块
	long cpucore_num = std::thread::hardware_concurrency();
	long blocklineinit = Memory1MB / 8 / cpucore_num / 4 / l1dataset.getcolCount() * 8000;
	blocklineinit = blocklineinit < 50 ? 50 : blocklineinit;
	//2.迭代计算
	long colcount = rasterRC.width;//l1dataset.getcolCount();
	long rowcount = rasterRC.height;//l1dataset.getrowCount();
	long startRId = 0;
	
	long processNumber = 0;
	QProgressDialog progressDialog(u8"查找表生成中", u8"终止", 0, rowcount);
	progressDialog.setWindowTitle(u8"查找表生成中");
	progressDialog.setWindowModality(Qt::WindowModal);
	progressDialog.setAutoClose(true);
	progressDialog.setValue(0);
	progressDialog.setMaximum(rowcount);
	progressDialog.setMinimum(0);
	progressDialog.show();
	omp_lock_t lock;
	omp_init_lock(&lock);




	for (startRId = 0; startRId < rowcount; startRId = startRId + blocklineinit) {
		long blockline = blocklineinit;
		if (startRId + blockline > rowcount) {
			blockline = rowcount - startRId;
		}
		Eigen::MatrixXd sar_r = rasterRC.getData(startRId, 0, blockline, colcount, 1);
		Eigen::MatrixXd sar_c = rasterRC.getData(startRId, 0, blockline, colcount, 2);
		Eigen::MatrixXd dem_x = demxyz.getData(startRId, 0, blockline, colcount, 1);
		Eigen::MatrixXd dem_y = demxyz.getData(startRId, 0, blockline, colcount, 2);
		Eigen::MatrixXd dem_z = demxyz.getData(startRId, 0, blockline, colcount, 3);


		long blockrows = sar_r.rows();
		long blockcols = sar_r.cols();

#pragma omp parallel for  
		for (long i = 0; i < blockrows; i++) {
			// 逐像素迭代计算
			double timeR = 0;
			double tx = 0;
			double ty = 0;
			double tz = 0;
			double R = 0;
			double slopex = 0, slopey = 0, slopez = 0;
			SatelliteOribtNode node{ 0,0,0,0,0,0,0,0 };
			bool antflag = false;
			for (long j = 0; j < blockcols; j++) {

				tx = dem_x(i, j);
				ty = dem_y(i, j);
				tz = dem_z(i, j);
				if (RD_PSTN(refrange,lamda, timeR,R,tx,ty,tz,slopex,slopey,slopez,polyfitmodel,node,d0,d1,d2,d3,d4) == ErrorCode::SUCCESS) {
					sar_r(i, j) =( timeR+ (imagestarttime + imageendtime) / 2 -imagestarttime) * prf;
					sar_c(i, j) = ((R - nearRange) * 2 / LIGHTSPEED) * fs;
				}
				else {
					sar_r(i, j) = -1;
					sar_c(i, j) = -1;
				}
			}
		}

		// 保存结果
		omp_set_lock(&lock);
		rasterRC.saveImage(sar_r, startRId, 0, 1);
		rasterRC.saveImage(sar_c, startRId, 0, 2);
 
		omp_unset_lock(&lock);

		Eigen::MatrixXd Angle_Arr = Eigen::MatrixXd::Zero(dem_x.rows(),dem_x.cols()).array()+181;
		if (localincAngleFlag) {
			Eigen::MatrixXd demslope_x = demslope.getData(startRId, 0, blockline, colcount, 1);
			Eigen::MatrixXd demslope_y = demslope.getData(startRId, 0, blockline, colcount, 2);
			Eigen::MatrixXd demslope_z = demslope.getData(startRId, 0, blockline, colcount, 3);
			Eigen::MatrixXd Angle_Arr = localincangleRaster.getData(startRId, 0, blockline, colcount, 1);

			double Rst_x = 0, Rst_y = 0, Rst_z = 0, localangle = 0;
			double slopeR = 0;
#pragma omp parallel for  
			for (long i = 0; i < blockrows; i++) {
				// 逐像素迭代计算
				double timeR = 0;
				double tx = 0;
				double ty = 0;
				double tz = 0;
				double R = 0;
				double slopex = 0, slopey = 0, slopez = 0;
				SatelliteOribtNode node{ 0,0,0,0,0,0,0,0 };
				bool antflag = false;


				for (long j = 0; j < blockcols; j++) {
					timeR = sar_r(i, j) / prf;
					slopex = demslope_x(i, j);
					slopey = demslope_y(i, j);
					slopez = demslope_z(i, j);
					tx = dem_x(i, j);
					ty = dem_y(i, j);
					tz = dem_z(i, j);

					polyfitmodel.getSatelliteOribtNode(timeR, node, antflag);
					Rst_x = node.Px - tx;
					Rst_y = node.Py - ty;
					Rst_z = node.Pz - tz;
					R = std::sqrt(Rst_x*Rst_x+Rst_y*Rst_y+Rst_z*Rst_z);
					slopeR = std::sqrt(slopex*slopex + slopey * slopey + slopez * slopez);
					localangle = ((slopex * Rst_x) + (slopey * Rst_y) + (slopez * Rst_z));
					localangle = std::acos(localangle / R/slopeR)*r2d; // 角度
					Angle_Arr(i, j) = localangle;
				}
			}
	
			// 保存结果
			omp_set_lock(&lock);
 
			if (localincAngleFlag) {
				localincangleRaster.saveImage(Angle_Arr, startRId, 0, 1);
			}
			else {}
			omp_unset_lock(&lock);
		}


		// 保存结果
		omp_set_lock(&lock);
 
		processNumber = processNumber + blockrows;
		qDebug() << u8"\rprocess bar:\t" << processNumber * 100.0 / rowcount << " % " << "\t\t\t";
		if (progressDialog.maximum() <= processNumber) {
			processNumber = progressDialog.maximum() - 1;
		}
		progressDialog.setValue(processNumber);
		omp_unset_lock(&lock);
	}
	progressDialog.close();
	return ErrorCode::SUCCESS;
}



ErrorCode GF3OrthSLC( QString inRasterPath, QString inlooktablePath, QString outRasterPath)
{
	gdalImage slcRaster(inRasterPath);// 
	gdalImage looktableRaster(inlooktablePath);// 
	gdalImage outRaster = CreategdalImage(outRasterPath, looktableRaster.height, looktableRaster.width, 1, looktableRaster.gt, looktableRaster.projection, true, true);// X,Y,Z
	//gdalImage outRaster(outRasterPath);// 

	if (outRaster.height != looktableRaster.height || outRaster.width != looktableRaster.width) {
		qDebug() << u8"look table size is not same as outRaster size"<< looktableRaster.height <<"!="<<outRaster.height<<"   "<<looktableRaster.width<<"!="<<outRaster.width;
		return ErrorCode::FAIL;
	}

	// 分块插值计算
	long blockline = Memory1MB / looktableRaster.width / 8 * 200;//300M
	blockline = blockline < 1 ? 1 : blockline;

	int64_t allcount = 0;
#pragma omp parallel for  
	for (long startrowid = 0; startrowid < looktableRaster.height; startrowid = startrowid + blockline) {
		long tempblockline = startrowid + blockline < looktableRaster.height ? blockline : looktableRaster.height - startrowid;
		Eigen::MatrixXd sar_r = looktableRaster.getData(startrowid, 0, tempblockline, looktableRaster.width, 1);
		Eigen::MatrixXd sar_c = looktableRaster.getData(startrowid, 0, tempblockline, looktableRaster.width, 2);

		int64_t slc_min_rid = sar_r.array().minCoeff();
		int64_t slc_max_rid = sar_r.array().maxCoeff();

		int64_t slc_r_len = slc_max_rid - slc_min_rid+1;
		slc_min_rid = slc_min_rid < 0 ? 0 : slc_min_rid-1;
		slc_r_len = slc_r_len + 2;

		Eigen::MatrixXd slcImg = slcRaster.getData(slc_min_rid, 0, slc_r_len, slcRaster.width, 1);
		Eigen::MatrixXd outImg = outRaster.getData(startrowid, 0, tempblockline, outRaster.width, 1);
 
		long lastr = 0;
		long nextr = 0;
		long lastc = 0;
		long nextc = 0;
		double Bileanervalue = 0;
		// 插值
		Landpoint p0{ 0,0,0 }, p11{ 0,0,0 }, p21{ 0,0,0 }, p12{ 0,0,0 }, p22{ 0,0,0 }, p{ 0,0,0 };

		long lookRows = sar_r.rows();
		long lookCols = sar_r.cols();

		long slcRows = slcImg.rows();
		long slcCols = slcImg.cols();

		for (long i = 0; i < lookRows; i++) {
			for (long j = 0; j < lookCols; j++) {
				p0 = { sar_c(i,j) - lastc, sar_r(i,j) - lastr,0 };
				lastr = std::floor(sar_r(i, j));
				nextr = std::ceil(sar_r(i, j));
				lastc = std::floor(sar_c(i, j));
				nextc = std::ceil(sar_c(i, j));
				lastr = lastr - slc_min_rid;
				nextr = nextr - slc_min_rid;
				if (lastr < 0 || lastc < 0 || nextr >= slcRows || nextc >= slcCols) {
					continue;
				}
				p11 = Landpoint{ 0,0,slcImg(lastr,lastc) };
				p21 = Landpoint{ 0,1,slcImg(nextr,lastc) };
				p12 = Landpoint{ 1,0,slcImg(lastr,nextc) };
				p22 = Landpoint{ 1,1,slcImg(nextr,nextc) };

				Bileanervalue = Bilinear_interpolation(p0, p11, p21, p12, p22);
				outImg(i, j) = Bileanervalue;
			}
 		}

		outRaster.saveImage(outImg, startrowid, 0, 1);
		allcount = allcount + tempblockline;
	}
 	return ErrorCode::SUCCESS;
}

ErrorCode GF3RDProcess(QString inxmlPath, QString indemPath, QString outworkdir, double gridx, double gridy)
{
	SARSimulationImageL1Dataset l1dataset;
	l1dataset.Open(inxmlPath);

	DemBox box = l1dataset.getExtend();
	double dlon = 0.2 * (box.max_lon - box.min_lon);
	double dlat = 0.2 * (box.max_lat - box.min_lat);

	double minlat = box.min_lat - dlat;
	double minlon = box.min_lon - dlon;
	double maxlat = box.max_lat + dlat;
	double maxlon = box.max_lon + dlon;
	qDebug() << u8"影像范围:";
    qDebug() << u8"Bounding Box:";  
    qDebug() << u8"Latitude:" << minlat <<"  -  "<< maxlat;
    qDebug() << u8"Longitude:" << minlon <<"  -  "<< maxlon;
	double centerlat = (minlat + maxlat) / 2;
	double centerlon = (minlon + maxlon) / 2;
	long sourceespgcode = getProjectEPSGCodeByLon_Lat(centerlon, centerlat);
	long demespgcode = GetEPSGFromRasterFile(indemPath);
	double grid_resolution = gridx < gridy ? gridx : gridy;
	double degreePerPixelX = getPixelSpacingInDegree(grid_resolution);
	double degreePerPixelY = getPixelSpacingInDegree(grid_resolution);
	bool  meter2degreeflag = ConvertResolutionToDegrees(
		sourceespgcode,
		grid_resolution,
		centerlon,
		centerlat,
		degreePerPixelX,
		degreePerPixelY
	);
	if (!meter2degreeflag) {
		qDebug() << u8"转换分辨率为经纬度失败";
		degreePerPixelX = getPixelSpacingInDegree(grid_resolution);
		degreePerPixelY = getPixelSpacingInDegree(grid_resolution);
	}
	qDebug() << u8"DEM影像范围:";
	qDebug() << u8"输入分辨率："<<gridx<<" \t" << gridy;
	qDebug() << u8"影像分辨率:\t" << grid_resolution;
	qDebug() << u8"分辨率转换为经纬度:\t" << degreePerPixelX << "\t" << degreePerPixelY;
	// 计算DEM的分辨率

	// 裁剪DEM
	QString filename = getFileNameWidthoutExtend(l1dataset.getxmlFilePath());
	filename = filename.right(5);
	QString clipDEMPath = JoinPath(outworkdir, getFileNameWidthoutExtend(indemPath) + filename + "_clip.tif");
	cropRasterByLatLon(indemPath.toUtf8().constData(), clipDEMPath.toUtf8().constData(), minlon, maxlon, minlat, maxlat);
	QString resampleDEMPath = JoinPath(outworkdir, getFileNameWidthoutExtend(indemPath) + filename + "_clip_resample.tif");
	resampleRaster(clipDEMPath.toUtf8().constData(), resampleDEMPath.toUtf8().constData(), degreePerPixelX, degreePerPixelY);

	QString outlooktablePath = JoinPath(outworkdir, getFileNameWidthoutExtend(l1dataset.getxmlFilePath()) + "_looktable.tif");
	QString outlocalAnglePath = JoinPath(outworkdir, getFileNameWidthoutExtend(l1dataset.getxmlFilePath()) + "_localAngle.tif");

	QString outOrthPath=JoinPath(outworkdir, getFileNameWidthoutExtend(l1dataset.getxmlFilePath()) + "_orth.tif");
	if (GF3RDCreateLookTable(inxmlPath,   resampleDEMPath, outworkdir, outlooktablePath, outlocalAnglePath,true) != ErrorCode::SUCCESS) {
		qDebug() << u8"查找表生成错误：\t" + getFileNameWidthoutExtend(inxmlPath);
		return ErrorCode::FAIL;
	}
	return ErrorCode::SUCCESS;
}

ErrorCode GF3MainOrthProcess(QString inDEMPath, QString inTarFilepath, QString outworkspacefolderpath, double pixelresultionDegreee, bool excutehh2vv)
{

	QProgressDialog progressDialog(u8"正射校正处理", u8"", 0, 6);
	progressDialog.setWindowTitle(u8"正射校正处理");
	progressDialog.setWindowModality(Qt::WindowModal);
	progressDialog.setAutoClose(true);
	progressDialog.setValue(0);
	progressDialog.setMaximum(6);
	progressDialog.setMinimum(0);
	progressDialog.show();

	qDebug() << u8"开始正射校正处理";
	// 获取任务名称
	QString tarfilename = getFileNameWidthoutExtend(inTarFilepath);

	// step 1. 创建工作空间
	GF3TargzFilenameClass tarnameclss=getFilename(tarfilename);
	QString productionname = tarnameclss.getProductName();
	QString workfolderpath = JoinPath(outworkspacefolderpath, productionname); // 工作空间
	createNewFolerPath(workfolderpath, true);
	qDebug() << u8"step 1. 创建工作空间 ok";
	progressDialog.setValue(1);
	// step 2.解压文件
	QString unarchiverFolderPath = JoinPath(workfolderpath, u8"unarchiver");
	createNewFolerPath(unarchiverFolderPath, true);
	unTarfile(inTarFilepath, unarchiverFolderPath);
	qDebug() << u8"step 2.解压文件 ok";
	progressDialog.setValue(2);
	// 在解压文件夹中以及子文件夹查找meta.xml文件
	QFileInfoList metalist = findFilePath(unarchiverFolderPath, u8"*.meta.xml");
	if (metalist.count() !=1) {
		qWarning() << u8"目标文件夹发现了多个meta.xml,不符合规则";
		QMessageBox::warning(nullptr, u8"警告", QString(u8"%1:%2").arg(tarfilename).arg(u8"目标文件夹发现了多个meta.xml,不符合规则"));
		return ErrorCode::METAXMLFOUNDERROR;
	}
	else {}
	QString metaxmlpath = metalist[0].canonicalFilePath();

	// step 3.文件转换为通用L1A文件
	QString L1AFolder = JoinPath(workfolderpath, u8"L1AFolder");
	createNewFolerPath(L1AFolder);
	ImportGF3L1AProcess(metaxmlpath, L1AFolder);
	qDebug() << u8"step 3.文件转换为通用L1A文件 ok";
	progressDialog.setValue(3);
	// step 4. 幅度转amp  
	QFileInfoList xmlfilelist = findFilePath(L1AFolder, u8"*.xml");
	if (xmlfilelist.count() == 0) {
		qWarning() << u8"目标文件夹没有发现了L1A数据 xml,不符合规则";
		QMessageBox::warning(nullptr, u8"警告", QString(u8"%1:%2").arg(tarfilename).arg(u8"目标文件夹没有发现了L1A数据 xml,不符合规则"));
		return ErrorCode::METAXMLFOUNDERROR;
	}

	QString outampfolder = JoinPath(workfolderpath, u8"ampRaster");
	createNewFolerPath(outampfolder);
	for (long i = 0; i < xmlfilelist.count(); i++) {

		QString filename = getFileNameWidthoutExtend(xmlfilelist[i].canonicalFilePath());
		QString l2bfilename = filename + "_amp";
		QString folderpath = getParantFromPath(xmlfilelist[i].canonicalFilePath());
		SARSimulationImageL1Dataset slcl1(RasterLevel::RasterSLC);
		slcl1.Open(folderpath, filename);
	

		SARSimulationImageL1Dataset l1B(RasterLevel::RasterL1B);
		l1B.OpenOrNew(outampfolder, l2bfilename, slcl1.getrowCount(), slcl1.getcolCount());
		QString srcxmlpath = slcl1.getxmlFilePath();
		QString tarxmlpath = l1B.getxmlFilePath();
		copyAndReplaceFile(srcxmlpath, tarxmlpath);
		l1B.loadFromXml();
		QString imgfilepath = slcl1.getImageRasterPath();
		Complex2AmpRaster(imgfilepath, l1B.getImageRasterPath()); // 转振幅
	}
	progressDialog.setValue(4);
	// step 5. 创建正射查找表
	QString L1AXmlPath = xmlfilelist[0].canonicalFilePath();
	QString looktablefolderpath = JoinPath(workfolderpath, u8"looktableRaster");
	createNewFolerPath(looktablefolderpath);
	if (GF3RDProcess(L1AXmlPath, inDEMPath, looktablefolderpath, pixelresultionDegreee, pixelresultionDegreee) == SUCCESS) {
		qDebug()<<(u8"正射表生成成功");
	}
	else {
		qDebug() << (u8"正射表生成失败");
	}
	progressDialog.setValue(5);
	qDebug() << u8"step 4. 创建正射查找表 ok";
	// step 6. 影像正射
	QFileInfoList looktableRasterPathList = findFilePath(looktablefolderpath, u8"*_looktable.tif");
	if (looktableRasterPathList.count() != 1) {
		qWarning() << u8"目标文件夹发现了多个查找表,不符合规则";
		QMessageBox::warning(nullptr, u8"警告", QString(u8"%1:%2").arg(tarfilename).arg(u8"目标文件夹发现了多个查找表,不符合规则"));
		return ErrorCode::METAXMLFOUNDERROR;
	}

	// step 6.1 影像入射角
	QFileInfoList looktableAngleRasterPathList = findFilePath(looktablefolderpath, u8"*_localAngle.tif");
	if (looktableAngleRasterPathList.count() != 1) {
		qWarning() << u8"目标文件夹应该只有1个入射角,不符合规则";
		QMessageBox::warning(nullptr, u8"警告", QString(u8"%1:%2").arg(tarfilename).arg(u8"目标文件夹发现了1个入射角,不符合规则"));
		return ErrorCode::METAXMLFOUNDERROR;
	}
	QString lookincidenceAnglePath = looktableAngleRasterPathList[0].canonicalFilePath();
	QString looktableRasterPath = looktableRasterPathList[0].canonicalFilePath();
	QString outworkpath = JoinPath(workfolderpath, u8"orth");
	createNewFolerPath(outworkpath, true);
	QFileInfoList l2filelist = findFilePath(outampfolder,u8"*.xml");
	for (long i = 0; i < l2filelist.count(); i++) {
		QString inl2filepath = l2filelist[i].canonicalFilePath();
		SARSimulationImageL1Dataset l1B(RasterLevel::RasterL1B);
		l1B.Open(inl2filepath);
		QString inRaster = l1B.getImageRasterPath();
		QString outname = getFileNameWidthoutExtend(inRaster) + "_orth.tif";
		QString outstringpath = JoinPath(outworkpath, outname);
		if (GF3OrthSLC(inRaster, looktableRasterPath, outstringpath) == SUCCESS) {
			qDebug() << (u8"正射生成成功");
		}
		else {
			qDebug() << (u8"正射生成失败");
		}
		
		qDebug() << u8"step 5. 正射影像生成 ok";
		// step 6.2 生成HH2VV	
		POLARTYPEENUM poltype = getDatasetGF3FilePolsarType(outname);
		if (poltype == POLARHH && excutehh2vv) {
			qDebug() << u8"HH2VV生成中:"<< outstringpath;
			QString intempHH2VV = JoinPath(outworkpath, getFileNameWidthoutExtend(outstringpath) + "_HH2VV_dB.tif");
			GF3_Sigma0_HH2VV(outstringpath, looktableRasterPath,intempHH2VV);
		}
		else {
			// 将amp转换为sigma0
			QString intempHH2VV = JoinPath(outworkpath, getFileNameWidthoutExtend(outstringpath) + "_HH2VV_dB.tif");
			amp2dBRaster(outstringpath, intempHH2VV);



			//qDebug() << u8"HH2VV不需要生成";
		}
		qDebug() << u8"step 6. HH2VV生成 ok";

	}
	progressDialog.setValue(6);
	progressDialog.close();
	return ErrorCode::SUCCESS;
}