KJ135
/
BaseLibraryCPP
mirror of http://172.16.0.12:5000/LAMPSARToolSoftware/BaseLibraryCPP.git
4
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

代码初始化

main
陈增辉 2024-11-15 09:38:46 +08:00
commit 1093d8febc
20 changed files with 5858 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
BaseConstVariable.h Normal file
View File

@ -0,0 +1,129 @@
#pragma once
#ifndef BASECONSTVARIABLE_H
#define BASECONSTVARIABLE_H
#define EIGEN_USE_MKL_ALL
//#define EIGEN_NO_DEBUG
#define EIGEN_USE_BLAS
#define EIGEN_USE_LAPACK
#define EIGEN_VECTORIZE_SSE2
//#define DEBUGSHOWDIALOG
//#include <mkl.h>
#include <complex>
#include <math.h>
#include <complex>
#define PI_180 180/3.141592653589793238462643383279
#define T180_PI 3.141592653589793238462643383279/180
#define LIGHTSPEED 299792458
#define PRECISIONTOLERANCE 1e-9
#define Radians2Degrees(Radians) Radians*PI_180
#define Degrees2Radians(Degrees) Degrees*T180_PI
#define MATPLOTDRAWIMAGE
#define earthRoute 0.000072292115
#define Memory1GB 1073741824
#define Memory1MB 1048576
#define Memory1KB 1024
const std::complex<double> imagI(0, 1);
const double PI = 3.141592653589793238462643383279;
const double epsilon = 0.000000000000001;
const double pi = 3.14159265358979323846;
const double d2r = pi / 180;
const double r2d = 180 / pi;
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;
/*********************************************** 基础枚举 ********************************************************************/
enum POLARTYPEENUM { // 极化类型
POLARHH,
POLARHV,
POLARVH,
POLARVV
};
/*********************************************** 基础结构体区域 ********************************************************************/
/// <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;
};
/*********************************************** FEKO仿真参数 ********************************************************************/
struct SatelliteAntPos {
double time;
double Px;
double Py;
double Pz;
double Vx;
double Vy;
double Vz;
double AntDirectX;
double AntDirectY;
double AntDirectZ;
double AVx;
double AVy;
double AVz;
double lon;
double lat;
double ati;
};
/*********************************************** 指针回收区域 ********************************************************************/
inline void delArrPtr(void* p)
{
delete[] p;
p = nullptr;
}
inline void delPointer(void* p)
{
delete p;
p = nullptr;
}
#endif

542
BaseTool.cpp Normal file
View File

@ -0,0 +1,542 @@
#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 <string>
#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>
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] <= 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;
}

112
BaseTool.h Normal file
View File

@ -0,0 +1,112 @@
#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"
///////////////////////////////////// 运行时间打印
/////////////////////////////////////////////////////////////
QString getCurrentTimeString();
QString getCurrentShortTimeString();
std::vector<QString> splitString(const QString& str, char delimiter);
std::vector<QString> convertQStringListToStdVector(const QStringList& qStringList);
/////////////////////////////// 基本图像类 结束
/////////////////////////////////////////////////////////////
std::string Convert(float Num);
QString JoinPath(const QString& path, const QString& filename);
////////////////////////////// 坐标部分基本方法 //////////////////////////////////////////
////////////////////////////// 坐标部分基本方法 //////////////////////////////////////////
////////////////////////////// 插值 ////////////////////////////////////////////
std::complex<double> Cubic_Convolution_interpolation(double u, double v,
Eigen::MatrixX<std::complex<double>> img);
std::complex<double> Cubic_kernel_weight(double s);
double Bilinear_interpolation(Landpoint p0, Landpoint p11, Landpoint p21, Landpoint p12,
Landpoint p22);
bool onSegment(Point3 Pi, Point3 Pj, Point3 Q);
Point3 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 sind(double degree);
double cosd(double d);
// 插值
ErrorCode polyfit(const double* x, const double* y, int xyLength, int poly_n, std::vector<double>& out_factor, double& out_chisq);
// 叉乘
Point3 crossProduct(const Point3& a, const Point3& b);
Eigen::Matrix3d rotationMatrix(const Eigen::Vector3d& axis, double angle);
long double convertToMilliseconds(const std::string& dateTimeStr);
/// <summary>
/// list 应该是按照从小到大的顺序排好
/// </summary>
/// <param name="list"></param>
/// <param name="findv"></param>
/// <returns></returns>
long FindValueInStdVector(std::vector<double>& list,double& findv);
long InsertValueInStdVector(std::vector<double>& list, double insertValue, bool repeatValueInsert = false);
long FindValueInStdVectorLast(std::vector<double>& list, double& findv);
#endif

613
EchoDataFormat.cpp Normal file
View File

@ -0,0 +1,613 @@
#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");
std::shared_ptr<GDALDataset> poDstDS(poDriver->Create(this->GPSPointFilePath.toUtf8().constData(), 16, PluseCount, 1, GDT_Float64, NULL));
GDALFlushCache((GDALDatasetH)poDstDS.get());
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");
std::shared_ptr<GDALDataset> poDstDS(poDriver->Create(this->echoDataFilePath.toUtf8().constData(), PlusePoints, PluseCount, 1, GDT_CFloat64, NULL));
GDALFlushCache((GDALDatasetH)poDstDS.get());
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;
}
}
QString EchoL0Dataset::getxmlName()
{
return xmlname;
}
QString EchoL0Dataset::getGPSPointFilename()
{
return GPSPointFilename;
}
QString EchoL0Dataset::getEchoDataFilename()
{
return GPSPointFilePath;
}
// 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;
}
SatelliteAntPos EchoL0Dataset::getSatelliteAntPos(long prf_id)
{
std::shared_ptr<double> antpos = this->getAntPos();
SatelliteAntPos prfpos{};
prfpos.time = antpos.get()[prf_id * 16 + 0];
prfpos.Px = antpos.get()[prf_id * 16 + 1];
prfpos.Py = antpos.get()[prf_id * 16 + 2];
prfpos.Pz = antpos.get()[prf_id * 16 + 3];
prfpos.Vx = antpos.get()[prf_id * 16 + 4];
prfpos.Vy = antpos.get()[prf_id * 16 + 5];
prfpos.Vz = antpos.get()[prf_id * 16 + 6];
prfpos.AntDirectX = antpos.get()[prf_id * 16 + 7];
prfpos.AntDirectY = antpos.get()[prf_id * 16 + 8];
prfpos.AntDirectZ = antpos.get()[prf_id * 16 + 9];
prfpos.AVx = antpos.get()[prf_id * 16 + 10];
prfpos.AVy = antpos.get()[prf_id * 16 + 11];
prfpos.AVz =antpos.get()[prf_id * 16 + 12];
prfpos.lon =antpos.get()[prf_id * 16 + 13];
prfpos.lat =antpos.get()[prf_id * 16 + 14];
prfpos.ati =antpos.get()[prf_id * 16 + 15];
return prfpos;
}
// 打印信息的实现
void EchoL0Dataset::printInfo() {
std::cout << "Simulation Task Name: " << this->simulationTaskName.toStdString() << std::endl;
std::cout << "Pulse Count: " << this->PluseCount << std::endl;
std::cout << "Pulse Points: " << this->PlusePoints << std::endl;
std::cout << "Near Range: " << this->NearRange << std::endl;
std::cout << "Far Range: " << this->FarRange << std::endl;
std::cout << "Center Frequency: " << this->centerFreq << std::endl;
std::cout << "Sampling Frequency: " << this->Fs << std::endl;
}
// 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("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.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 == "PluseCount") {
this->PluseCount = xmlReader.readElementText().toLong();
PluseCountflag = true;
}
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 == "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<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 * 16],delArrPtr);
demBand->RasterIO(GF_Read, 0, 0, 16, this->PluseCount, temp.get(), 16, 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();
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::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, 16, this->PluseCount, ptr.get(), 16, 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);
std::shared_ptr<GDALDataset> rasterDataset = OpenDataset(this->echoDataFilePath, 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.get());
}
else {
qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
}
}
rasterDataset.reset();
omp_unset_lock(&lock); //
omp_destroy_lock(&lock); //
return ErrorCode::SUCCESS;
}

