rc.c

雷达仿真的c程序

//==============================================================================================================================================

#include <math.h>
#include <stdio.h>
#include <stdlib.h>

//==============================================================================================================================================
//              常数定义
//==============================================================================================================================================

#define WLENGTH   0.00875                   //   波长
#define SLANT     7500                      //   作用距离
#define V_plane   90                        //   载机速度

#define PI        3.1415926535897
#define PRF       1000	
#define FS        220                     	//   兆赫
#define T1 	      30                        //   微秒
#define BW	      200                      	//   兆赫

#define ANUM  	  4096                      //   方位
#define RNUM      8192                      //   距离
#define RN        2048                      //   距离向有效数据

#define ZNUM      0                         //   FFT移位
#define YY        2                         //   回波数据2， 回波量化像0

//==============================================================================================================================================

void  rangecompression();
void  turncorner();
void  imageout();
float Max_val();
float Min_val();
void  fft(float *x, float *y, int n, int flag);

//==============================================================================================================================================
//                  全局变量
//==============================================================================================================================================

float   range_datar[ANUM][RNUM],  range_datai[ANUM][RNUM];
float   azimu_datar[RNUM][ANUM];

//==============================================================================================================================================

void main()
{
	printf("Range compressing, waiting...\n");
	rangecompression();

    if(YY>1)   //  回波数据
	{
      printf("Turn corner, waiting...\n\n");
  	  turncorner();
	}
	else       //  回波量化像
	{
	  printf("Imaging, waiting...\n");
	  imageout();
	}
}

//==============================================================================================================================================
//                     距离压缩
//==============================================================================================================================================

void rangecompression()
{
	int      i,j;
	unsigned char  temp[RNUM];
	int      frnum;
	int      start;
	float    K;
	float    refr[RNUM],refi[RNUM];
	float    dr[RNUM],di[RNUM];
	float    wnd;
	float    t;
	float    re, im;
	float    dianpr, dianpi;

	FILE     *fin;
	fin      = fopen("d:/data/10data/d1208f0-fish.dat","rb");
	start    =  0;

    fseek(fin, (long)((5865*4+18000)*8192*2 + RNUM * start * 2), 0);

//====================================================================================================================================================
//                           原始数据电平校正
//====================================================================================================================================================

	for(j=0;j<ANUM;j++)
	{
	    dianpr = 0.0;
		dianpi = 0.0;

		fread(&temp,sizeof(unsigned char),RNUM,fin);
		for( i=0; i<RNUM; i++ )
		{
			dianpr += temp[i];
		}
		dianpr = dianpr / RNUM;
		
		for(i=0;i<RNUM;i++)
		{
			if(i<8000)
			{
				range_datar[j][i]=(float)temp[i]-dianpr;
			}
			else
			{
				range_datar[j][i]=0;
			}
		}

		fread(&temp,sizeof(unsigned char),RNUM,fin);
		for( i=0; i<RNUM; i++ )
		{
			dianpi += temp[i];
		}
		dianpi = dianpi / RNUM;

		for(i=0;i<RNUM;i++)
		{
			if(i<8000)
			{
				range_datai[j][i]=(float)temp[i]-dianpi;
			}
			else
			{
				range_datai[j][i]=0;
			}
		}	
	}
//====================================================================================================================================================
	
	fclose(fin);
	frnum = (unsigned int)floor(FS*T1);                 // 脉冲宽度
	K     = (float)(BW/T1);                             // 调频率
	printf("frnum=%d---K=%f\n", frnum, K);

//==============================================================================================================================================
//                    距离压缩参考函数
//==============================================================================================================================================

	for( i=0; i<RNUM; i++ )
	{
		if( i<frnum)
		{
			t = (float) (i-frnum/2 ) / FS;

			wnd = (float) (0.54 - 0.46*cos( 2.0*PI*i/(frnum) ));
			refr[i] = (float) (wnd * cos( -PI*K*t*t ));
			refi[i] = (float) (wnd * sin( -PI*K*t*t ));
		}
		else
		{
			refr[i] = 0.0;
			refi[i] = 0.0;
		}
	}

	fft( refr, refi, RNUM, 0 );

//==============================================================================================================================================

	for(j=0;j<ANUM;j++)
	{
		for(i=0;i<RNUM;i++)
		{
			dr[i] = range_datar[j][i];
			di[i] = range_datai[j][i];
		}
		fft( dr, di, RNUM, 0 );

		for( i=0; i<RNUM; i++ )
		{
			re = dr[i];
			im = di[i];
			dr[i] = re*refr[i] - im*refi[i];
			di[i] = re*refi[i] + im*refr[i];
		}
		fft( dr, di, RNUM, 1 );

		for(i=0;i<RNUM;i++)
		{
			range_datar[j][i] = dr[i+ZNUM];
			range_datai[j][i] = di[i+ZNUM];
		}

	if(YY<1)     //  回波量化像
	{
	    for( i=0; i<RNUM; i++)  
		{
        	azimu_datar[i][j] = (float)sqrt( range_datar[j][i]*range_datar[j][i] + range_datai[j][i]*range_datai[j][i] );
		}
	}
	}
}

