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

修改： 

1.所有的RTPC代码全部修改为GPU代码；
2. 增加重值地表覆盖类型
3. 方向图插值修改为GPU代码
4. 后向散射系数函数修改为GPU代码
pull/1/head
陈增辉 2024-11-30 21:05:44 +08:00
parent bee90080f2
commit a62daae92c
7 changed files with 280 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
RasterProcessTool.ui
View File

@ -42,7 +42,13 @@
<widget class="QWidget" name="dockWidgetContents">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QTreeWidget" name="treeWidgetToolBox"/>
<widget class="QTreeWidget" name="treeWidgetToolBox">
<column>
<property name="text">
<string>工具箱</string>
</property>
</column>
</widget>
</item>
</layout>
</widget>

4
RasterProcessTool.vcxproj
View File

@ -75,9 +75,9 @@
<PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;_SILENCE_NONFLOATING_COMPLEX_DEPRECATION_WARNING;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<OpenMPSupport>true</OpenMPSupport>
<Optimization>MaxSpeed</Optimization>
<WholeProgramOptimization>true</WholeProgramOptimization>
<WholeProgramOptimization>false</WholeProgramOptimization>
<EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
<DebugInformationFormat>None</DebugInformationFormat>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
</ClCompile>
</ItemDefinitionGroup>

444
SimulationSAR/RTPCProcessCls.cpp
View File