190
EchoDataFormat.h Normal file
View File

@ -0,0 +1,190 @@
#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 getPluseDataSize(PluseData& pluseData);
ErrorCode getPluseDataFromBuffer(char* buffer, PluseData& data);
std::shared_ptr<PluseData> CreatePluseDataArr(long pluseCount);
std::shared_ptr<std::complex<double>> 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> CreatePluseAntPosArr(long pluseCount);
// 定义L0级数据
class 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();
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);
SatelliteAntPos getSatelliteAntPos(long plusePRFID);
// 打印信息的成员函数
void printInfo() ;
private: // 回波变量
long PluseCount;
long PlusePoints;
double NearRange;
double FarRange;
double centerFreq; // 入射中心频率
double Fs; // 等效采样频率
QString simulationTaskName;
double CenterAngle;
QString LookSide;
public: // 读写 XML 的函数
void saveToXml();
ErrorCode loadFromXml();
public:
// 读取文件
std::shared_ptr<double> getAntPos();
std::shared_ptr<std::complex<double>> getEchoArr(long startPRF, long PRFLen);
std::shared_ptr<std::complex<double>> getEchoArr();
//保存文件
ErrorCode saveAntPos(std::shared_ptr<double> ptr); // 注意这个方法很危险，请写入前检查数据是否正确
ErrorCode saveEchoArr(std::shared_ptr<std::complex<double>> echoPtr, long startPRF, long PRFLen);
};

195
FileOperator.cpp Normal file
View File

@ -0,0 +1,195 @@
#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>
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();
}
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"));
}
}

49
FileOperator.h Normal file
View File

@ -0,0 +1,49 @@
#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>
bool isDirectory(const QString& path);
bool isExists(const QString& path);
bool isFile(const QString& path);
void removeFile(const QString& filePath);
unsigned long convertToULong(const QString& input);
/// <summary>
/// 获取文件(绝对路径）
/// </summary>
/// <param name="folderpath"></param>
/// <param name="FilenameExtension"></param>
/// <returns></returns>
std::vector<QString> getFilelist(const QString& folderpath, const QString& FilenameExtension = ".*",int (*logfun)(QString logtext,int value)=nullptr);
QString getParantFolderNameFromPath(const QString& path);
QString getFileNameFromPath(const QString& path);
int write_binfile(char* filepath, char* data, size_t data_len);
char* read_textfile(char* text_path, int* length);
bool exists_test(const QString& name);
size_t fsize(FILE* fp);
QString getParantFromPath(const QString& path);
void copyFile(const QString& sourcePath, const QString& destinationPath);
// QT FileOperator
#endif

410
GeoOperator.cpp Normal file
View File

@ -0,0 +1,410 @@
#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"
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;
}
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));
}
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 };
// 计算点到直线的投影点的ä½<C3A4>ç½?
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 };
// 计算点到直线的è·<C3A8>ç¦?
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);
//std::cout << 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);
//std::cout << R << endl;
double angle = getAngle(Rsc, slopeVector);
if (angle >= 180) {
return 360 - angle;
}
else {
return angle;
}
}

126
GeoOperator.h Normal file
View File

@ -0,0 +1,126 @@
#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 LLA2XYZ(const Landpoint& LLA);
void LLA2XYZ(const Landpoint& LLA,Point3& XYZ);
Eigen::MatrixXd LLA2XYZ(Eigen::MatrixXd landpoint);
/// <summary>
/// 将地固参心坐标系转换为经纬度
/// </summary>
/// <param name="XYZ">固参心坐标系</param>
/// <returns>经纬度--degree</returns>
Landpoint XYZ2LLA(const Landpoint& XYZ);
Landpoint operator +(const Landpoint& p1, const Landpoint& p2);
Landpoint operator -(const Landpoint& p1, const Landpoint& p2);
bool operator ==(const Landpoint& p1, const Landpoint& p2);
Landpoint operator *(const Landpoint& p, double scale);
double getAngle(const Landpoint& a, const Landpoint& b);
double dot(const Landpoint& p1, const Landpoint& p2);
double getlength(const Landpoint& p1);
Landpoint crossProduct(const Landpoint& a, const Landpoint& b);
Landpoint getSlopeVector(const Landpoint& p0, const Landpoint& p1, const Landpoint& p2, const Landpoint& p3, const Landpoint& p4, bool inLBH=true);
double getlocalIncAngle(Landpoint& satepoint, Landpoint& landpoint, Landpoint& slopeVector);
float cross2d(Point3 a, Point3 b);
Point3 operator -(Point3 a, Point3 b);
Point3 operator +(Point3 a, Point3 b);
double operator /(Point3 a, Point3 b);
// 矢量计算
struct Vector3D {
double x, y, z;
};
// 计算两点之间的距离
double distance(const Vector3D& p1, const Vector3D& p2);
// 计算点到直线的最短距离
double pointToLineDistance(const Vector3D& point, const Vector3D& linePoint, const Vector3D& lineDirection);
Vector3D operator +(const Vector3D& p1, const Vector3D& p2);
Vector3D operator -(const Vector3D& p1, const Vector3D& p2);
bool operator ==(const Vector3D& p1, const Vector3D& p2);
Vector3D operator *(const Vector3D& p, double scale);
Vector3D operator *(double scale,const Vector3D& p );
double getAngle(const Vector3D& a, const Vector3D& b);
double getCosAngle(const Vector3D& a, const Vector3D& b);
double dot(const Vector3D& p1, const Vector3D& p2);
double getlength(const Vector3D& p1);
Vector3D 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 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 cartesianToSpherical(const CartesianCoordinates& cartesian);
CartesianCoordinates sphericalToCartesian(const SphericalCoordinates& spherical);
double getlocalIncAngle(Vector3D& satepoint, Vector3D& landpoint, Vector3D& slopeVector);
#endif

1512
ImageOperatorBase.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

352
ImageOperatorBase.h Normal file
View File

