增加BaseTool、ToolAbstract

.gitignore

@@ -32,9 +32,7 @@ mono_crash.*
 **/**/[Oo]ut/
 **/**/[Ll]og/
 **/**/[Ll]ogs/
-**/BaseTool/
-BaseTool/
-ToolAbstract/
+
 
 **/Releases
 # Visual Studio 2015/2017 cache/options directory

BaseTool/BaseConstVariable.h

@@ -0,0 +1,388 @@
+#pragma once
+
+#ifndef BASECONSTVARIABLE_H
+#define BASECONSTVARIABLE_H
+//#define EIGEN_USE_MKL_ALL
+//#define EIGEN_NO_DEBUG 
+
+
+
+#ifdef BASECONSTVARIABLE_API
+#define BASECONSTVARIABLEAPI __declspec(dllexport)
+#else
+#define BASECONSTVARIABLEAPI __declspec(dllimport)
+#endif
+
+
+
+/** 定义常见文件格式*********/
+#define ENVI_FILE_FORMAT_FILTER u8"ALL File(*.*);;ENVI Bin(*.bin);;ENVI Data(*.dat);;ENVI Data(*.data);;tiff影像(*.tif);;tiff影像(*.tiff)"
+#define XML_FILE_FORMAT_FILTER u8"ALL File(*.*);;XML File(*.xml);;tiff影像(*.tiff)"
+
+
+//
+//#define EIGEN_USE_BLAS
+//#define EIGEN_USE_LAPACK
+//#define EIGEN_VECTORIZE_SSE2
+
+//#define DEBUGSHOWDIALOG
+
+#define __CUDANVCC___ // 定义CUDA函数
+
+#define __PRFDEBUG__
+//#define __PRFDEBUG_PRFINF__
+//#define __ECHOTIMEDEBUG__
+
+#define __TBPIMAGEDEBUG__
+
+//#include <mkl.h>
+#include <complex>
+#include <math.h>
+#include <complex>
+#include <time.h>
+
+/** 打印时间 ***************************************************************/
+inline char* get_cur_time() {
+	static char s[20];
+	time_t t;
+	struct tm* ltime;
+	time(&t);
+	ltime = localtime(&t);
+	strftime(s, 20, "%Y-%m-%d %H:%M:%S", ltime);
+	return s;
+}
+
+#define PRINT(fmt, ...) printf("%s " fmt, get_cur_time(), ##__VA_ARGS__);
+
+
+
+
+#define MATPLOTDRAWIMAGE
+
+
+#define r2d 180/3.141592653589793238462643383279
+#define d2r 3.141592653589793238462643383279/180
+#define LIGHTSPEED 299792458
+#define PRECISIONTOLERANCE 1e-6
+#define Radians2Degrees(Radians) Radians*PI_180
+#define Degrees2Radians(Degrees) Degrees*T180_PI
+#define EARTHWE 0.000072292115
+#define PI 3.141592653589793238462643383279
+ 
+#define WGS84_A 6378137.0       // 长半轴 (m)
+#define WGS84_F (1.0/298.257223563)
+#define WGS84_B (WGS84_A*(1-WGS84_F)) // 短半轴 (m)
+
+
+#define earthRoute 0.000072292115
+#define Memory1GB 1073741824
+#define Memory1MB 1048576
+#define Memory1KB 1024
+
+const std::complex<double> imagI(0, 1);
+
+ 
+const double epsilon = 0.000000000000001;
+const double pi = 3.14159265358979323846;
+ 
+
+const double a = 6378137.0;		//椭球长半轴
+const double ae = 6378137.0;		//椭球长半轴
+const double ee = 0.0818191910428;// 第一偏心率
+const double f_inverse = 298.257223563;			//扁率倒数
+const double b = a - a / f_inverse;
+const double eSquare = (a * a - b * b) / (a * a);
+const double e = sqrt(eSquare);
+const double earth_Re = 6378136.49;
+const double earth_Rp = (1 - 1 / f_inverse) * earth_Re;
+const double earth_We = 0.000072292115;
+
+/*********************************************** openMap参数 ********************************************************************/
+static long Paral_num_thread = 14;
+
+
+/*********************************************** 基础枚举 ********************************************************************/
+
+enum POLARTYPEENUM { // 极化类型
+	POLARHH,
+	POLARHV,
+	POLARVH,
+	POLARVV,
+	POLARUNKOWN
+};
+
+
+enum SIGMATYPE {
+	DBVALUE,
+	AMPVALUE,
+	INTENSITYVALUE,
+	LINEARVALUE
+};
+
+
+/*********************************************** 基础结构体区域 ********************************************************************/
+
+/// <summary>
+/// 地理坐标点
+/// </summary>
+struct Landpoint //  点   SAR影像的像素坐标；
+{
+	double lon; // 经度x lon pixel_col
+	double lat; // 纬度y lat pixel_row
+	double ati; // 高程z ati pixel_time
+};
+
+struct Point2 {
+	double x = 0;
+	double y = 0;
+};
+
+
+struct Point3 {
+	double x = 0;
+	double y = 0;
+	double z = 0;
+	void setX(double ix) { x = ix; }
+	void setY(double iy) { y = iy; }
+	void setZ(double iz) { z = iz; }
+};
+
+struct Point_3d {
+	double x;
+	double y;
+	double z;
+};
+
+
+
+struct DemBox {
+	double min_lon;
+	double max_lon;
+	double min_lat;
+	double max_lat;
+};
+
+struct Vector3 {
+	double x, y, z;
+};
+
+
+struct Vector3_single {
+	float x, y, z;
+};
+
+
+/*********************************************** FEKO仿真参数 ********************************************************************/
+extern "C" struct SatellitePos {
+	double time;
+	double Px  ;
+	double Py  ;
+	double Pz  ;
+	double Vx  ;
+	double Vy  ;
+	double Vz  ;
+};
+
+
+extern "C" struct SatelliteAntPos {
+	double time; // 0
+	double Px;
+	double Py;
+	double Pz;
+	double Vx;
+	double Vy;
+	double Vz; //7
+	double AntDirectX;
+	double AntDirectY;
+	double AntDirectZ;
+	double AVx;
+	double AVy;
+	double AVz;//13
+	double ZeroAntDiectX;
+	double ZeroAntDiectY;
+	double ZeroAntDiectZ;
+	double lon;
+	double lat;
+	double ati; // 19
+};
+
+
+extern "C" struct PatternImageDesc {
+	long  phinum;
+	long  thetanum;
+	double  startTheta;
+	double  startPhi;
+	double  dtheta;
+	double  dphi;
+};
+
+
+struct CUDA_AntSate_PtrList {
+	long PRF_len = 0;
+	double* h_antpx = nullptr, * d_antpx = nullptr;
+	double* h_antpy = nullptr, * d_antpy = nullptr;
+	double* h_antpz = nullptr, * d_antpz = nullptr;
+	double* h_antvx = nullptr, * d_antvx = nullptr;
+	double* h_antvy = nullptr, * d_antvy = nullptr;
+	double* h_antvz = nullptr, * d_antvz = nullptr;
+	double* h_antdirectx = nullptr, * d_antdirectx = nullptr;
+	double* h_antdirecty = nullptr, * d_antdirecty = nullptr;
+	double* h_antdirectz = nullptr, * d_antdirectz = nullptr;
+	double* h_antXaxisX = nullptr, * d_antXaxisX = nullptr;
+	double* h_antXaxisY = nullptr, * d_antXaxisY = nullptr;
+	double* h_antXaxisZ = nullptr, * d_antXaxisZ = nullptr;
+	double* h_antYaxisX = nullptr, * d_antYaxisX = nullptr;
+	double* h_antYaxisY = nullptr, * d_antYaxisY = nullptr;
+	double* h_antYaxisZ = nullptr, * d_antYaxisZ = nullptr;
+	double* h_antZaxisX = nullptr, * d_antZaxisX = nullptr;
+	double* h_antZaxisY = nullptr, * d_antZaxisY = nullptr;
+	double* h_antZaxisZ = nullptr, * d_antZaxisZ = nullptr;
+};
+
+/*********************************************** 卫星轨道坐标 ********************************************************************/
+
+
+/// <summary>
+/// 轨道节点,坐标系统为WGS84
+/// </summary>
+struct SatelliteOribtNode {
+	double time;
+
+	double Px;// 位置
+	double Py;
+	double Pz;
+
+	double Vx;// 速度
+	double Vy;
+	double Vz;
+
+	double AVx; // 加速度
+	double AVy;
+	double AVz;
+
+	double AntXaxisX; // X天线指向，对应翻滚角等参数
+	double AntXaxisY; //  
+	double AntXaxisZ; //  
+
+	double AntYaxisX; // Y天线指向，对应翻滚角等参数
+	double AntYaxisY; //  
+	double AntYaxisZ; //  
+
+	double AntZaxisX; // Z天线指向，对应翻滚角等参数
+	double AntZaxisY; //  
+	double AntZaxisZ; //  
+
+
+	double AntDirecX; // 天线指向，对应翻滚角等参数
+	double AntDirecY;
+	double AntDirecZ;
+
+	double zeroDopplerDirectX; // 0 多普勒方向
+	double zeroDopplerDirectY;
+	double zeroDopplerDirectZ;
+
+	double beamAngle; // 波位角
+	double AzAngle;// 摆动角
+
+
+};
+
+
+struct SatelliteAntDirect {
+	double Xst;		 // 地面-->卫星矢量
+	double Yst;
+	double Zst;
+	double Vxs;		// 卫星速度
+	double Vys;
+	double Vzs;
+
+	double Xant;	// 天线坐标系下的 矢量坐标
+	double Yant;
+	double Zant;
+
+	double Norm;
+
+	double ThetaAnt; // 天线坐标系下的 theta 坐标系
+	double PhiAnt;
+};
+
+
+
+struct RadiationPatternGainPoint {
+	double theta;
+	double phi;
+	double GainValue;
+};
+
+
+
+
+/*********************************************** 指针回收区域 ********************************************************************/
+
+inline void delArrPtr(void* p)
+{
+	if (nullptr == p || NULL == p) {
+		return;
+	}
+	delete[] p;
+	p = nullptr;
+};
+
+inline void delPointer(void* p)
+{
+	if (nullptr == p || NULL == p) {
+		return;
+	}
+	delete p;
+	p = nullptr;
+};
+  
+inline void PrintTime() {
+	time_t current_time;
+	time(&current_time);
+	printf("Current timestamp in seconds: %ld\n", (long)current_time);
+};
+
+/** 计算分块 ******************************************************************/
+
+inline long getBlockRows(long sizeMB, long cols, long sizeMeta, long maxRows) {
+	long rownum = (round(Memory1MB * 1.0 / sizeMeta / cols * sizeMB) + cols - 1);
+	rownum = rownum < 0 ? 1 : rownum;
+	rownum = rownum < maxRows ? rownum : maxRows;
+	return rownum;
+};
+
+
+inline long nextpow2(long n) {
+	long en = ceil(log2(n));
+	return pow(2, en);
+};
+
+inline void releaseVoidArray(void* a)
+{
+	free(a);
+	a = NULL;
+};
+
+
+
+inline double converSigma2amp(double inSig, SIGMATYPE sigtype) {
+	switch (sigtype)
+	{
+	case DBVALUE:
+		return pow(10, inSig / 20);
+		break;
+	case AMPVALUE:
+		return inSig;
+		break;
+	case INTENSITYVALUE:
+		return pow(10, inSig / 10);
+		break;
+	default:
+		return inSig;
+		break;
+	}
+}
+
+
+#endif

BaseTool/BaseTool.cpp

@@ -0,0 +1,775 @@
+#include "stdafx.h"
+//#define EIGEN_USE_BLAS
+#define EIGEN_VECTORIZE_SSE4_2
+//#include <mkl.h>
+
+#include <iostream>
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <time.h>
+////#include <mkl.h>
+ 
+#include <omp.h>
+#include <QDir>
+#include < io.h >
+#include < stdio.h >
+#include < stdlib.h >
+#include <gdal.h>
+#include <gdal_priv.h>
+#include <gdalwarper.h>
+//#include <ogr_geos.h>
+#include <ogrsf_frmts.h> //#include "ogrsf_frmts.h"
+
+#include <fstream>
+#include <proj.h>
+#include "GeoOperator.h"
+
+#include <iostream>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include "baseTool.h"
+
+#include <gsl/gsl_fit.h> // 多项式拟合
+#include <gsl/gsl_cdf.h>    /* 提供了 gammaq 函数 */
+#include <gsl/gsl_vector.h> /* 提供了向量结构*/
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_multifit.h>
+#include <qcoreapplication.h>
+
+#include <xmmintrin.h> // 包含SSE指令集头文件
+#include <emmintrin.h> // 包含SSE2指令集头文件
+#include <omp.h>      // 包含OpenMP头文件
+#include <iostream>
+#include <string>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/date_time/posix_time/conversion.hpp>
+
+QString longDoubleToQStringScientific(long double value) {
+	std::ostringstream stream;
+
+	// 设置流的精度为35位有效数字，并使用科学计数法
+	stream << std::scientific << std::setprecision(35) << value;
+
+	// 将标准字符串转换为 QString
+	return QString::fromStdString(stream.str());
+}
+
+QString   getCurrentTimeString() {
+	struct tm ConversionTime;
+	std::time_t t = std::time(NULL);
+	char mbstr[100];
+	_localtime64_s(&ConversionTime, &t);
+	std::strftime(mbstr, sizeof(mbstr), "%Y-%m-%d %H:%M:%S", &ConversionTime);
+	QString strTime = mbstr;
+	return strTime;
+}
+
+QString   getCurrentShortTimeString() {
+	struct tm ConversionTime;
+	std::time_t t = std::time(NULL);
+	char mbstr[100];
+	_localtime64_s(&ConversionTime, &t);
+	std::strftime(mbstr, sizeof(mbstr), "%Y-%m-%d %H:%M:%S", &ConversionTime);
+	QString strTime = mbstr;
+	return strTime;
+}
+
+std::vector<QString>   splitString(const QString& str, char delimiter)
+{
+	QStringList tokens = str.split(delimiter);
+	return convertQStringListToStdVector(tokens);
+}
+
+
+std::complex<double>   Cubic_Convolution_interpolation(double u, double v, Eigen::MatrixX<std::complex<double>> img)
+{
+	if (img.rows() != 4 || img.cols() != 4) {
+		throw std::exception("the size of img's block is not right");
+	}
+	// 斤拷锟斤拷模锟斤拷
+	Eigen::MatrixX<std::complex<double>> wrc(1, 4);// 使锟斤拷 complex<double> 斤拷锟斤拷要原斤拷为锟剿伙拷取值
+	Eigen::MatrixX<std::complex<double>> wcr(4, 1);//
+	for (int i = 0; i < 4; i++) {
+		wrc(0, i) = Cubic_kernel_weight(u + 1 - i); // u+1,u,u-1,u-2
+		wcr(i, 0) = Cubic_kernel_weight(v + 1 - i);
+	}
+
+	Eigen::MatrixX<std::complex<double>> interValue = wrc * img * wcr;
+	return interValue(0, 0);
+}
+
+std::complex<double>   Cubic_kernel_weight(double s)
+{
+	s = abs(s);
+	if (s <= 1) {
+		return std::complex<double>(1.5 * s * s * s - 2.5 * s * s + 1, 0);
+	}
+	else if (s <= 2) {
+		return std::complex<double>(-0.5 * s * s * s + 2.5 * s * s - 4 * s + 2, 0);
+	}
+	else {
+		return std::complex<double>(0, 0);
+	}
+}
+
+/// <summary>
+///  p11  p12 -- x 
+///    p0(u,v)
+///  p21  p22
+///   |
+///   y
+/// p11(0,0)
+/// p21(0,1)
+/// P12(1,0)
+/// p22(1,1)
+/// </summary>
+/// <param name="p0">x,y,z</param>
+/// <param name="p1">x,y,z</param>
+/// <param name="p2">x,y,z</param>
+/// <param name="p3">x,y,z</param>
+/// <param name="p4">x,y,z</param>
+/// <returns></returns>
+double   Bilinear_interpolation(Landpoint p0, Landpoint p11, Landpoint p21, Landpoint p12, Landpoint p22)
+{
+	return	p11.ati * (1 - p0.lon) * (1 - p0.lat) +
+		p12.ati * p0.lon * (1 - p0.lat) +
+		p21.ati * (1 - p0.lon) * p0.lat +
+		p22.ati * p0.lon * p0.lat;
+}
+
+
+
+bool   onSegment(Point3 Pi, Point3 Pj, Point3 Q)
+{
+	if ((Q.x - Pi.x) * (Pj.y - Pi.y) == (Pj.x - Pi.x) * (Q.y - Pi.y)  //叉乘 
+		//保证Q点坐标在pi,pj之间 
+		&& std::min(Pi.x, Pj.x) <= Q.x && Q.x <= std::max(Pi.x, Pj.x)
+		&& std::min(Pi.y, Pj.y) <= Q.y && Q.y <= std::max(Pi.y, Pj.y))
+		return true;
+	else
+		return false;
+}
+
+Point3   invBilinear(Point3 p, Point3 a, Point3 b, Point3 c, Point3 d)
+{
+	Point3 res;
+
+	Point3 e = b - a;
+	Point3 f = d - a;
+	Point3 g = a - b + c - d;
+	Point3 h = p - a;
+
+	double k2 = cross2d(g, f);
+	double k1 = cross2d(e, f) + cross2d(h, g);
+	double k0 = cross2d(h, e);
+	double u, v;
+	// if edges are parallel, this is a linear equation
+	if (abs(k2) < 0.001)
+	{
+		v = -k0 / k1;
+		u = (h.x - f.x * v) / (e.x + g.x * v);
+		p.z = a.z + (b.z - a.z) * u + (d.z - a.z) * v + (a.z - b.z + c.z - d.z) * u * v;
+		return p;
+	}
+	// otherwise, it's a quadratic
+	else
+	{
+		float w = k1 * k1 - 4.0 * k0 * k2;
+		if (w < 0.0) {
+			// 可能在边界上
+			if (onSegment(a, b, p)) {
+				Point3 tt = b - a;
+				Point3 ttpa = p - a;
+				double scater = ttpa / tt;
+				if (scater < 0 || scater>1) { return { -9999,-9999,-9999 }; }
+				p.z = a.z + scater * tt.z;
+				return p;
+			}
+			else if (onSegment(b, c, p)) {
+				Point3 tt = c - b;
+				Point3 ttpa = p - b;
+				double scater = ttpa / tt;
+				if (scater < 0 || scater>1) { return { -9999,-9999,-9999 }; }
+				p.z = b.z + scater * tt.z;
+				return p;
+			}
+			else if (onSegment(c, d, p)) {
+				Point3 tt = d - c;
+				Point3 ttpa = p - c;
+				double scater = ttpa / tt;
+				if (scater < 0 || scater>1) { return { -9999,-9999,-9999 }; }
+				p.z = c.z + scater * tt.z;
+				return p;
+			}
+			else if (onSegment(d, a, p)) {
+				Point3 tt = a - d;
+				Point3 ttpa = p - d;
+				double scater = ttpa / tt;
+				if (scater < 0 || scater>1) { return { -9999,-9999,-9999 }; }
+				p.z = d.z + scater * tt.z;
+				return p;
+			}
+
+			return { -9999,-9999,-9999 };
+		}
+		else {
+			w = sqrt(w);
+
+			float ik2 = 0.5 / k2;
+			float v = (-k1 - w) * ik2;
+			float u = (h.x - f.x * v) / (e.x + g.x * v);
+
+			if (u < 0.0 || u>1.0 || v < 0.0 || v>1.0)
+			{
+				v = (-k1 + w) * ik2;
+				u = (h.x - f.x * v) / (e.x + g.x * v);
+			}
+			p.z = a.z + (b.z - a.z) * u + (d.z - a.z) * v + (a.z - b.z + c.z - d.z) * u * v;
+			return p;
+		}
+	}
+	p.z = a.z + (b.z - a.z) * u + (d.z - a.z) * v + (a.z - b.z + c.z - d.z) * u * v;
+	return p;
+}
+
+double   sind(double degree)
+{
+	return sin(degree * d2r);
+}
+
+double   cosd(double d)
+{
+	return cos(d * d2r);
+}
+
+
+std::string   Convert(float Num)
+{
+	std::ostringstream oss;
+	oss << Num;
+	std::string str(oss.str());
+	return str;
+}
+
+QString   JoinPath(const QString& path, const QString& filename)
+{
+	QDir dir(path);
+
+	// Ensure the path ends with the appropriate separator
+	if (!QDir::isAbsolutePath(path))
+		dir.makeAbsolute();
+
+	return dir.filePath(filename);
+}
+std::vector<QString>   convertQStringListToStdVector(const QStringList& qStringList)
+{
+	std::vector<QString> stdVector;
+
+	for (const QString& str : qStringList) {
+		stdVector.push_back(str);
+	}
+
+	return stdVector;
+};
+
+
+ErrorCode polyfit(const double* x, const double* y, int xyLength, int poly_n, std::vector<double>& out_factor, double& out_chisq) {
+	/*
+	 * x：自变量，视差
+	 * y：因变量，距离
+	 * xyLength: x、y长度
+	 * poly_n：拟合的阶次
+	 * out_factor：拟合的系数结果，从0阶到poly_n阶的系数
+	 * out_chisq：拟合曲线与数据点的优值函数最小值 ,χ2 检验
+	*/
+
+	gsl_matrix* XX = gsl_matrix_alloc(xyLength, poly_n + 1);
+	gsl_vector* c = gsl_vector_alloc(poly_n + 1);
+	gsl_matrix* cov = gsl_matrix_alloc(poly_n + 1, poly_n + 1);
+	gsl_vector* vY = gsl_vector_alloc(xyLength);
+
+	for (size_t i = 0; i < xyLength; i++)
+	{
+		gsl_matrix_set(XX, i, 0, 1.0);
+		gsl_vector_set(vY, i, y[i]);
+		for (int j = 1; j <= poly_n; j++)
+		{
+			gsl_matrix_set(XX, i, j, pow(x[i], j));
+		}
+	}
+	gsl_multifit_linear_workspace* workspace = gsl_multifit_linear_alloc(xyLength, poly_n + 1);
+	int r = gsl_multifit_linear(XX, vY, c, cov, &out_chisq, workspace);
+	gsl_multifit_linear_free(workspace);
+	out_factor.resize(c->size, 0);
+	for (size_t i = 0; i < c->size; ++i)
+	{
+		out_factor[i] = gsl_vector_get(c, i);
+	}
+
+	gsl_vector_free(vY);
+	gsl_matrix_free(XX);
+	gsl_matrix_free(cov);
+	gsl_vector_free(c);
+
+	return GSLState2ErrorCode(r);
+}
+
+Point3 crossProduct(const Point3& a, const Point3& b)
+{
+	return Point3{
+	a.y * b.z - a.z * b.y, // C_x
+	a.z * b.x - a.x * b.z, // C_y
+	a.x * b.y - a.y * b.x  // C_z
+	};
+}
+
+
+
+
+// 计算绕任意轴旋转的旋转矩阵
+Eigen::Matrix3d rotationMatrix(const Eigen::Vector3d& axis, double angle) {
+	// 确保旋转轴是单位向量
+	Eigen::Vector3d u = axis.normalized();
+
+	double cos_theta = cos(angle);
+	double sin_theta = sin(angle);
+
+	// 计算旋转矩阵
+	Eigen::Matrix3d R;
+	R <<
+		cos_theta + u.x() * u.x() * (1 - cos_theta), u.x()* u.y()* (1 - cos_theta) - u.z() * sin_theta, u.x()* u.z()* (1 - cos_theta) + u.y() * sin_theta,
+		u.y()* u.x()* (1 - cos_theta) + u.z() * sin_theta, cos_theta + u.y() * u.y() * (1 - cos_theta), u.y()* u.z()* (1 - cos_theta) - u.x() * sin_theta,
+		u.z()* u.x()* (1 - cos_theta) - u.y() * sin_theta, u.z()* u.y()* (1 - cos_theta) + u.x() * sin_theta, cos_theta + u.z() * u.z() * (1 - cos_theta);
+
+	return R;
+}
+
+
+
+
+
+long double convertToMilliseconds(const std::string& dateTimeStr) {
+	// 定义日期时间字符串
+	std::string dateTimeString = dateTimeStr;
+	// 使用 Boost.Date_Time 解析日期时间字符串
+	boost::posix_time::ptime dateTime = boost::posix_time::time_from_string(dateTimeString);
+
+	// 将 ptime 转换为自 epoch (1970年1月1日) 以来的毫秒数
+	boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
+	boost::posix_time::time_duration duration = dateTime - epoch;
+	long double milliseconds = duration.total_milliseconds() / 1000.0;
+	return milliseconds;
+
+}
+
+long FindValueInStdVector(std::vector<double>& list, double& findv)
+{
+	if (list.size() == 0) {
+		return -1;
+	}
+	else if (list.size() == 1) {
+		if (abs(list[0] - findv) < 1e-9) {
+			return 0;
+		}
+		else {
+			return -1;
+		}
+	}
+	else {}
+
+	if (abs(list[0] - findv) < 1e-9) {
+		return 0;
+	}
+	else if (abs(list[list.size() - 1] - findv) < 1e-9) {
+		return list.size() - 1;
+	}
+	else if (list[0] > findv) {
+		return -1;
+	}
+	else if (list[list.size() - 1] < findv) {
+		return -1;
+	}
+	else {}
+
+
+
+	long low = 0;
+	long high = list.size() - 1;
+	while (low <= high) {
+		long mid = (low + high) / 2;
+		if (abs(list[mid] - findv) < 1e-9) {
+			return mid;
+		}
+		else if (list[mid] < findv) {
+			low = mid + 1;
+		}
+		else if (list[mid] > findv) {
+			high = mid - 1;
+		}
+		else {}
+	}
+	return -1;
+}
+
+long InsertValueInStdVector(std::vector<double>& list, double insertValue, bool repeatValueInsert)
+{
+	if (list.size() == 0) {
+		list.insert(list.begin(), insertValue);
+		return 0;
+	}
+	else if (list.size() == 1) {
+		if (std::abs(list[0] - insertValue) < PRECISIONTOLERANCE) {
+			if (repeatValueInsert) {
+				list.push_back(insertValue);
+				return 1;
+			}
+			else {
+				return -1;
+			}
+		}
+		else if (insertValue > list[0]) {
+			list.push_back(insertValue);
+			return 1;
+		}
+		else if (insertValue < list[0]) {
+			list.push_back(insertValue);
+			return 0;
+		}
+	}
+	else {
+		long low = 0;
+		long high = list.size() - 1;
+		long mid = -1;
+		// 处理边界
+		if (list[high] <= insertValue)
+		{
+			if (std::abs(list[high] - insertValue) < PRECISIONTOLERANCE) {
+				if (repeatValueInsert) {
+					list.push_back(insertValue);
+				}
+				else {}
+			}
+			else {
+				list.push_back(insertValue);
+			}
+			return list.size() - 1;
+		}
+
+		if (list[low] >= insertValue) {
+
+			if (std::abs(list[low] - insertValue) < PRECISIONTOLERANCE) {
+				if (repeatValueInsert) {
+					list.insert(list.begin(), insertValue);
+				}
+				else {}
+			}
+			else {
+				list.insert(list.begin(), insertValue);
+			}
+			return 0;
+		}
+		// low<insertValue < high 
+		while ((high - low) > 1) {
+			mid = (low + high) / 2;
+			if (std::abs(list[mid] - insertValue) < PRECISIONTOLERANCE) {
+				if (repeatValueInsert) {
+					list.insert(list.begin() + mid, insertValue);
+				}
+				return mid;
+			}
+			else if (insertValue < list[mid]) {
+				high = mid;
+			}
+			else if (list[mid] < insertValue) {
+				low = mid;
+			}
+
+		}
+		if (list[low] <= insertValue && insertValue <= list[high])
+		{
+
+			if (std::abs(list[high] - insertValue) < PRECISIONTOLERANCE) {
+				if (repeatValueInsert) {
+					list.insert(list.begin() + high, insertValue);
+				}
+				else {}
+			}
+			else {
+				list.insert(list.begin() + high, insertValue);
+			}
+			return low;
+		}
+		else {
+			return -1;
+		}
+	}
+	return -1;
+}
+
+long FindValueInStdVectorLast(std::vector<double>& list, double& insertValue)
+{
+	if (list.size() == 0 || list.size() == 1) {
+		return -1;
+	}
+	else {
+		long low = 0;
+		long high = list.size() - 1;
+		long mid = -1;
+		// 处理边界
+		if (list[high]+ PRECISIONTOLERANCE < insertValue)
+		{
+			return -1;
+		}
+		else if (std::abs(list[high] - insertValue) < PRECISIONTOLERANCE)
+		{
+			return high;
+		}
+		else if (list[low] > insertValue) {
+			return -1;
+		}
+		else if (std::abs(list[low] - insertValue) < PRECISIONTOLERANCE) {
+			return low;
+		}
+		else {}
+		// low<insertValue < high 
+		while ((high - low) > 1) {
+			mid = (low + high) / 2;
+			if (insertValue < list[mid]) {
+				high = mid;
+			}
+			else if (list[mid] < insertValue) {
+				low = mid;
+			}
+			else {// insertValue==list[mid] , list[mid]===insertValue
+				return mid;// 
+			}
+		}
+		if (list[low] <= insertValue && insertValue <= list[high])
+		{
+			return low;
+		}
+		else {
+			return -1;
+		}
+	}
+	return -1;
+}
+
+
+ErrorCode polynomial_fit(const std::vector<double>& x, const std::vector<double>& y, int degree, std::vector<double>& out_factor, double& out_chisq) {
+	int xyLength = x.size();
+	double* xdata = new double[xyLength];
+	double* ydata = new double[xyLength];
+	for (long i = 0; i < xyLength; i++) {
+		xdata[i] = x[i];
+		ydata[i] = y[i];
+	}
+	ErrorCode state = polyfit(xdata, ydata, xyLength, degree, out_factor, out_chisq);
+
+	delete[] xdata;
+	delete[] ydata; // 释放内存
+	return state;
+}
+
+QVector<SatelliteAntPos> SatellitePos2SatelliteAntPos(QVector<SatellitePos> poses)
+{
+	QVector<SatelliteAntPos> antposes(poses.count());
+	for (long i = 0; i < poses.count(); i++) {
+		antposes[i].time = poses[i].time;
+		antposes[i].Px = poses[i].Px;
+		antposes[i].Py = poses[i].Py;
+		antposes[i].Pz = poses[i].Pz;
+		antposes[i].Vx = poses[i].Vx;
+		antposes[i].Vy = poses[i].Vy;
+		antposes[i].Vz = poses[i].Vz;
+	}
+	return antposes;
+}
+
+QVector<SatellitePos> SatelliteAntPos2SatellitePos(QVector<SatelliteAntPos> poses)
+{
+	QVector<SatellitePos> antposes(poses.count());
+	for (long i = 0; i < poses.count(); i++) {
+		antposes[i].time = poses[i].time;
+		antposes[i].Px = poses[i].Px;
+		antposes[i].Py = poses[i].Py;
+		antposes[i].Pz = poses[i].Pz;
+		antposes[i].Vx = poses[i].Vx;
+		antposes[i].Vy = poses[i].Vy;
+		antposes[i].Vz = poses[i].Vz;
+	}
+	return antposes;
+}
+
+
+QString getDebugDataPath(QString filename)
+{
+	QString folderName = "debugdata";
+	QString appDir = QCoreApplication::applicationDirPath();
+	QString folderpath = JoinPath(appDir, folderName);
+	if (!QDir(folderpath).exists()) {
+		QDir(appDir).mkdir(folderName);
+	}
+	QString datapath = JoinPath(folderpath, filename);
+	QFile datafile(datapath);
+	if (datafile.exists()) {
+		datafile.remove();
+	}
+	return datapath;
+}
+
+
+std::vector<std::string> split(const std::string& str, char delimiter) {
+	std::vector<std::string> tokens;
+	std::string token;
+	std::istringstream tokenStream(str);
+
+	while (std::getline(tokenStream, token, delimiter)) {
+		tokens.push_back(token);
+	}
+
+	return tokens;
+}
+
+
+Eigen::VectorXd linspace(double start, double stop, int num) {
+	Eigen::VectorXd result(num);
+
+	double step = (stop - start) / (num - 1);  // 计算步长
+	for (int i = 0; i < num; ++i) {
+		result[i] = start + i * step;  // 生成等间距数值
+	}
+
+	return result;
+}
+
+void initializeMatrixWithSSE2(Eigen::MatrixXd& mat, const double* data, long rowcount, long colcount) {
+	__m128d zero = _mm_setzero_pd();
+
+#pragma omp parallel for
+	for (long i = 0; i < rowcount; ++i) {
+		for (long j = 0; j < colcount; j += 2) { // 每次处理2个double
+			if (j + 2 <= colcount) {
+				__m128d src = _mm_loadu_pd(&data[i * colcount + j]);
+				_mm_storeu_pd(&mat(i, j), src);
+			}
+			else {
+				// 处理剩余部分
+				for (long k = j; k < colcount; ++k) {
+					mat(i, k) = data[i * colcount + k];
+				}
+			}
+		}
+	}
+}
+
+void initializeMatrixWithSSE2(Eigen::MatrixXf& mat, const float* data, long rowcount, long colcount) {
+	__m128 zero = _mm_setzero_ps();
+
+#pragma omp parallel for
+	for (long i = 0; i < rowcount; ++i) {
+		for (long j = 0; j < colcount; j += 4) { // 每次处理4个float
+			if (j + 4 <= colcount) {
+				__m128 src = _mm_loadu_ps(&data[i * colcount + j]);
+				_mm_storeu_ps(&mat(i, j), src);
+			}
+			else {
+				// 处理剩余部分
+				for (long k = j; k < colcount; ++k) {
+					mat(i, k) = data[i * colcount + k];
+				}
+			}
+		}
+	}
+}
+
+Eigen::MatrixXd BASECONSTVARIABLEAPI MuhlemanSigmaArray(Eigen::MatrixXd& eta_deg)
+{
+	Eigen::MatrixXd sigma = Eigen::MatrixXd::Zero(eta_deg.rows(), eta_deg.cols());
+	for (long i = 0; i < sigma.rows(); i++) {
+		for (long j = 0; j < sigma.cols(); j++) {
+			sigma(i,j) = calculate_MuhlemanSigma(eta_deg(i, j));
+		}
+	}
+	return sigma;
+}
+
+Eigen::MatrixXd BASECONSTVARIABLEAPI dB2Amp(Eigen::MatrixXd& sigma0)
+{
+	Eigen::MatrixXd sigma = Eigen::MatrixXd::Zero(sigma0.rows(), sigma0.cols());
+	for (long i = 0; i < sigma.rows(); i++) {
+		for (long j = 0; j < sigma.cols(); j++) {
+			sigma(i, j) =std::pow(10.0, sigma0(i,j)/20.0);
+		}
+	}
+	return sigma;
+}
+
+
+
+QDateTime parseCustomDateTime(const QString& dateTimeStr) {
+	// 手动解析日期时间字符串
+	int year = dateTimeStr.left(4).toInt();
+	int month = dateTimeStr.mid(5, 2).toInt();
+	int day = dateTimeStr.mid(8, 2).toInt();
+	int hour = dateTimeStr.mid(11, 2).toInt();
+	int minute = dateTimeStr.mid(14, 2).toInt();
+	int second = dateTimeStr.mid(17, 2).toInt();
+	int msec = dateTimeStr.mid(20, 6).toInt(); // 只取毫秒的前三位，因为QDateTime支持到毫秒
+
+	// 创建 QDate 和 QTime 对象
+	QDate date(year, month, day);
+	QTime time(hour, minute, second, msec ); // 转换为微秒，但QTime只支持毫秒精度
+
+	// 构造 QDateTime 对象
+	QDateTime result(date, time);
+
+	return result;
+}
+
+
+bool isLeapYear(int year) {
+	return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
+}
+
+int daysInMonth(int year, int month) {
+	if (month == 2) return isLeapYear(year) ? 29 : 28;
+	else if (month == 4 || month == 6 || month == 9 || month == 11) return 30;
+	else return 31;
+}
+
+
+TimestampMicroseconds parseAndConvert( std::string dateTimeStr) {
+	// 解析年、月、日、时、分、秒和微秒
+	int year = std::stoi(dateTimeStr.substr(0, 4));
+	int month = std::stoi(dateTimeStr.substr(5, 2));
+	int day = std::stoi(dateTimeStr.substr(8, 2));
+	int hour = std::stoi(dateTimeStr.substr(11, 2));
+	int minute = std::stoi(dateTimeStr.substr(14, 2));
+	int second = std::stoi(dateTimeStr.substr(17, 2));
+	int microsec = std::stoi(dateTimeStr.substr(20, 6));
+
+	// 计算从1970年至目标年份前一年的总天数
+	long long totalDays = 0;
+	for (int y = 1970; y < year; ++y) {
+		totalDays += isLeapYear(y) ? 366 : 365;
+	}
+
+	// 加上目标年份从1月到上一个月的天数
+	for (int m = 1; m < month; ++m) {
+		totalDays += daysInMonth(year, m);
+	}
+
+	// 加上本月的天数
+	totalDays += day - 1;
+
+	// 转换为总秒数，再加上小时、分钟、秒
+	long long totalSeconds = totalDays * 24 * 60 * 60 + hour * 60 * 60 + minute * 60 + second;
+
+	// 转换为毫秒和微秒
+	long long msecsSinceEpoch = totalSeconds * 1000 + microsec / 1000;
+	int microseconds = microsec % 1000;
+
+	return { msecsSinceEpoch, microseconds };
+}
+
+

