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

修复BP成像bug，增加了自定义prinf函数

pull/6/head
chenzenghui 2025-03-06 16:41:28 +08:00
parent 21e66455be
commit e62fafb3b7
8 changed files with 170 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
BaseCommonLibrary/BaseTool/PrintMsgToQDebug.cpp
View File

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

4
BaseCommonLibrary/BaseTool/PrintMsgToQDebug.h
View File

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

13
Toolbox/SimulationSARTool/SimulationSAR/BPBasic0_CUDA.cu
View File

@ -20,6 +20,7 @@
#include "GPUTool.cuh" #include "GPUTool.cuh"
#include "GPUBPTool.cuh" #include "GPUBPTool.cuh"
#include "BPBasic0_CUDA.cuh" #include "BPBasic0_CUDA.cuh"
#include <PrintMsgToQDebug.h>
#define c LIGHTSPEED #define c LIGHTSPEED
@ -157,21 +158,21 @@ void bpBasic0CUDA(GPUDATA& data, int flag,double* h_R) {
fftshiftKernel << <gridShift, blockShift >> > (data.phdata, data.Nfft, data.Np); fftshiftKernel << <gridShift, blockShift >> > (data.phdata, data.Nfft, data.Np);
PrintLasterError("bpBasic0CUDA Phase FFT Process"); PrintLasterError("bpBasic0CUDA Phase FFT Process");
printf("fft finished!!\n"); printfinfo("fft finished!!\n");
// ͼÏñÖؽ¨ // ͼÏñÖؽ¨
double r_start = data.r_vec[0]; double r_start = data.r_vec[0];
double dr = (data.r_vec[data.Nfft - 1] - r_start) / (data.Nfft - 1); double dr = (data.r_vec[data.Nfft - 1] - r_start) / (data.Nfft - 1);
printf("dr = %f\n",dr); printfinfo("dr = %f\n",dr);
long pixelcount = data.nx* data.ny; long pixelcount = data.nx* data.ny;
long grid_size = (pixelcount + BLOCK_SIZE - 1) / BLOCK_SIZE; long grid_size = (pixelcount + BLOCK_SIZE - 1) / BLOCK_SIZE;
printf("grid finished!!\n"); printfinfo("grid finished!!\n");
//double* d_R = (double*)mallocCUDADevice(sizeof(double) * data.nx * data.ny); //double* d_R = (double*)mallocCUDADevice(sizeof(double) * data.nx * data.ny);
printf("r_start=%e;dr=%e;nR=%d\n", r_start, dr, data.Nfft); printfinfo("r_start=%e;dr=%e;nR=%d\n", r_start, dr, data.Nfft);
printf("BPimage .....\n"); printfinfo("BPimage .....\n");
for (long ii = 0; ii < data.Np; ++ii) { for (long ii = 0; ii < data.Np; ++ii) {
processPulseKernel << <grid_size, BLOCK_SIZE >> > ( processPulseKernel << <grid_size, BLOCK_SIZE >> > (
ii, ii,
@ -186,7 +187,7 @@ void bpBasic0CUDA(GPUDATA& data, int flag,double* h_R) {
); );
PrintLasterError("processPulseKernel"); PrintLasterError("processPulseKernel");
if (ii % 1000==0) { if (ii % 1000==0) {
printf("\rPRF(%f %) %d / %d\t\t\t\t",(ii*100.0/data.Np), ii,data.Np); printfinfo("\rPRF(%f %) %d / %d\t\t\t\t",(ii*100.0/data.Np), ii,data.Np);
} }
} }
//FreeCUDADevice(d_R); //FreeCUDADevice(d_R);

3
Toolbox/SimulationSARTool/SimulationSAR/QSimulationBPImage.cpp
View File

@ -67,6 +67,7 @@ void QSimulationBPImage::onpushButtonImageSelectClicked()
void QSimulationBPImage::onbtnaccepted() void QSimulationBPImage::onbtnaccepted()
{ {
this->hide();
QString echofile = this->ui->lineEditEchoPath->text().trimmed(); QString echofile = this->ui->lineEditEchoPath->text().trimmed();
QString outImageFolder = getParantFromPath(this->ui->lineEditImagePath->text().trimmed()); QString outImageFolder = getParantFromPath(this->ui->lineEditImagePath->text().trimmed());
QString imagename = getFileNameFromPath(this->ui->lineEditImagePath->text().trimmed()); QString imagename = getFileNameFromPath(this->ui->lineEditImagePath->text().trimmed());
@ -102,7 +103,7 @@ void QSimulationBPImage::onbtnaccepted()
else { else {
TBPimag.Process(cpucore_num); TBPimag.Process(cpucore_num);
} }
this->show();
QMessageBox::information(this,u8"成像",u8"成像结束"); QMessageBox::information(this,u8"成像",u8"成像结束");
} }

4
Toolbox/SimulationSARTool/SimulationSAR/QSimulationBPImage.ui
View File

@ -45,7 +45,7 @@
</size> </size>
</property> </property>
<property name="text"> <property name="text">
<string>D:\Programme\vs2022\RasterMergeTest\LAMPCAE_SCANE\GF3_Simulation.xml</string> <string>D:\Programme\vs2022\RasterMergeTest\LAMPCAE_SCANE-all-scane\GF3_Simulation.xml</string>
</property> </property>
</widget> </widget>
</item> </item>
@ -156,7 +156,7 @@
</size> </size>
</property> </property>
<property name="text"> <property name="text">
<string>D:\Programme\vs2022\RasterMergeTest\LAMPCAE_SCANE\BPImage\GF3BPImage</string> <string>D:\Programme\vs2022\RasterMergeTest\LAMPCAE_SCANE-all-scane\BPImage\GF3BPImage</string>
</property> </property>
</widget> </widget>
</item> </item>

308
Toolbox/SimulationSARTool/SimulationSAR/TBPImageAlgCls.cpp
View File

@ -11,6 +11,7 @@
#include "ImageOperatorBase.h" #include "ImageOperatorBase.h"
#include "BPBasic0_CUDA.cuh" #include "BPBasic0_CUDA.cuh"
#include "BaseTool.h" #include "BaseTool.h"
#include <GPUBpSimulation.cuh>
void CreatePixelXYZ(std::shared_ptr<EchoL0Dataset> echoL0ds, QString outPixelXYZPath) void CreatePixelXYZ(std::shared_ptr<EchoL0Dataset> echoL0ds, QString outPixelXYZPath)
@ -276,237 +277,156 @@ ErrorCode TBPImageAlgCls::ProcessWithGridNet(long num_thread,QString xyzRasterPa
ErrorCode TBPImageAlgCls::ProcessGPU() ErrorCode TBPImageAlgCls::ProcessGPU()
{ {
std::shared_ptr<SARSimulationImageL1Dataset> L1ds=this->L1ds;
std::shared_ptr < EchoL0Dataset> L0ds=this->L0ds;
QString inGPSPath = L0ds->getGPSPointFilePath();
QString echoFilePath = L0ds->getEchoDataFilePath();
QString imgXYZPath = this->outRasterXYZPath;
QString outimgDataPath = L1ds->getImageRasterPath();
// 回波大小 size_t prfcount = L0ds->getPluseCount();
long freqpoint = this->L0ds->getPlusePoints(); size_t freqpoints = L0ds->getPlusePoints();
long PRFCount = this->L0ds->getPluseCount(); size_t block_pfrcount = Memory1MB / freqpoints / 8 * 2000;// 4GB -- 可以分配内存
// 图像范围
long imWidth = this->L1ds->getcolCount();
long imHeight = this->L1ds->getrowCount();
double refRange = this->L0ds->getRefPhaseRange(); size_t img_rowCont = L1ds->getrowCount();
size_t img_colCont = L1ds->getcolCount();
size_t block_imgRowCount = Memory1MB / img_colCont / 8 / 3 * 2000;// 4GB-- 可以分配内存
// 内存分配大小 gdalImage demgridimg(imgXYZPath);
long echoBlockline = Memory1GB / 8 / 2 / freqpoint * 4; //2GB gdalImageComplex im_finalds(outimgDataPath);
echoBlockline = echoBlockline < 1 ? 1 : echoBlockline; gdalImageComplex echods(echoFilePath);
long imageBlockline = Memory1GB / 8 / 2 / imHeight * 4; //2GB
imageBlockline = imageBlockline < 1 ? 1 : imageBlockline;
qDebug() << "echo block rows: " << echoBlockline; // 加载 GPS ，it should be same as prfcount;
qDebug() << "image block rows: " << imageBlockline; long gpspoints = prfcount;
std::shared_ptr<SatelliteAntPos> antpos = SatelliteAntPosOperator::readAntPosFile(inGPSPath, gpspoints);
// 天线坐标
std::shared_ptr<double> Pxs(new double[this->L0ds->getPluseCount()], delArrPtr);
std::shared_ptr<double> Pys(new double[this->L0ds->getPluseCount()], delArrPtr);
std::shared_ptr<double> Pzs(new double[this->L0ds->getPluseCount()], delArrPtr);
GPUDATA h_data{};// 任务参数
{ {
std::shared_ptr<double> antpos = this->L0ds->getAntPos(); //回波 频率参数
double time = 0; h_data.Nfft = freqpoints;
double Px = 0; qDebug() << u8"3.proces echo params:";
double Py = 0; double centerFreq = L0ds->getCenterFreq();
double Pz = 0; double bandwidth = L0ds->getBandwidth();
for (long i = 0; i < PRFCount; i++) { size_t freqpoints = L0ds->getPlusePoints();
time = antpos.get()[i * 19 + 0]; h_data.Freq = getFreqPoints_mallocHost(centerFreq - bandwidth / 2, centerFreq + bandwidth / 2, freqpoints);
Px = antpos.get()[i * 19 + 1]; h_data.minF = (double*)mallocCUDAHost(sizeof(double) * gpspoints);
Py = antpos.get()[i * 19 + 2]; for (long i = 0; i < gpspoints; i++) {
Pz = antpos.get()[i * 19 + 3]; h_data.minF[i] = h_data.Freq[0];
Pxs.get()[i] = Px;
Pys.get()[i] = Py;
Pzs.get()[i] = Pz;
}
antpos.reset();
} }
h_data.deltaF = bandwidth / (freqpoints - 1);
h_data.K = h_data.Nfft;
h_data.R0 = L0ds->getRefPhaseRange();
double startFreq=this->L0ds->getCenterFreq() - this->L0ds->getBandwidth() / 2;
gdalImage imageXYZ(this->outRasterXYZPath); // 图像坐标
for (long img_rid = 0; img_rid < imHeight; img_rid = img_rid + imageBlockline) {
// 获取坐标范围
long imrowcount = imageBlockline;
long imcolcount = imWidth;
std::shared_ptr<double> img_x = readDataArr<double>(imageXYZ, img_rid, 0, imrowcount, imcolcount, 1, GDALREADARRCOPYMETHOD::VARIABLEMETHOD);
std::shared_ptr<double> img_y = readDataArr<double>(imageXYZ, img_rid, 0, imrowcount, imcolcount, 2, GDALREADARRCOPYMETHOD::VARIABLEMETHOD);
std::shared_ptr<double> img_z = readDataArr<double>(imageXYZ, img_rid, 0, imrowcount, imcolcount, 3, GDALREADARRCOPYMETHOD::VARIABLEMETHOD);
std::shared_ptr<std::complex<double>> imgArr = this->L1ds->getImageRaster(img_rid, imrowcount); // 回波值
double img_x_min=0, img_x_max=0;
double img_y_min=0, img_y_max=0;
double img_z_min=0, img_z_max=0;
minValueInArr<double>(img_x.get(), imrowcount * imcolcount, img_x_min);
maxValueInArr<double>(img_x.get(), imrowcount * imcolcount, img_x_max);
minValueInArr<double>(img_y.get(), imrowcount * imcolcount, img_y_min);
maxValueInArr<double>(img_y.get(), imrowcount * imcolcount, img_y_max);
minValueInArr<double>(img_z.get(), imrowcount * imcolcount, img_z_min);
maxValueInArr<double>(img_z.get(), imrowcount * imcolcount, img_z_max);
qDebug() << "imgX:\t" << img_x_min << " ~ " << img_x_max;
qDebug() << "imgY:\t" << img_y_min << " ~ " << img_y_max;
qDebug() << "imgZ:\t" << img_z_min << " ~ " << img_z_max;
//shared_complexPtrToHostCuComplex(std::complex<double>*src, cuComplex * dst, long len)
// 处理
GPUDATA h_data;
h_data.Nfft = freqpoint;
h_data.K = freqpoint;
h_data.deltaF = this->L0ds->getBandwidth() / (freqpoint - 1);
// 计算maxWr（需要先计算deltaF）
double deltaF = h_data.deltaF; // 从输入参数获取 double deltaF = h_data.deltaF; // 从输入参数获取
double maxWr = 299792458.0f / (2.0f * deltaF); double maxWr = 299792458.0 / (2.0 * deltaF);
// 生成r_vec（主机端）
double* r_vec_host = (double*)mallocCUDAHost(sizeof(double) * h_data.Nfft);// new double[data.Nfft]; double* r_vec_host = (double*)mallocCUDAHost(sizeof(double) * h_data.Nfft);// new double[data.Nfft];
const double step = maxWr / h_data.Nfft; const double step = maxWr / h_data.Nfft;
const double start = -1*h_data.Nfft / 2.0f * step; const double start = -1 * h_data.Nfft / 2.0 * step;
printf("nfft=%d\n", h_data.Nfft);
for (int i = 0; i < h_data.Nfft; ++i) { for (int i = 0; i < h_data.Nfft; ++i) {
r_vec_host[i] = start + i * step; r_vec_host[i] = start + i * step;
} }
h_data.r_vec = r_vec_host; h_data.r_vec = r_vec_host;
// 处理天线坐标
h_data.AntX = (double*)mallocCUDAHost(sizeof(double) * block_pfrcount);
h_data.AntY = (double*)mallocCUDAHost(sizeof(double) * block_pfrcount);
h_data.AntZ = (double*)mallocCUDAHost(sizeof(double) * block_pfrcount);
h_data.x_mat = img_x.get();//地面 qDebug() << "r_vec [0]:\t" << h_data.r_vec[0];
h_data.y_mat = img_y.get(); qDebug() << "Range resolution(m):\t" << step;
h_data.z_mat = img_z.get(); qDebug() << "range Scence(m):\t" << maxWr;
h_data.nx = imcolcount; qDebug() << "start Freq:\t" << centerFreq - bandwidth / 2;
h_data.ny = imrowcount; qDebug() << "end Freq:\t" << centerFreq + bandwidth / 2;
qDebug() << "freq points:\t" << freqpoints;
qDebug() << "delta freq:\t" << h_data.deltaF;
qDebug() << "prf count:\t" << gpspoints;
qDebug() << "-----------------------------------------------------------";
}
minValueInArr<double>(h_data.x_mat, h_data.nx * h_data.ny, img_x_min); qDebug() << "BP......";
maxValueInArr<double>(h_data.x_mat, h_data.nx * h_data.ny, img_x_max); for (long img_start_rid = 0; img_start_rid < img_rowCont; img_start_rid = img_start_rid + block_imgRowCount) {
minValueInArr<double>(h_data.y_mat, h_data.nx * h_data.ny, img_y_min); long img_blockRowCount = block_imgRowCount;
maxValueInArr<double>(h_data.y_mat, h_data.nx * h_data.ny, img_y_max); long img_blockColCount = img_colCont;
minValueInArr<double>(h_data.z_mat, h_data.nx * h_data.ny, img_z_min);
maxValueInArr<double>(h_data.z_mat, h_data.nx * h_data.ny, img_z_max);
qDebug() << "imgX:\t" << img_x_min << " ~ " << img_x_max;
qDebug() << "imgY:\t" << img_y_min << " ~ " << img_y_max;
qDebug() << "imgZ:\t" << img_z_min << " ~ " << img_z_max;
qDebug() << "imgXYZ" << h_data.x_mat[5016600] << " , " << h_data.y_mat[5016600] << " , " << h_data.z_mat[5016600] << " , ";
std::shared_ptr<double> demX = readDataArr<double>(demgridimg, img_start_rid, 0, img_blockRowCount, img_blockColCount, 1, GDALREADARRCOPYMETHOD::VARIABLEMETHOD);
std::shared_ptr<double> demY = readDataArr<double>(demgridimg, img_start_rid, 0, img_blockRowCount, img_blockColCount, 2, GDALREADARRCOPYMETHOD::VARIABLEMETHOD);
std::shared_ptr<double> demZ = readDataArr<double>(demgridimg, img_start_rid, 0, img_blockRowCount, img_blockColCount, 3, GDALREADARRCOPYMETHOD::VARIABLEMETHOD);
h_data.x_mat = (double*)mallocCUDAHost(sizeof(double) * img_blockRowCount * img_blockColCount); // 成像网格
h_data.y_mat = (double*)mallocCUDAHost(sizeof(double) * img_blockRowCount * img_blockColCount);
h_data.z_mat = (double*)mallocCUDAHost(sizeof(double) * img_blockRowCount * img_blockColCount);
h_data.nx = img_blockColCount;
h_data.ny = img_blockRowCount;
h_data.R0 = refRange;// 参考斜距 for (long i = 0; i < h_data.ny; i++) {
for (long j = 0; j < h_data.nx; j++) {
h_data.im_final = (cuComplex*)mallocCUDAHost(sizeof(cuComplex) * imrowcount * imcolcount); h_data.x_mat[i * h_data.nx + j] = demX.get()[i * h_data.nx + j];
shared_complexPtrToHostCuComplex(imgArr.get(), h_data.im_final, imrowcount * imcolcount); h_data.y_mat[i * h_data.nx + j] = demY.get()[i * h_data.nx + j];
h_data.z_mat[i * h_data.nx + j] = demZ.get()[i * h_data.nx + j];
// 保存fft 结果
this->TimeEchoDataPath = JoinPath(this->L1ds->getoutFolderPath(), this->L0ds->getSimulationTaskName() + "_Timeecho.bin");
gdalImageComplex outTimeEchoImg = CreategdalImageComplexNoProj(this->TimeEchoDataPath,PRFCount, freqpoint, 1);
for (long prfid = 0; prfid < PRFCount; prfid = prfid + echoBlockline) {
long ehcoprfcount = echoBlockline;
long echofreqpoint = freqpoint;
std::shared_ptr<std::complex<double>> echoArr = this->L0ds->getEchoArr(prfid, ehcoprfcount);
// 复制天线方向图
std::shared_ptr<double> antpx(new double[ehcoprfcount], delArrPtr);
std::shared_ptr<double> antpy(new double[ehcoprfcount], delArrPtr);
std::shared_ptr<double> antpz(new double[ehcoprfcount], delArrPtr);
for (long anti = 0; anti < ehcoprfcount; anti++) {
if (anti + prfid < PRFCount) {
antpx.get()[anti] = Pxs.get()[anti + prfid];
antpy.get()[anti] = Pys.get()[anti + prfid];
antpz.get()[anti] = Pzs.get()[anti + prfid];
//if (abs(antpx.get()[anti]) < 10 || abs(antpy.get()[anti]) < 10 || abs(antpz.get()[anti]) < 10) {
// qDebug() << anti << ":" << antpx.get()[anti] << "," << antpy.get()[anti] << "," << antpz.get()[anti];
//}
} }
} }
// 起始频率
h_data.minF = (double*)mallocCUDAHost(sizeof(double) * ehcoprfcount); std::shared_ptr<std::complex<double>> imgArr = im_finalds.getDataComplexSharePtr(img_start_rid, 0, img_blockRowCount, img_blockColCount, 1);
h_data.Freq = (double*)mallocCUDAHost(sizeof(double) * ehcoprfcount); h_data.im_final = (cuComplex*)mallocCUDAHost(sizeof(cuComplex)* img_blockRowCount* img_blockColCount);
for (long anti = 0; anti < ehcoprfcount; anti++) {
h_data.minF[anti] = startFreq; for (long echo_start_pid = 0; echo_start_pid < prfcount; echo_start_pid = echo_start_pid + block_pfrcount) {
h_data.Freq[anti] = startFreq; long echo_blockPRFCount = block_pfrcount;
long echo_blockFreqCount = freqpoints;
// 读取回波
std::shared_ptr<std::complex<double>> echoData = readDataArrComplex<std::complex<double>>(echods, echo_start_pid,0, echo_blockPRFCount, echo_blockFreqCount,1, GDALREADARRCOPYMETHOD::VARIABLEMETHOD);
size_t echosize = sizeof(cuComplex) * echo_blockPRFCount * echo_blockFreqCount;
h_data.phdata = (cuComplex*)mallocCUDAHost(echosize);
shared_complexPtrToHostCuComplex(echoData.get(), h_data.phdata, size_t(echo_blockPRFCount * echo_blockFreqCount));
// 处理天线坐标
h_data.Np = echo_blockPRFCount;
for (long i = 0; i < h_data.Np; i++) {
h_data.AntX[i] = antpos.get()[i+echo_start_pid].Px;
h_data.AntY[i] = antpos.get()[i+echo_start_pid].Py;
h_data.AntZ[i] = antpos.get()[i+echo_start_pid].Pz;
} }
h_data.AntX = antpx.get(); // 天线
h_data.AntY = antpy.get();
h_data.AntZ = antpz.get();
// checkout
if (!this->checkZeros(h_data.AntX, ehcoprfcount) ||
!this->checkZeros(h_data.AntY, ehcoprfcount) ||
!this->checkZeros(h_data.AntZ, ehcoprfcount)
) {
printf("the ant position is not zeros!!!");
}
h_data.Np = ehcoprfcount;
h_data.phdata= (cuComplex*)mallocCUDAHost(sizeof(cuComplex) * ehcoprfcount * echofreqpoint);
qDebug() << ehcoprfcount <<":\t"<<h_data.Np;
shared_complexPtrToHostCuComplex(echoArr.get(), h_data.phdata, ehcoprfcount * echofreqpoint);
{ {
// BP qDebug() << "GPS points Count:\t" << gpspoints;
qDebug() << "PRF 0:\t " << QString("%1,%2,%3").arg(h_data.AntX[0]).arg(h_data.AntY[0]).arg(h_data.AntZ[0]);
qDebug() << "PRF " << gpspoints - 1 << ":\t " << QString("%1,%2,%3")
.arg(h_data.AntX[gpspoints - 1])
.arg(h_data.AntY[gpspoints - 1])
.arg(h_data.AntZ[gpspoints - 1]);
}
GPUDATA d_data; GPUDATA d_data;
initGPUData(h_data, d_data); initGPUData(h_data, d_data);
qDebug() << "------------------------------------------------------";
double min_r_vec = 0, max_r_cev = 0;
minValueInArr<double>(h_data.r_vec, h_data.Nfft, min_r_vec);
maxValueInArr<double>(h_data.r_vec, h_data.Nfft, max_r_cev);
qDebug() << "r_vec:\t" << min_r_vec << " ~ " << max_r_cev;
minValueInArr<double>(h_data.Freq, h_data.Nfft, min_r_vec);
maxValueInArr<double>(h_data.Freq, h_data.Nfft, max_r_cev);
qDebug() << "Freq:\t" << min_r_vec << " ~ " << max_r_cev;
// 打印参数
qDebug() << "R0\t" << h_data.R0;
qDebug() << "deltaF\t" << h_data.deltaF;
qDebug() << "Nfft\t" << h_data.Nfft;
qDebug() << "R0\t" << h_data.R0;
qDebug() << "K\t" << h_data.K;
qDebug() << "Np\t" << h_data.Np;
qDebug() << "nx\t" << h_data.nx;
qDebug() << "ny\t" << h_data.ny;
qDebug() << "------------------------------------------------------";
bpBasic0CUDA(d_data, 0); bpBasic0CUDA(d_data, 0);
DeviceToHost(h_data.im_final, d_data.im_final, sizeof(cuComplex) * d_data.nx * d_data.ny);
printf("BP finished!!!\n");
DeviceToHost(h_data.im_final, d_data.im_final, sizeof(cuComplex) * h_data.nx * h_data.ny);
DeviceToHost(h_data.phdata, d_data.phdata, sizeof(cuComplex) * h_data.Np * h_data.Nfft);
gdalImageComplex outTimeEchoImg = CreategdalImageComplexNoProj(this->TimeEchoDataPath, h_data.Np, h_data.Nfft, 1);
std::shared_ptr<std::complex<double>> data_time(new std::complex<double>[h_data.Np * h_data.Nfft], delArrPtr);
for (long i = 0; i < h_data.Np * h_data.Nfft; i++) {
data_time.get()[i] = std::complex<double>(h_data.phdata[i].x, h_data.phdata[i].y);
}
outTimeEchoImg.saveImage(data_time, 0, 0, h_data.Np, h_data.Nfft, 1);
HostCuComplexToshared_complexPtr(h_data.im_final, imgArr.get(), imrowcount * imcolcount);
freeGPUData(d_data); freeGPUData(d_data);
} FreeCUDAHost(h_data.phdata);
this->L1ds->saveImageRaster(imgArr, img_rid, imrowcount);
}
freeHostData(h_data);
qDebug() << QString(u8"\nimg proces [%1 precent ] , echo process [%2 precess]\t:img row [%3，%4）,echo pfr [%5,%6]")
.arg((img_start_rid+ img_blockRowCount)*100.0/ img_rowCont)
.arg((echo_start_pid + echo_blockPRFCount) * 100.0 / prfcount)
.arg(img_start_rid)
.arg(img_start_rid + img_blockRowCount)
.arg(echo_start_pid)
.arg(echo_start_pid + echo_blockPRFCount)
;
//HostCuComplexToshared_complexPtr(h_data.im_final, imgArr.get(), size_t(h_data.nx)* size_t(h_data.ny));
//testOutComplexDoubleArr(QString("im_final.bin"), imgArr.get(), h_data.ny, h_data.nx);
}
HostCuComplexToshared_complexPtr(h_data.im_final, imgArr.get(), size_t(h_data.nx)* size_t(h_data.ny));
im_finalds.saveImage(imgArr, img_start_rid, 0,img_blockRowCount, img_blockColCount, 1);
} }
qDebug() << QString("img proces [100 precent ] , echo process [100 precess] ");
L1ds->saveToXml();
qDebug() << "bp Image Result write to file :\t" << L1ds->getoutFolderPath();
this->L1ds->saveToXml();
return ErrorCode::SUCCESS; return ErrorCode::SUCCESS;
} }

2
Toolbox/SimulationSARTool/SimulationSARTool.vcxproj
View File

@ -41,7 +41,7 @@
<CharacterSet>Unicode</CharacterSet> <CharacterSet>Unicode</CharacterSet>
</PropertyGroup> </PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'" Label="Configuration"> <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType> <ConfigurationType>DynamicLibrary</ConfigurationType>
<PlatformToolset>v143</PlatformToolset> <PlatformToolset>v143</PlatformToolset>
<UseDebugLibraries>false</UseDebugLibraries> <UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization> <WholeProgramOptimization>true</WholeProgramOptimization>

21
Toolbox/SimulationSARTool/UnitTestMain.cpp
View File

@ -323,8 +323,6 @@ void testBpImage() {
GPUDATA d_data; GPUDATA d_data;
initGPUData(h_data, d_data); initGPUData(h_data, d_data);
/** 8. չʾ»Ø²¨ **************************************************************************************************/ /** 8. չʾ»Ø²¨ **************************************************************************************************/
{ {
DeviceToHost(h_data.phdata, d_data.phdata, sizeof(cuComplex) * d_data.Np * d_data.Nfft); DeviceToHost(h_data.phdata, d_data.phdata, sizeof(cuComplex) * d_data.Np * d_data.Nfft);
@ -374,7 +372,6 @@ void testBpImage() {
bpBasic0CUDA(d_data, 0); bpBasic0CUDA(d_data, 0);
DeviceToHost(h_data.im_final, d_data.im_final, sizeof(cuComplex) * d_data.nx * d_data.ny); DeviceToHost(h_data.im_final, d_data.im_final, sizeof(cuComplex) * d_data.nx * d_data.ny);
{ {
DeviceToHost(h_data.phdata, d_data.phdata, sizeof(cuComplex) * d_data.Np * d_data.Nfft); DeviceToHost(h_data.phdata, d_data.phdata, sizeof(cuComplex) * d_data.Np * d_data.Nfft);
std::shared_ptr<std::complex<double>> ifftdata(new std::complex<double>[d_data.Np * d_data.Nfft], delArrPtr); std::shared_ptr<std::complex<double>> ifftdata(new std::complex<double>[d_data.Np * d_data.Nfft], delArrPtr);
@ -390,8 +387,6 @@ void testBpImage() {
} }
testOutComplexDoubleArr(QString("echo_ifft_BPBasic.bin"), ifftdata.get(), d_data.Np, d_data.Nfft); testOutComplexDoubleArr(QString("echo_ifft_BPBasic.bin"), ifftdata.get(), d_data.Np, d_data.Nfft);
std::shared_ptr<std::complex<double>> im_finals(new std::complex<double>[d_data.nx * d_data.ny], delArrPtr); std::shared_ptr<std::complex<double>> im_finals(new std::complex<double>[d_data.nx * d_data.ny], delArrPtr);
{ {
for (long i = 0; i < d_data.ny; i++) { for (long i = 0; i < d_data.ny; i++) {
@ -410,14 +405,14 @@ void testBpImage() {
} }
int main(int argc, char* argv[]) { //int main(int argc, char* argv[]) {
//
QApplication a(argc, argv); // QApplication a(argc, argv);
//
testBpImage(); // testBpImage();
//
return 0; // return 0;
} //}