@ -0,0 +1,352 @@
#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()
struct ImageGEOINFO {
int width;
int height;
int bandnum;
};
enum GDALREADARRCOPYMETHOD {
MEMCPYMETHOD, // 直接拷贝
VARIABLEMETHOD // 变量赋值
};
// 判断是否需要输出为DLL
#define DLLOUT
// 文件打开 // 当指令销毁时，调用GDALClose 销毁类型
std::shared_ptr<GDALDataset> OpenDataset(const QString& in_path, GDALAccess rwmode= GA_ReadOnly);
void CloseDataset(GDALDataset* ptr);
// 数据格式转换
int TIFF2ENVI(QString in_tiff_path,QString out_envi_path);
int ENVI2TIFF(QString in_envi_path,QString out_tiff_path);
// 保存影像数据 --直接保存 ENVI 文件
int CreateDataset(QString new_file_path, int height, int width, int band_num, double* gt, QString projection, GDALDataType gdal_dtype, bool need_gt); // 创建文件
int saveDataset(QString new_file_path, int start_line, int start_cols, int band_ids, int datacols, int datarows, void* databuffer);
// 根据限制条件估算分块大小
int block_num_pre_memory(int width, int height, GDALDataType gdal_dtype,double memey_size);
// 将结果转换为复数 或者 实数
Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> 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> ReadMatrixDoubleData(int start_line, int width, int line_num, std::shared_ptr<GDALDataset> rasterDataset, GDALDataType gdal_datatype,int band_idx);
Eigen::MatrixXd getGeoTranslationArray(QString in_path);
ImageGEOINFO getImageINFO(QString in_path);
GDALDataType getGDALDataType(QString fileptah);
struct DemBox {
double min_lat; //纬度
double min_lon;//经度
double max_lat;//纬度
double max_lon;//经度
};
/// <summary>
/// gdalImage图像操作类
/// </summary>
class 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::MatrixXd getGeoTranslation();
virtual GDALDataType getDataType();
virtual void saveImage(Eigen::MatrixXd, int start_row, int start_col, int band_ids);
virtual void saveImage();
virtual void setNoDataValue(double nodatavalue, 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);
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 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);
Eigen::MatrixXcd getDataComplex(int start_row, int start_col, int rows_count, int cols_count, int band_ids);
void saveImage() override;
void savePreViewImage();
public:
Eigen::MatrixXcd data;
};
// 创建影像
gdalImage CreategdalImage(const QString& img_path, int height, int width, int band_num, Eigen::MatrixXd gt, QString projection, bool need_gt = true, bool overwrite = false);
gdalImageComplex 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 CreateEchoComplex(const QString& img_path, int height, int width, int band_num);
int ResampleGDAL(const char* pszSrcFile, const char* pszOutFile, double* gt, int new_width, int new_height, GDALResampleAlg eResample);
int ResampleGDALs(const char* pszSrcFile, int band_ids, GDALRIOResampleAlg eResample = GRIORA_Bilinear);
int alignRaster(QString inputPath, QString referencePath, QString outputPath, GDALResampleAlg eResample);
//--------------------- 保存文博 -------------------------------
int saveMatrixXcd2TiFF(Eigen::MatrixXcd data, QString out_tiff_path);
//----------------------------------------------------
template<typename T>
std::shared_ptr<T> readDataArr(gdalImage &img,int start_row, int start_col, int rows_count, int cols_count, int band_ids, GDALREADARRCOPYMETHOD method);
#ifndef DLLOUT
#else
//#define DllExport __declspec( dllexport )
//double __declspec(dllexport) ProcessMGCMathX_MGC(int Xbetaidx, int Xbwidx, double XTao, double satH, char* sigma_path, char* output_path,
// double p1_x, double p1_y, double p2_x, double p2_y, double p3_x, double p3_y, double p4_x, double p4_y)
#endif
#endif
template<typename T>
std::shared_ptr<T> readDataArr(gdalImage& imgds, int start_row, int start_col, int rows_count, int 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;
Eigen::MatrixXd datamatrix(rows_count, cols_count);
if (gdal_datatype == GDT_Byte) {
char* temp = new char[rows_count * cols_count];
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[rows_count * cols_count], delArrPtr);
if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
std::memcpy(result.get(), temp, rows_count * cols_count);
}
else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
long count = rows_count * cols_count;
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[rows_count * cols_count];
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[rows_count * cols_count], delArrPtr);
if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
std::memcpy(result.get(), temp, rows_count * cols_count);
}
else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
long count = rows_count * cols_count;
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[rows_count * cols_count];
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[rows_count * cols_count], delArrPtr);
if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
std::memcpy(result.get(), temp, rows_count * cols_count);
}
else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
long count = rows_count * cols_count;
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[rows_count * cols_count];
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[rows_count * cols_count], delArrPtr);
if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
std::memcpy(result.get(), temp, rows_count * cols_count);
}
else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
long count = rows_count * cols_count;
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[rows_count * cols_count];
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[rows_count * cols_count], delArrPtr);
if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
std::memcpy(result.get(), temp, rows_count * cols_count);
}
else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
long count = rows_count * cols_count;
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[rows_count * cols_count];
// 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[rows_count * cols_count];
// 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[rows_count * cols_count];
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[rows_count * cols_count], delArrPtr);
if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
std::memcpy(result.get(), temp, rows_count * cols_count);
}
else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
long count = rows_count * cols_count;
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[rows_count * cols_count];
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[rows_count * cols_count], delArrPtr);
if (method == GDALREADARRCOPYMETHOD::MEMCPYMETHOD) {
std::memcpy(result.get(), temp, rows_count * cols_count);
}
else if (method == GDALREADARRCOPYMETHOD::VARIABLEMETHOD) {
long count = rows_count * cols_count;
for (long i = 0; i < count; i++) {
result.get()[i] = T(temp[i]);
}
}
delete[] temp;
}
else {
}
GDALClose((GDALDatasetH)rasterDataset);
omp_unset_lock(&lock); // 锟酵放伙拷斤拷
omp_destroy_lock(&lock); // 劫伙拷斤拷
// GDALDestroy(); // or, DllMain at DLL_PROCESS_DETACH
return result;
}

495
ImageShowDialogClass.cpp Normal file
View File