@ -404,25 +404,108 @@ ErrorCode RTPCProcessCls::RTPCMainProcess(long num_thread)
long max = Memory1MB * 100 / 4 / 20 / PluseCount;
QMessageBox::warning(nullptr, u8"仿真场景太大了", u8"当前频点数下，脉冲数量最多为："+QString::number(max));
}
gdalImage demxyz(this->demxyzPath);// 地面点坐标
gdalImage demlandcls(this->LandCoverPath);// 地表覆盖类型
gdalImage demsloperxyz(this->demsloperPath);// 地面坡向
// 参数与分块计算
long demRow = demxyz.height;
long demCol = demxyz.width;
long blokline = 100;
// 每块 250MB*16 = 4GB
// dem 9
//
blokline = Memory1MB * 500 / 8 / demCol;
blokline = blokline < 1 ? 1 : blokline;
bool bloklineflag = false;
// 处理发射天线方向图
double Tminphi = TransformPattern->getMinPhi();
double Tmaxphi = TransformPattern->getMaxPhi();
double Tmintheta = TransformPattern->getMinTheta();
double Tmaxtheta = TransformPattern->getMaxTheta();
long Tphinum = TransformPattern->getPhis().size();
long Tthetanum = TransformPattern->getThetas().size();
double TstartTheta = Tmintheta;
double TstartPhi = Tminphi;
double Tdtheta = (Tmaxtheta - Tmintheta) / (Tthetanum - 1);
double Tdphi = (Tmaxphi - Tminphi) / (Tphinum - 1);
float* h_TantPattern = (float*)mallocCUDAHost(sizeof(float) * Tthetanum * Tphinum);
float* d_TantPattern = (float*)mallocCUDADevice(sizeof(float) * Tthetanum * Tphinum);
for (long i = 0; i < Tthetanum; i++) {
for (long j = 0; j < Tphinum; j++) {
h_TantPattern[i*Tphinum+j] = TransformPattern->getGainLearThetaPhi(TstartTheta + i * Tdtheta, TstartPhi + j * Tdphi);
}
}
HostToDevice(h_TantPattern, d_TantPattern, sizeof(float)* Tthetanum* Tphinum);
// 处理接收天线方向图
double Rminphi = ReceivePattern->getMinPhi();
double Rmaxphi = ReceivePattern->getMaxPhi();
double Rmintheta = ReceivePattern->getMinTheta();
double Rmaxtheta = ReceivePattern->getMaxTheta();
long Rphinum = ReceivePattern->getPhis().size();
long Rthetanum = ReceivePattern->getThetas().size();
double RstartTheta = Rmintheta;
double RstartPhi = Rminphi;
double Rdtheta = (Rmaxtheta - Rmintheta) / (Rthetanum - 1);
double Rdphi = (Rmaxphi - Rminphi) / (Rphinum - 1);
float* h_RantPattern = (float*)mallocCUDAHost(sizeof(float) * Rthetanum * Rphinum);
float* d_RantPattern = (float*)mallocCUDADevice(sizeof(float) * Rthetanum * Rphinum);
for (long i = 0; i < Rthetanum; i++) {
for (long j = 0; j < Rphinum; j++) {
h_RantPattern[i * Rphinum + j] = ReceivePattern->getGainLearThetaPhi(RstartTheta + i * Rdtheta, RstartPhi + j * Rdphi);
}
}
HostToDevice(h_RantPattern, d_RantPattern, sizeof(float)* Rthetanum* Rphinum);
//处理地表覆盖
QMap<long, long> clamap;
long clamapid = 0;
long startline = 0;
for (startline = 0; startline < demRow; startline = startline + blokline) {
Eigen::MatrixXd clsland = demlandcls.getData(startline, 0, blokline, demlandcls.width, 1);
long clsrows = clsland.rows();
long clscols = clsland.cols();
long clsid = 0;
for (long ii = 0; ii < clsrows; ii++) {
for (long jj = 0; jj < clscols; jj++) {
clsid = clsland(ii, jj);
if (clamap.contains(clsid)) {}
else {
clamap.insert(clsid, clamapid);
clamapid = clamapid + 1;
}
}
}
}
CUDASigmaParam* h_clsSigmaParam = (CUDASigmaParam*)mallocCUDAHost(sizeof(CUDASigmaParam) * clamapid);
CUDASigmaParam* d_clsSigmaParam = (CUDASigmaParam*)mallocCUDADevice(sizeof(CUDASigmaParam) * clamapid);
{
std::map<long, SigmaParam> tempSigmaParam = this->SigmaDatabasePtr->getsigmaParams( polartype);
for (long id : clamap.keys()) {
SigmaParam tempp = tempSigmaParam[id];
h_clsSigmaParam[clamap[id]].p1 = tempp.p1;
h_clsSigmaParam[clamap[id]].p2 = tempp.p2;
h_clsSigmaParam[clamap[id]].p3 = tempp.p3;
h_clsSigmaParam[clamap[id]].p4 = tempp.p4;
h_clsSigmaParam[clamap[id]].p5 = tempp.p5;
h_clsSigmaParam[clamap[id]].p6 = tempp.p6;
}
}
HostToDevice(h_clsSigmaParam, d_clsSigmaParam, sizeof(CUDASigmaParam) * clamapid);
// 临时变量声明
Eigen::MatrixXd dem_x = demxyz.getData(0, 0, blokline, demxyz.width, 1); // 地面坐标
long tempDemRows = dem_x.rows();
long tempDemCols = dem_x.cols();
@ -434,120 +517,41 @@ ErrorCode RTPCProcessCls::RTPCMainProcess(long num_thread)
Eigen::MatrixXd demsloper_z = Eigen::MatrixXd::Zero(tempDemRows, tempDemCols);
Eigen::MatrixXd sloperAngle = Eigen::MatrixXd::Zero(tempDemRows, tempDemCols);
float* h_dem_x;
float* h_dem_y;
float* h_dem_z;
float* h_demsloper_x;
float* h_demsloper_y;
float* h_demsloper_z;
float* h_demsloper_angle;
float* h_dem_x = (float*)mallocCUDAHost(sizeof(float) * blokline * tempDemCols);
float* h_dem_y = (float*)mallocCUDAHost(sizeof(float) * blokline * tempDemCols);
float* h_dem_z = (float*)mallocCUDAHost(sizeof(float) * blokline * tempDemCols);
float* h_demsloper_x = (float*)mallocCUDAHost(sizeof(float) * blokline * tempDemCols);
float* h_demsloper_y = (float*)mallocCUDAHost(sizeof(float) * blokline * tempDemCols);
float* h_demsloper_z = (float*)mallocCUDAHost(sizeof(float) * blokline * tempDemCols);
float* h_demsloper_angle = (float*)mallocCUDAHost(sizeof(float) * blokline * tempDemCols);
long* h_demcls = (long*)mallocCUDAHost(sizeof(long) * blokline * tempDemCols);
float* d_dem_x;
float* d_dem_y;
float* d_dem_z;
float* d_demsloper_x;
float* d_demsloper_y;
float* d_demsloper_z;
float* d_demsloper_angle;
mallocCUDAHost((void*)h_dem_x, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_dem_y, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_dem_z, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_demsloper_x, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_demsloper_y, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_demsloper_z, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_demsloper_angle, sizeof(float) * blokline * tempDemCols);
mallocCUDADevice((void*)d_dem_x, sizeof(float) * blokline * tempDemCols); // 7
mallocCUDADevice((void*)d_dem_y, sizeof(float) * blokline * tempDemCols);
mallocCUDADevice((void*)d_dem_z, sizeof(float) * blokline * tempDemCols);
mallocCUDADevice((void*)d_demsloper_x, sizeof(float) * blokline * tempDemCols);
mallocCUDADevice((void*)d_demsloper_y, sizeof(float) * blokline * tempDemCols);
mallocCUDADevice((void*)d_demsloper_z, sizeof(float) * blokline * tempDemCols);
mallocCUDADevice((void*)d_demsloper_angle, sizeof(float) * blokline * tempDemCols);
float* h_dem_theta; // 天线方向图
float* h_dem_phi;
float* d_dem_theta;
float* d_dem_phi;
mallocCUDAHost((void*)h_dem_theta, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_dem_phi, sizeof(float) * blokline * tempDemCols);
mallocCUDADevice((void*)d_dem_theta, sizeof(float) * blokline * tempDemCols);// 9
mallocCUDADevice((void*)d_dem_phi, sizeof(float) * blokline * tempDemCols);
HostToDevice((void*)h_dem_theta, (void*)d_dem_theta, sizeof(float) * blokline * tempDemCols);
HostToDevice((void*)h_dem_phi, (void*)d_dem_phi, sizeof(float) * blokline * tempDemCols);
// 提前声明参数变量
float* h_R;// 辐射方向
float* h_localangle;//入射角
float* d_R;// 辐射方向
float* d_localangle;//入射角
mallocCUDAHost((void*)h_R, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_localangle, sizeof(float) * blokline * tempDemCols); // 11
mallocCUDADevice((void*)d_R, sizeof(float) * blokline * tempDemCols);
mallocCUDADevice((void*)d_localangle, sizeof(float) * blokline * tempDemCols);
float* h_RstX;
float* h_RstY;
float* h_RstZ;
float* d_RstX;
float* d_RstY;
float* d_RstZ;
mallocCUDAHost((void*)h_RstX, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_RstY, sizeof(float) * blokline * tempDemCols);
mallocCUDAHost((void*)h_RstZ, sizeof(float) * blokline * tempDemCols); // 14
mallocCUDADevice((void*)d_RstX, sizeof(float)* blokline* tempDemCols);
mallocCUDADevice((void*)d_RstY, sizeof(float)* blokline* tempDemCols);
mallocCUDADevice((void*)d_RstZ, sizeof(float)* blokline* tempDemCols);
float* h_sigma0;
float* h_TransAnt;
float* h_ReciveAnt;
float* d_sigma0;
float* d_TransAnt;
float* d_ReciveAnt;
mallocCUDAHost((void*)h_sigma0 , sizeof(float)* blokline* tempDemCols);
mallocCUDAHost((void*)h_TransAnt , sizeof(float)* blokline* tempDemCols);
mallocCUDAHost((void*)h_ReciveAnt, sizeof(float)* blokline* tempDemCols); // 17
mallocCUDADevice((void*)d_sigma0, sizeof(float)* blokline* tempDemCols);
mallocCUDADevice((void*)d_TransAnt, sizeof(float)* blokline* tempDemCols);
mallocCUDADevice((void*)d_ReciveAnt, sizeof(float)* blokline* tempDemCols);
float* d_dem_x = (float*)mallocCUDADevice(sizeof(float) * blokline * tempDemCols); // 7
float* d_dem_y = (float*)mallocCUDADevice(sizeof(float) * blokline * tempDemCols);
float* d_dem_z = (float*)mallocCUDADevice(sizeof(float) * blokline * tempDemCols);
float* d_demsloper_x = (float*)mallocCUDADevice(sizeof(float) * blokline * tempDemCols);
float* d_demsloper_y = (float*)mallocCUDADevice(sizeof(float) * blokline * tempDemCols);
float* d_demsloper_z = (float*)mallocCUDADevice(sizeof(float) * blokline * tempDemCols);
float* d_demsloper_angle = (float*)mallocCUDADevice(sizeof(float) * blokline * tempDemCols);
long* d_demcls = (long*)mallocCUDADevice(sizeof(long) * blokline * tempDemCols);
// 回波
cuComplex* h_echoAmp;
cuComplex* d_echoAmp;
mallocCUDAHost((void*)h_echoAmp, sizeof(cuComplex)* blokline* tempDemCols);
mallocCUDADevice((void*)d_echoAmp, sizeof(cuComplex)* blokline* tempDemCols); //19
long* h_FreqID;
long* d_FreqID;
mallocCUDAHost((void*)h_FreqID, sizeof(long)* blokline* tempDemCols);
mallocCUDADevice((void*)d_FreqID, sizeof(long)* blokline* tempDemCols); //21
cuComplex* h_echoAmp = (cuComplex*)mallocCUDAHost(sizeof(cuComplex) * blokline * tempDemCols);
cuComplex* d_echoAmp = (cuComplex*)mallocCUDADevice(sizeof(cuComplex) * blokline * tempDemCols);
long* h_echoAmpFID = (long*)mallocCUDAHost(sizeof(long) * blokline * tempDemCols);
long* d_echoAmpFID = (long*)mallocCUDADevice(sizeof(long) * blokline * tempDemCols);
Eigen::MatrixXd landcover= Eigen::MatrixXd::Zero(blokline, tempDemCols);// 地面覆盖类型
long startline = 0;
for (startline = 0; startline < demRow; startline = startline + blokline) {
long newblokline = blokline;
if ((startline + blokline) < demRow) {
if ((startline + blokline) >= demRow) {
newblokline = demRow - startline;
bloklineflag = true;
}
dem_x = demxyz.getData(startline, 0, newblokline, demxyz.width, 1); // 地面坐标
dem_y = demxyz.getData(startline, 0, newblokline, demxyz.width, 2);
dem_z = demxyz.getData(startline, 0, newblokline, demxyz.width, 3);
@ -555,7 +559,6 @@ ErrorCode RTPCProcessCls::RTPCMainProcess(long num_thread)
demsloper_y = demsloperxyz.getData(startline, 0, newblokline, demsloperxyz.width, 2);
demsloper_z = demsloperxyz.getData(startline, 0, newblokline, demsloperxyz.width, 3);
sloperAngle = demsloperxyz.getData(startline, 0, newblokline, demsloperxyz.width, 4);
landcover = demlandcls.getData(startline, 0, newblokline, demlandcls.width, 1);
@ -566,88 +569,83 @@ ErrorCode RTPCProcessCls::RTPCMainProcess(long num_thread)
FreeCUDAHost(h_demsloper_x); FreeCUDADevice(d_demsloper_x);
FreeCUDAHost(h_demsloper_y); FreeCUDADevice(d_demsloper_y);
FreeCUDAHost(h_demsloper_z); FreeCUDADevice(d_demsloper_z); //6
FreeCUDAHost(h_demsloper_angle); FreeCUDADevice(d_demsloper_angle);//7
FreeCUDAHost(h_dem_theta); FreeCUDADevice(d_dem_theta);
FreeCUDAHost(h_dem_phi); FreeCUDADevice(d_dem_phi); //9
FreeCUDAHost(h_R); FreeCUDADevice(d_R);
FreeCUDAHost(h_localangle); FreeCUDADevice(d_localangle); //11
FreeCUDAHost(h_RstX); FreeCUDADevice(d_RstX);
FreeCUDAHost(h_RstY); FreeCUDADevice(d_RstY);
FreeCUDAHost(h_RstZ); FreeCUDADevice(d_RstZ); //14
FreeCUDAHost(h_sigma0 ); FreeCUDADevice(d_sigma0);
FreeCUDAHost(h_TransAnt ); FreeCUDADevice(d_TransAnt);
FreeCUDAHost(h_ReciveAnt); FreeCUDADevice(d_ReciveAnt); //17
FreeCUDAHost(h_demsloper_angle); FreeCUDADevice(d_demsloper_angle);//7
FreeCUDAHost(h_demcls); FreeCUDADevice(d_demcls);//7
FreeCUDAHost(h_echoAmp); FreeCUDADevice(d_echoAmp);//19
FreeCUDAHost(h_FreqID); FreeCUDADevice(d_FreqID);//20
FreeCUDAHost(h_echoAmpFID); FreeCUDADevice(d_echoAmpFID);//19
mallocCUDAHost((void*)h_dem_x, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_dem_y, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_dem_z, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_demsloper_x, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_demsloper_y, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_demsloper_z, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_demsloper_angle, sizeof(float) * blokline * tempDemCols);//7
mallocCUDAHost((void*)h_dem_theta, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_dem_phi, sizeof(float) * newblokline * tempDemCols); //9
mallocCUDAHost((void*)h_R, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_localangle, sizeof(float) * newblokline * tempDemCols);//11
mallocCUDAHost((void*)h_RstX, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_RstY, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_RstZ, sizeof(float) * newblokline * tempDemCols);//14
mallocCUDAHost((void*)h_sigma0, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_TransAnt, sizeof(float) * newblokline * tempDemCols);
mallocCUDAHost((void*)h_ReciveAnt, sizeof(float) * newblokline * tempDemCols);//17
mallocCUDAHost((void*)h_echoAmp, sizeof(cuComplex) * newblokline * tempDemCols);//19
mallocCUDAHost((void*)h_FreqID, sizeof(long) * newblokline * tempDemCols);//20
h_dem_x = (float*)mallocCUDAHost(sizeof(float) * newblokline * tempDemCols);
h_dem_y = (float*)mallocCUDAHost(sizeof(float) * newblokline * tempDemCols);
h_dem_z = (float*)mallocCUDAHost(sizeof(float) * newblokline * tempDemCols);
h_demsloper_x = (float*)mallocCUDAHost(sizeof(float) * newblokline * tempDemCols);
h_demsloper_y = (float*)mallocCUDAHost(sizeof(float) * newblokline * tempDemCols);
h_demsloper_z = (float*)mallocCUDAHost(sizeof(float) * newblokline * tempDemCols);
h_demsloper_angle = (float*)mallocCUDAHost(sizeof(float) * newblokline * tempDemCols);
h_demcls = (long*)mallocCUDAHost(sizeof(long) * newblokline * tempDemCols);
d_dem_x = (float*)mallocCUDADevice(sizeof(float) * newblokline * tempDemCols); // 7
d_dem_y = (float*)mallocCUDADevice(sizeof(float) * newblokline * tempDemCols);
d_dem_z = (float*)mallocCUDADevice(sizeof(float) * newblokline * tempDemCols);
d_demsloper_x = (float*)mallocCUDADevice(sizeof(float) * newblokline * tempDemCols);
d_demsloper_y = (float*)mallocCUDADevice(sizeof(float) * newblokline * tempDemCols);
d_demsloper_z = (float*)mallocCUDADevice(sizeof(float) * newblokline * tempDemCols);
d_demsloper_angle = (float*)mallocCUDADevice(sizeof(float) * newblokline * tempDemCols);
d_demcls = (long*)mallocCUDADevice(sizeof(long) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_dem_x, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_dem_y, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_dem_z, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_demsloper_x, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_demsloper_y, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_demsloper_z, sizeof(float) * newblokline * tempDemCols);//6
mallocCUDADevice((void*)d_demsloper_angle, sizeof(float) * newblokline * tempDemCols);//7
mallocCUDADevice((void*)d_dem_theta, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_dem_phi, sizeof(float) * newblokline * tempDemCols);// 9
mallocCUDADevice((void*)d_R, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_localangle, sizeof(float) * newblokline * tempDemCols);//11
mallocCUDADevice((void*)d_RstX, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_RstY, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_RstZ, sizeof(float) * newblokline * tempDemCols);//14
mallocCUDADevice((void*)d_sigma0, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_TransAnt, sizeof(float) * newblokline * tempDemCols);
mallocCUDADevice((void*)d_ReciveAnt, sizeof(float) * newblokline * tempDemCols);//17
mallocCUDADevice((void*)d_echoAmp, sizeof(cuComplex) * newblokline * tempDemCols); //19
mallocCUDADevice((void*)d_FreqID, sizeof(long) * newblokline * tempDemCols); //20
h_echoAmp = (cuComplex*)mallocCUDAHost(sizeof(cuComplex) * newblokline * tempDemCols);;
d_echoAmp = (cuComplex*)mallocCUDADevice(sizeof(cuComplex) * newblokline * tempDemCols);;
h_echoAmpFID = (long*)mallocCUDAHost(sizeof(long) * newblokline * tempDemCols);
d_echoAmpFID = (long*)mallocCUDADevice(sizeof(long) * newblokline * tempDemCols);
}
for (long i = 0; i < newblokline; i++) {
for (long j = 0; j < demxyz.width; j++) {
h_dem_x[i * demxyz.width + j] = dem_x(i, j);
h_dem_y[i * demxyz.width + j] = dem_y(i, j);
h_dem_z[i * demxyz.width + j] = dem_z(i, j);
h_demsloper_x[i * demxyz.width + j] = demsloper_x(i, j);
h_demsloper_y[i * demxyz.width + j] = demsloper_y(i, j);
h_demsloper_z[i * demxyz.width + j] = demsloper_z(i, j);
h_demsloper_angle[i * demxyz.width + j] = sloperAngle(i, j);
{ // 处理 dem -> 数量
float temp_dem_x;
float temp_dem_y;
float temp_dem_z;
float temp_demsloper_x;
float temp_demsloper_y;
float temp_demsloper_z;
float temp_sloperAngle;
long temp_demclsid;
for (long i = 0; i < newblokline; i++) {
for (long j = 0; j < demxyz.width; j++) {
temp_dem_x= float(dem_x(i, j)) ;
temp_dem_y= float(dem_y(i, j)) ;
temp_dem_z= float(dem_z(i, j)) ;
temp_demsloper_x= float(demsloper_x(i, j));
temp_demsloper_y= float(demsloper_y(i, j));
temp_demsloper_z= float(demsloper_z(i, j));
temp_sloperAngle= float(sloperAngle(i, j));
temp_demclsid = long(landcover(i,j));
h_dem_x[i * demxyz.width + j] = temp_dem_x ;
h_dem_y[i * demxyz.width + j] = temp_dem_y ;
h_dem_z[i * demxyz.width + j] = temp_dem_z ;
h_demsloper_x[i * demxyz.width + j] = temp_demsloper_x ;
h_demsloper_y[i * demxyz.width + j] = temp_demsloper_y ;
h_demsloper_z[i * demxyz.width + j] = temp_demsloper_z ;
h_demsloper_angle[i * demxyz.width + j] = temp_sloperAngle;
h_demcls[i * demxyz.width + j] = clamap[temp_demclsid];
}
}
}
}
HostToDevice((void*)h_dem_x, (void*)d_dem_x, sizeof(float) * newblokline * tempDemCols); // 复制 机器 -> GPU
HostToDevice((void*)h_dem_y, (void*)d_dem_y, sizeof(float) * newblokline * tempDemCols);
HostToDevice((void*)h_dem_z, (void*)d_dem_z, sizeof(float) * newblokline * tempDemCols);
HostToDevice((void*)h_demsloper_x, (void*)d_demsloper_x, sizeof(float) * newblokline * tempDemCols);
HostToDevice((void*)h_demsloper_y, (void*)d_demsloper_y, sizeof(float) * newblokline * tempDemCols);
HostToDevice((void*)h_demsloper_z, (void*)d_demsloper_z, sizeof(float) * newblokline * tempDemCols);
HostToDevice((void*)h_demsloper_angle, (void*)d_demsloper_angle, sizeof(float) * newblokline * tempDemCols);
HostToDevice((void*)h_dem_theta, (void*)d_dem_theta, sizeof(float) * blokline * tempDemCols);
HostToDevice((void*)h_dem_phi, (void*)d_dem_phi, sizeof(float) * blokline * tempDemCols);
HostToDevice((void*)h_demsloper_angle, (void*)d_demsloper_angle, sizeof(float) * newblokline * tempDemCols);
HostToDevice((void*)h_demcls, (void*)d_demcls, sizeof(float) * newblokline * tempDemCols);//地表覆盖
long pixelcount = newblokline * tempDemCols;
for (long prfid = 0; prfid < pluseCount; prfid++) {
{// 计算
std::cout << "\r[" << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString() << "] dem:\t" << startline << "\t-\t" << startline + newblokline << "\t:\t pluse :\t" << prfid << " / " << pluseCount << std::endl;
// 天线位置
float antpx = sateOirbtNodes[prfid].Px;
float antpy = sateOirbtNodes[prfid].Py;
@ -667,52 +665,34 @@ ErrorCode RTPCProcessCls::RTPCMainProcess(long num_thread)
float antZaxisX = sateOirbtNodes[prfid].AntZaxisX;
float antZaxisY = sateOirbtNodes[prfid].AntZaxisY;
float antZaxisZ = sateOirbtNodes[prfid].AntZaxisZ;//18
make_VectorA_B(antpx, antpy, antpz, d_dem_x, d_dem_y, d_dem_z, d_RstX, d_RstY, d_RstZ, pixelcount); // Rst = Rs - Rt;
Norm_Vector(d_RstX, d_RstY, d_RstZ,d_R,pixelcount); // R
cosAngle_VA_AB(d_RstX, d_RstY, d_RstZ, d_demsloper_x, d_demsloper_y, d_demsloper_z,d_localangle ,pixelcount); // 局部入射角
SatelliteAntDirectNormal(d_RstX, d_RstY, d_RstZ,antXaxisX, antXaxisY, antXaxisZ,antYaxisX, antYaxisY, antYaxisZ,antZaxisX, antZaxisY, antZaxisZ,antdirectx, antdirecty, antdirectz,d_dem_theta, d_dem_phi , pixelcount);// 计算角度
DeviceToHost(h_dem_theta, d_dem_theta, sizeof(float)*pixelcount); // 从GPU -> 主机
DeviceToHost(h_dem_phi, d_dem_phi, sizeof(float)*pixelcount);
DeviceToHost(h_localangle, d_localangle, sizeof(float)*pixelcount);
std::cout << "\r[" << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString() << "] GPU :\t" << std::endl;
CUDA_RTPC_SiglePRF(
antpx, antpy, antpz,// 天线坐标
antXaxisX, antXaxisY, antXaxisZ, // 天线坐标系
antYaxisX, antYaxisY, antYaxisZ, //
antZaxisX, antZaxisY, antZaxisZ,
antdirectx, antdirecty, antdirectz,// 天线指向
d_dem_x, d_dem_y, d_dem_z, d_demcls, // 地面坐标
d_demsloper_x, d_demsloper_y, d_demsloper_z, d_demsloper_angle,// 地面坡度
d_TantPattern, TstartTheta,TstartPhi, Tdtheta, Tdphi, Tthetanum, Tphinum,// 天线方向图相关
d_RantPattern, RstartTheta, RstartPhi, Rdtheta, Rdphi, Rthetanum,Rphinum,// 天线方向图相关
lamda, Fs, NearRange, Pt, PlusePoint, // 参数
d_clsSigmaParam, clamapid,// 地表覆盖类型-sigma插值对应函数-ulaby
d_echoAmp, d_echoAmpFID,
pixelcount
);
DeviceToHost(h_echoAmpFID, d_echoAmpFID, sizeof(long)* newblokline* tempDemCols);
DeviceToHost(h_echoAmp, d_echoAmp, sizeof(long)* newblokline* tempDemCols);
std::cout << "\r[" << QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss.zzz").toStdString() << "] GPU SIGMA:\t" << std::endl;
for (long ii =0; ii <blokline; ii++) { // 计算发射天线方向图
for (long jj = 0; jj < tempDemCols; jj++) {
h_TransAnt[ii * tempDemCols + jj] =TransformPattern->getGainLearThetaPhi(h_dem_theta[ii*tempDemCols+ jj], h_dem_phi[ii * tempDemCols + jj] );
}
}
for (long ii = 0; ii < blokline; ii++) { // 计算接收天线方向图
for (long jj = 0; jj < tempDemCols; jj++) {
h_ReciveAnt[ii * tempDemCols + jj] = ReceivePattern->getGainLearThetaPhi(h_dem_theta[ii * tempDemCols + jj], h_dem_phi[ii * tempDemCols + jj]);
}
}
for (long ii = 0; ii < blokline; ii++) {// 后向散射图
for (long jj = 0; jj < tempDemCols; jj++) {
h_sigma0[ii * tempDemCols + jj] = this->SigmaDatabasePtr->getAmp(landcover(ii,jj), h_localangle[ii*tempDemCols+jj] * r2d, polartype);
}
}
HostToDevice((void*)h_sigma0, (void*)d_sigma0, sizeof(float)* pixelcount);
HostToDevice((void*)h_TransAnt, (void*)d_TransAnt, sizeof(float)* pixelcount);
HostToDevice((void*)h_ReciveAnt, (void*)d_ReciveAnt, sizeof(float)* pixelcount);
// 计算回波
calculationEcho(d_sigma0, d_TransAnt, d_ReciveAnt,d_localangle, d_R, d_demsloper_angle,NearRange, Fs, Pt, lamda, PlusePoint,d_echoAmp, d_FreqID, pixelcount);
DeviceToHost(h_echoAmp, d_echoAmp, sizeof(float)* pixelcount);
DeviceToHost(h_FreqID, d_FreqID, sizeof(long)* pixelcount);
// 回波存档
for (long i = 0; i < pixelcount; i++) {
echo.get()[i*PlusePoint+ h_FreqID[i]] =std::complex<double>(h_echoAmp[i].x, h_echoAmp[i].y);
echo.get()[prfid*PlusePoint+ h_echoAmpFID[i]] =std::complex<double>(h_echoAmp[i].x, h_echoAmp[i].y);
}
std::cout << "\r"<<"dem:\t"<<startline <<"\t-\t"<<startline+newblokline<<"\t:\t pluse :\t"<<prfid<<" / " <<pluseCount ;
}
}
@ -722,32 +702,20 @@ ErrorCode RTPCProcessCls::RTPCMainProcess(long num_thread)
// 地面数据释放
FreeCUDAHost(h_dem_x); FreeCUDADevice(d_dem_x);
FreeCUDAHost(h_dem_y); FreeCUDADevice(d_dem_y);
FreeCUDAHost(h_dem_z); FreeCUDADevice(d_dem_z);
FreeCUDAHost(h_demsloper_x); FreeCUDADevice(d_demsloper_x);
FreeCUDAHost(h_demsloper_y); FreeCUDADevice(d_demsloper_y);
FreeCUDAHost(h_demsloper_z); FreeCUDADevice(d_demsloper_z); //6
FreeCUDAHost(h_dem_x); FreeCUDADevice(d_dem_x);
FreeCUDAHost(h_dem_y); FreeCUDADevice(d_dem_y);
FreeCUDAHost(h_dem_z); FreeCUDADevice(d_dem_z);
FreeCUDAHost(h_demsloper_x); FreeCUDADevice(d_demsloper_x);
FreeCUDAHost(h_demsloper_y); FreeCUDADevice(d_demsloper_y);
FreeCUDAHost(h_demsloper_z); FreeCUDADevice(d_demsloper_z); //6
FreeCUDAHost(h_demsloper_angle); FreeCUDADevice(d_demsloper_angle); //7
FreeCUDAHost(h_demcls); FreeCUDADevice(d_demcls);//7
FreeCUDAHost(h_echoAmp); FreeCUDADevice(d_echoAmp);//19
FreeCUDAHost(h_echoAmpFID); FreeCUDADevice(d_echoAmpFID);//19
// 临时变量释放
FreeCUDAHost(h_dem_theta); FreeCUDADevice(d_dem_theta);
FreeCUDAHost(h_dem_phi); FreeCUDADevice(d_dem_phi);// 9
FreeCUDAHost(h_R); FreeCUDADevice(d_R);
FreeCUDAHost(h_localangle); FreeCUDADevice(h_localangle); //11
FreeCUDAHost(h_RstX); FreeCUDADevice(d_RstX);
FreeCUDAHost(h_RstY); FreeCUDADevice(d_RstY);
FreeCUDAHost(h_RstZ); FreeCUDADevice(d_RstZ); //14
FreeCUDAHost(h_sigma0); FreeCUDADevice(d_sigma0);
FreeCUDAHost(h_TransAnt); FreeCUDADevice(d_TransAnt);
FreeCUDAHost(h_ReciveAnt); FreeCUDADevice(d_ReciveAnt); //17
FreeCUDAHost(h_echoAmp); FreeCUDADevice(d_echoAmp);//19
FreeCUDAHost(h_FreqID); FreeCUDADevice(d_FreqID);//20
FreeCUDAHost(h_TantPattern); FreeCUDADevice(d_TantPattern);
FreeCUDAHost(h_RantPattern); FreeCUDADevice(d_RantPattern);
FreeCUDAHost(h_clsSigmaParam); FreeCUDADevice(d_clsSigmaParam);
#endif

44
SimulationSAR/SARSatelliteSimulationAbstractCls.cpp
View File

@ -772,6 +772,50 @@ Eigen::MatrixXd AbstractRadiationPattern::getGainMatrix()
return this->GainMatrix;
}
double AbstractRadiationPattern::getMaxTheta()
{
double maxtheta = this->thetas[0];
long len = this->thetas.size();
if (maxtheta < this->thetas[len - 1]) {
maxtheta = this->thetas[len - 1];
}
return maxtheta;
}
double AbstractRadiationPattern::getMinTheta()
{
double mintheta = this->thetas[0];
long len = this->thetas.size();
if (mintheta > this->thetas[len - 1]) {
mintheta = this->thetas[len - 1];
}
return mintheta;
return 0.0;
}
double AbstractRadiationPattern::getMaxPhi()
{
double maxphi = this->phis[0];
long len = this->phis.size();
if (maxphi < this->phis[len - 1]) {
maxphi = this->phis[len - 1];
}
return maxphi;
return 0.0;
}
double AbstractRadiationPattern::getMinPhi()
{
double minphi = this->phis[0];
long len = this->phis.size();
if (minphi > this->phis[len - 1]) {
minphi = this->phis[len - 1];
}
return minphi;
return 0.0;
}