BaseTool/BaseTool.h

@@ -0,0 +1,226 @@
+#pragma once
+#ifndef BASETOOL_H
+#define BASETOOL_H
+#include "BaseConstVariable.h"
+
+///
+/// 基本类、基本函数
+///
+
+
+// //#include <mkl.h>
+#include <complex>
+#include <iostream>
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <time.h>
+#include <string>
+#include <omp.h>
+#include <gdal.h>
+#include <gdal_priv.h>
+#include <gdalwarper.h>
+#include <ogrsf_frmts.h>
+#include <fstream>
+#include "GeoOperator.h"
+#include <vector>
+#include <string>
+#include <QString>
+#include <QStringList>
+#include "LogInfoCls.h"
+#include <QString>
+#include <QDebug>
+#include <iomanip>
+#include <sstream>
+#include <QDatetime>
+#include <boost/cstdint.hpp>
+
+///////////////////////////////////// 基础数学函数 /////////////////////////////////////////////////////////////
+
+
+QString longDoubleToQStringScientific(long double value);
+
+///////////////////////////////////// 运行时间打印 /////////////////////////////////////////////////////////////
+
+
+QString BASECONSTVARIABLEAPI			 getCurrentTimeString();
+QString BASECONSTVARIABLEAPI			 getCurrentShortTimeString();
+
+std::vector<QString>   BASECONSTVARIABLEAPI	splitString(const QString& str, char delimiter);
+std::vector<QString>   BASECONSTVARIABLEAPI	 convertQStringListToStdVector(const QStringList& qStringList);
+///////////////////////////////  基本图像类 结束
+/////////////////////////////////////////////////////////////
+
+std::string 		 BASECONSTVARIABLEAPI		 Convert(float Num);
+QString 			  BASECONSTVARIABLEAPI	JoinPath(const QString& path, const QString& filename);
+
+////////////////////////////// 坐标部分基本方法 //////////////////////////////////////////
+
+////////////////////////////// 坐标部分基本方法 //////////////////////////////////////////
+
+//////////////////////////////  插值   ////////////////////////////////////////////
+
+std::complex<double>  BASECONSTVARIABLEAPI		 Cubic_Convolution_interpolation(double u, double v,
+															 Eigen::MatrixX<std::complex<double>> img);
+
+std::complex<double>  BASECONSTVARIABLEAPI		 Cubic_kernel_weight(double s);
+
+double  BASECONSTVARIABLEAPI	 Bilinear_interpolation(Landpoint p0, Landpoint p11, Landpoint p21, Landpoint p12,Landpoint p22);
+
+bool  BASECONSTVARIABLEAPI	 onSegment(Point3 Pi, Point3 Pj, Point3 Q);
+
+Point3  BASECONSTVARIABLEAPI	 invBilinear(Point3 p, Point3 a, Point3 b, Point3 c, Point3 d);
+
+//
+// WGS84 到J2000 坐标系的变换
+// 参考网址：https://blog.csdn.net/hit5067/article/details/116894616
+// 资料网址：http://celestrak.org/spacedata/
+// 参数文件：
+//		 a. Earth Orientation Parameter 文件： http://celestrak.org/spacedata/EOP-Last5Years.csv
+//       b. Space Weather Data  文件： http://celestrak.org/spacedata/SW-Last5Years.csv
+// 备注：上述文件是自2017年-五年内
+/**
+在wgs84 坐标系转到J2000 坐标系 主要 涉及到坐标的相互转换。一般给定的WGS坐标为 给定时刻的 t ,BLH
+转换步骤：
+step 1: WGS 84 转换到协议地球坐标系
+step 2: 协议地球坐标系 转换为瞬时地球坐标系
+step 3: 瞬时地球坐标系 转换为 瞬时真天球坐标系
+step 4: 瞬时真天球坐标系 转到瞬时平天球 坐标系
+step 5: 瞬时平天球坐标系转换为协议天球坐标系（J2000）
+**/
+
+double  BASECONSTVARIABLEAPI	 sind(double degree);
+
+double  BASECONSTVARIABLEAPI	 cosd(double d);
+
+// 插值
+ErrorCode  BASECONSTVARIABLEAPI	polyfit(const double* x, const double* y, int xyLength, int poly_n, std::vector<double>& out_factor, double& out_chisq);
+
+// 叉乘
+Point3  BASECONSTVARIABLEAPI	crossProduct(const Point3& a, const Point3& b);
+
+Eigen::Matrix3d BASECONSTVARIABLEAPI	 rotationMatrix(const Eigen::Vector3d& axis, double angle);
+ 
+long double  BASECONSTVARIABLEAPI	convertToMilliseconds(const std::string& dateTimeStr);
+
+QDateTime BASECONSTVARIABLEAPI parseCustomDateTime(const QString& dateTimeStr);
+/// <summary>
+/// list 应该是按照从小到大的顺序排好
+/// </summary>
+/// <param name="list"></param>
+/// <param name="findv"></param>
+/// <returns></returns>
+long  BASECONSTVARIABLEAPI	FindValueInStdVector(std::vector<double>& list,double& findv);
+
+long  BASECONSTVARIABLEAPI	InsertValueInStdVector(std::vector<double>& list, double insertValue, bool repeatValueInsert = false);
+
+long  BASECONSTVARIABLEAPI	FindValueInStdVectorLast(std::vector<double>& list, double& findv);
+
+ErrorCode  BASECONSTVARIABLEAPI	polynomial_fit(const std::vector<double>& x, const std::vector<double>& y, int degree, std::vector<double>& out_factor, double& out_chisq);
+
+QVector<SatelliteAntPos>  BASECONSTVARIABLEAPI	SatellitePos2SatelliteAntPos(QVector<SatellitePos> poses);
+
+QVector<SatellitePos> BASECONSTVARIABLEAPI	 SatelliteAntPos2SatellitePos(QVector<SatelliteAntPos> poses);
+
+QString  BASECONSTVARIABLEAPI	getDebugDataPath(QString filename);
+std::vector<std::string>  BASECONSTVARIABLEAPI	split(const std::string& str, char delimiter);
+Eigen::VectorXd BASECONSTVARIABLEAPI	 linspace(double start, double stop, int num);
+
+
+/** 内存赋值 ***********************************************************************************************************/
+void initializeMatrixWithSSE2(Eigen::MatrixXd& mat, const double* data, long rowcount, long colcount);
+void initializeMatrixWithSSE2(Eigen::MatrixXf& mat, const float* data, long rowcount, long colcount);
+
+Eigen::MatrixXd BASECONSTVARIABLEAPI MuhlemanSigmaArray(Eigen::MatrixXd& eta_deg);
+Eigen::MatrixXd BASECONSTVARIABLEAPI dB2Amp(Eigen::MatrixXd& sigma0);
+
+
+struct TimestampMicroseconds {
+	boost::int64_t msecsSinceEpoch; // 自1970-01-01T00:00:00 UTC以来的毫秒数
+	int microseconds;               // 额外的微秒（精确到微秒）
+};
+
+
+bool BASECONSTVARIABLEAPI  isLeapYear(int year);
+int  BASECONSTVARIABLEAPI daysInMonth(int year, int month);
+
+TimestampMicroseconds BASECONSTVARIABLEAPI parseAndConvert(  std::string  dateTimeStr);
+
+
+/** 模板函数类 ***********************************************************************************************************/
+
+inline double calculate_MuhlemanSigma(double eta_deg) {
+	const double eta_rad = eta_deg * M_PI / 180.0;  // 角度转弧度
+
+	const double cos_eta = std::cos(eta_rad);
+	const double sin_eta = std::sin(eta_rad);
+
+	const double denominator = sin_eta + 0.1 * cos_eta;
+
+	return (0.0133 * cos_eta) / std::pow(denominator, 3);
+};
+
+
+
+template<typename T>
+inline void  memsetInitArray(std::shared_ptr<T> ptr, long arrcount, T ti) {
+	for (long i = 0; i < arrcount; i++) {
+		ptr.get()[i] = ti;
+	}
+};
+
+template<typename T>
+inline void  memcpyArray(std::shared_ptr<T> srct, std::shared_ptr<T> dest, long arrcount) {
+	for (long i = 0; i < arrcount; i++) {
+		dest.get()[i] = srct.get()[i];
+	}
+};
+
+
+template<typename T>
+inline void  minValueInArr(T* ptr, long arrcount, T& minvalue) {
+
+	if (arrcount == 0)return;
+
+	minvalue = ptr[0];
+	for (long i = 0; i < arrcount; i++) {
+		if (minvalue > ptr[i]) {
+			minvalue = ptr[i];
+		}
+	}
+};
+
+template<typename T>
+inline void  maxValueInArr(T* ptr, long arrcount, T& maxvalue) {
+
+	if (arrcount == 0)return;
+
+	maxvalue = ptr[0];
+	for (long i = 0; i < arrcount; i++) {
+		if (maxvalue < ptr[i]) {
+			maxvalue = ptr[i];
+		}
+	}
+};
+
+
+
+/**  常用SAR工具 ***********************************************************************************************************/
+
+
+template<typename T>
+inline T complexAbs(std::complex<T> ccdata) {
+	return  T(sqrt(pow(ccdata.real(), 2) + pow(ccdata.imag(), 2)));
+};
+
+template<typename T>
+inline void complex2dB(std::complex<T>* ccdata, T* outdata, long long count) {
+
+	for (long long i = 0; i < count; i++) {
+		outdata[i] = 20 * log10(complexAbs(ccdata[i]));
+	}
+
+};
+
+
+
+#endif

BaseTool/EchoDataFormat.cpp