@ -0,0 +1,495 @@
#include "stdafx.h"
#include "ImageShowDialogClass.h"
#include "ui_ImageShowDialogClass.h"
ImageShowDialogClass ::ImageShowDialogClass(QWidget *parent)
: QDialog(parent)
{
ui=new Ui::ImageShowDialogClass;
ui->setupUi(this);
ui->m_plot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
connect(this->ui->m_plot, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(updateCursor(QMouseEvent*)));
this->graphclass=LAMPDATASHOWCLASS::NOWINDOWS;
this->menubar = new QMenuBar(this);
QMenu* windowsMenu = this->menubar->addMenu(u8"数据");
QAction* action_cursor_enable = windowsMenu->addAction(u8"打开游标");
QObject::connect(action_cursor_enable,SIGNAL(triggered()),this,SLOT(on_action_cursor_enable_trigged()));
this->tracer=new QCPItemTracer(this->ui->m_plot);
this->m_plot = ui->m_plot;
this->desCursor = nullptr;
this->HlineCursor = nullptr;
this->VlineCursor = nullptr;
this->desCursorflag=false;
this->HlineCursorflag=false;
this->VlineCursorflag = false;
this->statusbar=new QStatusBar(this);
this->statusbar->setMaximumHeight(20);
this->statusbar->setMinimumHeight(20);
ui->verticalLayout->setMenuBar(this->menubar);
ui->verticalLayout->addWidget(this->statusbar);
this->setLayout(ui->verticalLayout);
}
ImageShowDialogClass::~ImageShowDialogClass()
{}
void ImageShowDialogClass::on_action_cursor_enable_trigged()
{
this->desCursor = new ImageShowCursorDesClass(this);
this->desCursorflag = true;
for (size_t i = 0; i < this->getGraphCount(); i++) {
if (this->getGraphClass(i) == LAMPDATASHOWCLASS::LAMPColorMap) {
this->HlineCursorflag = true;
this->VlineCursorflag = true;
}
}
//下面的代码就是设置游标的外观
this->setMouseTracking(true);
tracer->setInterpolating(false);//禁用插值
tracer->setPen(QPen(Qt::DashLine));//虚线游标
tracer->setStyle(QCPItemTracer::tsPlus);//游标样式：十字星、圆圈、方框
tracer->setBrush(Qt::red);//游标颜色
if (this->graphclass == LAMPDATASHOWCLASS::LAMPColorMap) {
this->HlineCursor = new ImageShowCursorLineClass(this);
this->VlineCursor = new ImageShowCursorLineClass(this);
QObject::connect(this->HlineCursor, SIGNAL(windowsClose()), this, SLOT(on_action_Hlinecursor_close_trigged()));
QObject::connect(this->VlineCursor, SIGNAL(windowsClose()), this, SLOT(on_action_VVlinecursor_close_trigged()));
QObject::connect(this->ui->m_plot->xAxis, SIGNAL(rangeChanged(QCPRange)), this->HlineCursor, SLOT(xAxisRangeChanged(QCPRange)));
QObject::connect(this->ui->m_plot->yAxis, SIGNAL(rangeChanged(QCPRange)), this->HlineCursor, SLOT(xAxisRangeChanged(QCPRange)));
this->HlineCursor->show();
this->VlineCursor->show();
}
this->desCursor->show();
QObject::connect(this->desCursor, SIGNAL(windowsClose()), this, SLOT(on_action_descursor_close_trigged()));
}
void ImageShowDialogClass::PlotLine(QVector<double> xs, QVector<double> dataValues,QString Name)
{
if (dataValues.count() == 0) { return; }
QCPGraph* graph = ui->m_plot->addGraph();
graph->setName(Name);
graph->setData(xs, dataValues);
double min_y = dataValues[0];
double max_y = dataValues[0];
for (size_t i = 0; i < dataValues.count(); i++) {
min_y = min_y > dataValues[i] ? dataValues[i] : min_y;
max_y = max_y < dataValues[i] ? dataValues[i] : max_y;
}
double min_x = xs[0];
double max_x = xs[0];
for (size_t i = 0; i < xs.count(); i++) {
min_x = min_x > xs[i] ? xs[i] : min_x;
max_x = max_x < xs[i] ? xs[i] : max_x;
}
ui->m_plot->xAxis->setRange(min_x, max_x);
ui->m_plot->yAxis->setRange(min_y, max_y);
ui->m_plot->legend->setVisible(true);
ui->m_plot->replot();
//下面的代码就是设置游标的外观
this->setMouseTracking(true);
tracer->setInterpolating(false);//禁用插值
tracer->setPen(QPen(Qt::DashLine));//虚线游标
tracer->setStyle(QCPItemTracer::tsPlus);//游标样式：十字星、圆圈、方框
tracer->setBrush(Qt::red);//游标颜色
tracer->setGraph(graph); // 确保游标跟随
this->m_graphMap.insert(Name, graph);
}
void ImageShowDialogClass::Scatter(double dx,double dy)
{
QVector<double>xs(0);
QVector<double>ys(0);
xs.push_back(dx);
ys.push_back(dy);
// 设置画笔风格
QPen drawPen;
drawPen.setColor(Qt::red);
drawPen.setWidth(4);
// 绘制散点
QCPGraph* curGraph = ui->m_plot->addGraph();
curGraph->setPen(drawPen);
curGraph->setLineStyle(QCPGraph::lsNone);
curGraph->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssCircle, 2));
curGraph->setData(xs, ys);
ui->m_plot->xAxis->setVisible(true);
ui->m_plot->yAxis->setVisible(true);
}
void ImageShowDialogClass::Scatter(QVector<double> xs, QVector<double> ys)
{
// 设置画笔风格
QPen drawPen;
drawPen.setColor(Qt::red);
drawPen.setWidth(4);
// 绘制散点
QCPGraph* curGraph = ui->m_plot->addGraph();
curGraph->setPen(drawPen);
curGraph->setLineStyle(QCPGraph::lsNone);
curGraph->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssCircle, 2));
curGraph->setData(xs, ys);
ui->m_plot->xAxis->setVisible(true);
ui->m_plot->yAxis->setVisible(true);
}
void ImageShowDialogClass::load_double_MatrixX_data(Eigen::MatrixXd data, QString name)
{
this->setWindowTitle(name);
this->graphclass = LAMPDATASHOWCLASS::LAMPColorMap;
int ny = data.rows(); // 行数
int nx = data.cols(); // 列数
// 创建 Color Map
QCPColorMap* colorMap = new QCPColorMap(ui->m_plot->xAxis, ui->m_plot->yAxis);
colorMap->data()->setSize(nx, ny); // 设置 Color Map 的大小
colorMap->data()->setRange(QCPRange(0, nx), QCPRange(0, ny)); // 设置坐标轴的范围
// 填充数据
for (int xIndex = 0; xIndex < nx; ++xIndex) {
for (int yIndex = 0; yIndex < ny; ++yIndex) {
double magnitude = data(yIndex, xIndex); // 或者使用 std::arg() 获取相位
colorMap->data()->setCell(xIndex, yIndex,magnitude);
}
}
colorMap->setGradient(QCPColorGradient::gpJet);
colorMap->rescaleDataRange(true);
ui->m_plot->rescaleAxes();
ui->m_plot->replot();
}
void ImageShowDialogClass::load_double_MatrixX_data(Eigen::MatrixXd X, Eigen::MatrixXd Y, Eigen::MatrixXd data, QString name)
{
this->graphclass = LAMPDATASHOWCLASS::LAMPColorMap;
int nx = data.cols(); // 行数
int ny = data.rows(); // 列数
// 创建 Color Map
ui->m_plot->xAxis->setRange(X(0, 0), X(0, nx - 1));
ui->m_plot->yAxis->setRange(Y(0, 0), Y(ny - 1, 0));
QCPColorMap* colorMap = new QCPColorMap(ui->m_plot->xAxis, ui->m_plot->yAxis);
colorMap->data()->setSize(ny, nx); // 设置 Color Map 的大小
colorMap->data()->setRange(QCPRange(X(0,0), X(0,nx-1)), QCPRange(Y(0,0),Y(ny-1,0))); // 设置坐标轴的范围
// 填充数据
for (int xIndex = 0; xIndex < nx; ++xIndex) {
for (int yIndex = 0; yIndex < ny; ++yIndex) {
double magnitude = data(yIndex, xIndex); // 或者使用 std::arg() 获取相位
colorMap->data()->setCell(yIndex, xIndex, magnitude);
}
}
// add a color scale:
QCPColorScale* m_colorScale = new QCPColorScale(m_plot);
m_plot->plotLayout()->addElement(0, 1, m_colorScale);
m_colorScale->setType(QCPAxis::atRight);
colorMap->setColorScale(m_colorScale);
colorMap->setGradient(QCPColorGradient::gpJet);
colorMap->rescaleDataRange(true);
ui->m_plot->rescaleAxes();
ui->m_plot->replot();
}
void ImageShowDialogClass::remove_Data(QString name)
{
for(size_t i=0;i<this->m_plot->graphCount();i++){
if (this->m_plot->graph(i)->name() == name) {
this->m_plot->removeGraph(i);
this->m_plot->replot();
return;
}
}
}
LAMPDATASHOWCLASS ImageShowDialogClass::getGraphClass(size_t i)
{
if (this->m_plot->graphCount() == 0 || i > this->m_plot->graphCount())
{
return LAMPDATASHOWCLASS::NOWINDOWS;
}
QCPAbstractPlottable* plottable = this->ui->m_plot->plottable(i);
if (dynamic_cast<QCPGraph*>(plottable)) {
return LAMPDATASHOWCLASS::LAMPGraph;
}
else if (dynamic_cast<QCPScatterStyle*>(plottable)) {
return LAMPDATASHOWCLASS::LAMPScatterStyle;
}
else if (dynamic_cast<QCPColorMap*>(plottable)) {
return LAMPDATASHOWCLASS::LAMPColorMap;
}
else {
return LAMPDATASHOWCLASS::NOWINDOWS;
}
}
size_t ImageShowDialogClass::getGraphCount()
{
return this->m_plot->graphCount();
}
void ImageShowDialogClass::on_action_descursor_close_trigged()
{
this->desCursorflag = false;
}
void ImageShowDialogClass::on_action_Hlinecursor_close_trigged()
{
this->HlineCursorflag = false;
}
void ImageShowDialogClass::on_action_VVlinecursor_close_trigged()
{
this->VlineCursorflag = false;
}
void ImageShowDialogClass::updateCursor(QMouseEvent *event)
{
if (this->desCursorflag &&this->HlineCursorflag &&this->VlineCursorflag) {
//下面的代码就是设置游标的外观
this->setMouseTracking(false);
}
else {
// 准备获取数据
QPoint pos = event->pos();
double x=this->m_plot->xAxis->pixelToCoord(pos.x()); // 将鼠标位置映射到图表坐标系中
double y = this->m_plot->yAxis->pixelToCoord(pos.y());
this->statusbar->showMessage(u8"X: "+QString::number(x,'f', 6)+" y: "+QString::number(y, 'f', 6));
if (this->desCursorflag) {
if (this->graphclass == LAMPDATASHOWCLASS::LAMPColorMap) {
QCPColorMap* colorMap = dynamic_cast<QCPColorMap*>(this->ui->m_plot->plottable(0));
double dataValue = colorMap->data()->data(x, y);
this->desCursor->updateCursorContent(u8"X: " + QString::number(x, 'f', 6) + " y: " + QString::number(y, 'f', 6) +u8"\n" +u8"DataValue: "+QString::number(dataValue));
double xMin = this->m_plot->xAxis->range().lower;
double xMax = this->m_plot->xAxis->range().upper;
double yMin = this->m_plot->yAxis->range().lower;
double yMax = this->m_plot->yAxis->range().upper;
long XCount = 1000;
double xdelte = (xMax - xMin) / (XCount-1);
double ydelte = (yMax - yMin) / (XCount-1);
qDebug() << xMin << "," << xMax << " " << yMin << "," << yMax << " " << XCount<<" "<<xdelte<<" "<<ydelte;
QVector<double> Hx(XCount);
QVector<double> Hy(XCount);
QVector<double> Vx(XCount);
QVector<double> Vy(XCount);
for (long i = 0; i < XCount; i++)
{
Hx[i] = i * xdelte + xMin;
Hy[i] = colorMap->data()->data(Hx[i], y);
Vx[i] = i * ydelte + yMin;
Vy[i] = colorMap->data()->data(x, Vx[i]);
}
this->HlineCursor->UpdatePlotLine(Hx, Hy, u8"水平"); // 水平
this->VlineCursor->UpdatePlotLine(Vx, Vy, u8"垂直"); // 垂直
}
else if (this->graphclass == LAMPDATASHOWCLASS::LAMPGraph) {
}
else if (this->graphclass == LAMPDATASHOWCLASS::LAMPScatterStyle) {
}
else {
this->desCursor->updateCursorContent(u8"无法识别图像类型");
}
}
if (this->HlineCursorflag) {
}
if (this->VlineCursorflag) {
}
}
}
ImageShowCursorDesClass::ImageShowCursorDesClass(QWidget* parent)
{
// 创建 QLabel
label = new QLabel(this);
QFont font;
font.setPointSize(20); // 设置字体大小为20
label->setFont(font);
// 创建布局
QVBoxLayout* layout = new QVBoxLayout(this);
layout->addWidget(label);
// 设置布局
setLayout(layout);
this->resize(100, 50);
}
ImageShowCursorDesClass::~ImageShowCursorDesClass()
{
}
void ImageShowCursorDesClass::closeEvent(QCloseEvent* event)
{
QDialog::closeEvent(event);
}
void ImageShowCursorDesClass::updateCursorContent(QString content) {
this->label->setText(content);
}
ImageShowCursorLineClass::ImageShowCursorLineClass(QWidget* parent):QDialog(parent)
{
this->menubar = new QMenuBar(this);
//QMenu* toolMenu = this->menubar->addMenu(u8"工具");
//QAction* action_add_compare_line = toolMenu->addAction(u8"添加对比数据");
//QObject::connect(action_add_compare_line, SIGNAL(triggered()), this, SLOT(load_new_compare_line()));
this->tracerEnable = false;
this->tracer = nullptr;
this->tracerXText = nullptr;
this->tracerYText = nullptr;
// 创建 QLabel
this->customPlot = new QCustomPlot(this);
// 创建布局
QVBoxLayout* layout = new QVBoxLayout(this);
layout->addWidget(this->customPlot);
// 设置布局
setLayout(layout);
this->tracer = new QCPItemTracer(this->customPlot);
this->tracerYText = new QCPItemText(this->customPlot);
this->tracerXText = new QCPItemText(this->customPlot);
QObject::connect(this->customPlot, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(updateCursor(QMouseEvent*)));
this->customPlot->legend->setVisible(true);
this->setMinimumWidth(600);
this->setMinimumHeight(400);
}
ImageShowCursorLineClass::~ImageShowCursorLineClass()
{
}
void ImageShowCursorLineClass::loadPlotLine(QVector<double> xs, QVector<double> dataValues,QString Name)
{
if (dataValues.count() == 0) { return; }
QCPGraph* graph = this->customPlot->addGraph();
graph->setName(Name);
graph->setData(xs, dataValues);
double min_y = dataValues[0];
double max_y = dataValues[0];
for (size_t i = 0; i < dataValues.count(); i++) {
min_y = min_y > dataValues[i] ? dataValues[i] : min_y;
max_y = max_y < dataValues[i] ? dataValues[i] : max_y;
}
double min_x = xs[0];
double max_x = xs[0];
for (size_t i = 0; i < xs.count(); i++) {
min_x = min_x > xs[i] ? xs[i] : min_x;
max_x = max_x < xs[i] ? xs[i] : max_x;
}
customPlot->xAxis->setRange(min_x, max_x);
customPlot->yAxis->setRange(min_y, max_y);
customPlot->legend->setVisible(true);
customPlot->replot();
//下面的代码就是设置游标的外观
this->setMouseTracking(true);
tracer->setInterpolating(false);//禁用插值
tracer->setPen(QPen(Qt::DashLine));//虚线游标
tracer->setStyle(QCPItemTracer::tsPlus);//游标样式：十字星、圆圈、方框
tracer->setBrush(Qt::red);//游标颜色
tracer->setGraph(graph); // 确保游标跟随
this->m_graphMap.insert(Name, graph);
this->TrackName = Name;
}
void ImageShowCursorLineClass::UpdatePlotLine(QVector<double> xs, QVector<double> dataValues, QString Name)
{
this->customPlot->clearGraphs();
this->loadPlotLine(xs, dataValues, Name);
}
void ImageShowCursorLineClass::updateCursor(QMouseEvent* event)
{
if (tracerEnable)//游标使能
{
double x = this->customPlot->xAxis->pixelToCoord(event->pos().x());//鼠标点的像素坐标转plot坐标
tracer->setGraphKey(x);//设置游标的X值（这就是游标随动的关键代码）
double traceX = tracer->position->key();
double traceY = tracer->position->value();
tracerXText->setText(QDateTime::fromMSecsSinceEpoch(traceX * 1000.0).toString("hh:mm:ss.zzz"));//游标文本框，指示游标的X值
tracerYText->setText(QString::number(traceY));//游标文本框，指示游标的Y值
////计算游标X值对应的所有曲线的Y值
//for (int i = 0; i < this->customPlot->graphCount(); i++)
//{
// QCPGraph* graph = dynamic_cast<QCPGraph*>(this->customPlot->plottable(i));
// //搜索左边离traceX最近的key对应的点，详情参考findBegin函数的帮助
// QCPDataContainer<QCPGraphData>::const_iterator coorPoint = graph->data().data()->findBegin(traceX, true);//true代表向左搜索
// qDebug() << QString("graph%1对应的Y值是").arg(i) << coorPoint->value;
//}
}
}
void ImageShowCursorLineClass::closeEvent(QCloseEvent* event)
{
QDialog::closeEvent(event);
}
void ImageShowCursorLineClass::xAxisRangeChanged(QCPRange range) {
this->customPlot->xAxis->setRange(range);
customPlot->replot();
}
void ImageShowCursorLineClass::yAxisRangeChanged(QCPRange range) {
this->customPlot->yAxis->setRange(range);
customPlot->replot();
}
void ImageShowCursorLineClass::on_SwichTracerGraph_Name()
{
}
void ImageShowCursorLineClass::load_new_compare_line()
{
}

