public static void conjugate_complex(int n,complex[] in1,complex[] out1) {
int i = 0;
for(i=0;i<n;i++) {
out1[i].imag = -in1[i].imag;
out1[i].real = in1[i].real;
}
}
public static void Wn_i(int n, int i, complex Wn, int flag)
{
Wn.real = Math.Cos(2*PI*i/n);
if(flag == 1)
Wn.imag = -Math.Sin(2*PI*i/n);
else if(flag == 0)
Wn.imag = -Math.Sin(2*PI*i/n);
}
public static void c_abs(complex[] f,double[] out1,int n) {
int i = 0;
double t;
for(i=0;i<n;i++) {
t = f[i].real * f[i].real + f[i].imag * f[i].imag;
out1[i] = Math.Sqrt(t);
}
}
//傅里叶变化
public static void fft(int N, complex[] f)
{
complex t=new complex(),wn=new complex();//中间变量
int i,j,k,m,n,l,r,M;
int la,lb,lc;
/*----计算分解的级数M=log2(N)----*/
for(i=N,M=1;(i=i/2)!=1;M++);
/*----按照倒位序重新排列原信号----*/
for(i=1,j=N/2;i<=N-2;i++) {
if(i<j)
{
t=f[j];
f[j]=f[i];
f[i]=t;
}
k=N/2;
while(k<=j)
{
j=j-k;
k=k/2;
}
j=j+k;
}
/*----FFT算法----*/
for(m=1;m<=M;m++) {
la=(int)Math.Pow(2,m); //la=2^m代表第m级每个分组所含节点数
lb=la/2; //lb代表第m级每个分组所含碟形单元数
//同时它也表示每个碟形单元上下节点之间的距离
/*----碟形运算----*/
for(l=1;l<=lb;l++) {
r=(int)((l-1)*Math.Pow(2,M-m));
for(n=l-1;n<N-1;n=n+la) //遍历每个分组，分组总数为N/la
{
lc=n+lb; //n,lc分别代表一个碟形单元的上、下节点编号
Wn_i(N,r,wn,1);//wn=Wnr
c_mul(f[lc],wn,t);//t = f[lc] * wn复数运算
c_sub(f[n],t,(f[lc]));//f[lc] = f[n] - f[lc] * Wnr
c_plus(f[n],t,(f[n]));//f[n] = f[n] + f[lc] * Wnr
}
}
}
}
public static void c_div(complex a, complex b, complex c)
{
c.real = (a.real * b.real + a.imag * b.imag)/(b.real * b.real +b.imag * b.imag);
c.imag = (a.imag * b.real - a.real * b.imag)/(b.real * b.real +b.imag * b.imag);
}
public static void c_mul(complex a, complex b, complex c)
{
c.real = a.real * b.real - a.imag * b.imag;
c.imag = a.real * b.imag + a.imag * b.real;
}
public static void c_sub(complex a, complex b, complex c)
{
c.real = a.real - b.real;
c.imag = a.imag - b.imag;
}
public static void c_plus(complex a, complex b, complex c)
{
c.real = a.real + b.real;
c.imag = a.imag + b.imag;
}
public static void getRawData(complex[] data, double[] Tr, double[] R_path, double[] T_path, double[] Targets, double[] sigma, long TargetNum, double ApertureRange_min, double ApertureRange_max)
{
double tp = Tp;
calculateData(data, Tr, tp, R_path, T_path, Targets, sigma, TargetNum, R_center, ApertureRange_min, ApertureRange_max);
/*
double *data_r,*data_i;
FILE *file_r,*file_i;
file_r=fopen("RawEcho_r.dat","wb");
file_i=fopen("RawEcho_i.dat","wb");
data_r=new double[AziNum*RanNum];
data_i=new double[AziNum*RanNum];
for (int i=0;i<AziNum*RanNum;i++) {
data_r[i]=data[i].real;
data_i[i]=data[i].imag;
}
fwrite(data_r,sizeof(double),AziNum*RanNum,file_r);
fwrite(data_i,sizeof(double),AziNum*RanNum,file_i);
fclose(file_r);
fclose(file_i);
delete[] data_r;
delete[] data_i;*/
//生成参考函数
complex[] ran_ref=new complex[RanNum];
for (int i = 0; i < RanNum;i++ )
{
ran_ref[i] = new complex();
}
createRanRef(ran_ref, Tr);
fftshift(ran_ref, RanNum);
//回波生成
FFT.fft((int)RanNum, ran_ref);
for (int i = 0; i<AziNum; i++) {
complex[] tmpData = new complex[RanNum];
for (int j = 0; j < RanNum; j++) {
tmpData[j] = data[RanNum * i + j];
}
FFT.fft((int)RanNum, tmpData);
}
createRawData(data, data, ran_ref);
for (int i = 0; i<AziNum; i++) {
complex[] tmpData = new complex[RanNum];
for (int j = 0; j < RanNum; j++)
{
tmpData[j] = data[RanNum * i + j];
}
FFT.ifft((int)RanNum, tmpData);
}
}
public static void createRawData(complex[] dev_RawData, complex[] dev_data, complex[] RanRef)
{
for (int j = 0; j<AziNum; j++) {
for (int i = 0; i<RanNum; i++) {
double real = dev_RawData[j*RanNum + i].real;
double imag = dev_RawData[j*RanNum + i].imag;
dev_RawData[j*RanNum + i].real = real*RanRef[i].real - imag*RanRef[i].imag;
dev_RawData[j*RanNum + i].imag = real*RanRef[i].imag + imag*RanRef[i].real;
}
}
}
public static void calculateData(complex[] data, double[] Tr, double tp, double[] R_path, double[] T_path, double[] Targets, double[] sigma, long TargetNum, double R_center, double ApertureRange_min, double ApertureRange_max)
{
for (int j = 0; j<AziNum; j++) {
for (int i = 0; i<RanNum; i++) {
data[j*RanNum + i].real = 0;
data[j*RanNum + i].imag = 0;
for (int t = 0; t < TargetNum; t++) {
double TargetRange = Targets[t * 3 + 1] - R_path[3 * j + 1];
if ((TargetRange >= (ApertureRange_min)) && (TargetRange<(ApertureRange_max))) {
double Rt = Math.Sqrt(Math.Pow(T_path[3 * j + 0] - Targets[3 * t], 2) + Math.Pow(T_path[3 * j + 1] - Targets[3 * t + 1], 2) + Math.Pow(T_path[3 * j + 2] - Targets[3 * t + 2], 2));
double Rr = Math.Sqrt(Math.Pow(R_path[3 * j + 0] - Targets[3 * t], 2) + Math.Pow(R_path[3 * j + 1] - Targets[3 * t + 1], 2) + Math.Pow(R_path[3 * j + 2] - Targets[3 * t + 2], 2));
double R_target = Rt + Rr;
double delta_T = (R_target - (R_center)) / c;
//double R_target=Targets_Rs[j*(*TargetNum)+t];
//double delta_T=(R_target-(*R_center))/C;
//if (Math.Abs(Tr[i]-delta_T)<(*tp)/2) {
// data[j*RanNum+i].x=data[j*RanNum+i].x+sigma[t]*Math.Cospi(-2*Fc*R_target/C+Kr*Math.Pow(Tr[i]-delta_T,2));
// data[j*RanNum+i].y=data[j*RanNum+i].y+sigma[t]*Math.Sinpi(-2*Fc*R_target/C+Kr*Math.Pow(Tr[i]-delta_T,2));
//}
double StepLen = Math.Abs(Tr[1] - Tr[0]);
if (Math.Abs(Tr[i] - delta_T) <= Math.Abs(StepLen)) {
double new_sigma = sigma[t] * (StepLen - Math.Abs(Tr[i] - delta_T)) / StepLen;
data[j*RanNum + i].real = data[j*RanNum + i].real + new_sigma*Math.Cos(-2.0*PI*Fc*R_target / c);
data[j*RanNum + i].imag = data[j*RanNum + i].imag + new_sigma*Math.Sin(-2.0*PI*Fc*R_target / c);
}
}
}
}
}
}
public static void fftshift(complex[] ran_ref, long len)
{
double x, y;
for (int i = 0; i<len / 2; i++) {
x = ran_ref[i].real;
y = ran_ref[i].imag;
ran_ref[i].real = ran_ref[i + len / 2].real;
ran_ref[i].imag = ran_ref[i + len / 2].imag;
ran_ref[i + len / 2].real = x;
ran_ref[i + len / 2].imag = y;
}
}
public static void createRanRef(complex[] ran_ref, double[] Tr)
{
for (int i = 0; i<RanNum; i++) {
if (Math.Abs(Tr[i])<Tp / 2) {
ran_ref[i].real = Math.Cos(PI*Kr*Tr[i] * Tr[i]);
ran_ref[i].imag = Math.Sin(PI*Kr*Tr[i] * Tr[i]);
}
else {
ran_ref[i].real = 0;
ran_ref[i].imag = 0;
}
}
}
//傅里叶逆变换
public static void ifft(int N, complex[] f)
{
int i=0;
conjugate_complex(N,f,f);
fft(N,f);
conjugate_complex(N,f,f);
for(i=0;i<N;i++)
{
f[i].imag = (f[i].imag)/N;
f[i].real = (f[i].real)/N;
}
}