@@ -0,0 +1,822 @@
+#include "stdafx.h"
+#include "EchoDataFormat.h"
+#include <QFile>
+#include <QFileInfo>
+#include <QDir>
+#include <QString>
+#include <QFile>
+#include <QXmlStreamWriter>
+#include <QXmlStreamReader>
+#include <QDebug>
+#include "ImageOperatorBase.h"
+
+
+std::shared_ptr<PluseAntPos> CreatePluseAntPosArr(long pluseCount)
+{
+    return std::shared_ptr<PluseAntPos>(new PluseAntPos[pluseCount],delArrPtr);
+}
+
+long getPluseDataSize(PluseData& pluseData)
+{
+    long datasize = sizeof(long) + sizeof(double) + sizeof(double) * 6 + sizeof(long);// PRFId,time,px-vz,pluseCount
+    datasize = datasize + pluseData.plusePoints * sizeof(double) * 2; // 数据块
+    return datasize;
+}
+
+ErrorCode getPluseDataFromBuffer(char* buffer, PluseData & data)
+{
+    long seekid = 0;
+	std::memcpy(&data.id, buffer + seekid, sizeof(data.id));    seekid += sizeof(data.id);
+	std::memcpy(&data.time, buffer + seekid, sizeof(data.time)); seekid += sizeof(data.time);
+	std::memcpy(&data.Px, buffer + seekid, sizeof(data.Px));    seekid += sizeof(data.Px);
+	std::memcpy(&data.Py, buffer + seekid, sizeof(data.Py));    seekid += sizeof(data.Py);
+	std::memcpy(&data.Pz, buffer + seekid, sizeof(data.Pz));    seekid += sizeof(data.Pz);
+	std::memcpy(&data.Vx, buffer + seekid, sizeof(data.Vx));    seekid += sizeof(data.Vx);
+	std::memcpy(&data.Vy, buffer + seekid, sizeof(data.Vy));    seekid += sizeof(data.Vy);
+	std::memcpy(&data.Vz, buffer + seekid, sizeof(data.Vz));    seekid += sizeof(data.Vz);
+	std::memcpy(&data.plusePoints, buffer + seekid, sizeof(data.plusePoints)); seekid += sizeof(data.plusePoints);
+
+    Eigen::MatrixXd echoData_real = Eigen::MatrixXd::Zero(1, data.plusePoints);
+    Eigen::MatrixXd echoData_imag = Eigen::MatrixXd::Zero(1, data.plusePoints);
+    std::memcpy(echoData_real.data(), buffer + seekid, sizeof(data.plusePoints)); seekid += data.plusePoints * sizeof(double);
+    std::memcpy(echoData_imag.data(), buffer + seekid, sizeof(data.plusePoints));
+
+	std::shared_ptr<Eigen::MatrixXcd> echoData = std::make_shared<Eigen::MatrixXcd>(1, data.plusePoints);
+    echoData->real() = echoData_real.array();
+    echoData->imag() = echoData_imag.array();
+    return ErrorCode::SUCCESS;
+}
+
+std::shared_ptr<PluseData> CreatePluseDataArr(long pluseCount)
+{
+    return std::shared_ptr<PluseData>(new PluseData[pluseCount],delArrPtr);
+}
+
+std::shared_ptr<std::complex<double>> CreateEchoData(long plusePoints)
+{
+    return std::shared_ptr<std::complex<double>>(new std::complex<double>[plusePoints],delArrPtr);
+}
+
+EchoL0Dataset::EchoL0Dataset()
+{
+    this->folder="";
+    this->filename="";
+    this->xmlname="";
+    this->GPSPointFilename="";
+    this->echoDataFilename="";
+    this->xmlFilePath="";
+    this->GPSPointFilePath="";
+    this->echoDataFilePath="";
+    this->simulationTaskName = "";
+
+	this->PluseCount = 0;
+	this->PlusePoints = 0;
+	this->NearRange = 0;
+	this->FarRange = 0;
+	this->centerFreq = 0;
+	this->Fs = 0;
+
+    this->folder.clear();
+    this->filename.clear();
+    this->xmlname.clear();
+    this->GPSPointFilename.clear();
+    this->echoDataFilename.clear();
+    this->xmlFilePath.clear();
+    this->GPSPointFilePath.clear();
+    this->echoDataFilePath.clear();
+    this->simulationTaskName.clear();
+
+}
+
+EchoL0Dataset::~EchoL0Dataset()
+{
+}
+
+ErrorCode EchoL0Dataset::OpenOrNew(QString folder, QString filename, long PluseCount, long PlusePoints)
+{
+    qDebug() << "--------------Echo Data OpenOrNew ---------------------------------------";
+	qDebug() << "Folder: " << folder;
+	qDebug() << "Filename: " << filename;
+	QDir dir(folder);
+    if (dir.exists() == false)
+    {
+        dir.mkpath(folder);
+    }
+    else {}
+
+    if (dir.exists() == false) {
+        return ErrorCode::FOLDER_NOT_EXIST;
+    }
+    else {}
+    QString filePath = dir.filePath(filename); // 生成完整的文件路径
+ 
+    this->folder = folder;
+    this->filename = filename;
+    this->simulationTaskName = filename;
+
+    this->xmlname=filename+".xml";
+    this->GPSPointFilename=filename+".gpspos.data";
+    this->echoDataFilename = filename + ".L0echo.data";
+
+	this->xmlFilePath = dir.filePath(this->xmlname);
+	this->GPSPointFilePath = dir.filePath(this->GPSPointFilename);
+	this->echoDataFilePath = dir.filePath(this->echoDataFilename);
+
+    this->PluseCount = PluseCount;
+    this->PlusePoints = PlusePoints;
+
+
+    // 
+	if (QFile(this->xmlFilePath).exists())
+    {
+		this->loadFromXml();
+	}
+    else
+    {
+		this->saveToXml();
+	}
+
+    if (QFile(this->GPSPointFilePath).exists() == false) {
+        // 创建新文件
+        omp_lock_t lock;
+        omp_init_lock(&lock);
+        omp_set_lock(&lock);
+        GDALAllRegister();
+        CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+ 
+        GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("ENVI");
+        GDALDataset* poDstDS=(poDriver->Create(this->GPSPointFilePath.toUtf8().constData(), 19, PluseCount, 1, GDT_Float64, NULL));
+        GDALFlushCache((GDALDatasetH)poDstDS);
+        GDALClose(poDstDS);
+        //poDstDS.reset();
+        omp_unset_lock(&lock);	 //  
+        omp_destroy_lock(&lock); //  
+ 
+    }
+
+    if (QFile(this->echoDataFilePath).exists() == false) {
+
+        // 创建新文件
+        omp_lock_t lock;
+        omp_init_lock(&lock);
+        omp_set_lock(&lock);
+        GDALAllRegister();
+        CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+ 
+        GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("ENVI");
+        GDALDataset* poDstDS = (poDriver->Create(this->echoDataFilePath.toUtf8().constData(), PlusePoints, PluseCount, 1, GDT_CFloat64, NULL));
+        GDALFlushCache((GDALDatasetH)poDstDS);
+        GDALClose(poDstDS);
+        //poDstDS.reset();
+        omp_unset_lock(&lock);	 //  
+        omp_destroy_lock(&lock); //  
+
+    }
+
+ 
+
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode EchoL0Dataset::Open(QString xmlfilepath)
+{
+    QFileInfo fileInfo(xmlfilepath);
+    QString fileName = fileInfo.fileName(); // 获取文件名
+    QString fileSuffix = fileInfo.suffix(); // 获取后缀名
+    QString fileNameWithoutSuffix = fileInfo.baseName(); // 获取不带后缀的文件名
+    QString directoryPath = fileInfo.path(); // 获取文件夹路径
+    if (fileSuffix.toLower() == "xml" || fileSuffix.toLower() == ".xml") {
+        return this->Open(directoryPath,fileNameWithoutSuffix);
+    }
+    else {
+        return ErrorCode::ECHO_L0DATA_XMLNAMEERROR;
+    }
+
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode EchoL0Dataset::Open(QString folder, QString filename)
+{
+    QDir dir(folder);
+    if (dir.exists() == false)
+    {
+        return ErrorCode::FOLDER_NOT_EXIST;
+    }
+    else {}
+
+    if (dir.exists() == false) {
+        return ErrorCode::FOLDER_NOT_EXIST;
+    }
+    else {}
+    QString filePath = dir.filePath(filename); // 生成完整的文件路径
+
+    this->folder = folder;
+    this->filename = filename;
+    this->simulationTaskName = filename;
+
+    this->xmlname = filename + ".xml";
+    this->GPSPointFilename = filename + ".gpspos.data";
+    this->echoDataFilename = filename + ".L0echo.data";
+
+    this->xmlFilePath = dir.filePath(this->xmlname);
+    this->GPSPointFilePath = dir.filePath(this->GPSPointFilename);
+    this->echoDataFilePath = dir.filePath(this->echoDataFilename);
+
+    this->PluseCount = PluseCount;
+    this->PlusePoints = PlusePoints;
+
+    // 
+    if (QFile(this->xmlFilePath).exists())
+    {
+        this->loadFromXml();
+    }
+    else
+    {
+		return ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR;
+    }
+    return ErrorCode::SUCCESS;
+}
+
+QString EchoL0Dataset::getxmlName()
+{
+    return xmlname;
+}
+
+QString EchoL0Dataset::getGPSPointFilename()
+{
+    return GPSPointFilename;
+}
+
+QString EchoL0Dataset::getEchoDataFilename()
+{
+    return GPSPointFilePath;
+}
+
+QString EchoL0Dataset::getGPSPointFilePath()
+{
+    return this->GPSPointFilePath;
+}
+
+QString EchoL0Dataset::getEchoDataFilePath()
+{
+    return this->echoDataFilePath;
+}
+
+void EchoL0Dataset::initEchoArr(std::complex<double> init0)
+{
+    long blockline = Memory1MB  / 8 / 2 / this->PlusePoints * 8000;
+    
+    long start = 0;
+    for (start = 0; start < this->PluseCount; start = start + blockline) {
+        long templine = start + blockline < this->PluseCount ? blockline : this->PluseCount - start;
+        std::shared_ptr<std::complex<double>> echotemp = this->getEchoArr(start, templine);
+        for (long i = 0; i < templine; i++) {
+            for (long j = 0; j < this->PlusePoints; j++) {
+                echotemp.get()[i * this->PlusePoints + j] = init0;
+            }
+        }
+        this->saveEchoArr(echotemp, start, templine);
+        qDebug() << "echo init col : " << start << "\t-\t" << start + templine << "\t/\t" << this->PluseCount;
+    }
+}
+
+// Getter 和 Setter 方法实现
+long EchoL0Dataset::getPluseCount()  { return this->PluseCount; }
+void EchoL0Dataset::setPluseCount(long pulseCount) { this->PluseCount = pulseCount; }
+
+long EchoL0Dataset::getPlusePoints()  { return this->PlusePoints; }
+void EchoL0Dataset::setPlusePoints(long pulsePoints) {  this->PlusePoints = pulsePoints; }
+
+
+double EchoL0Dataset::getNearRange()  { return this->NearRange; }
+void EchoL0Dataset::setNearRange(double nearRange) { this->NearRange = nearRange; }
+
+double EchoL0Dataset::getFarRange()  { return this->FarRange; }
+void EchoL0Dataset::setFarRange(double farRange) { this->FarRange = farRange; }
+
+double EchoL0Dataset::getCenterFreq()  { return this->centerFreq; }
+void EchoL0Dataset::setCenterFreq(double freq) { this->centerFreq = freq; }
+
+double EchoL0Dataset::getFs()  { return this->Fs; }
+void EchoL0Dataset::setFs(double samplingFreq) { this->Fs = samplingFreq; }
+
+QString EchoL0Dataset::getSimulationTaskName()  { return this->simulationTaskName; }
+void EchoL0Dataset::setSimulationTaskName(const QString& taskName) { this->simulationTaskName = taskName; }
+
+double EchoL0Dataset::getCenterAngle()
+{
+    return this->CenterAngle;
+}
+
+void EchoL0Dataset::setCenterAngle(double angle)
+{
+    this->CenterAngle = angle;
+}
+
+QString EchoL0Dataset::getLookSide()
+{
+    return this->LookSide;
+}
+
+void EchoL0Dataset::setLookSide(QString lookside)
+{
+    this->LookSide = lookside;
+}
+
+double EchoL0Dataset::getBandwidth()
+{
+    return this->bandwidth;
+}
+
+void EchoL0Dataset::setBandwidth(double Inbandwidth)
+{
+    this->bandwidth = Inbandwidth;
+}
+
+SatelliteAntPos EchoL0Dataset::getSatelliteAntPos(long prf_id)
+{
+    std::shared_ptr<double> antpos = this->getAntPos();
+    SatelliteAntPos prfpos{};
+    prfpos.time = antpos.get()[prf_id *19 + 0];
+    prfpos.Px = antpos.get()[prf_id *19 + 1];
+    prfpos.Py = antpos.get()[prf_id *19 + 2];
+    prfpos.Pz = antpos.get()[prf_id *19 + 3];
+    prfpos.Vx = antpos.get()[prf_id *19 + 4];
+    prfpos.Vy = antpos.get()[prf_id *19 + 5];
+    prfpos.Vz = antpos.get()[prf_id *19 + 6];
+    prfpos.AntDirectX = antpos.get()[prf_id *19 + 7];
+    prfpos.AntDirectY = antpos.get()[prf_id *19 + 8];
+    prfpos.AntDirectZ = antpos.get()[prf_id *19 + 9];
+    prfpos.AVx = antpos.get()[prf_id *19 + 10];
+    prfpos.AVy = antpos.get()[prf_id *19 + 11];
+    prfpos.AVz =antpos.get()[prf_id *19 + 12];
+    prfpos.ZeroAntDiectX = antpos.get()[prf_id *19 + 13];
+    prfpos.ZeroAntDiectY = antpos.get()[prf_id *19 + 14];
+    prfpos.ZeroAntDiectZ = antpos.get()[prf_id *19 + 15];
+    prfpos.lon =antpos.get()[prf_id *19 + 16];
+    prfpos.lat =antpos.get()[prf_id *19 + 17];
+    prfpos.ati =antpos.get()[prf_id *19 + 18];
+    return prfpos;
+}
+
+void EchoL0Dataset::setRefPhaseRange(double refRange)
+{
+    this->refPhaseRange = refRange;
+}
+
+double EchoL0Dataset::getRefPhaseRange()
+{
+    return  this->refPhaseRange;
+}
+
+// 打印信息的实现
+void EchoL0Dataset::printInfo()  {
+    qDebug() << "Simulation Task Name: " << this->simulationTaskName ;
+    qDebug() << "Pulse Count: " << this->PluseCount ;
+    qDebug() << "Pulse Points: " << this->PlusePoints;
+    qDebug() << "Near Range: " << this->NearRange ;
+    qDebug() << "Far Range: " << this->FarRange;
+    qDebug() << "Center Frequency: " << this->centerFreq ;
+    qDebug() << "Sampling Frequency: " << this->Fs ;
+    qDebug() << "Band width: " << this->bandwidth ;
+}
+
+// xml文件读写
+void EchoL0Dataset::saveToXml() {
+
+	QString filePath = this->xmlFilePath;
+
+    QFile file(filePath);
+    if (!file.open(QIODevice::WriteOnly)) {
+        qWarning() << "Cannot open file for writing:" << filePath;
+        return;
+    }
+
+    QXmlStreamWriter xmlWriter(&file);
+    xmlWriter.setAutoFormatting(true);
+    xmlWriter.writeStartDocument();
+    xmlWriter.writeStartElement("SimulationConfig");
+
+    xmlWriter.writeTextElement("PluseCount", QString::number(this->PluseCount));
+    xmlWriter.writeTextElement("BandWidth", QString::number(this->bandwidth));
+    xmlWriter.writeTextElement("PlusePoints", QString::number(this->PlusePoints));
+    xmlWriter.writeTextElement("NearRange", QString::number(this->NearRange));
+    xmlWriter.writeTextElement("FarRange", QString::number(this->FarRange));
+    xmlWriter.writeTextElement("CenterFreq", QString::number(this->centerFreq));
+    xmlWriter.writeTextElement("Fs", QString::number(this->Fs));
+    xmlWriter.writeTextElement("CenterAngle", QString::number(this->CenterAngle));
+    xmlWriter.writeTextElement("LookSide", this->LookSide);
+    xmlWriter.writeTextElement("SimulationTaskName", this->simulationTaskName);
+    xmlWriter.writeTextElement("Filename", this->filename);
+    xmlWriter.writeTextElement("Xmlname", this->xmlname);
+    xmlWriter.writeTextElement("GPSPointFilename", this->GPSPointFilename);
+    xmlWriter.writeTextElement("EchoDataFilename", this->echoDataFilename);
+    xmlWriter.writeTextElement("refPhaseRange", QString::number(this->refPhaseRange));
+
+    xmlWriter.writeEndElement(); // SimulationConfig
+    xmlWriter.writeEndDocument();
+
+    file.close();
+}
+
+ErrorCode EchoL0Dataset::loadFromXml() {
+    QString filePath = this->xmlFilePath;
+    QFile file(filePath);
+    if (!file.open(QIODevice::ReadOnly)) {
+        qWarning() << "Cannot open file for reading:" << filePath;
+        return ErrorCode::FILEOPENFAIL;
+    }
+
+
+	bool PluseCountflag = false;
+	bool PlusePointsflag = false;
+	bool NearRangeflag = false;
+	bool FarRangeflag = false;
+	bool CenterFreqflag = false;
+	bool Fsflag = false;
+
+
+    QXmlStreamReader xmlReader(&file);
+    while (!xmlReader.atEnd() && !xmlReader.hasError()) {
+        xmlReader.readNext();
+
+        if (xmlReader.isStartElement()) {
+            QString elementName = xmlReader.name().toString();
+            if (elementName == "BandWidth") {
+                this->bandwidth = xmlReader.readElementText().toDouble();
+            }
+            else if (elementName == "PluseCount") {
+                this->PluseCount = xmlReader.readElementText().toLong();
+            }
+            else if (elementName == "PlusePoints") {
+                this->PlusePoints = xmlReader.readElementText().toLong();
+				PlusePointsflag = true;
+            }
+            else if (elementName == "NearRange") {
+                this->NearRange = xmlReader.readElementText().toDouble();
+                NearRangeflag = true;
+            }
+            else if (elementName == "FarRange") {
+                this->FarRange = xmlReader.readElementText().toDouble();
+                FarRangeflag = true;
+            }
+            else if (elementName == "CenterFreq") {
+                this->centerFreq = xmlReader.readElementText().toDouble();
+                CenterFreqflag = true;
+            }
+            else if (elementName == "Fs") {
+                this->Fs = xmlReader.readElementText().toDouble();
+                Fsflag = true;
+            }
+            else if (elementName == "refPhaseRange") {
+                this->refPhaseRange = xmlReader.readElementText().toDouble();
+                Fsflag = true;
+            }
+            else if (elementName == "SimulationTaskName") {
+                this->simulationTaskName = xmlReader.readElementText();
+            }
+            else if (elementName == "Filename") {
+                this->filename = xmlReader.readElementText();
+            }
+            else if (elementName == "Xmlname") {
+                this->xmlname = xmlReader.readElementText();
+            }
+            else if (elementName == "GPSPointFilename") {
+                this->GPSPointFilename = xmlReader.readElementText();
+            }
+            else if (elementName == "EchoDataFilename") {
+                this->echoDataFilename = xmlReader.readElementText();
+            }
+            else if (elementName == "CenterAngle") {
+                this->CenterAngle = xmlReader.readElementText().toDouble();
+            }
+            else if (elementName == "LookSide") {
+                this->LookSide = xmlReader.readElementText();
+            }
+        }
+    }
+
+    if (xmlReader.hasError()) {
+        qWarning() << "XML error:" << xmlReader.errorString();
+        file.close();
+        return ErrorCode::ECHO_L0DATA_XMLFILENOTOPEN;
+    }
+
+    if (!(PlusePointsflag && PlusePointsflag && FarRangeflag && NearRangeflag && CenterFreqflag && Fsflag)) {
+        file.close();
+        return ErrorCode::ECHO_L0DATA_XMLFILENOTOPEN;
+    }
+
+    file.close();
+
+    return ErrorCode::SUCCESS;
+}
+
+std::shared_ptr<SatelliteAntPos> EchoL0Dataset::getAntPosVelc()
+{
+    omp_lock_t lock;
+    omp_init_lock(&lock);
+    omp_set_lock(&lock);
+    long prfcount = this->PluseCount;
+    std::shared_ptr<SatelliteAntPos>  antposlist= SatelliteAntPosOperator::readAntPosFile(this->GPSPointFilePath, prfcount);
+
+    omp_unset_lock(&lock);	 //  
+    omp_destroy_lock(&lock); //  
+    return antposlist;
+}
+
+std::shared_ptr<double> EchoL0Dataset::getAntPos()
+{
+    omp_lock_t lock; 
+    omp_init_lock(&lock);
+    omp_set_lock(&lock);
+    // 读取文件
+    std::shared_ptr<GDALDataset> rasterDataset = OpenDataset(this->GPSPointFilePath, GDALAccess::GA_ReadOnly);
+
+    GDALDataType	gdal_datatype = rasterDataset->GetRasterBand(1)->GetRasterDataType();
+    GDALRasterBand* demBand = rasterDataset->GetRasterBand(1);
+
+    long width = rasterDataset->GetRasterXSize();
+    long height = rasterDataset->GetRasterYSize();
+    long band_num = rasterDataset->GetRasterCount();
+ 
+    std::shared_ptr<double>  temp = nullptr;
+
+    if (gdal_datatype == GDT_Float64) {
+        temp=std::shared_ptr<double>(new double[this->PluseCount * 19],delArrPtr);
+        demBand->RasterIO(GF_Read, 0, 0, 19, this->PluseCount, temp.get(), 19, this->PluseCount, gdal_datatype, 0, 0);
+    }
+    else {
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_GPSFILEFORMATERROR)) ;
+    }
+    rasterDataset.reset();
+    omp_unset_lock(&lock);	 //  
+    omp_destroy_lock(&lock); //  
+    return temp;
+}
+
+std::shared_ptr<std::complex<double>> EchoL0Dataset::getEchoArr(long startPRF, long& PRFLen)
+{
+    if (!(startPRF < this->PluseCount)) {
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_PRFIDXOUTRANGE))<<startPRF<<"  "<<this->PluseCount;
+        return nullptr;
+    }
+    else {}
+
+    omp_lock_t lock;
+    omp_init_lock(&lock);
+    omp_set_lock(&lock);
+    std::shared_ptr<GDALDataset> rasterDataset = OpenDataset(this->echoDataFilePath, GDALAccess::GA_ReadOnly);
+
+
+    GDALDataType	gdal_datatype = rasterDataset->GetRasterBand(1)->GetRasterDataType();
+    GDALRasterBand* poBand = rasterDataset->GetRasterBand(1);
+    if (NULL==poBand||nullptr == poBand) {
+        omp_lock_t lock;
+        omp_init_lock(&lock);
+        omp_set_lock(&lock);
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+        return nullptr;
+    }
+    else {}
+    long width = rasterDataset->GetRasterXSize();
+    long height = rasterDataset->GetRasterYSize();
+    long band_num = rasterDataset->GetRasterCount();
+
+    PRFLen = (PRFLen + startPRF) < height ? PRFLen : height - startPRF;
+
+    std::shared_ptr<std::complex<double>>  temp = nullptr;
+	if (height != this->PluseCount || width != this->PlusePoints) {
+		qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+	}
+	else {
+		if (gdal_datatype == GDT_CFloat64) {
+            temp= std::shared_ptr<std::complex<double>>(new std::complex<double>[PRFLen * width ], delArrPtr);
+            poBand->RasterIO(GF_Read, 0, startPRF, width, PRFLen, temp.get(), width, PRFLen, GDT_CFloat64, 0, 0);
+            GDALFlushCache((GDALDatasetH)rasterDataset.get());
+		}
+		else {
+			qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+		}
+	}
+     
+    rasterDataset.reset();
+    omp_unset_lock(&lock);	 //  
+    omp_destroy_lock(&lock); //  
+    return temp;
+}
+
+
+std::vector<std::complex<double>> EchoL0Dataset::getEchoArrVector(long startPRF, long& PRFLen) {
+    if (!(startPRF < this->PluseCount)) {
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_PRFIDXOUTRANGE)) << startPRF << "  " << this->PluseCount;
+        return std::vector<std::complex<double>>(0);
+    }
+    else {}
+
+    omp_lock_t lock;
+    omp_init_lock(&lock);
+    omp_set_lock(&lock);
+    std::shared_ptr<GDALDataset> rasterDataset = OpenDataset(this->echoDataFilePath, GDALAccess::GA_ReadOnly);
+
+
+    GDALDataType	gdal_datatype = rasterDataset->GetRasterBand(1)->GetRasterDataType();
+    GDALRasterBand* poBand = rasterDataset->GetRasterBand(1);
+    if (NULL == poBand || nullptr == poBand) {
+        omp_lock_t lock;
+        omp_init_lock(&lock);
+        omp_set_lock(&lock);
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+        return std::vector<std::complex<double>>(0);
+    }
+    else {}
+    long width = rasterDataset->GetRasterXSize();
+    long height = rasterDataset->GetRasterYSize();
+    long band_num = rasterDataset->GetRasterCount();
+
+    PRFLen = (PRFLen + startPRF) < height ? PRFLen : height - startPRF;
+
+    std::vector<std::complex<double>> tempArr(size_t(PRFLen) * width);
+    if (height != this->PluseCount || width != this->PlusePoints) {
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+    }
+    else {
+        if (gdal_datatype == GDT_CFloat64) {
+            std::shared_ptr<std::complex<double>>  temp(new std::complex<double>[PRFLen * width], delArrPtr);
+            poBand->RasterIO(GF_Read, 0, startPRF, width, PRFLen, temp.get(), width, PRFLen, GDT_CFloat64, 0, 0);
+            GDALFlushCache((GDALDatasetH)rasterDataset.get());
+
+
+			for (long i = 0; i < PRFLen; i++){
+				for (long j = 0; j < width; j++){
+					tempArr[i * width + j] = temp.get()[i * width + j];
+				}
+			}
+
+        }
+        else {
+            qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+        }
+    }
+
+    rasterDataset.reset();
+    omp_unset_lock(&lock);	 //  
+    omp_destroy_lock(&lock); //  
+    return tempArr;
+}
+
+
+std::shared_ptr<std::complex<double>> EchoL0Dataset::getEchoArr()
+{
+    return  this->getEchoArr(0,this->PluseCount);
+}
+
+ErrorCode EchoL0Dataset::saveAntPos(std::shared_ptr<double> ptr)
+{
+    omp_lock_t lock;
+    omp_init_lock(&lock);
+    omp_set_lock(&lock);
+    // 读取文件
+    std::shared_ptr<GDALDataset> rasterDataset = OpenDataset(this->GPSPointFilePath, GDALAccess::GA_Update);
+
+    GDALDataType	gdal_datatype = rasterDataset->GetRasterBand(1)->GetRasterDataType();
+    GDALRasterBand* demBand = rasterDataset->GetRasterBand(1);
+
+    long width = rasterDataset->GetRasterXSize();
+    long height = rasterDataset->GetRasterYSize();
+    long band_num = rasterDataset->GetRasterCount();
+
+    if (gdal_datatype == GDT_Float64) {  
+        demBand->RasterIO(GF_Write, 0, 0, 19, this->PluseCount, ptr.get(), 19, this->PluseCount, gdal_datatype, 0, 0);
+    }
+    else {
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_GPSFILEFORMATERROR));
+        omp_unset_lock(&lock);	 //  
+        omp_destroy_lock(&lock); //  
+		return ErrorCode::ECHO_L0DATA_GPSFILEFORMATERROR;
+    }
+    rasterDataset.reset();
+    omp_unset_lock(&lock);	 //  
+    omp_destroy_lock(&lock); //
+    return ErrorCode::SUCCESS;
+}
+
+ErrorCode EchoL0Dataset::saveEchoArr(std::shared_ptr<std::complex<double>> echoPtr, long startPRF, long PRFLen)
+{
+    if (!(startPRF < this->PluseCount)) {
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_PRFIDXOUTRANGE));
+        return ErrorCode::ECHO_L0DATA_PRFIDXOUTRANGE;
+    }
+    else {}
+
+    omp_lock_t lock;
+    omp_init_lock(&lock);
+    omp_set_lock(&lock);
+
+    GDALAllRegister();
+    CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+    GDALDataset* rasterDataset = (GDALDataset*)(GDALOpen(this->echoDataFilePath.toUtf8().constData(), GDALAccess::GA_Update));
+
+    GDALDataType	gdal_datatype = rasterDataset->GetRasterBand(1)->GetRasterDataType();
+    GDALRasterBand* poBand = rasterDataset->GetRasterBand(1);
+    if (NULL == poBand || nullptr == poBand) {
+        omp_lock_t lock;
+        omp_init_lock(&lock);
+        omp_set_lock(&lock);
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+        return ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR;
+    }
+    else {}
+    long width = rasterDataset->GetRasterXSize();
+    long height = rasterDataset->GetRasterYSize();
+    long band_num = rasterDataset->GetRasterCount();
+ 
+    if (height != this->PluseCount || width != this->PlusePoints) {
+        qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+        omp_unset_lock(&lock);	 //  
+        omp_destroy_lock(&lock); //  
+        return ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR;
+    }
+    else {
+        if (gdal_datatype == GDT_CFloat64) {
+            poBand->RasterIO(GF_Write, 0, startPRF, width, PRFLen,  echoPtr.get(), width, PRFLen, GDT_CFloat64, 0, 0);
+            GDALFlushCache((GDALDatasetH)rasterDataset);
+        }
+        else {
+            qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
+        }
+    }
+    GDALClose(rasterDataset);
+    rasterDataset = nullptr;
+    GDALDestroy();
+    omp_unset_lock(&lock);	 //  
+    omp_destroy_lock(&lock); //  
+   
+    return ErrorCode::SUCCESS;
+}
+
+std::shared_ptr<SatelliteAntPos> SatelliteAntPosOperator::readAntPosFile(QString filepath, long& count)
+{
+    gdalImage antimg(filepath);
+    long rowcount = count;
+    long colcount = 19;
+    std::shared_ptr<double> antlist = readDataArr<double>(antimg, 0, 0, rowcount, colcount, 1, GDALREADARRCOPYMETHOD::VARIABLEMETHOD);
+    std::shared_ptr<SatelliteAntPos> antpos(new SatelliteAntPos[rowcount], delArrPtr);
+    for (long i = 0; i < rowcount; i++) {
+		antpos.get()[i].time = antlist.get()[i * 19 + 0];
+		antpos.get()[i].Px = antlist.get()[i * 19 + 1];
+		antpos.get()[i].Py = antlist.get()[i * 19 + 2];
+		antpos.get()[i].Pz = antlist.get()[i * 19 + 3];
+		antpos.get()[i].Vx = antlist.get()[i * 19 + 4];
+		antpos.get()[i].Vy = antlist.get()[i * 19 + 5];
+		antpos.get()[i].Vz = antlist.get()[i * 19 + 6]; //7
+		antpos.get()[i].AntDirectX = antlist.get()[i * 19 + 7];
+		antpos.get()[i].AntDirectY = antlist.get()[i * 19 + 8];
+		antpos.get()[i].AntDirectZ = antlist.get()[i * 19 + 9];
+		antpos.get()[i].AVx = antlist.get()[i * 19 + 10];
+		antpos.get()[i].AVy = antlist.get()[i * 19 + 11];
+		antpos.get()[i].AVz = antlist.get()[i * 19 + 12];
+		antpos.get()[i].ZeroAntDiectX = antlist.get()[i * 19 + 13];
+		antpos.get()[i].ZeroAntDiectY = antlist.get()[i * 19 + 14];
+		antpos.get()[i].ZeroAntDiectZ = antlist.get()[i * 19 + 15];
+		antpos.get()[i].lon = antlist.get()[i * 19 + 16];
+		antpos.get()[i].lat = antlist.get()[i * 19 + 17];
+		antpos.get()[i].ati = antlist.get()[i * 19 + 18]; // 19
+    }
+    return antpos;
+}
+
+void SatelliteAntPosOperator::writeAntPosFile(QString filepath, std::shared_ptr<SatelliteAntPos> data, const long count)
+{
+    gdalImage antimg=CreategdalImageDouble(filepath,count,19,1,true,true);
+    long rowcount = count;
+    long colcount = 19;
+    std::shared_ptr<double> antpos(new double[rowcount*19], delArrPtr);
+    for (long i = 0; i < colcount; i++) {
+		antpos.get()[i * 19 + 1] = data.get()[i].time;
+		antpos.get()[i * 19 + 2] = data.get()[i].Px;
+		antpos.get()[i * 19 + 3] = data.get()[i].Py;
+		antpos.get()[i * 19 + 4] = data.get()[i].Pz;
+		antpos.get()[i * 19 + 5] = data.get()[i].Vx;
+		antpos.get()[i * 19 + 6] = data.get()[i].Vy;
+		antpos.get()[i * 19 + 7] = data.get()[i].Vz;
+		antpos.get()[i * 19 + 8] = data.get()[i].AntDirectX;
+		antpos.get()[i * 19 + 9] = data.get()[i].AntDirectY;
+		antpos.get()[i * 19 + 10] = data.get()[i].AntDirectZ;
+		antpos.get()[i * 19 + 11] = data.get()[i].AVx;
+		antpos.get()[i * 19 + 12] = data.get()[i].AVy;
+		antpos.get()[i * 19 + 13] = data.get()[i].AVz;
+		antpos.get()[i * 19 + 14] = data.get()[i].ZeroAntDiectX;
+		antpos.get()[i * 19 + 15] = data.get()[i].ZeroAntDiectY;
+		antpos.get()[i * 19 + 16] = data.get()[i].ZeroAntDiectZ;
+		antpos.get()[i * 19 + 17] = data.get()[i].lon;
+		antpos.get()[i * 19 + 18] = data.get()[i].lat;
+		antpos.get()[i * 19 + 19] = data.get()[i].ati;
+    }
+    antimg.saveImage(antpos, 0,0,rowcount, colcount, 1);
+ 
+    return  ;
+
+
+
+}

BaseTool/EchoDataFormat.h