154
ImageShowDialogClass.h Normal file
View File

@ -0,0 +1,154 @@

#pragma once
#ifndef IMAGESHOWDIALOGCLASS_H
#define IMAGESHOWDIALOGCLASS_H
#include "BaseConstVariable.h"
#include <QDialog>
#include <QLabel>
#include "qcustomplot.h"
#include <Eigen/Core>
#include <Eigen/Dense>
//===========================
// 定义需要绘制的图像的类型
//===========================
enum LAMPDATASHOWCLASS {
LAMPGraph,
LAMPColorMap,
LAMPScatterStyle,
NOWINDOWS
};
namespace Ui {
class ImageShowDialogClass;
};
//===========================
// 构建游标类型
// 1. 单纯的描述游标，主要用来展示坐标，还有当前数据信息
// 2. 区域性描述游标，通过线，等用来展示某一个区域的信息
//===========================
class ImageShowCursorDesClass : public QDialog
{
Q_OBJECT
public:
QLabel* label;
public:
ImageShowCursorDesClass(QWidget* parent = nullptr);
~ImageShowCursorDesClass();
public slots:
void updateCursorContent(QString content);
signals:
bool windowsClose();
protected:
void closeEvent(QCloseEvent* event) override;
};
class ImageShowCursorLineClass :public QDialog {
Q_OBJECT
public:
QMenuBar* menubar;
QMenu* DataList;
QMenu* RemoveList;
QCustomPlot* customPlot;
bool tracerEnable;
QCPItemTracer* tracer; //游标
QCPItemText* tracerYText; //图标标签
QCPItemText* tracerXText; //游标标签
QMap<QString, QCPAbstractPlottable*> m_graphMap;
QMap<QString, QAction*> data_action_map;
QString TrackName;
public:
ImageShowCursorLineClass(QWidget* parent = nullptr);
~ImageShowCursorLineClass();
public:
void loadPlotLine(QVector<double> xs, QVector<double> dataValues, QString Name);
void UpdatePlotLine(QVector<double> xs, QVector<double> dataValues, QString Name);
void updateCursor(QMouseEvent* event);
public slots:
void xAxisRangeChanged(QCPRange);
void yAxisRangeChanged(QCPRange);
void on_SwichTracerGraph_Name();
void load_new_compare_line();
signals:
bool windowsClose();
protected:
void closeEvent(QCloseEvent* event) override;
};
//===========================
// 构建数据展示窗口
// 1. 单纯的描述游标，主要用来展示坐标，还有当前数据信息
// 2. 区域性描述游标，通过线，等用来展示某一个区域的信息
//===========================
class ImageShowDialogClass : public QDialog
{
Q_OBJECT
private:
LAMPDATASHOWCLASS graphclass;
public:
QMenuBar* menubar;
QStatusBar* statusbar;
ImageShowCursorDesClass* desCursor; // 描述游标
ImageShowCursorLineClass* HlineCursor;// H 游标
ImageShowCursorLineClass* VlineCursor;// V 游标
bool desCursorflag;
bool HlineCursorflag;
bool VlineCursorflag;
QCustomPlot* m_plot;
QCPItemTracer* tracer; //游标
public:
QMap<QString, QCPAbstractPlottable*> m_graphMap;
public:
ImageShowDialogClass(QWidget *parent = nullptr);
~ImageShowDialogClass();
public:
void PlotLine(QVector<double> xs, QVector<double> ys, QString Name);
void Scatter(double dx, double dy);
void Scatter(QVector<double> xs, QVector<double> ys);
void load_double_MatrixX_data(Eigen::MatrixXd data, QString name);
void load_double_MatrixX_data(Eigen::MatrixXd X,Eigen::MatrixXd Y,Eigen::MatrixXd data, QString name);
void remove_Data( QString name);
LAMPDATASHOWCLASS getGraphClass(size_t i = 0);
size_t getGraphCount();
private:
Ui::ImageShowDialogClass* ui;
public slots:
void updateCursor(QMouseEvent* event);
public slots: // cursor
void on_action_cursor_enable_trigged();
void on_action_descursor_close_trigged();
void on_action_Hlinecursor_close_trigged();
void on_action_VVlinecursor_close_trigged();
};
#endif