//==============================================================================================================================================
//                     矩阵转置
//==============================================================================================================================================

void turncorner()
{
	int   i,j;
	FILE  *fout1, *fout2;

	fout1 = fopen("rc-end.r","wb");
	fout2 = fopen("rc-end.i","wb");

	for(j=0; j<ANUM; j++)            // R数据
	{
		for(i=6724;i<RNUM;i++)       //去掉前6724行数据
		{
          azimu_datar[i-6724][j] = range_datar[j][i];
		}
		for (i=1468; i<RN; i++)
		{
          azimu_datar[i][j] = 0.0;
		}
    }
	for(i=0;i<RN;i++)            
    {
		fwrite( azimu_datar[i], sizeof(float), ANUM, fout1 );
	}

	for(j=0; j<ANUM; j++)            // I数据
	{
		for(i=6724;i<RNUM;i++)       //去掉前6724行数据
		{
          azimu_datar[i-6724][j] = range_datai[j][i];
		}
		for (i=1468; i<RN; i++)
		{
          azimu_datar[i][j] = 0.0;
		}
    }
	for(i=0;i<RN;i++)          
    {
		fwrite( azimu_datar[i], sizeof(float), ANUM, fout2 );
	}

	fclose(fout1);
	fclose(fout2);
}

//==============================================================================================================================================
//                                    直方图量化
//==============================================================================================================================================

float Max_val(float * fp, int a)
{
	int i;
	float x;

	x=fp[0];
	for(i=1;i<a;i++)
	{
		if(fp[i]>x) { x=fp[i]; }
	}
	return x;
}

float Min_val(float * fp, int a)
{
	int i;
	float x;

	x=fp[0];
	for(i=1;i<a;i++)
	{
		if(fp[i]<x){ x=fp[i]; }
	}
	return x;
}

//==============================================================================================================================================

void imageout()
{
	float tmpval;
	float *MaxArray,*MinArray;
	int i,j,z,height,width, N, idx_bottom, idx_top, num;
	int * hisg;
	unsigned char *out;
	float  x,y;
	FILE   *fidw;
	
	height=RNUM;
	width=ANUM;

	fidw=fopen("output2.raw","wb");
	
	// hisgram level
	N = width;
	
	MaxArray=calloc(height,sizeof(float));
	MinArray=calloc(height,sizeof(float));
	hisg = calloc( N, sizeof(int) );
	out=calloc(width,sizeof(unsigned char));

	for( i=0; i<N; i++ )
	{
		hisg[i] = 0;
	}

	for(i=0;i<height;i++)
	{
		MaxArray[i]=Max_val(azimu_datar[i],width);
		MinArray[i]=Min_val(azimu_datar[i],width);
	}
	x = Max_val(MaxArray,height);
	y = Min_val(MinArray,height);
	free(MaxArray);
	free(MinArray);

	// for hisgram
	for(i=0;i<height;i++)
	{
		for(j=0;j<width;j++)
		{
			z= (int) floor((azimu_datar[i][j]-y)*N/(x-y));
			if( z>= N )
				z = N-1;
			if( z<0 )
				z = 0;
			hisg[z] ++;
		}
	}

	// for 最小值 直方图的索引
	num = ( int ) floor( width*height*0.015 );
	z = 0;
	i = 0;
	while( z<num )
	{
		z += hisg[i];
		i ++ ;
	}
	idx_bottom = i - 1 ;
	
	// for 最大值 直方图的索引
	num = ( int ) floor( width*height*0.015 );
	z = 0;
	i = N-1;
	while( z<num )
	{
		z += hisg[ i ];
		i --;
	}
	idx_top = i + 1 ;

	// 确定用于量化的最大值和最小值
	tmpval = idx_top * ( x - y ) / N + y ;
	y = idx_bottom * ( x - y ) / N + y ;
	x = tmpval ;

	// 量化成256级灰度
	for(i=0;i<height;i++)
	{
		for(j=0;j<width;j++)
		{
			z=(int) floor( (azimu_datar[i][j]-y)*256/(x-y) );
			if( z>255 )
				z = 255;
			if( z<0 )
				z = 0;
			out[j]=(unsigned char)z;
		}
		fwrite(&out[0],sizeof(unsigned char),width,fidw);
	}

	free(out);
	free(hisg);
	fclose(fidw);	
}
//==============================================================================================================================================
//                    FILE           END
//==============================================================================================================================================