@@ -0,0 +1,225 @@
+#pragma once
+/*****************************************************************//**
+ * \file   EchoDataFormat.h
+ * \brief  存储仿真过程中的各级产品数据格式，主要包含回波数据格式、仿真参数数据库
+ * 
+ * \author 30453
+ * \date   October 2024
+ *********************************************************************/
+
+
+#include "BaseConstVariable.h"
+
+#include <complex>
+#include <iostream>
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <omp.h>
+#include <memory>
+#include <vector>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <QString>
+
+
+#include "BaseTool.h"
+#include <iostream>
+#include <fstream>
+#include <complex>
+#include <gdal.h>
+#include <gdal_priv.h>
+#include <gdalwarper.h>
+#include <string>
+#include <memory>
+#include <QString>
+#include <cpl_conv.h> // for CPLMalloc()
+
+//========================================================================
+// 成像回波格式
+// file type:
+// PRFCOUNT
+// PRFPOINT
+// nearRange
+// farRange
+// PRF1,time,Px,Py,Pz,Vx,Vy,Vz
+// PRF2,time,Px,Py,Pz,Vx,Vy,Vz
+// ------------------  脉冲文件部分    --------------------------------------
+// PRF1,time,Px,Py,Pz,Vx,Vy,Vz,PRFPOINT,RealData,imagData
+// PRF2,time,Px,Py,Pz,Vx,Vy,Vz,PRFPOINT,RealData,imagData
+// --------------------------------------------------------------
+// 注意Bp并不关心脉冲的顺序，只是关注脉冲的坐标位置，默认按照脉冲的解析顺序进行组织
+//========================================================================
+
+// 成像用的回波脉冲文件格式
+
+/// <summary>
+/// 回波数据--废弃
+/// </summary>
+struct PluseData {
+	long id;  // PRF id
+	double time;// 时间
+	double Px; // 坐标
+	double Py;
+	double Pz;
+	double Vx; // 速度
+	double Vy;
+	double Vz;
+	long plusePoints; // 脉冲点数
+	std::shared_ptr<std::complex<double>> echoData; // 回波数据
+};
+
+long  BASECONSTVARIABLEAPI	getPluseDataSize(PluseData& pluseData);
+ErrorCode BASECONSTVARIABLEAPI	 getPluseDataFromBuffer(char* buffer, PluseData& data);
+std::shared_ptr<PluseData>  BASECONSTVARIABLEAPI	CreatePluseDataArr(long pluseCount);
+std::shared_ptr<std::complex<double>> BASECONSTVARIABLEAPI	 CreateEchoData(long plusePoints);
+
+
+
+/// <summary>
+/// 姿态数据
+/// </summary>
+struct PluseAntPos {
+	long id;  // PRF id
+	double time;// 时间
+	double Px; // 坐标
+	double Py;
+	double Pz;
+	double Vx; // 速度
+	double Vy;
+	double Vz;
+};
+std::shared_ptr<PluseAntPos>  BASECONSTVARIABLEAPI	CreatePluseAntPosArr(long pluseCount);
+
+
+class BASECONSTVARIABLEAPI SatelliteAntPosOperator {
+public:
+	static std::shared_ptr<SatelliteAntPos>  readAntPosFile(QString filepath,long& count);
+	static void writeAntPosFile(QString filepath, std::shared_ptr< SatelliteAntPos> data,const long count);
+
+
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// 定义L0级数据
+class   BASECONSTVARIABLEAPI	EchoL0Dataset {
+
+public:
+	EchoL0Dataset();
+	~EchoL0Dataset();
+
+
+public:
+	ErrorCode OpenOrNew(QString folder, QString filename,long PluseCount,long PlusePoints);
+	ErrorCode Open(QString xmlfilepath);
+	ErrorCode Open(QString folder, QString filename);
+	QString getxmlName();
+	QString getGPSPointFilename();
+	QString getEchoDataFilename();
+	QString getGPSPointFilePath();
+	QString getEchoDataFilePath();
+	void initEchoArr(std::complex<double> init0);
+
+
+private: // 产品名称设置
+	QString folder;
+	QString filename;
+	QString xmlname;
+	QString GPSPointFilename;
+	QString echoDataFilename;
+	//
+	QString xmlFilePath;
+	QString GPSPointFilePath;
+	QString echoDataFilePath;
+
+
+
+public: // 文件处理部分
+	// Getter 和 Setter 方法
+	long getPluseCount() ;
+	void setPluseCount(long pulseCount);
+
+	long getPlusePoints() ;
+	void setPlusePoints(long pulsePoints);
+
+	double getNearRange() ;
+	void setNearRange(double nearRange);
+
+	double getFarRange() ;
+	void setFarRange(double farRange);
+
+	double getCenterFreq() ;
+	void setCenterFreq(double freq);
+
+	double getFs() ;
+	void setFs(double samplingFreq);
+
+	QString getSimulationTaskName() ;
+	void setSimulationTaskName(const QString& taskName);
+
+	double getCenterAngle();
+	void setCenterAngle(double angle);
+
+	QString getLookSide();
+	void setLookSide(QString lookside);
+
+	double getBandwidth();
+	void setBandwidth(double Inbandwidth);
+
+	SatelliteAntPos getSatelliteAntPos(long plusePRFID);
+
+	void setRefPhaseRange(double refRange);
+	double getRefPhaseRange();
+	// 打印信息的成员函数
+	void printInfo() ;	
+
+private: // 回波变量
+	long PluseCount;
+	long PlusePoints;
+	double NearRange;
+	double FarRange;
+	double centerFreq; // 入射中心频率
+	double Fs; // 等效采样频率
+	QString simulationTaskName;
+
+	double CenterAngle;
+	QString LookSide;
+	double refPhaseRange;
+	double bandwidth;
+
+public: 	// 读写 XML 的函数
+	void saveToXml();
+	ErrorCode loadFromXml();
+
+public:
+	// 读取文件
+	std::shared_ptr< SatelliteAntPos> getAntPosVelc();
+	std::shared_ptr<double> getAntPos();
+	std::shared_ptr<std::complex<double>> getEchoArr(long startPRF, long& PRFLen);
+	std::shared_ptr<std::complex<double>> getEchoArr();
+	std::vector<std::complex<double>> getEchoArrVector(long startPRF, long& PRFLen);
+	//保存文件
+	ErrorCode saveAntPos(std::shared_ptr<double> ptr); // 注意这个方法很危险，请写入前检查数据是否正确
+	ErrorCode saveEchoArr(std::shared_ptr<std::complex<double>> echoPtr, long startPRF, long PRFLen);
+
+};
+
+
+
+

BaseTool/FileOperator.cpp

@@ -0,0 +1,322 @@
+#include "stdafx.h"
+#include "FileOperator.h"
+#include <boost/filesystem.hpp>
+#include <string>
+#include <memory.h>
+#include <memory>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <fstream>
+#include <QDebug>
+#include <QString>
+#include <QMessageBox>
+#include <QDirIterator>
+#include <QProcess>
+#include <QFileInfoList>
+
+
+
+
+QString addMaskToFileName(const QString& filePath,QString _zzname) {
+	// 获取文件路径和文件名
+	QFileInfo fileInfo(filePath);
+
+	// 获取文件名和扩展名
+	QString baseName = fileInfo.baseName();  // 不包含扩展名的文件名
+	QString extension = fileInfo.suffix();   // 文件扩展名（例如 ".txt", ".jpg"）
+
+	// 拼接新的文件名
+	QString newFileName = baseName + _zzname;  // 在文件名中增加 "_mask"
+	if (!extension.isEmpty()) {
+		newFileName += "." + extension;  // 如果有扩展名，添加扩展名
+	}
+
+	// 返回新的文件路径
+	QString newFilePath = fileInfo.path() + "/" + newFileName;
+	return newFilePath;
+}
+
+
+std::vector<QString>    getFilelist(const QString& folderpath, const QString& filenameExtension, int (*logfun)(QString logtext, int value))
+{
+	QString filenameExtensionStr = filenameExtension;
+	filenameExtensionStr = filenameExtensionStr.remove(0, 1);
+	std::vector<QString> filenames(0);
+	if (isExists(folderpath) && isDirectory(folderpath)) {
+		QDir directory(folderpath);
+		if (directory.exists() && directory.isReadable()) {
+			QFileInfoList fileList = directory.entryInfoList(QDir::Files | QDir::NoDotAndDotDot);
+			for (const QFileInfo& fileInfo : fileList) {
+//				qDebug() << fileInfo.filePath() + "\nExtension: (" + filenameExtensionStr + ", " + fileInfo.suffix() + ")";
+				if (filenameExtensionStr == u8"*" || filenameExtensionStr == fileInfo.suffix()) {
+					filenames.push_back(fileInfo.filePath());
+				}
+				if (logfun) {
+					logfun(fileInfo.filePath() + "\nExtension: (" + filenameExtensionStr + ", " + fileInfo.suffix() + ")", 4);
+				}
+			}
+		}
+		else {
+			qWarning() << "Folder does not exist or is not readable: " << folderpath;
+		}
+		return filenames;
+	}
+	else {
+		return std::vector<QString>(0);
+	}
+
+}
+
+QString    getParantFolderNameFromPath(const QString& path)
+{
+	QDir directory(path);
+	directory.cdUp();
+	QString parentPath = directory.absolutePath();
+	return directory.dirName();
+}
+
+QString    getParantFromPath(const QString& path)
+{
+	//qDebug() << path;
+	QDir directory(path);
+	directory.cdUp();
+	QString parentPath = directory.absolutePath();
+	//qDebug() << parentPath;
+	return parentPath;
+}
+
+QString    getFileNameFromPath(const QString& path)
+{
+	QFileInfo fileInfo(path);
+	return fileInfo.fileName();
+}
+
+QString getFileNameWidthoutExtend(QString path)
+{
+	QFileInfo fileInfo(path);
+	QString fileNameWithoutExtension = fileInfo.completeBaseName();  // 获取无后缀文件名
+	qDebug() << u8"File name without extension: " << fileNameWithoutExtension;
+	return fileNameWithoutExtension;
+}
+
+QString BASECONSTVARIABLEAPI getFileExtension(QString path)
+{
+	QFileInfo fileInfo(path);
+	QString fileExtension = fileInfo.suffix();  // 获取无后缀文件名
+	return fileExtension;
+}
+
+bool    isDirectory(const QString& path)
+{
+	QFileInfo fileinfo(path);
+	return fileinfo.isDir();
+}
+
+bool    isExists(const QString& path)
+{
+	QFileInfo fileinfo(path);
+	return fileinfo.exists();
+}
+
+bool    isFile(const QString& path)
+{
+	QFileInfo fileinfo(path);
+	return fileinfo.isFile();
+}
+
+int    write_binfile(char* filepath, char* data, size_t data_len)
+{
+	FILE* pd = fopen(filepath, "w");
+	if (NULL == pd) {
+		return 2;
+	}
+	//数据块首地址: "&a"，元素大小: "sizeof(unsigned __int8)"， 元素个数: "10"， 文件指针："pd"
+	fwrite(data, sizeof(char), data_len, pd);
+	fclose(pd);
+	return -1;
+}
+
+  char*  read_textfile(char* text_path, int* length)
+{
+	char* data = NULL;
+	FILE* fp1 = fopen(text_path, "r");
+	if (fp1 == NULL) {
+		return NULL;
+	}
+	else {}
+	// 读取文件
+	fseek(fp1, 0, SEEK_END);
+	int data_length = ftell(fp1);
+	data = (char*)malloc((data_length + 1) * sizeof(char));
+	rewind(fp1);
+	if (data_length == fread(data, sizeof(char), data_length, fp1)) {
+		data[data_length] = '\0'; // 文件尾
+	}
+	else {
+		free(data);
+		fclose(fp1);
+		return NULL;
+	}
+	fclose(fp1);
+	*length = data_length + 1;
+	return data;
+}
+
+bool    exists_test(const QString& name)
+{
+	return isExists(name);
+}
+
+size_t    fsize(FILE* fp)
+{
+	size_t n;
+	fpos_t fpos;        // 当前位置
+	fgetpos(fp, &fpos); // 获取当前位置
+	fseek(fp, 0, SEEK_END);
+	n = ftell(fp);
+	fsetpos(fp, &fpos); // 恢复之前的位置
+	return n;
+}
+
+
+void    removeFile(const QString& filePath)
+{
+	QFile file(filePath);
+
+	if (file.exists()) {
+		if (file.remove()) {
+			qDebug() << "File removed successfully: " << filePath;
+		}
+		else {
+			qWarning() << "Failed to remove file: " << filePath;
+		}
+	}
+	else {
+		qDebug() << "File does not exist: " << filePath;
+	}
+}
+
+unsigned long    convertToULong(const QString& input) {
+	bool ok; // Used to check if the conversion was successful
+	unsigned long result = input.toULong(&ok);
+
+	if (!ok) {
+		qWarning() << "Conversion to unsigned long failed for input: " << input;
+	}
+
+	return result;
+}
+
+void   copyFile(const QString& sourcePath, const QString& destinationPath) {
+	QFile sourceFile(sourcePath);
+	QFile destinationFile(destinationPath);
+	qDebug() << QString("copy file ready !! from ") + sourcePath+"  to  "+destinationPath ;
+	if (sourceFile.exists()) {
+		if (sourceFile.copy(destinationPath)) {
+			qDebug() << QString("copy file sucessfully !! from ") + sourcePath+"  to  "+destinationPath ;
+			// 复制成功
+			//QMessageBox::information(nullptr, u8"成功", u8"文件复制成功");
+		}
+		else {
+			// 复制失败
+			if(sourceFile.exists()){
+				QMessageBox::critical(nullptr, QObject::tr("error"), QObject::tr("The file already exists !!"));
+			}
+			else{
+				QMessageBox::critical(nullptr, QObject::tr("error"), QObject::tr("file copy error"));
+			}
+		}
+	}
+	else {
+		// 源文件不存在
+		QMessageBox::warning(nullptr, QObject::tr("warning"), QObject::tr("Source file not found"));
+	}
+}
+
+
+
+
+bool copyAndReplaceFile(const  QString& sourceFilePath, const   QString& destinationFilePath) {
+	// 检查源文件是否存在
+	if (!QFile::exists(sourceFilePath)) {
+		qDebug() << "Source file does not exist:" << sourceFilePath;
+		return false;
+	}
+
+	// 如果目标文件存在，则删除它
+	if (QFile::exists(destinationFilePath)) {
+		if (!QFile::remove(destinationFilePath)) {
+			qDebug() << "Failed to remove existing destination file:" << destinationFilePath;
+			return false;
+		}
+	}
+
+	// 复制文件
+	if (!QFile::copy(sourceFilePath, destinationFilePath)) {
+		qDebug() << "Failed to copy file from" << sourceFilePath << "to" << destinationFilePath;
+		return false;
+	}
+
+	qDebug() << "File copied successfully from" << sourceFilePath << "to" << destinationFilePath;
+	return true;
+}
+
+
+bool BASECONSTVARIABLEAPI unTarfile(QString inTargzPath, QString outGzFolderPath)
+{
+	// tar -zxvf 压缩包路径 文件或目录路径
+	QProcess process;
+	// 同步执行（阻塞当前线程）
+	QString cmdstr = QString("tar -zxvf %1 -C  %2").arg(inTargzPath).arg(outGzFolderPath);
+	process.execute("cmd.exe", QStringList() << "/c" << cmdstr); // "/c" 表示执行后关闭 CMD
+	process.waitForFinished(); // 等待执行完成
+	// 获取输出
+	QString output = QString::fromLocal8Bit(process.readAllStandardOutput());
+	QString error = QString::fromLocal8Bit(process.readAllStandardError());
+	qDebug() << "Output:" << output;
+	qDebug() << "Error:" << error;
+	return true;
+}
+
+bool BASECONSTVARIABLEAPI createNewFolerPath(QString inpath, bool isremoveExist)
+{
+	QDir outDir(inpath);
+	if (outDir.exists()) {
+		if (isremoveExist) {
+			outDir.removeRecursively();
+		}
+		else {
+			return true;
+		}
+	}
+	QDir().mkpath(inpath);
+	return true;
+}
+
+QFileInfoList   findFilePath(const QString& strFilePath, const QString& strNameFilters)
+{
+	QFileInfoList fileList;
+	if (strFilePath.isEmpty() || strNameFilters.isEmpty())
+	{
+		return fileList;
+	}
+
+	QDir dir;
+	QStringList filters;
+	filters << strNameFilters;
+	dir.setPath(strFilePath);
+	dir.setNameFilters(filters);
+	QDirIterator iter(dir, QDirIterator::Subdirectories);
+	while (iter.hasNext())
+	{
+		iter.next();
+		QFileInfo info = iter.fileInfo();
+		if (info.isFile())
+		{
+			fileList.append(info);
+		}
+	}
+	return fileList;
+}//blog.csdn.net/sinat_33419023/article/details/106105037

BaseTool/FileOperator.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#ifndef FILEOPERATOR_H
+#define FILEOPERATOR_H
+#include "BaseConstVariable.h"
+#include <string.h>
+#include <memory.h>
+#include <memory>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <vector>
+#include <QString>
+#include <QDir>
+#include <QFile>
+#include <QDebug>
+#include <QFileInfoList>
+
+
+bool   BASECONSTVARIABLEAPI	  isDirectory(const QString& path);
+bool   BASECONSTVARIABLEAPI	  isExists(const QString& path);
+bool   BASECONSTVARIABLEAPI	  isFile(const QString& path);
+void   BASECONSTVARIABLEAPI	  removeFile(const QString& filePath);
+unsigned long   BASECONSTVARIABLEAPI	  convertToULong(const QString& input);
+/// <summary>
+/// 获取文件(绝对路径）
+/// </summary>
+/// <param name="folderpath"></param>
+/// <param name="FilenameExtension"></param>
+/// <returns></returns>
+std::vector<QString>   BASECONSTVARIABLEAPI	  getFilelist(const QString& folderpath, const QString& FilenameExtension = ".*", int (*logfun)(QString logtext, int value) = nullptr);
+
+QString  BASECONSTVARIABLEAPI	   getParantFolderNameFromPath(const QString& path);
+
+QString  BASECONSTVARIABLEAPI	   getFileNameFromPath(const QString& path);
+
+QString   BASECONSTVARIABLEAPI	getFileNameWidthoutExtend(QString path);
+
+QString   BASECONSTVARIABLEAPI	getFileExtension(QString path);
+
+int    BASECONSTVARIABLEAPI	write_binfile(char* filepath, char* data, size_t data_len);
+
+char* read_textfile(char* text_path, int* length);
+
+bool    BASECONSTVARIABLEAPI	exists_test(const QString& name);
+
+size_t   BASECONSTVARIABLEAPI	fsize(FILE* fp);
+
+QString    BASECONSTVARIABLEAPI	 getParantFromPath(const QString& path);
+void    BASECONSTVARIABLEAPI	 copyFile(const QString& sourcePath, const QString& destinationPath);
+QString   BASECONSTVARIABLEAPI	addMaskToFileName(const QString& filePath, QString _zzname);
+// QT FileOperator
+
+bool   BASECONSTVARIABLEAPI	copyAndReplaceFile(const QString& sourceFilePath, const QString& destinationFilePath);
+
+// 压缩包文件解压
+bool BASECONSTVARIABLEAPI unTarfile(QString inTargzPath,QString outGzFolderPath);
+bool BASECONSTVARIABLEAPI createNewFolerPath(QString inpath, bool isremoveExist = false);
+
+QFileInfoList BASECONSTVARIABLEAPI findFilePath(const QString& dirPath, const QString& pattern);
+
+#endif

BaseTool/GeoOperator.cpp

@@ -0,0 +1,511 @@
+#include "stdafx.h"
+#include "GeoOperator.h"
+#include <iostream>
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <time.h>
+////#include <mkl.h>
+#include <string>
+#include <omp.h>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <gdal.h>
+#include <gdal_priv.h>
+#include <gdalwarper.h>
+//#include <ogr_geos.h>
+#include <ogrsf_frmts.h> //#include "ogrsf_frmts.h"
+#include <fstream>
+#include <proj.h>
+#include "GeoOperator.h"
+#include <ogr_spatialref.h>  // OGRSpatialReference 用于空间参考转换
+#include <gdal_alg.h>        // 用于 GDALWarp 操作
+#include <ogr_spatialref.h>
+
+
+Landpoint   operator +(const Landpoint& p1, const Landpoint& p2)
+{
+	return Landpoint{ p1.lon + p2.lon,p1.lat + p2.lat,p1.ati + p2.ati };
+}
+
+Landpoint   operator -(const Landpoint& p1, const Landpoint& p2)
+{
+	return Landpoint{ p1.lon - p2.lon,p1.lat - p2.lat,p1.ati - p2.ati };
+}
+
+bool   operator ==(const Landpoint& p1, const Landpoint& p2)
+{
+	return p1.lat == p2.lat && p1.lon == p2.lon && p1.ati == p2.ati;
+}
+
+
+
+Landpoint   operator *(const Landpoint& p, double scale)
+{
+	return Landpoint{
+		p.lon * scale,
+		p.lat * scale,
+		p.ati * scale
+	};
+}
+
+
+Landpoint   LLA2XYZ(const Landpoint& LLA) {
+	double L = LLA.lon * d2r;
+	double B = LLA.lat * d2r;
+	double H = LLA.ati;
+
+	double sinB = sin(B);
+	double cosB = cos(B);
+
+	//double N = a / sqrt(1 - e * e * sin(B) * sin(B));
+	double N = a / sqrt(1 - eSquare * sinB * sinB);
+	Landpoint result = { 0,0,0 };
+	result.lon = (N + H) * cosB * cos(L);
+	result.lat = (N + H) * cosB * sin(L);
+	//result.z = (N * (1 - e * e) + H) * sin(B);
+	result.ati = (N * (1 - 1 / f_inverse) * (1 - 1 / f_inverse) + H) * sinB;
+	return result;
+}
+
+void LLA2XYZ(const Landpoint& LLA, Point3& XYZ)
+{
+	double L = LLA.lon * d2r;
+	double B = LLA.lat * d2r;
+	double H = LLA.ati;
+
+	double sinB = sin(B);
+	double cosB = cos(B);
+
+	//double N = a / sqrt(1 - e * e * sin(B) * sin(B));
+	double N = a / sqrt(1 - eSquare * sinB * sinB);
+	Landpoint result = { 0,0,0 };
+	XYZ.x = (N + H) * cosB * cos(L);
+	XYZ.y = (N + H) * cosB * sin(L);
+	//result.z = (N * (1 - e * e) + H) * sin(B);
+	XYZ.z = (N * (1 - 1 / f_inverse) * (1 - 1 / f_inverse) + H) * sinB;
+
+}
+
+
+Eigen::MatrixXd   LLA2XYZ(Eigen::MatrixXd landpoint)
+{
+	landpoint.col(0) = landpoint.col(0).array() * d2r; // lon
+	landpoint.col(1) = landpoint.col(1).array() * d2r; // lat
+
+	Eigen::MatrixXd sinB = (landpoint.col(1).array().sin());//lat
+	Eigen::MatrixXd cosB = (landpoint.col(1).array().cos());//lat
+
+	Eigen::MatrixXd N = a / ((1 - sinB.array().pow(2) * eSquare).array().sqrt());
+	Eigen::MatrixXd result(landpoint.rows(), 3);
+
+	result.col(0) = (N.array() + landpoint.col(2).array()) * cosB.array() * Eigen::cos(landpoint.col(0).array()).array(); //x
+	result.col(1) = (N.array() + landpoint.col(2).array()) * cosB.array() * Eigen::sin(landpoint.col(0).array()).array(); //y
+
+	result.col(2) = (N.array() * (1 - 1 / f_inverse) * (1 - 1 / f_inverse) + landpoint.col(2).array()) * sinB.array(); //z
+
+	return result;
+}
+
+
+Landpoint   XYZ2LLA(const Landpoint& XYZ) {
+	double tmpX = XYZ.lon;// 
+	double temY = XYZ.lat;// 
+	double temZ = XYZ.ati;
+
+	double curB = 0;
+	double N = 0;
+	double sqrtTempXY = sqrt(tmpX * tmpX + temY * temY);
+	double calB = atan2(temZ, sqrtTempXY);
+	int counter = 0;
+	double sinCurB = 0;
+	while (abs(curB - calB) * r2d > epsilon && counter < 25)
+	{
+		curB = calB;
+		sinCurB = sin(curB);
+		N = a / sqrt(1 - eSquare * sinCurB * sinCurB);
+		calB = atan2(temZ + N * eSquare * sinCurB, sqrtTempXY);
+		counter++;
+	}
+
+	Landpoint result = { 0,0,0 };
+	result.lon = atan2(temY, tmpX) * r2d;
+	result.lat = curB * r2d;
+	result.ati = temZ / sinCurB - N * (1 - eSquare);
+	return result;
+}
+
+
+
+void XYZ2BLH_FixedHeight(double x, double y, double z,double ati, Landpoint& point) {
+	const double a = 6378137.0;       // WGS84长半轴 
+	const double f = 1.0 / 298.257223563;
+	const double e2 = 2 * f - f * f;      // 第一偏心率平方
+
+	// 计算经度L (弧度)
+	const double L_rad = std::atan2(y, x);
+	point.lon = L_rad * 180.0 / M_PI; // 转为度
+
+	const double p = std::sqrt(x * x + y * y);
+	const double H = ati;       // 使用已知高度
+
+	// 初始纬度估算（考虑已知高度H）
+	double B_rad = std::atan2(z, p * (1 - e2 * (a / (a + H))));
+
+	// 迭代计算纬度B（固定H）
+	for (int i = 0; i < 10; ++i) {   // 已知H时迭代次数减少
+		const double sin_B = std::sin(B_rad);
+		const double N = a / std::sqrt(1 - e2 * sin_B * sin_B);
+		const double delta = e2 * N / (N + H);  // 高度固定时的修正项
+
+		const double B_new = std::atan2(z, p * (1 - delta));
+
+		if (std::abs(B_new - B_rad) < 1e-9) {
+			B_rad = B_new;
+			break;
+		}
+		B_rad = B_new;
+	}
+
+	point.lat = B_rad * 180.0 / M_PI; // 弧度转度
+
+	// 经度范围修正 [-180°, 180°]
+	point.lon = std::fmod(point.lon + 360.0, 360.0);
+	if (point.lon > 180.0) point.lon -= 360.0;
+	point.ati = ati;
+}
+
+
+double   getAngle(const Landpoint& a, const Landpoint& b)
+{
+	double c = dot(a, b) / (getlength(a) * getlength(b));
+	if (a.lon * b.lat - a.lat * b.lon >= 0) {
+		return acos(c > 1 ? 1 : c < -1 ? -1 : c) * r2d;
+	}
+	else {
+		return 360 - acos(c > 1 ? 1 : c < -1 ? -1 : c) * r2d;
+	}
+}
+
+double   dot(const Landpoint& p1, const Landpoint& p2)
+{
+	return p1.lat * p2.lat + p1.lon * p2.lon + p1.ati * p2.ati;
+}
+
+double   getlength(const Landpoint& p1) {
+
+	return sqrt(dot(p1, p1));
+}
+
+Landpoint   crossProduct(const Landpoint& a, const Landpoint& b) {
+	return Landpoint{
+		a.lat * b.ati - a.ati * b.lat,//x 
+		a.ati * b.lon - a.lon * b.ati,//y
+		a.lon * b.lat - a.lat * b.lon//z
+	};
+}
+
+float   cross2d(Point3 a, Point3 b)
+{
+	return a.x * b.y - a.y * b.x;
+}
+
+Point3   operator -(Point3 a, Point3 b)
+{
+	return Point3{ a.x - b.x, a.y - b.y, a.z - b.z };
+}
+
+Point3   operator +(Point3 a, Point3 b)
+{
+	return Point3{ a.x + b.x, a.y + b.y, a.z + b.z };
+}
+
+double   operator /(Point3 a, Point3 b)
+{
+	return sqrt(pow(a.x, 2) + pow(a.y, 2)) / sqrt(pow(b.x, 2) + pow(b.y, 2));
+}
+
+double BASECONSTVARIABLEAPI getPixelSpacingInDegree(double pixelSpacingInMeter)
+{
+	return pixelSpacingInMeter / WGS84_A * r2d;
+ 
+}
+
+double BASECONSTVARIABLEAPI getPixelSpacingInMeter(double pixelSpacingInDegree)
+{
+	return pixelSpacingInDegree * WGS84_A * r2d;
+}
+
+
+Landpoint   getSlopeVector(const Landpoint& p0, const  Landpoint& p1, const  Landpoint& p2, const  Landpoint& p3, const Landpoint& p4,bool inLBH) {
+	Landpoint n0, n1, n2, n3, n4;
+	if (inLBH) {
+		n0 = LLA2XYZ(p0);
+		n1 = LLA2XYZ(p1);
+		n2 = LLA2XYZ(p2);
+		n3 = LLA2XYZ(p3);
+		n4 = LLA2XYZ(p4);
+	}
+	else {
+		n0 = p0;
+		n1 = p1;
+		n2 = p2;
+		n3 = p3;
+		n4 = p4;
+	}
+
+	Landpoint n01 = n1 - n0, n02 = n2 - n0, n03 = n3 - n0, n04 = n4 - n0;
+	// 锟斤拷n01为锟斤拷锟斤拷锟斤拷锟斤拷
+	Landpoint np01 = p1 - p0, np02 = p2 - p0, np03 = p3 - p0, np04 = p4 - p0;
+	double a2 = getAngle(Landpoint{ np01.lon,np01.lat,0 }, Landpoint{ np02.lon,np02.lat,0 });// 01->02  
+	double a3 = getAngle(Landpoint{ np01.lon,np01.lat,0 }, Landpoint{ np03.lon,np03.lat,0 });// 01->03  
+	double a4 = getAngle(Landpoint{ np01.lon,np01.lat,0 }, Landpoint{ np04.lon,np04.lat,0 });// 01->04  
+	//qDebug() << a2 << "\t" << a3 << "\t" << a4 << endl;
+	a2 = 360 - a2;
+	a3 = 360 - a3;
+	a4 = 360 - a4;
+	Landpoint N, W, S, E;
+	N = n01;
+	if (a2 >= a3 && a2 >= a4) {
+		W = n02;
+		if (a3 >= a4) {
+			S = n03;
+			E = n04;
+		}
+		else {
+			S = n04;
+			E = n03;
+		}
+	}
+	else if (a3 >= a2 && a3 >= a4) {
+		W = n03;
+		if (a2 >= a4) {
+			S = n02;
+			E = n04;
+		}
+		else {
+			S = n04;
+			E = n02;
+		}
+	}
+	else if (a4 >= a2 && a4 >= a3)
+	{
+		W = n04;
+		if (a2 >= a3) {
+			S = n02;
+			E = n03;
+		}
+		else {
+			S = n03;
+			E = n02;
+		}
+	}
+	return (crossProduct(N, W) + crossProduct(W, S) + crossProduct(S, E) + crossProduct(E, N)) * 0.25;
+}
+
+
+
+double   distance(const Vector3D& p1, const Vector3D& p2)
+{
+	double dx = p1.x - p2.x;
+	double dy = p1.y - p2.y;
+	double dz = p1.z - p2.z;
+	return std::sqrt(dx * dx + dy * dy + dz * dz);
+}
+
+double   pointToLineDistance(const Vector3D& point, const Vector3D& linePoint, const Vector3D& lineDirection)
+{
+	Vector3D pointToLine = { point.x - linePoint.x, point.y - linePoint.y, point.z - linePoint.z };
+
+	// 璁＄畻鐐瑰埌鐩寸嚎鐨勬姇褰辩偣鐨勪綅缃?
+	double t = (pointToLine.x * lineDirection.x + pointToLine.y * lineDirection.y + pointToLine.z * lineDirection.z) /
+		(lineDirection.x * lineDirection.x + lineDirection.y * lineDirection.y + lineDirection.z * lineDirection.z);
+
+	// 璁＄畻鎶曞奖鐐?
+	Vector3D projection = { linePoint.x + t * lineDirection.x, linePoint.y + t * lineDirection.y, linePoint.z + t * lineDirection.z };
+
+	// 璁＄畻鐐瑰埌鐩寸嚎鐨勮窛绂?
+	return distance(point, projection);
+}
+
+Vector3D operator+(const Vector3D& p1, const Vector3D& p2)
+{
+	return  Vector3D{ p1.x + p2.x,p1.y + p2.y,p1.z + p2.z };
+}
+
+Vector3D operator-(const Vector3D& p1, const Vector3D& p2)
+{
+	return  Vector3D{ p1.x - p2.x,p1.y - p2.y,p1.z - p2.z };
+}
+
+bool operator==(const Vector3D& p1, const Vector3D& p2)
+{
+	return p1.x == p2.x && p1.y == p2.y && p1.z == p2.z;
+}
+
+Vector3D operator*(const Vector3D& p, double scale)
+{
+	return Vector3D{
+		p.x * scale,
+		p.y * scale,
+		p.z * scale
+	};
+}
+
+Vector3D operator*(double scale, const Vector3D& p)
+{
+	return Vector3D{
+		p.x * scale,
+		p.y * scale,
+		p.z * scale
+	};
+}
+
+double getAngle(const Vector3D& a, const Vector3D& b)
+{
+	double c = dot(a, b) / (getlength(a) * getlength(b));
+	if (a.x * b.y - a.y * b.x >= 0) {
+		return acos(c > 1 ? 1 : c < -1 ? -1 : c) * r2d;
+	}
+	else {
+		return 360 - acos(c > 1 ? 1 : c < -1 ? -1 : c) * r2d;
+	}
+}
+
+double getCosAngle(const Vector3D& a, const Vector3D& b)
+{
+	double c = dot(a, b) / (getlength(a) * getlength(b));
+	return acos(c > 1 ? 1 : c < -1 ? -1 : c) * r2d;
+}
+
+double dot(const Vector3D& p1, const Vector3D& p2)
+{
+	return p1.y * p2.y + p1.x * p2.x + p1.z * p2.z;
+}
+
+double getlength(const Vector3D& p1)
+{
+	return std::sqrt(std::pow(p1.x, 2) + std::pow(p1.y, 2) + std::pow(p1.z, 2));
+}
+
+Vector3D crossProduct(const Vector3D& a, const Vector3D& b)
+{
+	return Vector3D{
+		a.y * b.z - a.z * b.y,//x 
+		a.z * b.x - a.x * b.z,//y
+		a.x * b.y - a.y * b.x//z
+	};
+}
+
+
+/// <summary>
+///      n1
+///   n4 n0 n2           
+///      n3
+/// </summary>
+Vector3D getSlopeVector(const Vector3D& n0, const Vector3D& n1, const Vector3D& n2, const Vector3D& n3, const Vector3D& n4)
+{
+	Vector3D n01 = n1 - n0, n02 = n2 - n0, n03 = n3 - n0, n04 = n4 - n0;
+	return (crossProduct(n01, n04) + crossProduct(n04, n03) + crossProduct(n03, n02) + crossProduct(n02, n01)) * 0.25;
+}
+
+
+SphericalCoordinates   cartesianToSpherical(const CartesianCoordinates& cartesian)
+{
+	SphericalCoordinates spherical;
+
+	spherical.r = std::sqrt(cartesian.x * cartesian.x + cartesian.y * cartesian.y + cartesian.z * cartesian.z);
+	spherical.theta = std::acos(cartesian.z / spherical.r);
+	spherical.phi = std::atan2(cartesian.y, cartesian.x);
+
+	return spherical;
+}
+
+CartesianCoordinates   sphericalToCartesian(const SphericalCoordinates& spherical)
+{
+	CartesianCoordinates cartesian;
+
+	cartesian.x = spherical.r * std::sin(spherical.theta) * std::cos(spherical.phi);
+	cartesian.y = spherical.r * std::sin(spherical.theta) * std::sin(spherical.phi);
+	cartesian.z = spherical.r * std::cos(spherical.theta);
+
+	return cartesian;
+}
+
+
+double getlocalIncAngle(Landpoint& satepoint, Landpoint& landpoint, Landpoint& slopeVector) {
+	Landpoint Rsc = satepoint - landpoint; // AB=B-A
+	//double R = getlength(Rsc);
+	//qDebug() << R << endl;
+	double angle = getAngle(Rsc, slopeVector);
+	if (angle >= 180) {
+		return 360 - angle;
+	}
+	else {
+		return angle;
+	}
+}
+
+
+double getlocalIncAngle(Vector3D& satepoint, Vector3D& landpoint, Vector3D& slopeVector){
+	Vector3D Rsc = satepoint - landpoint; // AB=B-A
+	//double R = getlength(Rsc);
+	//qDebug() << R << endl;
+	double angle = getAngle(Rsc, slopeVector);
+	if (angle >= 180) {
+		return 360 - angle;
+	}
+	else {
+		return angle;
+	}
+}
+
+bool BASECONSTVARIABLEAPI ConvertResolutionToDegrees(int sourceEPSG, double resolutionMeters, double refLon, double refLat, double& degreePerPixelX, double& degreePerPixelY){
+	// 初始化源坐标系（平面投影）和目标坐标系（WGS84 经纬度）
+	OGRSpatialReference sourceSRS, targetSRS;
+	sourceSRS.importFromEPSG(sourceEPSG);   // 源坐标系需明确 EPSG 
+	targetSRS.importFromEPSG(4326);         // 目标为 WGS84 经纬度 
+
+	// 创建坐标转换器：经纬度 -> 平面坐标
+	OGRCoordinateTransformation* toPlane = OGRCreateCoordinateTransformation(&targetSRS, &sourceSRS);
+	if (!toPlane) return false;
+
+	// 将参考点经纬度转换为平面坐标
+	double x = refLon, y = refLat;
+	if (!toPlane->Transform(1, &x, &y)) {
+		OGRCoordinateTransformation::DestroyCT(toPlane);
+		return false;
+	}
+
+	// 创建坐标转换器：平面坐标 -> 经纬度
+	OGRCoordinateTransformation* toGeo = OGRCreateCoordinateTransformation(&sourceSRS, &targetSRS);
+	if (!toGeo) {
+		OGRCoordinateTransformation::DestroyCT(toPlane);
+		return false;
+	}
+
+	// 计算东向分辨率（经度变化量）
+	double eastX = x + resolutionMeters, eastY = y;
+	double eastLon = eastX, eastLat = eastY;
+	if (!toGeo->Transform(1, &eastLon, &eastLat)) {
+		OGRCoordinateTransformation::DestroyCT(toPlane);
+		OGRCoordinateTransformation::DestroyCT(toGeo);
+		return false;
+	}
+	degreePerPixelX = (eastLon - refLon) / resolutionMeters;  // 经度方向每米对应度数 
+
+	// 计算北向分辨率（纬度变化量）
+	double northX = x, northY = y + resolutionMeters;
+	double northLon = northX, northLat = northY;
+	if (!toGeo->Transform(1, &northLon, &northLat)) {
+		OGRCoordinateTransformation::DestroyCT(toPlane);
+		OGRCoordinateTransformation::DestroyCT(toGeo);
+		return false;
+	}
+	degreePerPixelY = (northLat - refLat) / resolutionMeters;  // 纬度方向每米对应度数 
+
+	// 释放资源
+	OGRCoordinateTransformation::DestroyCT(toPlane);
+	OGRCoordinateTransformation::DestroyCT(toGeo);
+	return true;
+}

BaseTool/GeoOperator.h

@@ -0,0 +1,150 @@
+#pragma once
+
+
+#ifndef _GEOOPERATOR_H
+#define _GEOOPERATOR_H
+
+#include "BaseConstVariable.h"
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <string.h>
+#include <iostream>
+
+
+/// <summary>
+/// 将经纬度转换为地固参心坐标系
+/// </summary>
+/// <param name="XYZP">经纬度点--degree</param>
+/// <returns>投影坐标系点</returns>
+Landpoint   BASECONSTVARIABLEAPI	  LLA2XYZ(const Landpoint& LLA);
+void   BASECONSTVARIABLEAPI	LLA2XYZ(const Landpoint& LLA,Point3& XYZ);
+Eigen::MatrixXd    BASECONSTVARIABLEAPI	 LLA2XYZ(Eigen::MatrixXd landpoint);
+
+double BASECONSTVARIABLEAPI	 getPixelSpacingInDegree(double pixelSpacingInMeter);
+
+double BASECONSTVARIABLEAPI	 getPixelSpacingInMeter(double pixelSpacingInDegree);
+/// <summary>
+/// 将地固参心坐标系转换为经纬度
+/// </summary>
+/// <param name="XYZ">固参心坐标系</param>
+/// <returns>经纬度--degree</returns>
+Landpoint   BASECONSTVARIABLEAPI	  XYZ2LLA(const Landpoint& XYZ);
+
+void BASECONSTVARIABLEAPI XYZ2BLH_FixedHeight(double x, double y, double z, double ati, Landpoint& point);
+
+Landpoint   BASECONSTVARIABLEAPI	  operator +(const Landpoint& p1, const Landpoint& p2);
+
+Landpoint     BASECONSTVARIABLEAPI	operator -(const Landpoint& p1, const Landpoint& p2);
+
+bool     BASECONSTVARIABLEAPI	operator ==(const Landpoint& p1, const Landpoint& p2);
+
+Landpoint    BASECONSTVARIABLEAPI	 operator *(const Landpoint& p, double scale);
+
+double    BASECONSTVARIABLEAPI	 getAngle(const Landpoint& a, const Landpoint& b);
+
+double    BASECONSTVARIABLEAPI	 dot(const Landpoint& p1, const Landpoint& p2);
+
+double    BASECONSTVARIABLEAPI	 getlength(const Landpoint& p1);
+
+Landpoint    BASECONSTVARIABLEAPI	 crossProduct(const Landpoint& a, const Landpoint& b);
+
+
+Landpoint    BASECONSTVARIABLEAPI	 getSlopeVector(const Landpoint& p0, const Landpoint& p1, const Landpoint& p2, const Landpoint& p3, const Landpoint& p4, bool inLBH=true);
+
+double   BASECONSTVARIABLEAPI	getlocalIncAngle(Landpoint& satepoint, Landpoint& landpoint, Landpoint& slopeVector);
+
+float    BASECONSTVARIABLEAPI	 cross2d(Point3 a, Point3 b);
+
+Point3   BASECONSTVARIABLEAPI	  operator -(Point3 a, Point3 b);
+
+Point3    BASECONSTVARIABLEAPI	 operator +(Point3 a, Point3 b);
+
+double   BASECONSTVARIABLEAPI	  operator /(Point3 a, Point3 b);
+
+
+
+// 矢量计算 
+struct Vector3D {
+	double x, y, z;
+};
+
+// 计算两点之间的距离
+double   BASECONSTVARIABLEAPI	  distance(const Vector3D& p1, const Vector3D& p2);
+// 计算点到直线的最短距离
+double   BASECONSTVARIABLEAPI	  pointToLineDistance(const Vector3D& point, const Vector3D& linePoint, const Vector3D& lineDirection);
+
+Vector3D   BASECONSTVARIABLEAPI	  operator +(const Vector3D& p1, const Vector3D& p2);
+
+Vector3D   BASECONSTVARIABLEAPI	  operator -(const Vector3D& p1, const Vector3D& p2);
+
+bool   BASECONSTVARIABLEAPI	  operator ==(const Vector3D& p1, const Vector3D& p2);
+
+Vector3D   BASECONSTVARIABLEAPI	  operator *(const Vector3D& p, double scale);
+
+Vector3D   BASECONSTVARIABLEAPI	  operator *(double scale,const Vector3D& p );
+
+double   BASECONSTVARIABLEAPI	  getAngle(const Vector3D& a, const Vector3D& b);
+
+double   BASECONSTVARIABLEAPI	  getCosAngle(const Vector3D& a, const Vector3D& b);
+
+double   BASECONSTVARIABLEAPI	  dot(const Vector3D& p1, const Vector3D& p2);
+
+double   BASECONSTVARIABLEAPI	  getlength(const Vector3D& p1);
+
+Vector3D    BASECONSTVARIABLEAPI	 crossProduct(const Vector3D& a, const Vector3D& b);
+
+
+
+/// <summary>
+///      n1
+///   n4 n0 n2           
+///      n3
+/// </summary>
+/// <param name="n0"></param>
+/// <param name="n1"></param>
+/// <param name="n2"></param>
+/// <param name="n3"></param>
+/// <param name="n4"></param>
+/// <returns></returns>
+Vector3D  BASECONSTVARIABLEAPI	 getSlopeVector(const Vector3D& n0, const Vector3D& n1, const Vector3D& n2, const Vector3D& n3, const Vector3D& n4);
+
+
+struct CartesianCoordinates {
+	double x, y, z;
+};
+
+struct SphericalCoordinates {
+	double r, theta, phi;
+};
+
+SphericalCoordinates    BASECONSTVARIABLEAPI	 cartesianToSpherical(const CartesianCoordinates& cartesian);
+
+CartesianCoordinates   BASECONSTVARIABLEAPI	  sphericalToCartesian(const SphericalCoordinates& spherical);
+
+double   BASECONSTVARIABLEAPI	getlocalIncAngle(Vector3D& satepoint, Vector3D& landpoint, Vector3D& slopeVector);
+
+
+
+/**
+ * @brief 将平面坐标分辨率（米）转换为经纬度分辨率（度）
+ * @param sourceEPSG 平面坐标系 EPSG 码（如 UTM Zone 50N 对应 32650）
+ * @param resolutionMeters 输入分辨率（单位：米）
+ * @param refLon 参考点经度（十进制度，用于计算局部转换系数）
+ * @param refLat 参考点纬度（十进制度，用于计算局部转换系数）
+ * @param[out] degreePerPixelX 经度方向分辨率（度/像素）
+ * @param[out] degreePerPixelY 纬度方向分辨率（度/像素）
+ * @return 是否转换成功
+ */
+bool BASECONSTVARIABLEAPI ConvertResolutionToDegrees(
+    int sourceEPSG,
+    double resolutionMeters,
+    double refLon,
+    double refLat,
+    double& degreePerPixelX,
+    double& degreePerPixelY
+);
+
+#endif

BaseTool/ImageOperatorBase.h

@@ -0,0 +1,631 @@
+#pragma once
+/**
+ * 影像数据操作项
+ * 所有数据相关的操作，都是基于ENVI的数据格式
+ * 影像读写操作时基于 GDAL 库
+ * **/
+
+
+
+#ifndef IMAGEOPERATORBASE_H
+#define IMAGEOPERATORBASE_H
+#include "BaseConstVariable.h"
+#include "GeoOperator.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <complex>
+#include <gdal.h>
+#include <gdal_priv.h>
+#include <gdalwarper.h>
+#include <string>
+#include <memory>
+#include <QString>
+#include <cpl_conv.h> // for CPLMalloc()
+#include "LogInfoCls.h"
+#include <QObject>
+#include <QList>
+#include <functional>
+#include "ShowProessAbstract.h"
+
+
+
+enum ProjectStripDelta {
+	Strip_6, // 6度带
+	Strip_3
+};
+
+enum CoordinateSystemType { // 坐标系类型
+	GeoCoordinateSystem,
+	ProjectCoordinateSystem,
+	UNKNOW
+};
+
+struct PointRaster { // 影像坐标点
+	double x;
+	double y;
+	double z;
+};
+
+
+struct PointXYZ {
+	double x, y, z;
+};
+
+struct  PointGeo {
+	double lon, lat, ati;
+};
+
+struct PointImage {
+	double pixel_x, pixel_y;
+};
+
+
+
+struct ImageGEOINFO {
+	int width;
+	int height;
+	int bandnum;
+};
+
+
+enum GDALREADARRCOPYMETHOD {
+	MEMCPYMETHOD,		// 直接拷贝
+	VARIABLEMETHOD		// 变量赋值
+
+};
+
+
+
+
+
+
+/// 根据经纬度获取
+/// EPSG代码，根据经纬度返回对应投影坐标系统，其中如果在中华人民共和国境内，默认使用
+/// CGCS2000坐标系统(EPSG 4502 ~ 4512 6度带,EPSG 4534 ~ 4554 3度带)，其余地方使用WGS坐标系统，
+/// 投影方法 高斯克吕格（国内）， 高斯克吕格
+/// \param long 经度
+/// \param lat 纬度
+/// \return 对应投影坐标系统的 EPSG编码,-1 表示计算错误
+long   BASECONSTVARIABLEAPI	getProjectEPSGCodeByLon_Lat(double lon, double lat, ProjectStripDelta stripState= ProjectStripDelta::Strip_6);
+
+long  BASECONSTVARIABLEAPI	 getProjectEPSGCodeByLon_Lat_inStrip3(double lon, double lat);
+
+long  BASECONSTVARIABLEAPI	 getProjectEPSGCodeByLon_Lat_inStrip6(double lon, double lat);
+
+
+QString   BASECONSTVARIABLEAPI	GetProjectionNameFromEPSG(long epsgCode);
+
+
+long   BASECONSTVARIABLEAPI	GetEPSGFromRasterFile(QString filepath);
+
+std::shared_ptr<PointRaster>   BASECONSTVARIABLEAPI	GetCenterPointInRaster(QString filepath);
+
+CoordinateSystemType   BASECONSTVARIABLEAPI	getCoordinateSystemTypeByEPSGCode(long EPSGCODE);
+
+
+// 文件打开 // 当指令销毁时，调用GDALClose 销毁类型
+std::shared_ptr<GDALDataset>   BASECONSTVARIABLEAPI	  OpenDataset(const QString& in_path, GDALAccess rwmode = GA_ReadOnly);
+void    BASECONSTVARIABLEAPI	 CloseDataset(GDALDataset* ptr);
+
+// 数据格式转换
+int   BASECONSTVARIABLEAPI	  TIFF2ENVI(QString in_tiff_path, QString out_envi_path);
+int   BASECONSTVARIABLEAPI	  ENVI2TIFF(QString in_envi_path, QString out_tiff_path);
+
+// 保存影像数据 --直接保存 ENVI 文件
+
+int  BASECONSTVARIABLEAPI	   CreateDataset(QString new_file_path, int height, int width, int band_num, double* gt, QString projection, GDALDataType gdal_dtype, bool need_gt); // 创建文件
+
+int   BASECONSTVARIABLEAPI	  saveDataset(QString new_file_path, int start_line, int start_cols, int band_ids, int datacols, int datarows, void* databuffer);
+
+// 根据限制条件估算分块大小
+int   BASECONSTVARIABLEAPI	  block_num_pre_memory(int width, int height, GDALDataType gdal_dtype, double memey_size);
+
+// 将结果转换为复数 或者 实数
+Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>    BASECONSTVARIABLEAPI	 ReadComplexMatrixData(int start_line, int width, int line_num, std::shared_ptr<GDALDataset> rasterDataset, GDALDataType gdal_datatype);
+
+Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>    BASECONSTVARIABLEAPI	  ReadMatrixDoubleData(int start_line, int width, int line_num, std::shared_ptr<GDALDataset> rasterDataset, GDALDataType gdal_datatype, int band_idx);
+
+Eigen::MatrixXd  BASECONSTVARIABLEAPI	   getGeoTranslationArray(QString in_path);
+ImageGEOINFO   BASECONSTVARIABLEAPI	  getImageINFO(QString in_path);
+
+GDALDataType    BASECONSTVARIABLEAPI	 getGDALDataType(QString fileptah);
+
+
+struct RasterExtend {
+	double min_x;  
+	double min_y; 
+	double max_x; 
+	double max_y; 
+};
+
+
+
+
+
+/// <summary>
+/// gdalImage图像操作类
+/// </summary>
+
+class    BASECONSTVARIABLEAPI	 gdalImage
+{
+
+public: // 方法
+	gdalImage();
+	gdalImage(const QString& raster_path);
+	~gdalImage();
+	virtual void setHeight(int);
+	virtual void setWidth(int);
+	virtual void setTranslationMatrix(Eigen::MatrixXd gt);
+	virtual void setData(Eigen::MatrixXd, int data_band_ids = 1);
+	virtual Eigen::MatrixXd getData(int start_row, int start_col, int rows_count, int cols_count, int band_ids);
+	virtual Eigen::MatrixXf getDataf(int start_row, int start_col, int rows_count, int cols_count, int band_ids);
+	virtual Eigen::MatrixXi getDatai(int start_row, int start_col, int rows_count, int cols_count, int band_ids);
+	virtual ErrorCode getData(double* data, int start_row, int start_col, int rows_count, int cols_count, int band_ids);
+	virtual ErrorCode getData(long* data, int start_row, int start_col, int rows_count, int cols_count, int band_ids);
+	virtual Eigen::MatrixXd getGeoTranslation();
+	virtual GDALDataType getDataType();
+	virtual void saveImage(Eigen::MatrixXd, int start_row, int start_col, int band_ids);
+	virtual void saveImage(Eigen::MatrixXf, int start_row, int start_col, int band_ids);
+	virtual void saveImage(Eigen::MatrixXi, int start_row, int start_col, int band_ids);
+	virtual void saveImage(std::shared_ptr<double>, int start_row, int start_col,int rowcount,int colcount, int band_ids);
+	virtual void saveImage(std::shared_ptr<float>, int start_row, int start_col, int rowcount, int colcount, int band_ids);
+	virtual void saveImage(std::shared_ptr<int>, int start_row, int start_col, int rowcount, int colcount, int band_ids);
+
+	virtual void saveImage();
+	virtual void setNoDataValue(double nodatavalue, int band_ids);
+	virtual void setNoDataValuei(int nodatavalue, int band_ids);
+	virtual double getNoDataValue(int band_ids);
+	virtual int getNoDataValuei(int band_ids);
+	virtual int InitInv_gt();
+	virtual Landpoint getRow_Col(double lon, double lat);
+	virtual Landpoint getLandPoint(double i, double j, double ati);
+
+	virtual void getLandPoint(double  i, double  j, double  ati, Landpoint& Lp);
+
+	virtual double mean(int bandids = 1);
+	double BandmaxValue(int bandids = 1);
+	double BandminValue(int bandids = 1);
+	virtual GDALRPCInfo getRPC();
+	virtual Eigen::MatrixXd getLandPoint(Eigen::MatrixXd points);
+
+	virtual Eigen::MatrixXd getHist(int bandids);
+
+	virtual RasterExtend getExtend();
+
+
+
+
+
+public:
+	QString img_path; // 图像文件
+	int height; // 高
+	int width; // 宽
+	int band_num;// 波段数
+	int start_row;// 
+	int start_col;//
+	int data_band_ids;
+	Eigen::MatrixXd gt; // 变换矩阵
+	Eigen::MatrixXd inv_gt; // 逆变换矩阵
+	Eigen::MatrixXd data;
+	QString projection;
+};
+
+
+
+/// <summary>
+/// gdalImage图像操作类
+/// </summary>
+class   BASECONSTVARIABLEAPI	  gdalImageComplex :public gdalImage
+{
+
+public: // 方法
+	gdalImageComplex(const QString& raster_path);
+	~gdalImageComplex();
+	void setData(Eigen::MatrixXcd);
+	void saveImage(Eigen::MatrixXcd data, int start_row, int start_col, int band_ids);
+	void saveImage(std::shared_ptr<std::complex<double>> data, long start_row, long start_col, long rowCount, long colCount, int band_ids);
+	void saveImage(std::complex<double>* data, long start_row, long start_col, long rowcount, long colcount, int banids);
+	
+	Eigen::MatrixXcd getDataComplex(int start_row, int start_col, int rows_count, int cols_count, int band_ids);
+	std::shared_ptr<std::complex<double>> getDataComplexSharePtr(int start_row, int start_col, int rows_count, int cols_count, int band_ids);
+
+	void saveComplexImage();//override;
+	void savePreViewImage();
+public:
+	Eigen::MatrixXcd data;
+};
+
+
+bool BASECONSTVARIABLEAPI CopyProjectTransformMatrixFromRasterAToRasterB(QString RasterAPath, QString  RasterBPath);
+
+
+// 创建影像
+gdalImage	BASECONSTVARIABLEAPI CreategdalImageDouble(QString& img_path, int height, int width, int band_num, bool overwrite = false, bool isEnvi = false);
+gdalImage	BASECONSTVARIABLEAPI CreategdalImageFloat(QString& img_path, int height, int width, int band_num, bool overwrite = false, bool isEnvi = false);
+gdalImage   BASECONSTVARIABLEAPI CreategdalImageDouble(const QString& img_path, int height, int width, int band_num, Eigen::MatrixXd gt, QString projection, bool need_gt = true, bool overwrite = false, bool isEnvi = false);
+gdalImage   BASECONSTVARIABLEAPI CreategdalImage(const QString& img_path, int height, int width, int band_num, Eigen::MatrixXd gt, QString projection,bool need_gt = true, bool overwrite = false, bool isEnvi = false, GDALDataType datetype = GDT_Float32);
+gdalImage   BASECONSTVARIABLEAPI CreategdalImage(const QString& img_path, int height, int width, int band_num, Eigen::MatrixXd gt, long espgcode, GDALDataType eType = GDT_Float32, bool need_gt = true, bool overwrite = false, bool isENVI = false);
+
+gdalImageComplex   BASECONSTVARIABLEAPI	  CreategdalImageComplex(const QString& img_path, int height, int width, int band_num, Eigen::MatrixXd gt, QString projection, bool need_gt = true, bool overwrite = false);
+gdalImageComplex   BASECONSTVARIABLEAPI	  CreategdalImageComplexNoProj(const QString& img_path, int height, int width, int band_num, bool overwrite = true);
+
+gdalImageComplex   BASECONSTVARIABLEAPI	  CreateEchoComplex(const QString& img_path, int height, int width, int band_num);
+
+ErrorCode  BASECONSTVARIABLEAPI	  DEM2XYZRasterAndSlopRaster(QString dempath, QString demxyzpath, QString demsloperPath);
+
+int   BASECONSTVARIABLEAPI	  ResampleGDAL(const char* pszSrcFile, const char* pszOutFile, double* gt, int new_width, int new_height, GDALResampleAlg eResample);
+
+void  BASECONSTVARIABLEAPI	 resampleRaster(const char* inputRaster, const char* outputRaster, double targetPixelSizeX, double targetPixelSizeY);
+
+void  BASECONSTVARIABLEAPI	 cropRasterByLatLon(const char* inputFile, const char* outputFile, double minLon, double maxLon, double minLat, double maxLat);
+
+int   BASECONSTVARIABLEAPI	  ResampleGDALs(const char* pszSrcFile, int band_ids, GDALRIOResampleAlg eResample = GRIORA_Bilinear);
+
+void  BASECONSTVARIABLEAPI	 transformRaster(const char* inputFile, const char* outputFile, int sourceEPSG, int targetEPSG);
+
+ErrorCode   BASECONSTVARIABLEAPI	transformCoordinate(double x, double y, int sourceEPSG, int targetEPSG, Point2& p);
+
+int   BASECONSTVARIABLEAPI	alignRaster(QString  inputPath, QString referencePath, QString outputPath, GDALResampleAlg eResample);
+
+
+void BASECONSTVARIABLEAPI ResampleByReferenceRasterB(QString pszSrcFile, QString RefrasterBPath, QString pszOutFile, GDALResampleAlg eResample);
+
+//--------------------- 保存文博 -------------------------------
+
+int  BASECONSTVARIABLEAPI	   saveMatrixXcd2TiFF(Eigen::MatrixXcd data, QString out_tiff_path);
+
+//----------------------------------------------------
+
+void  BASECONSTVARIABLEAPI	 clipRaster(QString inRasterPath, QString outRasterPath, long minRow, long maxRow, long minCol, long maxCol);
+
+// 坐标系转换
+void BASECONSTVARIABLEAPI ConvertCoordinateSystem(QString inRasterPath, QString outRasterPath, long outepsgcode);
+
+//--------------------- 图像合并流程    ------------------------------
+enum MERGEMODE
+{
+	MERGE_GEOCODING,
+};
+
+void BASECONSTVARIABLEAPI MergeTiffs(QList<QString> inputFiles, QString outputFile);
+ 
+ErrorCode   BASECONSTVARIABLEAPI	MergeRasterProcess(QVector<QString> filepath, QString outfileptah, QString mainString, MERGEMODE  mergecode = MERGEMODE::MERGE_GEOCODING, bool isENVI = false, ShowProessAbstract* dia = nullptr);
+
+
+ErrorCode  BASECONSTVARIABLEAPI	 MergeRasterInGeoCoding(QVector<gdalImage> inimgs, gdalImage resultimg, gdalImage maskimg, ShowProessAbstract* dia = nullptr);
+
+
+// 保存矩阵转换为envi文件，默认数据格式为double
+bool   BASECONSTVARIABLEAPI	saveEigenMatrixXd2Bin(Eigen::MatrixXd data, QString dataStrPath);
+
+
+// 测试
+void  BASECONSTVARIABLEAPI	testOutAntPatternTrans(QString antpatternfilename, double* antPatternArr, double starttheta, double deltetheta, double startphi, double deltaphi, long thetanum, long phinum);
+void  BASECONSTVARIABLEAPI	testOutAmpArr(QString filename, float* amp, long rowcount, long colcount);
+void  BASECONSTVARIABLEAPI	testOutAmpArr(QString filename, double* amp, long rowcount, long colcount);
+void  BASECONSTVARIABLEAPI	testOutClsArr(QString filename, long* amp, long rowcount, long colcount);
+void  BASECONSTVARIABLEAPI	testOutComplexDoubleArr(QString filename, std::complex<double>* data, long rowcount, long colcount);
+void  BASECONSTVARIABLEAPI	testOutDataArr(QString filename, double* data, long rowcount, long colcount);
+void  BASECONSTVARIABLEAPI	testOutDataArr(QString filename, float* data, long rowcount, long colcount);
+void  BASECONSTVARIABLEAPI	testOutDataArr(QString filename, long* data, long rowcount, long colcount);
+ 
+
+
+void BASECONSTVARIABLEAPI  CreateSARIntensityByLookTable(QString IntensityRasterPath, QString LookTableRasterPath, QString SARIntensityPath, long min_rid, long max_rid, long min_cid, long max_cid, std::function<void(long, long)> processBarShow = {});
+
+bool BASECONSTVARIABLEAPI   ConvertVrtToEnvi(QString vrtPath, QString outPath);
+
+
+
+
+void BASECONSTVARIABLEAPI	 MultiLookRaster(QString inRasterPath, QString outRasterPath, long looklineNumrow, long looklineNumCol);
+ErrorCode  BASECONSTVARIABLEAPI	Complex2PhaseRaster(QString inComplexPath, QString outRasterPath);
+ErrorCode  BASECONSTVARIABLEAPI	Complex2dBRaster(QString inComplexPath, QString outRasterPath);
+ErrorCode  BASECONSTVARIABLEAPI	Complex2AmpRaster(QString inComplexPath, QString outRasterPath);
+ErrorCode  BASECONSTVARIABLEAPI	amp2dBRaster(QString inPath, QString outRasterPath);
+
+
+ErrorCode  BASECONSTVARIABLEAPI	ResampleDEM(QString indemPath, QString outdemPath, double gridx, double gridy);
+
+
+void BASECONSTVARIABLEAPI	CloseAllGDALRaster();
+
+
+
+//---------------------  图像文件读写   ------------------------------
+
+
+
+template<typename T>
+inline std::shared_ptr<T> readDataArr(gdalImage& imgds, long start_row, long start_col, long& rows_count, long& cols_count, int band_ids, GDALREADARRCOPYMETHOD method)
+{
+	std::shared_ptr<T> result = nullptr;
+
+	omp_lock_t lock;
+	omp_init_lock(&lock);
+	omp_set_lock(&lock);
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+	GDALDataset* rasterDataset = (GDALDataset*)(GDALOpen(imgds.img_path.toUtf8().constData(), GA_ReadOnly)); // 锟斤拷只斤拷式锟斤拷取斤拷影锟斤拷
+
+	GDALDataType	gdal_datatype = rasterDataset->GetRasterBand(1)->GetRasterDataType();
+	GDALRasterBand* demBand = rasterDataset->GetRasterBand(band_ids);
+
+	rows_count = start_row + rows_count <= imgds.height ? rows_count : imgds.height - start_row;
+	cols_count = start_col + cols_count <= imgds.width ? cols_count : imgds.width - start_col;
+
+	int64_t pixel_count64 = static_cast<int64_t>(rows_count)* static_cast<int64_t>(cols_count);
+
+
+	//Eigen::MatrixXd datamatrix(rows_count, cols_count);
+
+	if (gdal_datatype == GDT_Byte) {
+		char* temp = new char[pixel_count64];
+		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+			std::memcpy(result.get(), temp, pixel_count64);
+		}
+		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+			long count = pixel_count64;
+			for (long i = 0; i < count; i++) {
+				result.get()[i] = T(temp[i]);
+			}
+		}
+
+		delete[] temp;
+	}
+	else if (gdal_datatype == GDT_UInt16) {
+		unsigned short* temp = new unsigned short[pixel_count64];
+		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+			std::memcpy(result.get(), temp, pixel_count64);
+		}
+		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+			long count = pixel_count64;
+			for (long i = 0; i < count; i++) {
+				result.get()[i] = T(temp[i]);
+			}
+		}
+		delete[] temp;
+	}
+	else if (gdal_datatype == GDT_Int16) {
+		short* temp = new short[pixel_count64];
+		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+			std::memcpy(result.get(), temp, pixel_count64);
+		}
+		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+			long count = pixel_count64;
+			for (long i = 0; i < count; i++) {
+				result.get()[i] = T(temp[i]);
+			}
+		}
+		delete[] temp;
+	}
+	else if (gdal_datatype == GDT_UInt32) {
+		unsigned int* temp = new unsigned int[pixel_count64];
+		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+			std::memcpy(result.get(), temp, pixel_count64);
+		}
+		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+			long count = pixel_count64;
+			for (long i = 0; i < count; i++) {
+				result.get()[i] = T(temp[i]);
+			}
+		}
+		delete[] temp;
+	}
+	else if (gdal_datatype == GDT_Int32) {
+		int* temp = new int[pixel_count64];
+		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+			std::memcpy(result.get(), temp, pixel_count64);
+		}
+		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+			long count = pixel_count64;
+			for (long i = 0; i < count; i++) {
+				result.get()[i] = T(temp[i]);
+			}
+		}
+		delete[] temp;
+	}
+	// else if (gdal_datatype == GDT_UInt64) {
+	//	unsigned long* temp = new unsigned long[pixel_count64];
+	//	demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count,
+	//rows_count, gdal_datatype, 0, 0); 	for (int i = 0; i < rows_count; i++) { 		for (int j = 0; j <
+	//cols_count; j++) { 			datamatrix(i, j) = temp[i * cols_count + j];
+	//		}
+	//	}
+	//	delete[] temp;
+	// }
+	// else if (gdal_datatype == GDT_Int64) {
+	//	long* temp = new long[pixel_count64];
+	//	demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count,
+	//rows_count, gdal_datatype, 0, 0); 	for (int i = 0; i < rows_count; i++) { 		for (int j = 0; j <
+	//cols_count; j++) { 			datamatrix(i, j) = temp[i * cols_count + j];
+	//		}
+	//	}
+	//	delete[] temp;
+	// }
+	else if (gdal_datatype == GDT_Float32) {
+		float* temp = new float[pixel_count64];
+		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+
+		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+			std::memcpy(result.get(), temp, pixel_count64);
+		}
+		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+			long count = pixel_count64;
+			for (long i = 0; i < count; i++) {
+				result.get()[i] = T(temp[i]);
+			}
+		}
+		delete[] temp;
+	}
+	else if (gdal_datatype == GDT_Float64) {
+		double* temp = new double[pixel_count64];
+		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+
+		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+			std::memcpy(result.get(), temp, pixel_count64);
+		}
+		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+			long count = pixel_count64;
+			for (long i = 0; i < count; i++) {
+				result.get()[i] = T(temp[i]);
+			}
+		}
+		delete[] temp;
+	}
+	//else if (gdal_datatype == GDT_CFloat32) {
+	//	if (std::is_same<T, std::complex<double>>::value || std::is_same<T, std::complex<double>>::value) {
+	//		float* temp = new float[pixel_count64 * 2];
+	//		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+
+	//		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+	//		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+	//			std::memcpy(result.get(), temp, pixel_count64);
+	//		}
+	//		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+	//			long count = pixel_count64;
+	//			for (long i = 0; i < count; i++) {
+	//				result.get()[i] = T(temp[i * 2],
+	//					temp[i * 2 + 1]);
+	//			}
+	//		}
+	//		delete[] temp;
+	//	}
+	//	else {
+	//		result = nullptr;
+	//	}
+	//}
+	//else if (gdal_datatype == GDT_CFloat64 ) {
+	//	if (std::is_same<T, std::complex<double>>::value || std::is_same<T, std::complex<double>>::value) {
+	//		double* temp = new double[pixel_count64 * 2];
+	//		demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+
+	//		result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+	//		if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+	//			std::memcpy(result.get(), temp, pixel_count64);
+	//		}
+	//		else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+	//			long count = pixel_count64;
+	//			for (long i = 0; i < count; i++) {
+	//				result.get()[i] = T(temp[i * 2],
+	//					temp[i * 2 + 1]);
+	//			}
+	//		}
+	//		delete[] temp;
+	//	}
+	//	else {
+	//		result = nullptr;
+	//	}
+	//}
+	else {
+	}
+	GDALClose((GDALDatasetH)rasterDataset);
+	omp_unset_lock(&lock);	 // 锟酵放伙拷斤拷
+	omp_destroy_lock(&lock); // 劫伙拷斤拷
+	GDALDestroy(); // or, DllMain at DLL_PROCESS_DETACH
+	return result;
+};
+ 
+template<typename T>
+inline std::shared_ptr<T> readDataArrComplex(gdalImageComplex& imgds, long start_row, long start_col, long& rows_count, long& cols_count, int band_ids, GDALREADARRCOPYMETHOD method)
+{
+	std::shared_ptr<T> result = nullptr;
+
+	omp_lock_t lock;
+	omp_init_lock(&lock);
+	omp_set_lock(&lock);
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+	GDALDataset* rasterDataset = (GDALDataset*)(GDALOpen(imgds.img_path.toUtf8().constData(), GA_ReadOnly)); // 锟斤拷只斤拷式锟斤拷取斤拷影锟斤拷
+
+	GDALDataType	gdal_datatype = rasterDataset->GetRasterBand(1)->GetRasterDataType();
+	GDALRasterBand* demBand = rasterDataset->GetRasterBand(band_ids);
+
+	rows_count = start_row + rows_count <= imgds.height ? rows_count : imgds.height - start_row;
+	cols_count = start_col + cols_count <= imgds.width ? cols_count : imgds.width - start_col;
+
+	int64_t pixel_count64 = static_cast<int64_t>(rows_count) * static_cast<int64_t>(cols_count);
+
+	//Eigen::MatrixXd datamatrix(rows_count, cols_count);
+
+	if (gdal_datatype == GDT_CFloat32) {
+		if (std::is_same<T, std::complex<double>>::value || std::is_same<T, std::complex<double>>::value) {
+			float* temp = new float[pixel_count64 * 2];
+			demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+
+			result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+			if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+				std::memcpy(result.get(), temp, pixel_count64);
+			}
+			else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+				long count = pixel_count64;
+				for (long i = 0; i < count; i++) {
+					result.get()[i] = T(temp[i * 2],
+						temp[i * 2 + 1]);
+				}
+			}
+			delete[] temp;
+		}
+		else {
+			result = nullptr;
+		}
+	}
+	else if (gdal_datatype == GDT_CFloat64) {
+		if (std::is_same<T, std::complex<double>>::value || std::is_same<T, std::complex<double>>::value) {
+			double* temp = new double[pixel_count64 * 2];
+			demBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, temp, cols_count, rows_count, gdal_datatype, 0, 0);
+
+			result = std::shared_ptr<T>(new T[pixel_count64], delArrPtr);
+			if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
+				std::memcpy(result.get(), temp, pixel_count64);
+			}
+			else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
+				long count = pixel_count64;
+				for (long i = 0; i < count; i++) {
+					result.get()[i] = T(temp[i * 2],
+						temp[i * 2 + 1]);
+				}
+			}
+			delete[] temp;
+		}
+		else {
+			result = nullptr;
+		}
+	}
+	else {
+	}
+	GDALClose((GDALDatasetH)rasterDataset);
+	omp_unset_lock(&lock);	 // 锟酵放伙拷斤拷
+	omp_destroy_lock(&lock); // 劫伙拷斤拷
+	GDALDestroy(); // or, DllMain at DLL_PROCESS_DETACH
+	return result;
+};
+
+
+
+
+//---------------------  图像分块   ------------------------------
+
+
+
+
+
+
+
+#endif
+