33
ImageShowDialogClass.ui Normal file
View File

@ -0,0 +1,33 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>ImageShowDialogClass</class>
<widget class="QDialog" name="ImageShowDialogClass">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>600</width>
<height>400</height>
</rect>
</property>
<property name="windowTitle">
<string>复数展示</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QCustomPlot" name="m_plot" native="true"/>
</item>
</layout>
</widget>
<layoutdefault spacing="6" margin="11"/>
<customwidgets>
<customwidget>
<class>QCustomPlot</class>
<extends>QWidget</extends>
<header location="global">qcustomplot.h</header>
<container>1</container>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>

228
LogInfoCls.cpp Normal file
View File

@ -0,0 +1,228 @@
#include "stdafx.h"
#include "LogInfoCls.h"
std::string errorCode2errInfo(ErrorCode e)
{
switch (e)
{
_CASE_STR(SUCCESS);
_CASE_STR(VIRTUALABSTRACT);
_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);
//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 );
// RTPC
_CASE_STR(RTPC_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;
}
}

97
LogInfoCls.h Normal file
View File

@ -0,0 +1,97 @@
#pragma once
/*****************************************************************//**
* \file LogInfoCls.h
* \brief 错误枚举类，以及返回错误信息
*
* \author 陈增辉
* \date October 2024
*********************************************************************/
#include <string>
// 定义变换
#define _CASE_STR(x) case x : return #x; break;
enum ErrorCode {
SUCCESS = -1,// 执行成功
VIRTUALABSTRACT = -2,// virtual abstract function ，not implement
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,
//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 */
// RTPC
RTPC_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,
};
std::string errorCode2errInfo(ErrorCode code);
ErrorCode GSLState2ErrorCode(int gslState);