5
SimulationSAR/SARSatelliteSimulationAbstractCls.h
View File

@ -118,6 +118,11 @@ public:
virtual std::vector<double> getThetas();
virtual std::vector<double> getPhis();
virtual Eigen::MatrixXd getGainMatrix();
virtual double getMaxTheta();
virtual double getMinTheta();
virtual double getMaxPhi();
virtual double getMinPhi();
private:
std::vector<RadiationPatternGainPoint> GainMap; // 天线方向图

14
SimulationSAR/SigmaDatabase.cpp
View File

@ -141,3 +141,17 @@ double SigmaDatabase::getAmp(long cls, double angle, POLARTYPEENUM polartype)
}
}
std::map<long, SigmaParam> SigmaDatabase::getsigmaParams(POLARTYPEENUM polartype)
{
switch (polartype)
{
case(POLARHH): { return this->HH_sigmaParam; }
case(POLARHV): { return this->HV_sigmaParam; }
case(POLARVH): { return this->VH_sigmaParam; }
case(POLARVV): { return this->VV_sigmaParam; }
default:
return std::map<long, SigmaParam>();
}
}

2
SimulationSAR/SigmaDatabase.h
View File

@ -73,6 +73,8 @@ public:
double getAmp(long cls, double angle, POLARTYPEENUM polartype);
std::map<long, SigmaParam> getsigmaParams( POLARTYPEENUM polartype);
private:
std::map<long, SigmaParam> HH_sigmaParam;
std::map<long, SigmaParam> HV_sigmaParam;