BaseTool/LogInfoCls.cpp

@@ -0,0 +1,233 @@
+#include "stdafx.h"
+#include "LogInfoCls.h"
+
+std::string errorCode2errInfo(ErrorCode e)
+{
+    switch (e)
+    {
+        _CASE_STR(SUCCESS); 
+        _CASE_STR(VIRTUALABSTRACT);
+        _CASE_STR(FAIL);
+        _CASE_STR(FILENOFOUND);
+        _CASE_STR(OrbitNodeNotEnough);
+        _CASE_STR(XYDataPointNotEqual);
+        _CASE_STR(FILEOPENFAIL           );
+        _CASE_STR(XMLPARSEFAIL           );
+        _CASE_STR(XMLNOTFOUNDElEMENT     );
+        _CASE_STR(FILEPATHISEMPTY);
+        _CASE_STR(FOLDER_NOT_EXIST);
+        _CASE_STR(FILE_NOT_EXIST);
+        _CASE_STR(FIND_ID_ERROR);
+        _CASE_STR(INSERT_ID_ERROR);
+        _CASE_STR(EPSGCODE_NOTSAME);
+        _CASE_STR(EPSGCODE_NOTSUPPORT);
+        _CASE_STR(RASTERBAND_NOTEQUAL);
+        _CASE_STR(RASTER_DATETYPE_NOTSAME);
+        //GSL 1xx
+        _CASE_STR(Error_GSL_FAILURE );
+        _CASE_STR(Error_GSL_CONTINUE );
+        _CASE_STR(Error_GSL_EDOM );
+        _CASE_STR(Error_GSL_ERANGE );
+        _CASE_STR(Error_GSL_EFAULT );
+        _CASE_STR(Error_GSL_EINVAL );
+        _CASE_STR(Error_GSL_EFAILED );
+        _CASE_STR(Error_GSL_EFACTOR );
+        _CASE_STR(Error_GSL_ESANITY );
+        _CASE_STR(Error_GSL_ENOMEM );
+        _CASE_STR(Error_GSL_EBADFUNC );
+        _CASE_STR(Error_GSL_ERUNAWAY );
+        _CASE_STR(Error_GSL_EMAXITER );
+        _CASE_STR(Error_GSL_EZERODIV );
+        _CASE_STR(Error_GSL_EBADTOL );
+        _CASE_STR(Error_GSL_ETOL );
+        _CASE_STR(Error_GSL_EUNDRFLW );
+        _CASE_STR(Error_GSL_EOVRFLW );
+        _CASE_STR(Error_GSL_ELOSS );
+        _CASE_STR(Error_GSL_EROUND );
+        _CASE_STR(Error_GSL_EBADLEN );
+        _CASE_STR(Error_GSL_ENOTSQR );
+        _CASE_STR(Error_GSL_ESING );
+        _CASE_STR(Error_GSL_EDIVERGE );
+        _CASE_STR(Error_GSL_EUNSUP );
+        _CASE_STR(Error_GSL_EUNIMPL );
+        _CASE_STR(Error_GSL_ECACHE );
+        _CASE_STR(Error_GSL_ETABLE );
+        _CASE_STR(Error_GSL_ENOPROG );
+        _CASE_STR(Error_GSL_ENOPROGJ );
+        _CASE_STR(Error_GSL_ETOLF );
+        _CASE_STR(Error_GSL_ETOLX );
+        _CASE_STR(Error_GSL_ETOLG );
+        _CASE_STR(Error_GSL_EOF );
+        // RFPC 
+        _CASE_STR(RFPC_PARAMSISEMPTY);
+        _CASE_STR(ECHO_L0DATA_NOTOPEN);
+        _CASE_STR(ECHO_L0DATA_ROW_COL_NOEQUAL);
+        _CASE_STR(ECHO_L0DATA_PRFIDXOUTRANGE);
+        _CASE_STR(ECHO_L0DATA_GPSFILEFORMATERROR);
+        _CASE_STR(ECHO_L0DATA_ECHOFILEFORMATERROR);
+        _CASE_STR(ECHO_L0DATA_ECHOFILENOTOPEN);
+        _CASE_STR(ECHO_L0DATA_GPSFILEFNOTOPEN);
+        _CASE_STR(ECHO_L0DATA_XMLFILENOTOPEN);
+        _CASE_STR(OUTOFRANGE);
+        _CASE_STR(ECHO_L0DATA_XMLNAMEERROR);
+        // 
+        _CASE_STR(TBP_L0OPENFAIL);
+
+        //
+        _CASE_STR(IMAGE_L1DATA_XMLNAMEERROR);
+        _CASE_STR(IMAGE_L1DATA_XMLNAMEOPENERROR);
+
+
+    default:
+        break;
+    }
+    return "UNKNOW_EVENT!";
+}
+
+ErrorCode GSLState2ErrorCode(int gslState)
+{
+     
+    switch (gslState)
+    {
+    case 0:
+        return ErrorCode::SUCCESS;
+        break;
+    case -1:
+        return ErrorCode::Error_GSL_FAILURE;
+        break;
+    case -2:
+        return ErrorCode::Error_GSL_CONTINUE;
+        break;
+    case 1:
+        return ErrorCode::Error_GSL_EDOM;      // 输入域错误，例如 sqrt(-1)
+        break;
+
+    case 2:
+        return ErrorCode::Error_GSL_ERANGE;    // 输出范围错误，例如 exp(1e100)
+        break;
+
+    case 3:
+        return ErrorCode::Error_GSL_EFAULT;     // 无效指针
+        break;
+
+    case 4:
+        return ErrorCode::Error_GSL_EINVAL;     // 用户提供的无效参数
+        break;
+
+    case 5:
+        return ErrorCode::Error_GSL_EFAILED;    // 通用失败
+        break;
+
+    case 6:
+        return ErrorCode::Error_GSL_EFACTOR;    // 因子分解失败
+        break;
+
+    case 7:
+        return ErrorCode::Error_GSL_ESANITY;    // 理智检查失败，通常不应该发生
+        break;
+
+    case 8:
+        return ErrorCode::Error_GSL_ENOMEM;     // 内存分配失败
+        break;
+
+    case 9:
+        return ErrorCode::Error_GSL_EBADFUNC;    // 用户提供的函数存在问题
+        break;
+
+    case 10:
+        return ErrorCode::Error_GSL_ERUNAWAY;   // 迭代过程失控
+        break;
+
+    case 11:
+        return ErrorCode::Error_GSL_EMAXITER;   // 超过最大迭代次数
+        break;
+
+    case 12:
+        return ErrorCode::Error_GSL_EZERODIV;   // 尝试进行零除
+        break;
+
+    case 13:
+        return ErrorCode::Error_GSL_EBADTOL;    // 用户指定的容忍度无效
+        break;
+
+    case 14:
+        return ErrorCode::Error_GSL_ETOL;       // 未能达到指定的容忍度
+        break;
+
+    case 15:
+        return ErrorCode::Error_GSL_EUNDRFLW;   // 下溢
+        break;
+
+    case 16:
+        return ErrorCode::Error_GSL_EOVRFLW;    // 上溢
+        break;
+
+    case 17:
+        return ErrorCode::Error_GSL_ELOSS;      // 精度损失
+        break;
+
+    case 18:
+        return ErrorCode::Error_GSL_EROUND;     // 因舍入错误而失败
+        break;
+
+    case 19:
+        return ErrorCode::Error_GSL_EBADLEN;    // 矩阵或向量长度不匹配
+        break;
+
+    case 20:
+        return ErrorCode::Error_GSL_ENOTSQR;    // 矩阵不是方阵
+        break;
+
+    case 21:
+        return ErrorCode::Error_GSL_ESING;      // 检测到明显的奇异性
+        break;
+
+    case 22:
+        return ErrorCode::Error_GSL_EDIVERGE;   // 积分或级数发散
+        break;
+
+    case 23:
+        return ErrorCode::Error_GSL_EUNSUP;     // 请求的特性不受硬件支持
+        break;
+
+    case 24:
+        return ErrorCode::Error_GSL_EUNIMPL;    // 请求的特性尚未实现
+        break;
+
+    case 25:
+        return ErrorCode::Error_GSL_ECACHE;     // 超过缓存限制
+        break;
+
+    case 26:
+        return ErrorCode::Error_GSL_ETABLE;     // 超过表限制
+        break;
+
+    case 27:
+        return ErrorCode::Error_GSL_ENOPROG;    // 迭代未能朝向解决方案取得进展
+        break;
+
+    case 28:
+        return ErrorCode::Error_GSL_ENOPROGJ;   // 雅可比评估未能改善解决方案
+        break;
+
+    case 29:
+        return ErrorCode::Error_GSL_ETOLF;      // 无法达到 F 的指定容忍度
+        break;
+
+    case 30:
+        return ErrorCode::Error_GSL_ETOLX;      // 无法达到 X 的指定容忍度
+        break;
+
+    case 31:
+        return ErrorCode::Error_GSL_ETOLG;      // 无法达到梯度的指定容忍度
+        break;
+
+    case 32:
+        return ErrorCode::Error_GSL_EOF;        // 文件结束
+        break;
+
+    default:
+        return ErrorCode::Error_GSL_FAILURE;    // 未知错误，返回一般失败
+        break;
+    }
+}