515
SARSimulationImageL1.cpp Normal file
View File

@ -0,0 +1,515 @@
#include "stdafx.h"
#include "SARSimulationImageL1.h"
#include "LogInfoCls.h"
#include <memory>
#include <QFile>
#include <QDomDocument>
#include <QXmlStreamReader>
SARSimulationImageL1Dataset::SARSimulationImageL1Dataset()
{
}
SARSimulationImageL1Dataset::~SARSimulationImageL1Dataset()
{
}
QString SARSimulationImageL1Dataset::getoutFolderPath()
{
return outFolderPath;
}
QString SARSimulationImageL1Dataset::getDatesetName()
{
return L1DatasetName;
}
QString SARSimulationImageL1Dataset::getxmlfileName()
{
return xmlfileName;
}
QString SARSimulationImageL1Dataset::getxmlFilePath()
{
return xmlFilePath;
}
QString SARSimulationImageL1Dataset::getImageRasterName()
{
return ImageRasterName;
}
QString SARSimulationImageL1Dataset::getImageRasterPath()
{
return ImageRasterPath;
}
QString SARSimulationImageL1Dataset::getGPSPointFilename()
{
return GPSPointFilename;
}
QString SARSimulationImageL1Dataset::getGPSPointFilePath()
{
return GPSPointFilePath;
}
ErrorCode SARSimulationImageL1Dataset::OpenOrNew(QString folder, QString filename, long inrowCount, long incolCount)
{
qDebug() << "--------------Image Raster L1 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->rowCount = inrowCount;
this->colCount = incolCount;
this->outFolderPath = folder;
this->L1DatasetName = filename;
this->xmlfileName = filename + ".xml";
this->GPSPointFilename = filename + ".gpspos.data";
this->ImageRasterName = filename + ".bin";
this->xmlFilePath = dir.filePath(this->xmlfileName);
this->GPSPointFilePath = dir.filePath(this->GPSPointFilename);
this->ImageRasterPath = dir.filePath(this->ImageRasterName);
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");
std::shared_ptr<GDALDataset> poDstDS(poDriver->Create(this->GPSPointFilePath.toUtf8().constData(), 16, rowCount, 1, GDT_Float64, NULL));
GDALFlushCache((GDALDatasetH)poDstDS.get());
poDstDS.reset();
omp_unset_lock(&lock);
omp_destroy_lock(&lock);
}
if (QFile(this->ImageRasterPath).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");
std::shared_ptr<GDALDataset> poDstDS(poDriver->Create(this->ImageRasterPath.toUtf8().constData(), colCount, rowCount, 1, GDT_CFloat64, NULL));
GDALFlushCache((GDALDatasetH)poDstDS.get());
poDstDS.reset();
omp_unset_lock(&lock); //
omp_destroy_lock(&lock); //
}
return ErrorCode::SUCCESS;
}
ErrorCode SARSimulationImageL1Dataset::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->outFolderPath = folder;
this->L1DatasetName = filename;
this->xmlfileName = filename + ".xml";
this->GPSPointFilename = filename + ".gpspos.data";
this->ImageRasterName = filename + ".bin";
this->xmlFilePath = dir.filePath(this->xmlfileName);
this->GPSPointFilePath = dir.filePath(this->GPSPointFilename);
this->ImageRasterPath = dir.filePath(this->ImageRasterName);
if (QFile(this->xmlFilePath).exists())
{
this->loadFromXml();
}
else
{
return ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR;
}
}
ErrorCode SARSimulationImageL1Dataset::Open(QString xmlPath)
{
QFileInfo fileInfo(xmlPath);
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::IMAGE_L1DATA_XMLNAMEERROR;
}
return ErrorCode::SUCCESS;
}
void SARSimulationImageL1Dataset::saveToXml()
{
QFile file(this->xmlFilePath);
if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for writing:" << file.errorString();
return;
}
QXmlStreamWriter xmlWriter(&file);
xmlWriter.setAutoFormatting(true);
xmlWriter.writeStartDocument();
xmlWriter.writeStartElement("Parameters");
xmlWriter.writeTextElement("RowCount", QString::number(this->rowCount));
xmlWriter.writeTextElement("ColCount", QString::number(this->colCount));
xmlWriter.writeTextElement("Rnear", QString::number(this->Rnear));
xmlWriter.writeTextElement("Rfar", QString::number(this->Rfar));
xmlWriter.writeTextElement("Rref", QString::number(this->Rref));
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.writeEndElement(); // Parameters
xmlWriter.writeEndDocument();
file.close();
}
ErrorCode SARSimulationImageL1Dataset::loadFromXml()
{
QFile file(this->xmlFilePath);
if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
qDebug() << "Cannot open file for reading:" << file.errorString();
return ErrorCode::IMAGE_L1DATA_XMLNAMEOPENERROR;
}
QXmlStreamReader xmlReader(&file);
while (!xmlReader.atEnd() && !xmlReader.hasError()) {
QXmlStreamReader::TokenType token = xmlReader.readNext();
if (token == QXmlStreamReader::StartDocument) {
continue;
}
if (token == QXmlStreamReader::StartElement) {
if (xmlReader.name() == "Parameters") {
continue;
}
else if (xmlReader.name() == "RowCount") {
this->rowCount = xmlReader.readElementText().toLong();
}
else if (xmlReader.name() == "ColCount") {
this->colCount = xmlReader.readElementText().toLong();
}
else if (xmlReader.name() == "Rnear") {
this->Rnear = xmlReader.readElementText().toDouble();
}
else if (xmlReader.name() == "Rfar") {
this->Rfar = xmlReader.readElementText().toDouble();
}
else if (xmlReader.name() == "Rref") {
this->Rref = xmlReader.readElementText().toDouble();
}
else if (xmlReader.name() == "CenterFreq") {
this->centerFreq = xmlReader.readElementText().toDouble();
}
else if (xmlReader.name() == "Fs") {
this->Fs = xmlReader.readElementText().toDouble();
}
else if (xmlReader.name() == "CenterAngle") {
this->CenterAngle = xmlReader.readElementText().toDouble();
}
else if (xmlReader.name() == "LookSide") {
this->LookSide = xmlReader.readElementText();
}
}
}
if (xmlReader.hasError()) {
qDebug() << "XML error:" << xmlReader.errorString();
return ErrorCode::IMAGE_L1DATA_XMLNAMEPARASEERROR;
}
file.close();
return ErrorCode::SUCCESS;
}
std::shared_ptr<double> SARSimulationImageL1Dataset::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->rowCount * 16], delArrPtr);
demBand->RasterIO(GF_Read, 0, 0, 10, this->rowCount, temp.get(), 16, this->rowCount, 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;
}
ErrorCode SARSimulationImageL1Dataset::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, 16, this->rowCount, ptr.get(), 16, this->rowCount, 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;
}
std::shared_ptr<std::complex<double>> SARSimulationImageL1Dataset::getImageRaster()
{
return this->getImageRaster(0, this->rowCount);
}
ErrorCode SARSimulationImageL1Dataset::saveImageRaster(std::shared_ptr<std::complex<double>> echoPtr, long startPRF, long PRFLen)
{
if (!(startPRF < this->rowCount)) {
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);
std::shared_ptr<GDALDataset> rasterDataset = OpenDataset(this->ImageRasterPath, 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->rowCount || width != this->colCount) {
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.get());
}
else {
qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_ECHOFILEFORMATERROR));
}
}
rasterDataset.reset();
omp_unset_lock(&lock); //
omp_destroy_lock(&lock); //
return ErrorCode::SUCCESS;
}
std::shared_ptr<std::complex<double>> SARSimulationImageL1Dataset::getImageRaster(long startPRF, long PRFLen)
{
if (!(startPRF < this->rowCount)) {
qDebug() << QString::fromStdString(errorCode2errInfo(ErrorCode::ECHO_L0DATA_PRFIDXOUTRANGE)) << startPRF << " " << this->rowCount;
return nullptr;
}
else {}
omp_lock_t lock;
omp_init_lock(&lock);
omp_set_lock(&lock);
std::shared_ptr<GDALDataset> rasterDataset = OpenDataset(this->ImageRasterPath, 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();
std::shared_ptr<std::complex<double>> temp = nullptr;
if (height != this->rowCount || width != this->colCount) {
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;
}
Eigen::MatrixXcd SARSimulationImageL1Dataset::getImageRasterMatrix()
{
std::shared_ptr<std::complex<double>> data = this->getImageRaster();
Eigen::MatrixXcd dataimg = Eigen::MatrixXcd::Zero(this->rowCount, this->colCount);
for (long i = 0; i < this->rowCount; i++) {
for (long j = 0; j < this->colCount; j++) {
dataimg(i, j) = data.get()[i*colCount+j];
}
}
return Eigen::MatrixXcd();
}
ErrorCode SARSimulationImageL1Dataset::saveImageRaster(Eigen::MatrixXcd& dataimg, long startPRF)
{
std::shared_ptr<std::complex<double>> data(new std::complex<double>[dataimg.rows()* dataimg.cols()]);
long dataimgrows = dataimg.rows();
long dataimgcols = dataimg.cols();
for (long i = 0; i < dataimgrows; i++) {
for (long j = 0; j < dataimgcols; j++) {
data.get()[i * dataimgcols + j] = dataimg(i, j);
}
}
this->saveImageRaster(data, startPRF,dataimgrows);
return ErrorCode();
}
// Getter 和 Setter 方法实现
long SARSimulationImageL1Dataset::getrowCount() { return this->rowCount; }
void SARSimulationImageL1Dataset::setrowCount(long rowCountin) { this->rowCount = rowCountin; }
long SARSimulationImageL1Dataset::getcolCount() { return this->colCount; }
void SARSimulationImageL1Dataset::setcolCount(long pulsePointsin) { this->colCount = pulsePointsin; }
double SARSimulationImageL1Dataset::getNearRange() { return this->Rnear; }
void SARSimulationImageL1Dataset::setNearRange(double nearRange) { this->Rnear = nearRange; }
double SARSimulationImageL1Dataset::getFarRange() { return this->Rfar; }
void SARSimulationImageL1Dataset::setFarRange(double farRange) { this->Rfar = farRange; }
double SARSimulationImageL1Dataset::getRefRange()
{
return this->Rref;
}
void SARSimulationImageL1Dataset::setRefRange(double refRange)
{
this->Rref = refRange;
}
double SARSimulationImageL1Dataset::getCenterFreq() { return this->centerFreq; }
void SARSimulationImageL1Dataset::setCenterFreq(double freq) { this->centerFreq = freq; }
double SARSimulationImageL1Dataset::getFs() { return this->Fs; }
void SARSimulationImageL1Dataset::setFs(double samplingFreq) { this->Fs = samplingFreq; }
double SARSimulationImageL1Dataset::getCenterAngle()
{
return this->CenterAngle;
}
void SARSimulationImageL1Dataset::setCenterAngle(double angle)
{
this->CenterAngle = angle;
}
QString SARSimulationImageL1Dataset::getLookSide()
{
return this->LookSide;
}
void SARSimulationImageL1Dataset::setLookSide(QString looksides)
{
this->LookSide = looksides;
}

105
SARSimulationImageL1.h Normal file
View File

@ -0,0 +1,105 @@
#pragma once
#include "BaseConstVariable.h"
#include "BaseTool.h"
#include "ImageOperatorBase.h"
#include "GeoOperator.h"
#include "FileOperator.h"
#include "LogInfoCls.h"
class SARSimulationImageL1Dataset
{
public:
SARSimulationImageL1Dataset();
~SARSimulationImageL1Dataset();
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);
private: // xml中参数
long rowCount;
long colCount;
double Rnear;
double Rfar;
double Rref;
double centerFreq;
double Fs;
double CenterAngle;
QString LookSide;
public:
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 getCenterAngle();
void setCenterAngle(double angle);
QString getLookSide();
void setLookSide(QString lookside);
};

1
stdafx.cpp Normal file
View File

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

0
stdafx.h Normal file
View File