BaseTool/LogInfoCls.h

@@ -0,0 +1,103 @@
+#pragma once
+/*****************************************************************//**
+ * \file   LogInfoCls.h
+ * \brief  错误枚举类，以及返回错误信息
+ * 
+ * \author 陈增辉
+ * \date   October 2024
+ *********************************************************************/
+#include "BaseConstVariable.h"
+#include <string>
+
+// 定义变换
+#define _CASE_STR(x) case x : return #x; break; 
+
+
+enum ErrorCode {
+	SUCCESS = -1,// 执行成功
+	VIRTUALABSTRACT = -2,// virtual abstract function ，not implement
+	FAIL=0,
+	FILENOFOUND = 1,
+	OrbitNodeNotEnough = 2,
+	XYDataPointNotEqual = 3,
+	FILEOPENFAIL = 4,
+	XMLPARSEFAIL = 5,
+	XMLNOTFOUNDElEMENT = 6,
+	FILEPATHISEMPTY = 7,
+	FOLDER_NOT_EXIST = 8,
+	FILE_NOT_EXIST = 9,
+	FIND_ID_ERROR = 10,
+	INSERT_ID_ERROR = 11,
+	EPSGCODE_NOTSAME = 12,
+	EPSGCODE_NOTSUPPORT = 13,
+	RASTERBAND_NOTEQUAL = 14,  
+	RASTER_DATETYPE_NOTSAME = 15,
+	//GSL 1xx
+	Error_GSL_FAILURE = -101,
+	Error_GSL_CONTINUE = -102,  /* iteration has not converged */
+	Error_GSL_EDOM = 101,   /* input domain error, e.g sqrt(-1) */
+	Error_GSL_ERANGE = 102,   /* output range error, e.g. exp(1e100) */
+	Error_GSL_EFAULT = 103,   /* invalid pointer */
+	Error_GSL_EINVAL = 104,   /* invalid argument supplied by user */
+	Error_GSL_EFAILED = 105,   /* generic failure */
+	Error_GSL_EFACTOR = 106,   /* factorization failed */
+	Error_GSL_ESANITY = 107,   /* sanity check failed - shouldn't happen */
+	Error_GSL_ENOMEM = 108,   /* malloc failed */
+	Error_GSL_EBADFUNC = 109,   /* problem with user-supplied function */
+	Error_GSL_ERUNAWAY = 110,  /* iterative process is out of control */
+	Error_GSL_EMAXITER = 111,  /* exceeded max number of iterations */
+	Error_GSL_EZERODIV = 112,  /* tried to divide by zero */
+	Error_GSL_EBADTOL = 113,  /* user specified an invalid tolerance */
+	Error_GSL_ETOL = 114,  /* failed to reach the specified tolerance */
+	Error_GSL_EUNDRFLW = 115,  /* underflow */
+	Error_GSL_EOVRFLW = 116,  /* overflow  */
+	Error_GSL_ELOSS = 117,  /* loss of accuracy */
+	Error_GSL_EROUND = 118,  /* failed because of roundoff error */
+	Error_GSL_EBADLEN = 119,  /* matrix, vector lengths are not conformant */
+	Error_GSL_ENOTSQR = 120,  /* matrix not square */
+	Error_GSL_ESING = 121,  /* apparent singularity detected */
+	Error_GSL_EDIVERGE = 122,  /* integral or series is divergent */
+	Error_GSL_EUNSUP = 123,  /* requested feature is not supported by the hardware */
+	Error_GSL_EUNIMPL = 124,  /* requested feature not (yet) implemented */
+	Error_GSL_ECACHE = 125,  /* cache limit exceeded */
+	Error_GSL_ETABLE = 126,  /* table limit exceeded */
+	Error_GSL_ENOPROG = 127,  /* iteration is not making progress towards solution */
+	Error_GSL_ENOPROGJ = 128,  /* jacobian evaluations are not improving the solution */
+	Error_GSL_ETOLF = 129,  /* cannot reach the specified tolerance in F */
+	Error_GSL_ETOLX = 130,  /* cannot reach the specified tolerance in X */
+	Error_GSL_ETOLG = 131,  /* cannot reach the specified tolerance in gradient */
+	Error_GSL_EOF = 132,  /* end of file */
+
+	// RFPC
+	RFPC_PARAMSISEMPTY = 201,
+	// L0 数据
+	ECHO_L0DATA_NOTOPEN = 202,
+	ECHO_L0DATA_ROW_COL_NOEQUAL = 203, // 行或者列数量错误
+	ECHO_L0DATA_PRFIDXOUTRANGE = 204,			// PRF 索引超出范围
+	ECHO_L0DATA_GPSFILEFORMATERROR = 205, // GPS文件错误
+	ECHO_L0DATA_ECHOFILEFORMATERROR = 206, // 回波文件格式错误
+	ECHO_L0DATA_ECHOFILENOTOPEN = 207, // 回波文件打开错误
+	ECHO_L0DATA_GPSFILEFNOTOPEN = 208, // GPS文件打开错误
+	ECHO_L0DATA_XMLFILENOTOPEN = 209, // xml文件打开错误
+	OUTOFRANGE = 210, // 超出范围
+	ECHO_L0DATA_XMLNAMEERROR = 211, // 超出范围
+	// BP成像
+	TBP_L0OPENFAIL = 301, // 0级文件打开错误
+
+	// L1图像
+	IMAGE_L1DATA_XMLNAMEERROR = 401,
+	IMAGE_L1DATA_XMLNAMEOPENERROR = 402,
+	IMAGE_L1DATA_XMLNAMEPARASEERROR = 403,
+	
+	METAXMLFOUNDERROR
+}; 
+
+
+
+std::string  BASECONSTVARIABLEAPI	 errorCode2errInfo(ErrorCode code);
+
+
+ErrorCode  BASECONSTVARIABLEAPI	 GSLState2ErrorCode(int gslState);
+
+
+

BaseTool/MergeRasterOperator.cpp

@@ -0,0 +1,488 @@
+#include "stdafx.h"
+#include "ImageOperatorBase.h"
+#include "BaseTool.h"
+#include "GeoOperator.h"
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <omp.h>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <gdal.h>
+#include <gdal_utils.h>
+#include <gdal_priv.h>
+#include <gdalwarper.h>
+#include <proj.h>
+#include <string.h>
+#include <memory>
+#include <iostream>
+#include "FileOperator.h"
+#include <opencv2/opencv.hpp>
+#include <QMessageBox>
+#include <QDir>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <QProgressDialog>
+#include <gdal_priv.h>
+#include <ogr_spatialref.h>  // OGRSpatialReference 用于空间参考转换
+#include <gdal_alg.h>        // 用于 GDALWarp 操作
+
+ErrorCode MergeRasterProcess(QVector<QString> filepaths, QString outfileptah, QString mainString, MERGEMODE  mergecode, bool isENVI, ShowProessAbstract* dia)
+{
+	// 参数检查
+	if (!isExists(mainString)) {
+		qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::FILENOFOUND)) << "\t" << mainString;
+		return ErrorCode::FILENOFOUND;
+	}
+	else {}
+	gdalImage mainimg(mainString);
+	QVector<gdalImage> imgdslist(filepaths.count());
+	for (long i = 0; i < filepaths.count(); i++) {
+		if (!isExists(filepaths[i])) {
+			qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::FILENOFOUND)) << "\t" << filepaths[i];
+			return ErrorCode::FILENOFOUND;
+		}
+		else {
+			imgdslist[i] = gdalImage(filepaths[i]);
+			if (imgdslist[i].band_num != mainimg.band_num) {
+				qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::RASTERBAND_NOTEQUAL)) << "\t" << imgdslist[i].band_num << " != " << mainimg.band_num;
+				return ErrorCode::RASTERBAND_NOTEQUAL;
+			}
+		}
+	}
+
+	// 检查坐标系是否统一
+	long EPSGCode = GetEPSGFromRasterFile(mainString);
+	long tempCode = 0;
+	for (long i = 0; i < filepaths.count(); i++) {
+		tempCode = GetEPSGFromRasterFile(filepaths[i]);
+		if (EPSGCode != tempCode) {
+			qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::EPSGCODE_NOTSAME)) << "\t" << EPSGCode << "!=" << tempCode;
+			return ErrorCode::EPSGCODE_NOTSAME;
+		}
+	}
+
+	// 检查影像类型是否统一
+	GDALDataType mainType = mainimg.getDataType();
+	for (long i = 0; i < imgdslist.count(); i++) {
+		if (mainType != imgdslist[i].getDataType()) {
+			qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::RASTER_DATETYPE_NOTSAME)) << "\t" << mainType << "!=" << imgdslist[i].getDataType();
+			return ErrorCode::RASTER_DATETYPE_NOTSAME;
+		}
+	}
+
+	Eigen::MatrixXd maingt = mainimg.getGeoTranslation();
+	Eigen::MatrixXd rgt = Eigen::MatrixXd::Zero(2, 3);
+	RasterExtend mainExtend = mainimg.getExtend();
+	rgt(0, 1) = (mainExtend.max_x - mainExtend.min_x) / (mainimg.width - 1); //dx
+	rgt(1, 2) = -1 * std::abs(((mainExtend.max_y - mainExtend.min_y) / (mainimg.height - 1)));//dy
+	QVector<RasterExtend> extendlist(imgdslist.count());
+	for (long i = 0; i < imgdslist.count(); i++) {
+		extendlist[i] = imgdslist[i].getExtend();
+		mainExtend.min_x = mainExtend.min_x < extendlist[i].min_x ? mainExtend.min_x : extendlist[i].min_x;
+		mainExtend.max_x = mainExtend.max_x > extendlist[i].max_x ? mainExtend.max_x : extendlist[i].max_x;
+		mainExtend.min_y = mainExtend.min_y < extendlist[i].min_y ? mainExtend.min_y : extendlist[i].min_y;
+		mainExtend.max_y = mainExtend.max_y > extendlist[i].max_y ? mainExtend.max_y : extendlist[i].max_y;
+	}
+
+	rgt(0, 0) = mainExtend.min_x;
+	rgt(1, 0) = mainExtend.max_y;
+
+	// 计算数量
+
+	long width = std::ceil((mainExtend.max_x - mainExtend.min_x) / rgt(0, 1) + 1);
+	long height = std::ceil(std::abs((mainExtend.min_y - mainExtend.max_y) / rgt(1, 2)) + 1);
+	OGRSpatialReference oSRS;
+	if (oSRS.importFromEPSG(EPSGCode) != OGRERR_NONE) {
+		qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::EPSGCODE_NOTSUPPORT)) << "\t" << EPSGCode;
+		return ErrorCode::EPSGCODE_NOTSUPPORT;
+	}
+
+	gdalImage resultImage = CreategdalImage(outfileptah, height, width, mainimg.band_num, rgt, EPSGCode, mainType, true, true, isENVI);
+
+	QString resultMaskString = addMaskToFileName(outfileptah, QString("_MASK"));
+	gdalImage maskImage = CreategdalImage(resultMaskString, height, width, 1, rgt, EPSGCode, GDT_Int32, true, true, isENVI);
+
+	// 初始化
+	long resultline = Memory1MB * 500 / 8 / resultImage.width;
+	resultline = resultline < 10000 ? resultline : 10000; // 最多100行
+	resultline = resultline > 0 ? resultline : 2;
+	long bandnum = resultImage.band_num + 1;
+	long starti = 0;
+	long rasterCount = imgdslist.count();
+
+
+
+	QProgressDialog progressDialog(u8"初始化影像", u8"终止", 0, resultImage.height);
+	progressDialog.setWindowTitle(u8"初始化影像");
+	progressDialog.setWindowModality(Qt::WindowModal);
+	progressDialog.setAutoClose(true);
+	progressDialog.setValue(0);
+	progressDialog.setMaximum(resultImage.height);
+	progressDialog.setMinimum(0);
+	progressDialog.show();
+
+
+	for (starti = 0; starti < resultImage.height; starti = starti + resultline) {
+		long blocklines = resultline;
+		blocklines = starti + blocklines < resultImage.height ? blocklines : resultImage.height - starti;
+		for (long b = 1; b < bandnum; b++) {
+			Eigen::MatrixXd data = resultImage.getData(starti, 0, blocklines, resultImage.width, b);
+			Eigen::MatrixXi maskdata = maskImage.getDatai(starti, 0, blocklines, resultImage.width, b);
+			data = data.array() * 0;
+			maskdata = maskdata.array() * 0;
+			resultImage.saveImage(data, starti, 0, b);
+			maskImage.saveImage(maskdata, starti, 0, b);
+		}
+		if (nullptr != dia) {
+			dia->showProcess(starti * 1.0 / resultImage.height, u8"初始化影像数据");
+		}
+		progressDialog.setValue(starti + blocklines);
+	}
+	progressDialog.close();
+
+
+
+	switch (mergecode)
+	{
+	case MERGE_GEOCODING:
+		return MergeRasterInGeoCoding(imgdslist, resultImage, maskImage, dia);
+	default:
+		break;
+	}
+
+
+	return ErrorCode::SUCCESS;
+}
+
+ErrorCode MergeRasterInGeoCoding(QVector<gdalImage> imgdslist, gdalImage resultimg, gdalImage maskimg, ShowProessAbstract* dia)
+{
+	omp_set_num_threads(Paral_num_thread);
+	// 逐点合并计算
+	QVector<RasterExtend> extendlist(imgdslist.count());
+	for (long i = 0; i < imgdslist.count(); i++) {
+		extendlist[i] = imgdslist[i].getExtend();
+		imgdslist[i].InitInv_gt();
+	}
+
+	// 分块计算
+	long resultline = Memory1MB * 1000 / 8 / resultimg.width;
+	resultline = resultline < 300 ? resultline : 300; // 最多100行
+
+	long bandnum = resultimg.band_num + 1;
+	long starti = 0;
+	long rasterCount = imgdslist.count();
+
+	long processNumber = 0;
+	QProgressDialog progressDialog(u8"合并影像", u8"终止", 0, resultimg.height);
+	progressDialog.setWindowTitle(u8"合并影像");
+	progressDialog.setWindowModality(Qt::WindowModal);
+	progressDialog.setAutoClose(true);
+	progressDialog.setValue(0);
+	progressDialog.setMaximum(resultimg.height);
+	progressDialog.setMinimum(0);
+	progressDialog.show();
+	omp_lock_t lock;
+	omp_init_lock(&lock);
+
+#pragma omp parallel for
+	for (starti = 0; starti < resultimg.height; starti = starti + resultline) {
+		long blocklines = resultline;
+		blocklines = starti + blocklines < resultimg.height ? blocklines : resultimg.height - starti;
+
+		long rid = starti;
+		long cid = 0;
+
+		Landpoint pp = { 0,0,0 };
+		Landpoint lp = { 0,0,0 };
+
+		for (long ir = 0; ir < rasterCount; ir++) {// 影像
+			long minRid = imgdslist[ir].height;
+			long maxRid = 0;
+
+			Eigen::MatrixXd ridlist = resultimg.getData(starti, 0, blocklines, resultimg.width, 1);
+			ridlist = ridlist.array() * 0;
+			Eigen::MatrixXd cidlist = ridlist.array() * 0;
+
+			for (long i = 0; i < blocklines; i++) {// 行号
+				rid = starti + i;
+				for (long j = 0; j < resultimg.width; j++) {// 列号
+					cid = j;
+					resultimg.getLandPoint(rid, cid, 0, pp);
+					lp = imgdslist[ir].getRow_Col(pp.lon, pp.lat); // 获取点坐标
+					ridlist(i, j) = lp.lat;
+					cidlist(i, j) = lp.lon;
+				}
+			}
+
+			//ImageShowDialogClass* dialog = new ImageShowDialogClass;
+			//dialog->show();
+			//dialog->load_double_MatrixX_data(cidlist, u8"");
+
+			//dialog->exec();
+
+
+			if (ridlist.maxCoeff() < 0 || ridlist.minCoeff() >= imgdslist[ir].height) {
+				continue;
+			}
+
+			if (cidlist.maxCoeff() < 0 || cidlist.minCoeff() >= imgdslist[ir].width) {
+				continue;
+			}
+
+			minRid = std::floor(ridlist.minCoeff());
+			maxRid = std::ceil(ridlist.maxCoeff());
+			minRid = minRid < 0 ? 0 : minRid;
+			maxRid = maxRid < imgdslist[ir].height ? maxRid : imgdslist[ir].height - 1;
+
+			long rowlen = maxRid - minRid + 1;
+			if (rowlen <= 0) {
+				continue;
+			}
+			// 获取分配代码
+			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 rowcount = 0;
+			long colcount = 0;
+			double ridtemp = 0, cidtemp = 0;
+
+			long lastr = 0, nextr = 0;
+			long lastc = 0, nextc = 0;
+
+			double r0 = 0, c0 = 0;
+
+			for (long b = 1; b < bandnum; b++) {
+				Eigen::MatrixXd resultdata = resultimg.getData(starti, 0, blocklines, resultimg.width, b);
+				Eigen::MatrixXi resultmask = maskimg.getDatai(starti, 0, blocklines, resultimg.width, b);
+				Eigen::MatrixXd data = imgdslist[ir].getData(minRid, 0, rowlen, imgdslist[ir].width, b);
+
+				double nodata = imgdslist[ir].getNoDataValue(b);
+				for (long ii = 0; ii < data.rows(); ii++) {
+					for (long jj = 0; jj < data.cols(); jj++) {
+						if (std::abs(data(ii, jj) - nodata) < 1e-6) {
+							data(ii, jj) = 0;
+						}
+					}
+				}
+				rowcount = ridlist.rows();
+				colcount = ridlist.cols();
+				double Bileanervalue = 0;
+				for (long i = 0; i < rowcount; i++) {
+					for (long j = 0; j < colcount; j++) {
+						ridtemp = ridlist(i, j);
+						cidtemp = cidlist(i, j);
+
+						lastr = std::floor(ridtemp);
+						nextr = std::ceil(ridtemp);
+						lastc = std::floor(cidtemp);
+						nextc = std::ceil(cidtemp);
+
+						if (lastr < 0 || lastr >= imgdslist[ir].height
+							|| nextr < 0 || nextr >= imgdslist[ir].height
+							|| lastc < 0 || lastc >= imgdslist[ir].width
+							|| nextc < 0 || nextc >= imgdslist[ir].width) {
+							continue;
+						}
+						else {}
+
+						r0 = ridtemp - std::floor(ridtemp);
+						c0 = cidtemp - std::floor(cidtemp);
+
+						lastr = lastr - minRid;
+						nextr = nextr - minRid;
+
+						p0 = Landpoint{ c0,r0,0 };
+						p11 = Landpoint{ 0,0,data(lastr,lastc) };
+						p21 = Landpoint{ 0,1,data(nextr,lastc) };
+						p12 = Landpoint{ 1,0,data(lastr,nextc) };
+						p22 = Landpoint{ 1,1,data(nextr,nextc) };
+						Bileanervalue = Bilinear_interpolation(p0, p11, p21, p12, p22);
+						if (std::abs(Bileanervalue) < 1e-6 || resultmask(i, j) > 0) {
+							continue;
+						}
+						resultdata(i, j) = resultdata(i, j) + Bileanervalue;
+						resultmask(i, j) = resultmask(i, j) + 1;
+					}
+				}
+				resultimg.saveImage(resultdata, starti, 0, b);
+				maskimg.saveImage(resultmask, starti, 0, b);
+			}
+		}
+
+		omp_set_lock(&lock);
+		processNumber = processNumber + blocklines;
+		qDebug() << "\rprocess bar:\t" << processNumber * 100.0 / resultimg.height << " % " << "\t\t\t";
+		if (nullptr != dia) {
+			dia->showProcess(processNumber * 1.0 / resultimg.height, u8"合并图像");
+		}
+		if (progressDialog.maximum() <= processNumber) {
+			processNumber = progressDialog.maximum() - 1;
+		}
+		progressDialog.setValue(processNumber);
+		omp_unset_lock(&lock);
+	}
+	omp_destroy_lock(&lock);
+
+	progressDialog.setWindowTitle(u8"影像掩膜");
+	progressDialog.setLabelText(u8"影像掩膜");
+	for (starti = 0; starti < resultimg.height; starti = starti + resultline) {
+		long blocklines = resultline;
+		blocklines = starti + blocklines < resultimg.height ? blocklines : resultimg.height - starti;
+		for (long b = 1; b < bandnum; b++) {
+			Eigen::MatrixXd data = resultimg.getData(starti, 0, blocklines, resultimg.width, b);
+			Eigen::MatrixXd maskdata = maskimg.getData(starti, 0, blocklines, maskimg.width, b);
+
+			for (long i = 0; i < data.rows(); i++) {
+				for (long j = 0; j < data.cols(); j++) {
+					if (maskdata(i, j) == 0) {
+						data(i, j) = -9999;
+						continue;
+					}
+					data(i, j) = data(i, j) / maskdata(i, j);
+				}
+			}
+
+			resultimg.saveImage(data, starti, 0, b);
+			maskimg.saveImage(maskdata, starti, 0, b);
+		}
+		if (nullptr != dia) {
+			dia->showProcess((starti + blocklines) * 1.0 / resultimg.height, u8"影像掩膜");
+		}
+		progressDialog.setValue(starti + blocklines);
+	}
+
+
+	progressDialog.close();
+	return ErrorCode::SUCCESS;
+}
+
+
+void MergeTiffs(QList<QString> inputFiles, QString outputFile) {
+	GDALAllRegister();
+
+	if (inputFiles.isEmpty()) {
+		fprintf(stderr, "No input files provided.\n");
+		return;
+	}
+
+	// Open the first file to determine the data type and coordinate system
+	GDALDataset* poFirstDS = (GDALDataset*)GDALOpen(inputFiles.first().toUtf8().constData(), GA_ReadOnly);
+	if (poFirstDS == nullptr) {
+		fprintf(stderr, "Failed to open the first file %s\n", inputFiles.first().toUtf8().constData());
+		return;
+	}
+
+	double adfGeoTransform[6];
+	CPLErr eErr = poFirstDS->GetGeoTransform(adfGeoTransform);
+	if (eErr != CE_None) {
+		fprintf(stderr, "Failed to get GeoTransform for the first file %s\n", inputFiles.first().toUtf8().constData());
+		GDALClose(poFirstDS);
+		return;
+	}
+
+	int nXSize = 0;
+	int nYSize = 0;
+	double minX = std::numeric_limits<double>::max();
+	double minY = std::numeric_limits<double>::max();
+	double maxX = std::numeric_limits<double>::lowest();
+	double maxY = std::numeric_limits<double>::lowest();
+	double pixelWidth = adfGeoTransform[1];
+	double pixelHeight = adfGeoTransform[5];
+
+	// Determine the bounding box and size of the output raster
+	for (const QString& inputFile : inputFiles) {
+		GDALDataset* poSrcDS = (GDALDataset*)GDALOpen(inputFile.toUtf8().constData(), GA_ReadOnly);
+		if (poSrcDS == nullptr) {
+			fprintf(stderr, "Failed to open %s\n", inputFile.toUtf8().constData());
+			continue;
+		}
+
+		double adfThisTransform[6];
+		eErr = poSrcDS->GetGeoTransform(adfThisTransform);
+		if (eErr != CE_None) {
+			fprintf(stderr, "Failed to get GeoTransform for %s\n", inputFile.toUtf8().constData());
+			GDALClose(poSrcDS);
+			continue;
+		}
+
+		minX = std::min(minX, adfThisTransform[0]);
+		minY = std::min(minY, adfThisTransform[3] + adfThisTransform[5] * poSrcDS->GetRasterYSize());
+		maxX = std::max(maxX, adfThisTransform[0] + adfThisTransform[1] * poSrcDS->GetRasterXSize());
+		maxY = std::max(maxY, adfThisTransform[3]);
+
+		GDALClose(poSrcDS);
+	}
+
+	nXSize = static_cast<int>(std::ceil((maxX - minX) / pixelWidth));
+	nYSize = static_cast<int>(std::ceil((maxY - minY) / (-pixelHeight)));
+
+	GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("GTiff");
+	if (poDriver == nullptr) {
+		fprintf(stderr, "GTiff driver not available.\n");
+		GDALClose(poFirstDS);
+		return;
+	}
+
+	char** papszOptions = nullptr;
+	GDALDataset* poDstDS = poDriver->Create(outputFile.toUtf8().constData(), nXSize, nYSize, 1, poFirstDS->GetRasterBand(1)->GetRasterDataType(), papszOptions);
+	if (poDstDS == nullptr) {
+		fprintf(stderr, "Creation of output file failed.\n");
+		GDALClose(poFirstDS);
+		return;
+	}
+
+	poDstDS->SetGeoTransform(adfGeoTransform);
+
+	const OGRSpatialReference* oSRS = poFirstDS->GetSpatialRef();
+	poDstDS->SetSpatialRef(oSRS);
+
+	float fillValue = std::numeric_limits<float>::quiet_NaN();
+	void* pafScanline = CPLMalloc(GDALGetDataTypeSizeBytes(poFirstDS->GetRasterBand(1)->GetRasterDataType()) * nXSize);
+	memset(pafScanline, 0, GDALGetDataTypeSizeBytes(poFirstDS->GetRasterBand(1)->GetRasterDataType()) * nXSize);
+
+	// Initialize all pixels to NaN
+	for (int iY = 0; iY < nYSize; ++iY) {
+		GDALRasterBand* poBand = poDstDS->GetRasterBand(1);
+		poBand->RasterIO(GF_Write, 0, iY, nXSize, 1, pafScanline, nXSize, 1, poFirstDS->GetRasterBand(1)->GetRasterDataType(), 0, 0);
+	}
+
+	CPLFree(pafScanline);
+
+	// Read each source image and write into the destination image
+	for (const QString& inputFile : inputFiles) {
+		GDALDataset* poSrcDS = (GDALDataset*)GDALOpen(inputFile.toUtf8().constData(), GA_ReadOnly);
+		if (poSrcDS == nullptr) {
+			fprintf(stderr, "Failed to open %s\n", inputFile.toUtf8().constData());
+			continue;
+		}
+
+		double adfThisTransform[6];
+		poSrcDS->GetGeoTransform(adfThisTransform);
+
+		int srcXSize = poSrcDS->GetRasterXSize();
+		int srcYSize = poSrcDS->GetRasterYSize();
+
+		int dstXOffset = static_cast<int>(std::round((adfThisTransform[0] - minX) / pixelWidth));
+		int dstYOffset = static_cast<int>(std::round((maxY - adfThisTransform[3]) / (-pixelHeight)));
+
+		GDALRasterBand* poSrcBand = poSrcDS->GetRasterBand(1);
+		GDALRasterBand* poDstBand = poDstDS->GetRasterBand(1);
+
+		void* pafBuffer = CPLMalloc(GDALGetDataTypeSizeBytes(poFirstDS->GetRasterBand(1)->GetRasterDataType()) * srcXSize * srcYSize);
+		poSrcBand->RasterIO(GF_Read, 0, 0, srcXSize, srcYSize, pafBuffer, srcXSize, srcYSize, poFirstDS->GetRasterBand(1)->GetRasterDataType(), 0, 0);
+
+		poDstBand->RasterIO(GF_Write, dstXOffset, dstYOffset, srcXSize, srcYSize, pafBuffer, srcXSize, srcYSize, poFirstDS->GetRasterBand(1)->GetRasterDataType(), 0, 0);
+
+		CPLFree(pafBuffer);
+		GDALClose(poSrcDS);
+	}
+
+	GDALClose(poDstDS);
+	GDALClose(poFirstDS);
+
+}
+
+
+

BaseTool/PrintMsgToQDebug.cpp

@@ -0,0 +1,36 @@
+#include "PrintMsgToQDebug.h"
+#include <QDebug>
+BASECONSTVARIABLEAPI void PrintMsgToQDebug(char* msg)
+{
+    qDebug() << QString(msg);
+    return  ;
+}
+
+BASECONSTVARIABLEAPI void PrintfToQDebug(const char* msg)
+{
+    qDebug() << QString(msg);
+    return;
+}
+
+BASECONSTVARIABLEAPI void PrintTipMsgToQDebug(const char* tip, const char* msg)
+{
+    qDebug() <<QString(tip)<<"\t:\t" << QString(msg);
+    return;
+}
+// 自定义的 printf 风格函数
+BASECONSTVARIABLEAPI void printfinfo(const char* format, ...) {
+    char buffer[256];  // 假设最大输出长度为 256 字节
+    va_list args;
+
+    // 使用 va_start 获取可变参数列表
+    va_start(args, format);
+
+    // 使用 vsnprintf 将格式化字符串写入 buffer
+    vsnprintf(buffer, sizeof(buffer), format, args);
+
+    // 结束可变参数列表的使用
+    va_end(args);
+
+    // 将格式化后的字符串转发给 PrintfToQDebug
+    PrintfToQDebug(buffer);
+}

BaseTool/PrintMsgToQDebug.h

@@ -0,0 +1,16 @@
+#pragma once
+#ifndef PRINTMSGTOQDEBUG_H_
+#define PRINTMSGTOQDEBUG_H_
+#include "BaseConstVariable.h"
+#include <format>
+extern "C" BASECONSTVARIABLEAPI void PrintMsgToQDebug(char* msg);
+extern "C" BASECONSTVARIABLEAPI void PrintfToQDebug(const char* msg);
+extern "C" BASECONSTVARIABLEAPI void PrintTipMsgToQDebug(const char* tip, const char* msg);
+extern "C" BASECONSTVARIABLEAPI void printfinfo(const char* format, ...);
+
+ 
+
+#endif // !PRINTMSGTOQDEBUG_H_
+
+
+ 

BaseTool/QToolProcessBarDialog.cpp

@@ -0,0 +1,24 @@
+#include "QToolProcessBarDialog.h"
+#include "ui_QToolProcessBarDialog.h"
+
+QToolProcessBarDialog::QToolProcessBarDialog(QWidget *parent)
+	: ui(new Ui::QToolProcessBarDialogClass), QDialog(parent)
+{
+	ui->setupUi(this);
+	ui->progressBar->setRange(0, 100);
+}
+
+QToolProcessBarDialog::~QToolProcessBarDialog()
+{}
+
+void QToolProcessBarDialog::showProcess(double precent, QString tip)
+{
+	ui->progressBar->setValue(std::ceil(precent * 100));
+	ui->labelTip->setText(tip);
+	this->update();
+}
+
+void QToolProcessBarDialog::showToolInfo(QString tip)
+{
+	ui->textEditTip->append("\n"+tip);
+}

BaseTool/QToolProcessBarDialog.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "BaseConstVariable.h"
+#include <QDialog>
+
+#include "ImageOperatorBase.h"
+
+namespace Ui {
+	class QToolProcessBarDialogClass;
+}
+
+class  BASECONSTVARIABLEAPI	 QToolProcessBarDialog : public QDialog, public  ShowProessAbstract
+{
+	Q_OBJECT
+public:
+	QToolProcessBarDialog(QWidget *parent = nullptr);
+	~QToolProcessBarDialog();
+
+private:
+	Ui::QToolProcessBarDialogClass* ui;
+public:
+	virtual void showProcess(double precent, QString tip) override;
+	virtual void showToolInfo(QString tip) override;
+};

BaseTool/QToolProcessBarDialog.ui

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QToolProcessBarDialogClass</class>
+ <widget class="QDialog" name="QToolProcessBarDialogClass">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>600</width>
+    <height>400</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>QToolProcessBarDialog</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QWidget" name="widget" native="true">
+     <layout class="QGridLayout" name="gridLayout">
+      <item row="1" column="2">
+       <widget class="QPushButton" name="OKpushButton">
+        <property name="minimumSize">
+         <size>
+          <width>120</width>
+          <height>26</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>120</width>
+          <height>26</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>退出</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="labelTip">
+        <property name="text">
+         <string>提示</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0" colspan="2">
+       <widget class="QProgressBar" name="progressBar">
+        <property name="value">
+         <number>24</number>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="title">
+      <string/>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_2">
+      <item>
+       <widget class="QTextEdit" name="textEditTip"/>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources/>
+ <connections/>
+</ui>

BaseTool/RasterToolBase.cpp

@@ -0,0 +1,276 @@
+/**
+ * @file RasterProjectBase.cpp
+ * @brief None
+ * @author 陈增辉 (3045316072@qq.com)
+ * @version 2.5.0
+ * @date 24-6-4
+ * @copyright Copyright (c) Since 2024 中科卫星应用研究院  All rights reserved.
+ */
+
+#include <QDebug>
+#include "RasterToolBase.h"
+#include "gdal_priv.h"
+#include "ogr_spatialref.h"
+#include "cpl_conv.h" // for CPLMalloc()
+#include <QTextCodec>
+#include <iostream>
+#include <QFile>
+#include "SARSimulationImageL1.h"
+#include <QMessageBox>
+
+namespace RasterToolBase {
+	long getProjectEPSGCodeByLon_Lat(double lon, double lat, ProjectStripDelta stripState)
+	{
+		long EPSGCode = 0;
+		switch(stripState) {
+			case ProjectStripDelta::Strip_3: {
+				break;
+			};
+			case ProjectStripDelta::Strip_6: {
+				break;
+			}
+			default: {
+				EPSGCode = -1;
+				break;
+			}
+		}
+		qDebug() << QString(" EPSG code : %1").arg(EPSGCode);
+		return EPSGCode;
+	}
+	long getProjectEPSGCodeByLon_Lat_inStrip3(double lon, double lat)
+	{
+		// EPSG 4534 ~ 4554 3 度带
+		// 首先判断是否是在 中国带宽范围
+		// 中心经度范围 ：75E ~ 135E 实际范围 73.5E ~ 136.5E,
+		// 纬度范围 3N ~ 54N，放宽到 0N~ 60N
+		if(73.5 <= lon && lon <= 136.5 && 0 <= lat && lat <= 60) { // 中国境内
+			long code = trunc((lon - 73.5) / 3) + 4534;
+			return code;
+		} else { // 非中国境内 使用 高斯克吕格
+			bool isSouth = lat < 0; // 简单判断南北半球，这里仅为示例，实际应用可能需要更细致的逻辑
+			long prefix = isSouth ? 327000 : 326000;
+			// std::string prefix = isSouth ? "327" : "326";
+			lon			  = fmod(lon + 360.0, 360.0);
+			long zone	  = std::floor((lon + 180.0) / 3.0);
+			prefix		  = prefix + zone;
+			return prefix;
+		}
+		return 0;
+	}
+	long getProjectEPSGCodeByLon_Lat_inStrip6(double lon, double lat)
+	{
+		// EPSG 4502 ~ 4512   6度带
+		// 首先判断是否是在 中国带宽范围
+		// 中心经度范围 ：75E ~ 135E 实际范围 72.0E ~ 138E,
+		// 纬度范围 3N ~ 54N，放宽到 0N~ 60N
+		if(73.5 <= lon && lon <= 136.5 && 0 <= lat && lat <= 60) { // 中国境内
+			long code = trunc((lon - 72.0) / 6) + 4502;
+			return code;
+		} else { // 非中国境内 使用 UTM// 确定带号，6度带从1开始到60，每6度一个带
+			int	   zone			= static_cast<int>((lon + 180.0) / 6.0) + 1;
+			bool   isSouth		= lon < 0;				   // 判断是否在南半球
+			long epsgCodeBase = isSouth ? 32700 : 32600; // 计算EPSG代码
+			long prefix		= static_cast<int>(epsgCodeBase + zone);
+			return prefix;
+		}
+		return 0;
+	}
+
+	QString GetProjectionNameFromEPSG(long epsgCode)
+	{
+		qDebug() << "============= GetProjectionNameFromEPSG ======================";
+		OGRSpatialReference oSRS;
+
+		// 设置EPSG代码
+		if(oSRS.importFromEPSG(epsgCode) != OGRERR_NONE) {
+			qDebug() << "epsgcode not  recognition";
+			return "";
+		}
+
+		// 获取并输出坐标系的描述（名称）
+		const char* pszName = oSRS.GetAttrValue("GEOGCS");
+		if(pszName) {
+			qDebug() << "Coordinate system name for EPSG " + QString::number(epsgCode)
+					 << " is: " + QString::fromStdString(pszName);
+			return QString::fromStdString(pszName);
+		} else {
+			qDebug() << "Unable to retrieve the name for EPSG " + QString::number(epsgCode);
+			return "";
+		}
+
+		//		char*				wkt = NULL;
+		//		// 转换为WKT格式
+		//		oSRS.exportToWkt(&wkt);
+		//
+		//		qDebug() << wkt;
+		//
+		//		// 从WKT中解析投影名称，这里简化处理，实际可能需要更复杂的逻辑来准确提取名称
+		//		std::string wktStr(wkt);
+		//		long start = wktStr.find("PROJCS[\"") + 8; // 找到"PROJCS["后的第一个双引号位置
+		//		// 从start位置开始找下一个双引号，这之间的内容即为投影名称
+		//		int	end		 = wktStr.find('\"', start);
+		//		QString projName = QString::fromStdString(wktStr.substr(start, end - start));
+		//
+		//		// 释放WKT字符串内存
+		//		CPLFree(wkt);
+
+		// return projName;
+	}
+	long GetEPSGFromRasterFile(QString filepath)
+	{
+		qDebug() << "============= GetEPSGFromRasterFile ======================";
+		//		QTextCodec* codec = QTextCodec::codecForLocale(); // 获取系统默认编码的文本编解码器
+		//		QByteArray	byteArray = codec->fromUnicode(filepath); // 将QString转换为QByteArray
+		//,这个应该会自动释放 		const char* charArray = byteArray.constData(); //
+		// 获取QByteArray的const char*指针
+
+		{
+			if(QFile(filepath).exists()){
+				qDebug() << "info: the image found.\n";
+			}else{
+				return -1;
+			}
+
+			GDALAllRegister();
+			CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES"); // 注册GDAL驱动
+			//			qDebug()<<filepath.toLocal8Bit().constData()<<std::endl;
+			// 打开影像文件
+			GDALDataset* poDataset;
+			poDataset = (GDALDataset*)GDALOpen(filepath.toUtf8().data(), GA_ReadOnly);
+			if(NULL==poDataset) {
+				qDebug() << "Error: Unable to open the image.\n";
+				return -1;
+			}
+
+			// 获取影像的投影信息
+			const char* pszProjection = poDataset->GetProjectionRef();
+
+			qDebug() << QString::fromUtf8(pszProjection);
+
+			// 创建SpatialReference对象
+			OGRSpatialReference oSRS;
+			if(oSRS.importFromWkt((char**)&pszProjection) != OGRERR_NONE) {
+				qDebug() << ("Error: Unable to import projection information.\n");
+				GDALClose(poDataset);
+				return -1;
+			}
+
+			long epsgCode = atoi(oSRS.GetAuthorityCode(nullptr)); // 获取EPSG代码
+
+			if(epsgCode != 0) {
+				GDALClose(poDataset);
+				qDebug() << QString("file %1 :epsg Code %2").arg(filepath).arg(epsgCode);
+				return epsgCode;
+			} else {
+				qDebug() << "EPSG code could not be determined from the spatial reference.";
+				GDALClose(poDataset);
+				return -1;
+			}
+		}
+	}
+	std::shared_ptr<PointRaster> GetCenterPointInRaster(QString filepath)
+	{
+		qDebug() << "============= GetCenterPointInRaster ======================";
+		//		QTextCodec* codec = QTextCodec::codecForLocale(); // 获取系统默认编码的文本编解码器
+		//		QByteArray	byteArray = codec->fromUnicode(filepath); // 将QString转换为QByteArray
+		//,这个应该会自动释放 		const char* charArray = byteArray.constData(); //
+		// 获取QByteArray的const char*指针
+		GDALAllRegister();
+		CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+		CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+		// qDebug()<<filepath.toLocal8Bit().constData()<<std::endl;
+		GDALDataset* poDataset = (GDALDataset*)GDALOpen(filepath.toUtf8().data(), GA_ReadOnly);
+		if(nullptr==poDataset||NULL==poDataset) {
+			qDebug() << "Could not open dataset";
+			return nullptr; // 表示读取失败
+		}
+
+		double x, y, z;
+
+		bool   flag = false;
+
+		{
+			double adfGeoTransform[6];
+			if(poDataset->GetGeoTransform(adfGeoTransform) != CE_None) {
+				qDebug() << "Failed to get GeoTransform";
+				return nullptr;
+			}
+
+			double dfWidth	 = poDataset->GetRasterXSize();
+			double dfHeight	 = poDataset->GetRasterYSize();
+
+			// 计算中心点坐标（像素坐标）
+			double dfCenterX = adfGeoTransform[0] + dfWidth * adfGeoTransform[1] / 2.0
+							 + dfHeight * adfGeoTransform[2] / 2.0;
+			double dfCenterY = adfGeoTransform[3] + dfWidth * adfGeoTransform[4] / 2.0
+							 + dfHeight * adfGeoTransform[5] / 2.0;
+
+			OGRSpatialReference oSRS;
+			oSRS.importFromWkt(poDataset->GetProjectionRef());
+
+			if(oSRS.IsGeographic()) {
+				qDebug() << "Center coords (already in geographic): (" + QString::number(dfCenterX)
+								+ ", " + QString::number(dfCenterY) + ")";
+				flag = true;
+				x	 = dfCenterX;
+				y	 = dfCenterY;
+			} else {
+				// 如果不是地理坐标系，转换到WGS84
+				OGRSpatialReference oSRS_WGS84;
+				oSRS_WGS84.SetWellKnownGeogCS("WGS84");
+
+				OGRCoordinateTransformation* poCT =
+					OGRCreateCoordinateTransformation(&oSRS, &oSRS_WGS84);
+				if(poCT == nullptr) {
+					qDebug() << "Failed to create coordinate transformation";
+					return nullptr;
+				}
+
+				// double dfLon, dfLat;
+				if(poCT->Transform(1, &dfCenterX, &dfCenterY)) {
+					qDebug() << "Center coords (transformed to WGS84): ("
+									+ QString::number(dfCenterX) + ", " + QString::number(dfCenterY)
+							 << ")";
+					flag = true;
+					x	 = dfCenterX;
+					y	 = dfCenterY;
+				} else {
+					qDebug() << "Transformation failed.";
+				}
+				OGRCoordinateTransformation::DestroyCT(poCT);
+			}
+		}
+		if(nullptr==poDataset||NULL==poDataset){}else{
+			GDALClose(poDataset);
+		}
+
+		if(flag) {
+			std::shared_ptr<PointRaster> RasterCenterPoint = std::make_shared<PointRaster>();
+			RasterCenterPoint->x						   = x;
+			RasterCenterPoint->y						   = y;
+			RasterCenterPoint->z						   = 0;
+			return RasterCenterPoint;
+		} else {
+			return nullptr;
+		}
+	}
+	CoordinateSystemType getCoordinateSystemTypeByEPSGCode(long epsg_code)
+	{
+		OGRSpatialReference oSRS;
+		if(oSRS.importFromEPSG(epsg_code) == OGRERR_NONE) {
+			if(oSRS.IsGeographic()) {
+				return CoordinateSystemType::GeoCoordinateSystem;
+			} else if(oSRS.IsProjected()) {
+				return CoordinateSystemType::ProjectCoordinateSystem;
+			}
+			else {
+				return CoordinateSystemType::UNKNOW;
+			}
+		} else {
+			return CoordinateSystemType::UNKNOW;
+		}
+	}
+}; // namespace RasterToolBase
+
+
+

BaseTool/RasterToolBase.h

@@ -0,0 +1,96 @@
+/**
+ * @file RasterProjectBase.h
+ * @brief None
+ * @author 陈增辉 (3045316072@qq.com)
+ * @version 2.5.0
+ * @date 24-6-4
+ * @copyright Copyright (c) Since 2024 中科卫星应用研究院  All rights reserved.
+ */
+
+#ifndef LAMPCAE_RASTERTOOLBASE_H
+#define LAMPCAE_RASTERTOOLBASE_H
+#include "BaseConstVariable.h"
+#include "gdal_priv.h"
+#include <memory>
+#include "LogInfoCls.h"
+
+
+namespace RasterToolBase {
+
+	static bool GDALAllRegisterEnable = false;
+
+
+	enum ProjectStripDelta {
+		Strip_6, // 6度带
+		Strip_3
+	};
+
+	enum CoordinateSystemType { // 坐标系类型
+		GeoCoordinateSystem,
+		ProjectCoordinateSystem,
+		UNKNOW
+	};
+
+	struct PointRaster { // 影像坐标点
+		double x;
+		double y;
+		double z;
+	};
+
+
+	struct PointXYZ {
+		double x, y, z;
+	};
+
+	struct  PointGeo {
+		double lon, lat, ati;
+	};
+
+	struct PointImage {
+		double pixel_x, pixel_y;
+	};
+
+	/// 根据经纬度获取
+	/// EPSG代码，根据经纬度返回对应投影坐标系统，其中如果在中华人民共和国境内，默认使用
+	/// CGCS2000坐标系统(EPSG 4502 ~ 4512 6度带,EPSG 4534 ~ 4554 3度带)，其余地方使用WGS坐标系统，
+	/// 投影方法 高斯克吕格（国内）， 高斯克吕格
+	/// \param long 经度
+	/// \param lat 纬度
+	/// \return 对应投影坐标系统的 EPSG编码,-1 表示计算错误
+	long   BASECONSTVARIABLEAPI	getProjectEPSGCodeByLon_Lat(double long, double lat,
+		ProjectStripDelta stripState = ProjectStripDelta::Strip_3);
+
+	long   BASECONSTVARIABLEAPI	getProjectEPSGCodeByLon_Lat_inStrip3(double lon, double lat);
+
+	long   BASECONSTVARIABLEAPI	getProjectEPSGCodeByLon_Lat_inStrip6(double lon, double lat);
+
+
+	QString   BASECONSTVARIABLEAPI	GetProjectionNameFromEPSG(long epsgCode);
+
+
+	long   BASECONSTVARIABLEAPI	GetEPSGFromRasterFile(QString filepath);
+
+	std::shared_ptr<PointRaster>   BASECONSTVARIABLEAPI	GetCenterPointInRaster(QString filepath);
+
+	CoordinateSystemType   BASECONSTVARIABLEAPI	getCoordinateSystemTypeByEPSGCode(long EPSGCODE);
+
+};// namespace RasterProjectConvertor
+
+
+
+
+// 遥感类常用数据
+
+
+
+
+
+
+
+
+
+
+
+
+
+#endif // LAMPCAE_RASTERTOOLBASE_H

BaseTool/SARSimulationImageL1.h

@@ -0,0 +1,218 @@
+#pragma once
+
+#include "BaseConstVariable.h"
+
+#include "BaseTool.h"
+#include "ImageOperatorBase.h"
+#include "GeoOperator.h"
+#include "FileOperator.h"
+#include "LogInfoCls.h"
+
+enum RasterLevel {
+	RasterSLC,
+	RasterL1B,
+	RasterL2
+};
+
+class   BASECONSTVARIABLEAPI	SARSimulationImageL1Dataset
+{
+public:
+	SARSimulationImageL1Dataset(RasterLevel Rasterlevel= RasterLevel::RasterSLC);
+	~SARSimulationImageL1Dataset();
+
+private:
+	RasterLevel Rasterlevel;
+public:
+	RasterLevel getRasterLevel();
+
+
+private :
+	QString outFolderPath;
+	QString L1DatasetName;
+	QString xmlfileName;
+	QString xmlFilePath;
+	QString ImageRasterName;
+	QString ImageRasterPath;
+	QString GPSPointFilename;
+	QString GPSPointFilePath;
+
+public:
+	QString getoutFolderPath(); 
+	QString getDatesetName();
+	QString getxmlfileName();
+	QString getxmlFilePath();
+	QString getImageRasterName();
+	QString getImageRasterPath();
+	QString getGPSPointFilename(); // GPS点
+	QString getGPSPointFilePath();
+
+
+public:
+	ErrorCode OpenOrNew(QString folder, QString filename, long rowCount, long colCount);
+	ErrorCode Open(QString folderPath, QString Name);
+	ErrorCode Open(QString xmlPath);
+public:
+	void saveToXml();
+	ErrorCode loadFromXml();
+	std::shared_ptr<double> getAntPos();
+	ErrorCode saveAntPos(std::shared_ptr<double> ptr); // 注意这个方法很危险，请写入前检查数据是否正确
+	
+	std::shared_ptr<std::complex<double>> getImageRaster();
+	ErrorCode saveImageRaster(std::shared_ptr<std::complex<double>> echoPtr, long startPRF, long PRFLen);
+	std::shared_ptr<std::complex<double>> getImageRaster(long startPRF, long PRFLen);
+	
+	Eigen::MatrixXcd getImageRasterMatrix();
+	ErrorCode saveImageRaster(Eigen::MatrixXcd& data, long startPRF);
+
+	gdalImage getImageRasterGdalImage();
+
+private: // xml中参数
+	  
+	long rowCount;
+	long colCount;
+
+	double Rnear;  
+	double Rfar;  
+	double Rref;  
+
+	double centerFreq;  
+	double Fs;  
+	double prf;
+
+	double CenterAngle; 
+	QString LookSide;
+	QVector<SatelliteAntPos> sateposes;
+
+	double startImageTime;
+	double EndImageTime;
+
+public:
+
+	 void	setStartImageTime(double imageTime);
+	 double getStartImageTime();
+
+	 void	setEndImageTime(double imageTime);
+	 double getEndImageTime();
+
+
+	QVector<SatelliteAntPos> getXmlSateAntPos();
+	void setSateAntPos(QVector<SatelliteAntPos> pos);
+
+	long getrowCount();
+	void setrowCount(long rowCount);
+
+	long getcolCount();
+	void setcolCount(long pulsePoints);
+
+	double getNearRange();
+	void setNearRange(double nearRange);
+
+	double getFarRange();
+	void setFarRange(double farRange);
+
+	double getRefRange();
+	void setRefRange(double refRange);
+
+	double getCenterFreq();
+	void setCenterFreq(double freq);
+
+	double getFs();
+	void setFs(double samplingFreq);
+
+	double getPRF();
+	void setPRF(double PRF);
+
+	double getCenterAngle();
+	void setCenterAngle(double angle);
+
+	QString getLookSide();
+	void setLookSide(QString lookside);
+
+public:// 多普勒参数
+	double TotalProcessedAzimuthBandWidth, DopplerParametersReferenceTime;
+	double d0, d1, d2, d3, d4;
+	double r0, r1, r2, r3, r4;
+	double DEM;
+	double  incidenceAngleNearRange, incidenceAngleFarRange;
+
+public:
+
+	double getTotalProcessedAzimuthBandWidth();
+	void setTotalProcessedAzimuthBandWidth(double v);
+
+	double getDopplerParametersReferenceTime();
+	void setDopplerParametersReferenceTime(double v);
+
+	// 多普勒参数
+	QVector<double> getDopplerParams();
+	void setDopplerParams(double d0, double d1, double d2, double d3, double d4);
+
+	// 多普勒中心系数
+	QVector<double> getDopplerCenterCoff();
+	void setDopplerCenterCoff(double r0, double r1, double r2, double r3, double r4);
+
+
+	double getIncidenceAngleNearRange();
+	void setIncidenceAngleNearRangeet(double angle);
+
+	double getIncidenceAngleFarRange();
+	void setIncidenceAngleFarRange(double angle);
+
+private:
+	double  latitude_center, longitude_center, 
+		latitude_topLeft, longitude_topLeft,
+		latitude_topRight, longitude_topRight,
+		latitude_bottomLeft, longitude_bottomLeft, 
+		latitude_bottomRight, longitude_bottomRight;
+public:
+	// Getter and Setter functions
+	double getLatitudeCenter();
+	void setLatitudeCenter(double value);
+
+	double getLongitudeCenter();
+	void setLongitudeCenter(double value);
+
+	double getLatitudeTopLeft();
+	void setLatitudeTopLeft(double value);
+
+	double getLongitudeTopLeft();
+	void setLongitudeTopLeft(double value);
+
+	double getLatitudeTopRight();
+	void setLatitudeTopRight(double value);
+
+	double getLongitudeTopRight();
+	void setLongitudeTopRight(double value);
+
+	double getLatitudeBottomLeft();
+	void setLatitudeBottomLeft(double value);
+
+	double getLongitudeBottomLeft();
+	void setLongitudeBottomLeft(double value);
+
+	double getLatitudeBottomRight();
+	void setLatitudeBottomRight(double value);
+
+	double getLongitudeBottomRight();
+	void setLongitudeBottomRight(double value);
+public:
+	DemBox getExtend();
+
+
+public:
+	double getdrange();
+	void setdrange(double dr);
+
+	double getdAz();
+	void setdAz(double dAz);
+private:
+	double dr, dAz;
+
+};
+
+
+
+
+
+
+

BaseTool/ShowProessAbstract.cpp

@@ -0,0 +1,18 @@
+#include "stdafx.h"
+#include "ShowProessAbstract.h"
+#include "BaseTool.h"
+#include "GeoOperator.h"
+#include "FileOperator.h"
+#include <QString>
+
+
+void ShowProessAbstract::showProcess(double precent, QString tip)
+{
+
+}
+
+void ShowProessAbstract::showToolInfo(QString tip)
+{
+}
+
+

BaseTool/TestImageOperator.cpp

@@ -0,0 +1,146 @@
+#include "stdafx.h"
+#include "ImageOperatorBase.h"
+#include "BaseTool.h"
+#include "GeoOperator.h"
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <omp.h>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <gdal.h>
+#include <gdal_utils.h>
+#include <gdal_priv.h>
+#include <gdalwarper.h>
+#include <proj.h>
+#include <string.h>
+#include <memory>
+#include <iostream>
+#include "FileOperator.h"
+#include <opencv2/opencv.hpp>
+#include <QMessageBox>
+#include <QDir>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <QProgressDialog>
+#include <gdal_priv.h>
+#include <ogr_spatialref.h>  // OGRSpatialReference 用于空间参考转换
+#include <gdal_alg.h>        // 用于 GDALWarp 操作
+
+
+
+void testOutAmpArr(QString filename, float* amp, long rowcount, long colcount)
+{
+
+
+	Eigen::MatrixXd h_amp_img = Eigen::MatrixXd::Zero(rowcount, colcount);
+
+	for (long hii = 0; hii < rowcount; hii++) {
+		for (long hjj = 0; hjj < colcount; hjj++) {
+			h_amp_img(hii, hjj) = amp[hii * colcount + hjj];
+		}
+	}
+	QString ampPath = getDebugDataPath(filename);
+	saveEigenMatrixXd2Bin(h_amp_img, ampPath);
+	qDebug() << filename.toLocal8Bit().constData();
+	qDebug() << "max:\t" << h_amp_img.maxCoeff();
+	qDebug() << "min:\t" << h_amp_img.minCoeff();
+}
+
+void testOutAmpArr(QString filename, double* amp, long rowcount, long colcount)
+{
+
+
+	Eigen::MatrixXd h_amp_img = Eigen::MatrixXd::Zero(rowcount, colcount);
+
+	for (long hii = 0; hii < rowcount; hii++) {
+		for (long hjj = 0; hjj < colcount; hjj++) {
+			h_amp_img(hii, hjj) = amp[hii * colcount + hjj];
+		}
+	}
+	QString ampPath = getDebugDataPath(filename);
+	saveEigenMatrixXd2Bin(h_amp_img, ampPath);
+	qDebug() << filename.toLocal8Bit().constData();
+	qDebug() << "max:\t" << h_amp_img.maxCoeff();
+	qDebug() << "min:\t" << h_amp_img.minCoeff();
+}
+
+
+void testOutClsArr(QString filename, long* amp, long rowcount, long colcount) {
+
+	Eigen::MatrixXd h_amp_img = Eigen::MatrixXd::Zero(rowcount, colcount);
+
+	for (long hii = 0; hii < rowcount; hii++) {
+		for (long hjj = 0; hjj < colcount; hjj++) {
+			h_amp_img(hii, hjj) = amp[hii * colcount + hjj];
+		}
+	}
+	QString ampPath = getDebugDataPath(filename);
+	saveEigenMatrixXd2Bin(h_amp_img, ampPath);
+	qDebug() << filename.toLocal8Bit().constData();
+	qDebug() << "max:\t" << h_amp_img.maxCoeff();
+	qDebug() << "min:\t" << h_amp_img.minCoeff();
+
+}
+
+void  testOutComplexDoubleArr(QString filename, std::complex<double>* data, long rowcount, long colcount)
+{
+	QString ampPath = getDebugDataPath(filename);
+	gdalImageComplex   compleximg = CreateEchoComplex(ampPath, rowcount, colcount, 1);
+	compleximg.saveImage(data, 0, 0, rowcount, colcount, 1);
+
+	return;
+}
+
+void  testOutDataArr(QString filename, double* data, long rowcount, long colcount)
+{
+	return testOutAmpArr(filename, data, rowcount, colcount);
+}
+
+void  testOutDataArr(QString filename, float* data, long rowcount, long colcount)
+{
+	return testOutAmpArr(filename, data, rowcount, colcount);
+}
+
+void  testOutDataArr(QString filename, long* data, long rowcount, long colcount)
+{
+	return testOutClsArr(filename, data, rowcount, colcount);
+}
+
+void testOutAntPatternTrans(QString antpatternfilename, double* antPatternArr,
+	double starttheta, double deltetheta,
+	double startphi, double deltaphi,
+	long thetanum, long phinum)
+{
+
+
+	Eigen::MatrixXd antPatternMatrix(thetanum, phinum);
+	for (long t = 0; t < thetanum; ++t) {
+		for (long p = 0; p < phinum; ++p) {
+			long index = t * phinum + p;
+			if (index < thetanum * phinum) {
+				antPatternMatrix(t, p) = static_cast<double>(antPatternArr[index]);  // Copy to Eigen matrix
+			}
+		}
+	}
+
+	Eigen::MatrixXd gt(2, 3);
+	gt(0, 0) = startphi;//x
+	gt(0, 1) = deltaphi;
+	gt(0, 2) = 0;
+
+	gt(1, 0) = starttheta;
+	gt(1, 1) = 0;
+	gt(1, 2) = deltetheta;
+
+	QString antpatternfilepath = getDebugDataPath(antpatternfilename);
+	gdalImage  ds = CreategdalImageDouble(antpatternfilepath, thetanum, phinum, 1, gt, "", true, true, true);
+	ds.saveImage(antPatternMatrix, 0, 0, 1);
+}
+
+
+
+
+
+

BaseTool/gdalImageComplexOperator.cpp

@@ -0,0 +1,547 @@
+#include "stdafx.h"
+#include "ImageOperatorBase.h"
+#include "BaseTool.h"
+#include "GeoOperator.h"
+#include <Eigen/Core>
+#include <Eigen/Dense>
+#include <omp.h>
+#include <io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <gdal.h>
+#include <gdal_utils.h>
+#include <gdal_priv.h>
+#include <gdalwarper.h>
+#include <proj.h>
+#include <string.h>
+#include <memory>
+#include <iostream>
+#include "FileOperator.h"
+#include <opencv2/opencv.hpp>
+#include <QMessageBox>
+#include <QDir>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <QProgressDialog>
+#include <gdal_priv.h>
+#include <ogr_spatialref.h>  // OGRSpatialReference 用于空间参考转换
+#include <gdal_alg.h>        // 用于 GDALWarp 操作
+
+
+
+
+
+
+
+
+
+gdalImageComplex::gdalImageComplex(const QString& raster_path)
+{
+	omp_lock_t lock;
+	omp_init_lock(&lock);
+	omp_set_lock(&lock);
+	this->img_path = raster_path;
+
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+	GDALDataset* rasterDataset = (GDALDataset*)(GDALOpen(
+		raster_path.toUtf8().constData(), GA_ReadOnly));
+	this->width = rasterDataset->GetRasterXSize();
+	this->height = rasterDataset->GetRasterYSize();
+	this->band_num = rasterDataset->GetRasterCount();
+
+	double* gt = new double[6];
+	rasterDataset->GetGeoTransform(gt);
+	this->gt = Eigen::MatrixXd(2, 3);
+	this->gt << gt[0], gt[1], gt[2], gt[3], gt[4], gt[5];
+
+	double a = this->gt(0, 0);
+	double b = this->gt(0, 1);
+	double c = this->gt(0, 2);
+	double d = this->gt(1, 0);
+	double e = this->gt(1, 1);
+	double f = this->gt(1, 2);
+
+	this->projection = rasterDataset->GetProjectionRef();
+
+	// 释放投影
+	GDALFlushCache((GDALDatasetH)rasterDataset);
+	GDALClose((GDALDatasetH)rasterDataset);
+	rasterDataset = NULL; // 指矫匡拷
+	this->InitInv_gt();
+	delete[] gt;
+	GDALDestroy(); // or, DllMain at DLL_PROCESS_DETACH
+	omp_unset_lock(&lock);	 // 锟酵放伙拷斤拷
+	omp_destroy_lock(&lock); // 劫伙拷斤拷
+}
+
+gdalImageComplex::~gdalImageComplex() {}
+
+void gdalImageComplex::setData(Eigen::MatrixXcd data)
+{
+	this->data = data;
+}
+
+void gdalImageComplex::saveImage(Eigen::MatrixXcd data, int start_row, int start_col, int band_ids)
+{
+
+
+
+	omp_lock_t lock;
+	omp_init_lock(&lock);
+	omp_set_lock(&lock);
+	if (start_row + data.rows() > this->height || start_col + data.cols() > this->width) {
+		QString tip = u8"file path: " + this->img_path;
+		qDebug() << tip;
+		throw std::exception(tip.toUtf8().constData());
+	}
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+	GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("ENVI");
+	GDALDataset* poDstDS = nullptr;
+	if (exists_test(this->img_path)) {
+		poDstDS = (GDALDataset*)(GDALOpen(this->img_path.toUtf8().constData(), GA_Update));
+	}
+	else {
+		poDstDS = poDriver->Create(this->img_path.toUtf8().constData(), this->width, this->height,
+			this->band_num, GDT_CFloat64, NULL); // 斤拷锟斤拷
+		poDstDS->SetProjection(this->projection.toUtf8().constData());
+
+		double gt_ptr[6];
+		for (int i = 0; i < this->gt.rows(); i++) {
+			for (int j = 0; j < this->gt.cols(); j++) {
+				gt_ptr[i * 3 + j] = this->gt(i, j);
+			}
+		}
+		poDstDS->SetGeoTransform(gt_ptr);
+		//delete[] gt_ptr;
+	}
+
+	int		datarows = data.rows();
+	int		datacols = data.cols();
+
+	if (this->getDataType() == GDT_CFloat64)
+	{
+
+		double* databuffer = new double[data.size() * 2];
+		for (int i = 0; i < data.rows(); i++) {
+			for (int j = 0; j < data.cols(); j++) {
+				databuffer[i * data.cols() * 2 + j * 2] = data(i, j).real();
+				databuffer[i * data.cols() * 2 + j * 2 + 1] = data(i, j).imag();
+			}
+		}
+
+		// poDstDS->RasterIO(GF_Write,start_col, start_row, datacols, datarows, databuffer, datacols,
+		// datarows, GDT_Float32,band_ids, num,0,0,0);
+		poDstDS->GetRasterBand(band_ids)->RasterIO(GF_Write, start_col, start_row, datacols, datarows,
+			databuffer, datacols, datarows, GDT_CFloat64, 0, 0);
+		GDALFlushCache(poDstDS);
+		delete databuffer;
+
+	}
+	else if (this->getDataType() == GDT_CFloat32) {
+
+		float* databuffer = new float[data.size() * 2];
+		for (int i = 0; i < data.rows(); i++) {
+			for (int j = 0; j < data.cols(); j++) {
+				databuffer[i * data.cols() * 2 + j * 2] = float(data(i, j).real());
+				databuffer[i * data.cols() * 2 + j * 2 + 1] =float( data(i, j).imag());
+			}
+		}
+
+		// poDstDS->RasterIO(GF_Write,start_col, start_row, datacols, datarows, databuffer, datacols,
+		// datarows, GDT_Float32,band_ids, num,0,0,0);
+		poDstDS->GetRasterBand(band_ids)->RasterIO(GF_Write, start_col, start_row, datacols, datarows,
+			databuffer, datacols, datarows, GDT_CFloat32, 0, 0);
+		GDALFlushCache(poDstDS);
+		delete databuffer;
+	}
+	else {
+		throw std::exception("gdalImageComplex::saveImage: data type error");
+	}
+
+
+
+	GDALClose((GDALDatasetH)poDstDS);
+	GDALDestroy(); // or, DllMain at DLL_PROCESS_DETACH
+	omp_unset_lock(&lock);	 //
+	omp_destroy_lock(&lock); //
+}
+
+void gdalImageComplex::saveImage(std::shared_ptr<std::complex<double>> data, long start_row, long start_col, long rowCount, long colCount, int band_ids)
+{
+	omp_lock_t lock;
+	omp_init_lock(&lock);
+	omp_set_lock(&lock);
+	if (start_row + rowCount > this->height || start_col + colCount > this->width) {
+		QString tip = u8"file path: " + this->img_path;
+		qDebug() << tip;
+		throw std::exception(tip.toUtf8().constData());
+		return;
+	}
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+	GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("ENVI");
+	GDALDataset* poDstDS = nullptr;
+	if (exists_test(this->img_path)) {
+		poDstDS = (GDALDataset*)(GDALOpen(this->img_path.toUtf8().constData(), GA_Update));
+	}
+	else {
+		poDstDS = poDriver->Create(this->img_path.toUtf8().constData(), this->width, this->height,
+			this->band_num, GDT_CFloat64, NULL); // 斤拷锟斤拷
+		poDstDS->SetProjection(this->projection.toUtf8().constData());
+
+		double gt_ptr[6];
+		for (int i = 0; i < this->gt.rows(); i++) {
+			for (int j = 0; j < this->gt.cols(); j++) {
+				gt_ptr[i * 3 + j] = this->gt(i, j);
+			}
+		}
+		poDstDS->SetGeoTransform(gt_ptr);
+		//delete[] gt_ptr;
+	}
+
+	double* databuffer = new double[rowCount * colCount * 2];
+	for (long i = 0; i < rowCount; i++) {
+		for (long j = 0; j < colCount; j++) {
+			databuffer[i * colCount * 2 + j * 2] = data.get()[i * colCount + j].real();
+			databuffer[i * colCount * 2 + j * 2 + 1] = data.get()[i * colCount + j].imag();
+		}
+	}
+
+	// poDstDS->RasterIO(GF_Write,start_col, start_row, datacols, datarows, databuffer, datacols,
+	// datarows, GDT_Float32,band_ids, num,0,0,0);
+	poDstDS->GetRasterBand(band_ids)->RasterIO(GF_Write, start_col, start_row, colCount, rowCount,
+		databuffer, colCount, rowCount, GDT_CFloat64, 0, 0);
+	GDALFlushCache(poDstDS);
+	delete databuffer;
+	GDALClose((GDALDatasetH)poDstDS);
+	GDALDestroy(); // or, DllMain at DLL_PROCESS_DETACH
+	omp_unset_lock(&lock);	 //
+	omp_destroy_lock(&lock); //
+
+}
+
+void gdalImageComplex::saveImage(std::complex<double>* data, long start_row, long start_col, long rowCount, long colCount, int band_ids)
+{
+	omp_lock_t lock;
+	omp_init_lock(&lock);
+	omp_set_lock(&lock);
+	if (start_row + rowCount > this->height || start_col + colCount > this->width) {
+		QString tip = u8"file path: " + this->img_path;
+		qDebug() << tip;
+		throw std::exception(tip.toUtf8().constData());
+		return;
+	}
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+	GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("ENVI");
+	GDALDataset* poDstDS = nullptr;
+	if (exists_test(this->img_path)) {
+		poDstDS = (GDALDataset*)(GDALOpen(this->img_path.toUtf8().constData(), GA_Update));
+	}
+	else {
+		poDstDS = poDriver->Create(this->img_path.toUtf8().constData(), this->width, this->height,
+			this->band_num, GDT_CFloat64, NULL); // 斤拷锟斤拷
+		poDstDS->SetProjection(this->projection.toUtf8().constData());
+
+		double gt_ptr[6];
+		for (int i = 0; i < this->gt.rows(); i++) {
+			for (int j = 0; j < this->gt.cols(); j++) {
+				gt_ptr[i * 3 + j] = this->gt(i, j);
+			}
+		}
+		poDstDS->SetGeoTransform(gt_ptr);
+		//delete[] gt_ptr;
+	}
+
+	double* databuffer = new double[rowCount * colCount * 2];
+	for (long i = 0; i < rowCount; i++) {
+		for (long j = 0; j < colCount; j++) {
+			databuffer[i * colCount * 2 + j * 2] = data[i * colCount + j].real();
+			databuffer[i * colCount * 2 + j * 2 + 1] = data[i * colCount + j].imag();
+		}
+	}
+
+	// poDstDS->RasterIO(GF_Write,start_col, start_row, datacols, datarows, databuffer, datacols,
+	// datarows, GDT_Float32,band_ids, num,0,0,0);
+	poDstDS->GetRasterBand(band_ids)->RasterIO(GF_Write, start_col, start_row, colCount, rowCount,
+		databuffer, colCount, rowCount, GDT_CFloat64, 0, 0);
+	GDALFlushCache(poDstDS);
+	delete databuffer;
+	GDALClose((GDALDatasetH)poDstDS);
+	GDALDestroy(); // or, DllMain at DLL_PROCESS_DETACH
+	omp_unset_lock(&lock);	 //
+	omp_destroy_lock(&lock); //
+}
+
+Eigen::MatrixXcd gdalImageComplex::getDataComplex(int start_row, int start_col, int rows_count,
+	int cols_count, int band_ids)
+{
+	GDALDataset* poDataset;
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+
+	// 打开TIFF文件
+	poDataset = (GDALDataset*)GDALOpen(this->img_path.toUtf8().constData(), GA_ReadOnly);
+	if (poDataset == nullptr) {
+		QMessageBox::warning(nullptr, u8"错误", u8"无法打开文件：" + this->img_path);
+		qDebug() << u8"无法打开文件：" + this->img_path;
+	}
+
+	// 获取数据集的第一个波段
+	GDALRasterBand* poBand;
+	poBand = poDataset->GetRasterBand(1);
+	rows_count = start_row + rows_count <= this->height ? rows_count : this->height - start_row;
+	cols_count = start_col + cols_count <= this->width ? cols_count : this->width - start_col;
+	// 读取波段信息，假设是复数类型
+	int		nXSize = cols_count; poBand->GetXSize();
+	int		nYSize = rows_count; poBand->GetYSize();
+	Eigen::MatrixXcd rasterData(nYSize, nXSize); // 使用Eigen的MatrixXcd
+	if (this->getDataType() == GDT_CFloat64)
+	{
+		long long pixelCount =long long( nXSize) *long long( nYSize);
+		double* databuffer = new double[pixelCount * 2];
+		poBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, databuffer, cols_count, rows_count, GDT_CFloat64, 0, 0);
+		GDALClose((GDALDatasetH)poDataset);
+
+		for (long long i = 0; i < nYSize; i++) {
+			for (long long j = 0; j < nXSize; j++) {
+				rasterData(i, j) = std::complex<double>(databuffer[i * nXSize * 2 + j * 2],
+					databuffer[i * nXSize * 2 + j * 2 + 1]);
+			}
+		}
+
+		delete[] databuffer;
+	}
+	else if(this->getDataType()==GDT_CFloat32)
+	{
+		long long pixelCount = long long(nXSize) * long long(nYSize);
+		float* databuffer = new float[pixelCount * 2];
+		poBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, databuffer, cols_count, rows_count, GDT_CFloat32, 0, 0);
+		GDALClose((GDALDatasetH)poDataset);
+
+		for (long long i = 0; i < nYSize; i++) {
+			for (long long j = 0; j < nXSize; j++) {
+				rasterData(i, j) = std::complex<double>(databuffer[i * nXSize * 2 + j * 2],
+					databuffer[i * nXSize * 2 + j * 2 + 1]);
+			}
+		}
+
+		delete[] databuffer;
+	}
+
+
+	return rasterData;
+}
+
+std::shared_ptr<std::complex<double>> gdalImageComplex::getDataComplexSharePtr(int start_row, int start_col, int rows_count, int cols_count, int band_ids)
+{
+	GDALDataset* poDataset;
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+
+	// 打开TIFF文件
+	poDataset = (GDALDataset*)GDALOpen(this->img_path.toUtf8().constData(), GA_ReadOnly);
+	if (poDataset == nullptr) {
+		QMessageBox::warning(nullptr, u8"错误", u8"无法打开文件：" + this->img_path);
+		qDebug() << u8"无法打开文件：" + this->img_path;
+	}
+
+	// 获取数据集的第一个波段
+	GDALRasterBand* poBand;
+	poBand = poDataset->GetRasterBand(1);
+
+	// 读取波段信息，假设是复数类型
+
+
+	double* databuffer = new double[rows_count * cols_count * 2];
+	poBand->RasterIO(GF_Read, start_col, start_row, cols_count, rows_count, databuffer, cols_count,
+		rows_count, GDT_CFloat64, 0, 0);
+	GDALClose((GDALDatasetH)poDataset);
+
+	std::shared_ptr<std::complex<double>> rasterData(new std::complex<double>[rows_count * cols_count], delArrPtr);
+
+	for (size_t i = 0; i < rows_count; i++) {
+		for (size_t j = 0; j < cols_count; j++) {
+			rasterData.get()[i * cols_count + j] = std::complex<double>(databuffer[i * cols_count * 2 + j * 2],
+				databuffer[i * cols_count * 2 + j * 2 + 1]);
+		}
+	}
+
+	delete[] databuffer;
+	return rasterData;
+}
+
+void gdalImageComplex::saveComplexImage()
+{
+	this->saveImage(this->data, this->start_row, this->start_col, this->data_band_ids);
+}
+void gdalImageComplex::savePreViewImage()
+{
+	qDebug() << "void gdalImageComplex::savePreViewImage()";
+	Eigen::MatrixXd data_abs = Eigen::MatrixXd::Zero(this->height, this->width);
+	data_abs = (this->data.array().real().pow(2) + this->data.array().imag().pow(2))
+		.array()
+		.log10() * 10.0; // 计算振幅
+
+	double				   min_abs = data_abs.minCoeff();		 // 最大值
+	double				   max_abs = data_abs.maxCoeff();		 // 最小值
+	double				   delta = (max_abs - min_abs) / 1000; // 1000分位档
+	Eigen::MatrixX<size_t> data_idx =
+		((data_abs.array() - min_abs).array() / delta).array().floor().cast<size_t>();
+
+	// 初始化
+	double hist[1001];
+	for (size_t i = 0; i < 1001; i++) {
+		hist[i] = 0; // 初始化
+	}
+	for (size_t i = 0; i < this->height; i++) {
+		for (size_t j = 0; j < this->width; j++) {
+			hist[data_idx(i, j)]++;
+		}
+	}
+
+	// 统计
+	size_t count = this->height * this->width;
+	double precent = 0;
+	size_t curCount = 0;
+	double pre2 = 0;
+	bool   findprec_2 = true;
+	double pre98 = 0;
+	bool   findprec_98 = true;
+	for (size_t i = 0; i < 1001; i++) {
+		precent = precent + hist[i];
+		if (findprec_2 & precent / count > 0.02) {
+			pre2 = i * delta + min_abs;
+			findprec_2 = false;
+		}
+		if (findprec_98 & precent / count > 0.98) {
+			pre98 = (i - 1) * delta + min_abs;
+			findprec_98 = false;
+		}
+	}
+	// 拉伸
+	delta = (pre98 - pre2) / 200;
+	data_idx =
+		((data_abs.array() - pre2).array() / delta).array().floor().cast<size_t>();
+
+	for (size_t i = 0; i < this->height; i++) {
+		for (size_t j = 0; j < this->width; j++) {
+			if (data_idx(i, j) < 0) {
+				data_idx(i, j) = 0;
+			}
+			else if (data_idx(i, j) > 255) {
+				data_idx(i, j) = 255;
+			}
+			else {
+
+			}
+		}
+	}
+
+	// 赋值
+	QString	  filePath = this->img_path;
+	QFile	  file(filePath);
+	QFileInfo fileInfo(file);
+
+	QString	  directory = fileInfo.absolutePath();
+	qDebug() << "文件所在目录：" << directory;
+	QString baseName = fileInfo.completeBaseName();
+	qDebug() << "无后缀文件名：" << baseName;
+
+	// 创建文件路径
+	QString			previewImagePath = JoinPath(directory, baseName + "_preview.png");
+	cv::Mat			img(this->height, this->width, CV_8U, cv::Scalar(0));
+
+	for (size_t i = 0; i < this->height; i++) {
+		for (size_t j = 0; j < this->width; j++) {
+			img.at<uchar>(i, j) = (uchar)(data_idx(i, j));
+		}
+	}
+	//std::string outimgpath=previewImagePath.toUtf8().data();
+	cv::imwrite(previewImagePath.toUtf8().data(), img);
+}
+
+
+
+gdalImageComplex CreategdalImageComplex(const QString& img_path, int height, int width,
+	int band_num, Eigen::MatrixXd gt, QString projection,
+	bool need_gt, bool overwrite)
+{
+	if (exists_test(img_path.toUtf8().constData())) {
+		if (overwrite) {
+			gdalImageComplex result_img(img_path);
+			return result_img;
+		}
+		else {
+			throw "file has exist!!!";
+			exit(1);
+		}
+	}
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+	GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("ENVI");
+	GDALDataset* poDstDS = poDriver->Create(img_path.toUtf8().constData(), width, height, band_num,
+		GDT_CFloat64, NULL);
+	if (need_gt) {
+		poDstDS->SetProjection(projection.toUtf8().constData());
+
+		// 锟斤拷锟斤拷转锟斤拷锟斤拷锟斤拷
+		double gt_ptr[6] = { 0 };
+		for (int i = 0; i < gt.rows(); i++) {
+			for (int j = 0; j < gt.cols(); j++) {
+				gt_ptr[i * 3 + j] = gt(i, j);
+			}
+		}
+		poDstDS->SetGeoTransform(gt_ptr);
+	}
+	//for(int i = 1; i <= band_num; i++) {
+	//	poDstDS->GetRasterBand(i)->SetNoDataValue(0); // 回波部分
+	//}
+	GDALFlushCache((GDALDatasetH)poDstDS);
+	GDALClose((GDALDatasetH)poDstDS);
+	GDALDestroy(); // or, DllMain at DLL_PROCESS_DETACH
+	gdalImageComplex result_img(img_path);
+	return result_img;
+}
+
+gdalImageComplex  CreategdalImageComplexNoProj(const QString& img_path, int height, int width, int band_num, bool overwrite)
+{
+
+	// 创建新文件
+	omp_lock_t lock;
+	omp_init_lock(&lock);
+	omp_set_lock(&lock);
+	GDALAllRegister();
+	CPLSetConfigOption("GDAL_FILENAME_IS_UTF8", "YES");
+
+	GDALDriver* poDriver = GetGDALDriverManager()->GetDriverByName("ENVI");
+	GDALDataset* poDstDS = (poDriver->Create(img_path.toUtf8().constData(), width, height, band_num, GDT_CFloat64, NULL));
+	GDALFlushCache((GDALDatasetH)poDstDS);
+	GDALClose((GDALDatasetH)poDstDS);
+	//poDstDS.reset();
+	omp_unset_lock(&lock);	 //  
+	omp_destroy_lock(&lock); //  
+
+	gdalImageComplex result_img(img_path);
+	return result_img;
+}
+
+gdalImageComplex CreateEchoComplex(const QString& img_path, int height, int width, int band_num)
+{
+	// 创建图像
+	Eigen::MatrixXd gt = Eigen::MatrixXd::Zero(2, 3);
+	//Xgeo = GeoTransform[0] + Xpixel * GeoTransform[1] + Ypixel * GeoTransform[2]
+	//Ygeo = GeoTransform[3] + Xpixel * GeoTransform[4] + Ypixel * GeoTransform[5]
+	// X
+	gt(0, 0) = 0; gt(0, 2) = 1; gt(0, 2) = 0;
+	gt(1, 0) = 0; gt(1, 1) = 0; gt(1, 2) = 1;
+	// Y
+	QString projection = "";
+	gdalImageComplex echodata = CreategdalImageComplex(img_path, height, width, 1, gt, projection, false, true);
+	return echodata;
+
+}
+

BaseTool/stdafx.cpp

@@ -0,0 +1 @@
+#include "stdafx.h"

ToolAbstract/QToolAbstract.cpp

@@ -0,0 +1,41 @@
+#include "QToolAbstract.h"
+
+QToolAbstract::QToolAbstract(QObject* parent)
+:QObject(parent)
+{
+
+}
+
+QToolAbstract::~QToolAbstract()
+{
+
+}
+
+void QToolAbstract::setToolXpath(QVector<QString> intoolPath)
+{
+	this->toolPath = intoolPath;
+}
+
+void QToolAbstract::setToolName(QString intoolname)
+{
+	this->toolname = intoolname;
+}
+
+QVector<QString> QToolAbstract::getToolXpath()
+{
+	return this->toolPath;
+}
+
+QString QToolAbstract::getToolName()
+{
+	return this->toolname;
+}
+
+void QToolAbstract::excute()
+{
+	this->run();
+}
+
+void QToolAbstract::run()
+{
+}

ToolAbstract/QToolAbstract.h

@@ -0,0 +1,40 @@
+#pragma once
+#ifndef QToolAbstract_H_
+#define QToolAbstract_H_
+
+#include "BaseConstVariable.h"
+#include <QTreeWidgetItem>
+#include <QPushButton>
+#include <QMessageBox>
+#include <QDebug>
+#include <QWidget>
+#include <QItemDelegate>
+#include <QString>
+
+
+// 菱땍屢 QTreeWidgetItem 셨넓잚
+class BASECONSTVARIABLEAPI QToolAbstract : public QObject {
+    Q_OBJECT
+public:
+    QToolAbstract(QObject* parent=nullptr);
+    ~QToolAbstract();
+public slots:
+   virtual  void excute();
+   virtual void setToolXpath(QVector<QString> toolPath);
+   virtual void setToolName(QString toolname);
+   virtual QVector<QString> getToolXpath();
+   virtual QString getToolName();
+public:
+    QVector<QString> toolPath;
+    QString toolname;
+public:
+	virtual void run();
+};
+
+/*
+// 鬧꿍묏야芎
+PluginTool_*.dll
+void RegisterPreToolBox(RasterProcessTool* mainWindows);
+extern "C" void RegisterPreToolBox(LAMPMainWidget::RasterMainWidget* mainwindows,ToolBoxWidget* toolbox);
+*/
+#endif // !1