void debugWritePatch_Line(int lineNo, complexFloat *line, char *basename,
int n_range, int n_az)
{
FILE *fp;
meta_parameters *meta;
char outname[320],name[320];
char *mode;
strcpy(outname,g.out);
strcat(strcat(outname,"_"),basename);
strcat(strcpy(name,outname),".img");
if (lineNo == 0) {
meta = meta_read(g.in1);
meta->general->line_count = n_range;
meta->general->sample_count = n_az;
meta->general->data_type = COMPLEX_REAL32;
meta->general->image_data_type = COMPLEX_IMAGE;
meta_write(meta, name);
} else {
meta = meta_read(name);
}
mode = lineNo == 0 ? "wb" : "ab";
fp = fopenImage(name,mode);
put_complexFloat_line(fp, meta, lineNo, line);
FCLOSE(fp);
if (lineNo == meta->general->line_count - 1)
patchToRGBImage(outname, TRUE);
meta_free(meta);
}
/*
DebugWritePatch:
Outputs the current patch trans array, and
converts it to amplitude and phase.
*/
void debugWritePatch(const patch *p,char *basename)
{
FILE *fp;
char name[1024],outname[1024];
meta_parameters *meta;
int i;
strcpy(outname,g.out);
strcat(strcat(outname,"_"),basename);
strcat(strcpy(name,outname),".img");
meta = meta_read(g.in1);
meta->general->line_count = p->n_range;
meta->general->sample_count = p->n_az;
meta->general->data_type = COMPLEX_REAL32;
meta->general->image_data_type = COMPLEX_IMAGE;
meta_write(meta, name);
fp = fopenImage(name,"wb");
for (i=0; i<p->n_range; ++i)
put_complexFloat_line(fp, meta, i, p->trans+i*p->n_az);
FCLOSE(fp);
meta_free(meta);
patchToRGBImage(outname, TRUE);
}
/*
writePatch:
Outputs one full patch of data to the given file.
*/
void writePatch(const patch *p,const satellite *s,meta_parameters *meta,
const file *f,int patchNo)
{
int outLine; /* Counter for line base output */
FILE *fp_amp,*fp_cpx; /* File pointers for the amplitude and complex outputs*/
FILE *fp_pwr,*fp_sig; /* File pointers for the power and Sigma_0 outputs */
FILE *fp_gam,*fp_bet; /* File pointers for the Gamma_0 and Beta_0 outputs */
complexFloat *outputBuf; /* Buffer for one line of patch = n_range */
complexFloat *mlBuf; /* Buffer for multilooking the amplitude image */
float *amps; /* Output Amplitude = n_az/nlooks X n_range */
float *pwrs; /* Output power */
char *openMode="ab"; /* Normally append output.*/
int mlCount=0; /* Counter for setting up the multilook buffer */
int writeNoiseTable=0; /* Flag to determine whether to write the noise table and
antenna pattern */
int off_slc = f->n_az_valid * (patchNo-1);
int off_ml = f->n_az_valid * (patchNo-1) / (f->nlooks);
if (patchNo==1)
openMode="wb"; /* for first patch, truncate output. */
if ((patchNo==1) && (s->vecLen!=0))
writeNoiseTable=1; /* If first patch AND antenna pattern correction,
write the noise table */
update_status("Range-doppler done");
if (!quietflag) printf(" WRITING PATCH OUT...\n");
elapse(0);
/* Allocate buffer space ------------------------*/
amps = (float *) MALLOC(p->n_range*sizeof(float));
pwrs = (float *) MALLOC(p->n_range*sizeof(float));
outputBuf = (complexFloat *)MALLOC(p->n_range*sizeof(complexFloat));
mlBuf = (complexFloat *)MALLOC(p->n_range*f->nlooks*sizeof(complexFloat));
/* Fill in metadata */
meta_get_latLon(meta, meta->general->line_count/2,
meta->general->sample_count/2, 0.0,
&(meta->general->center_latitude),
&(meta->general->center_longitude));
meta_parameters *metaCpx=meta_copy(meta);
metaCpx->general->data_type = COMPLEX_REAL32;
metaCpx->general->image_data_type = COMPLEX_IMAGE;
metaCpx->general->radiometry = r_AMP;
metaCpx->general->line_count = f->n_az_valid * patchNo;
metaCpx->general->sample_count = p->n_range;
meta_get_latLon(metaCpx, metaCpx->general->line_count/2,
metaCpx->general->sample_count/2, 0.0,
&(metaCpx->general->center_latitude),
&(metaCpx->general->center_longitude));
metaCpx->general->start_line = f->firstLineToProcess + s->dop_precomp + 1;
metaCpx->general->start_sample = f->skipFile + 1;
metaCpx->general->x_pixel_size = f->rngpix;
metaCpx->general->y_pixel_size = f->azpix;
meta_write(metaCpx, f->out_cpx);
fp_cpx=fopenImage(f->out_cpx,openMode);
meta_parameters *metaAmp=meta_copy(metaCpx);
metaAmp->general->data_type = REAL32;
metaAmp->general->image_data_type = AMPLITUDE_IMAGE;
metaAmp->general->radiometry = r_AMP;
metaAmp->general->line_count = f->n_az_valid / f->nlooks * patchNo;
metaAmp->general->y_pixel_size *= f->nlooks;
metaAmp->sar->azimuth_time_per_pixel *= f->nlooks;
meta_write(metaAmp, f->out_amp);
fp_amp=fopenImage(f->out_amp,openMode);
meta_parameters *metaPower=0, *metaSigma=0, *metaGamma=0, *metaBeta=0;
if (s->imageType.power) {
metaPower=meta_copy(metaAmp);
metaPower->general->image_data_type = AMPLITUDE_IMAGE;
metaPower->general->radiometry = r_POWER;
meta_write(metaPower, f->out_pwr);
fp_pwr=fopenImage(f->out_pwr,openMode);
}
if (s->imageType.sigma) {
metaSigma=meta_copy(metaAmp);
metaSigma->general->image_data_type = AMPLITUDE_IMAGE;
metaSigma->general->radiometry = r_SIGMA;
meta_write(metaSigma, f->out_sig);
fp_sig=fopenImage(f->out_sig,openMode);
}
if (s->imageType.gamma) {
metaGamma=meta_copy(metaAmp);
metaGamma->general->image_data_type = AMPLITUDE_IMAGE;
metaGamma->general->image_data_type = r_GAMMA;
meta_write(metaGamma, f->out_gam);
fp_gam=fopenImage(f->out_gam,openMode);
}
if (s->imageType.beta) {
metaBeta=meta_copy(metaAmp);
metaBeta->general->image_data_type = AMPLITUDE_IMAGE;
metaBeta->general->radiometry = r_BETA;
meta_write(metaBeta, f->out_bet);
fp_bet=fopenImage(f->out_bet,openMode);
}
/* This gets messy */
for (outLine = 0; outLine < f->n_az_valid; outLine++)
{
int j; /* loop counter */
int base = f->firstOutputLine+outLine; /* loop counter for transposed data */
if(writeNoiseTable==1) {
if (!quietflag) printf(" Writing .noise and .ant files\n");
}
/* Print statement for the antenna pattern correction option */
if(s->vecLen==0) {
if(!quietflag && (outLine % 1024 == 0)) {
printf(" ...Writing Line %i\n",outLine);
}
}
if(s->vecLen!=0) {
if(!quietflag && (outLine % 1024 == 0)) {
printf(" ...Writing Line %i and applying Antenna Pattern Correction\n",
outLine);
}
}
/* Fill up the buffers */
for (j=0; j<p->n_range; j++,base+=p->n_az)
{
outputBuf[j] = p->trans[base];
/* For speed, if we aren't correcting the antenna pattern,
write the multi-look buffer now */
if(s->vecLen==0)
{
mlBuf[j+mlCount*p->n_range].real = outputBuf[j].real;
mlBuf[j+mlCount*p->n_range].imag = outputBuf[j].imag;
}
}
/* Apply the Antenna Pattern Correction if desired */
if(s->vecLen!=0)
{
/* On the first time through, write out the noise table */
if(writeNoiseTable==1)
{
writeTable(meta,s,p->n_range);
writeNoiseTable=0;
}
antptn_correct(meta,outputBuf,base,p->n_range,s);
if(!quietflag && (j==0)) printf(" Correcting Line %d\n",outLine);
/* Otherwise, write the multi-look buffer now */
for(j=0;j<p->n_range;j++)
{
mlBuf[j+mlCount*p->n_range].real = outputBuf[j].real;
mlBuf[j+mlCount*p->n_range].imag = outputBuf[j].imag;
}
}
put_complexFloat_line(fp_cpx, metaCpx, outLine+off_slc, outputBuf);
mlCount+=1;
/* Multilook takes f->nlooks lines of data and averages them together,
and writes one line on return */
if(mlCount==f->nlooks)
{
/* multilook on the power image, then use the power image to generate
an amplitude, and all other detected images from the command line.
Be careful because I recycle amps after writing out the line of
amplitude data, and it gets used as the sigma_0, beta_0, and gamma_0
line. It my be confusing, but it uses less memory.*/
multilook(mlBuf,p->n_range,f->nlooks,pwrs);
intensity(p->n_range,pwrs,amps);
put_float_line(fp_amp, metaAmp, outLine/f->nlooks+off_ml, amps);
if (s->imageType.power) {
put_float_line(fp_pwr, metaPower, outLine/f->nlooks+off_ml, pwrs);
}
if (s->imageType.sigma)
{
calculateRCS(SIGMA_0, meta, pwrs, amps,
base-mlCount/2, p->n_range,s);
put_float_line(fp_sig, metaSigma, outLine/f->nlooks+off_ml, amps);
}
if (s->imageType.gamma)
{
calculateRCS(GAMMA_0, meta, pwrs, amps,
base-mlCount/2, p->n_range,s);
put_float_line(fp_gam, metaGamma, outLine/f->nlooks+off_ml, amps);
}
if (s->imageType.beta)
{
calculateRCS(BETA_0, meta, pwrs, amps,
base-mlCount/2, p->n_range,s);
put_float_line(fp_bet, metaBeta, outLine/f->nlooks+off_ml, amps);
}
mlCount=0;
}
}
FCLOSE(fp_cpx);
FCLOSE(fp_amp);
if (s->imageType.power)
FCLOSE(fp_pwr);
if (s->imageType.sigma)
FCLOSE(fp_sig);
if (s->imageType.gamma)
FCLOSE(fp_gam);
if (s->imageType.beta)
FCLOSE(fp_bet);
if (!quietflag) printf("\n");
if (logflag) printLog("\n");
if (!quietflag) {
printf(" AMPLITUDE IMAGE FINISHED: Wrote %i lines and %i samples\n",
f->n_az_valid/f->nlooks,p->n_range);
printf(" PATCH FINISHED: Wrote %i lines of %i samples (float)\n\n",
f->n_az_valid,p->n_range);
}
FREE((void *)amps);
FREE((void *)pwrs);
FREE((void *)outputBuf);
FREE((void *)mlBuf);
meta_free(metaAmp);
meta_free(metaCpx);
if (metaPower) meta_free(metaPower);
if (metaSigma) meta_free(metaSigma);
if (metaGamma) meta_free(metaGamma);
if (metaBeta) meta_free(metaBeta);
if (!quietflag) elapse(1);
}
int main (int argc, char *argv [])
{
FILE *fp;
getRec *signalGetRec;
file *f;
int ii, kk, ll, mm, give_usage_action=0, offset;
int filter_azimuth, filter_range, filter_size;
struct ARDOP_PARAMS params;
meta_parameters *meta;
complexFloat *image_in, *image_out, impulse_response, sum;
double lines=0.0, samples=0.0;
double time, range_time, azimuth_time, beam_center_time, pulse_duration;
double pulse_envelope, antenna_beam_pattern, wavelength, chirp_slope;
double slant_range, pulse_repetition_frequency, range_sampling_rate;
double exposure_time, r, theta;
printf("%s\n",date_time_stamp());
fflush(NULL);
printf("Program: atdp\n\n");
logflag=0;
quietflag=1;
give_usage_action=parse_cla(argc,argv,¶ms,&meta);
if (give_usage_action==0) give_usage(argv[0]);
if (logflag) {
StartWatchLog(fLog);
printLog("Program: atdp\n\n");
}
printf(" Initialization ...\n");
/* Read input out of SAR processing parameter file */
atdp_setup(¶ms,meta,&f,&signalGetRec);
/* Define some parameters */
beam_center_time = samples * lines / 2; // check!!!
pulse_duration = params.pulsedur;
wavelength = params.wavl;
chirp_slope = params.slope;
pulse_repetition_frequency = params.prf;
range_sampling_rate = params.fs;
exposure_time = 0.64; // fix me
filter_azimuth = (int)(exposure_time * pulse_repetition_frequency / 2 + 0.5);
filter_range = (int)(pulse_duration * range_sampling_rate / 2 + 0.5);
filter_size = filter_azimuth * filter_range * 4;
/* Write metadata */
lines = signalGetRec->nLines;
samples = signalGetRec->nSamples;
meta->general->line_count = lines - filter_azimuth*2;
meta->general->sample_count = samples - filter_range*2;
meta->general->data_type = COMPLEX_REAL32;
meta->general->image_data_type = COMPLEX_IMAGE;
meta_write(meta, f->out_cpx);
/* Arrange for memory */
image_in = (complexFloat *) MALLOC (sizeof(complexFloat)*samples*lines);
image_out = (complexFloat *) MALLOC (sizeof(complexFloat)*meta->general->sample_count);
/* Read raw SAR image */
for (ii=0; ii<lines; ii++)
getSignalLine(signalGetRec,ii,&image_in[ii],0,samples);
/* Open output image */
fp = FOPEN(f->out_cpx, "wb");
/* Loop through the image */
printf(" Start SAR processing raw image ...\n");
printf(" Match filter size: %i lines, %i samples\n",
filter_azimuth*2, filter_range*2);
for (ii=filter_azimuth; ii<lines-filter_azimuth; ii++) {
for (kk=filter_range; kk<samples-filter_range; kk++) {
offset = ii*samples + kk;
ll=0;mm=0;
/* Apply match filter */
for (ll=0; ll<filter_azimuth*2; ll++) {
for (mm=0; mm<filter_range*2; mm++) {
sum.real = 0.0;
sum.imag = 0.0;
/* Determine range and azimuth time */
range_time = (kk+mm) * meta->sar->range_time_per_pixel;
azimuth_time = (ii+ll) * meta->sar->azimuth_time_per_pixel;
/* Envelope of transmitted radar pulse */
slant_range = meta_get_slant(meta, ii+ll, kk+mm);
time = range_time - 2*slant_range/speedOfLight;
pulse_envelope = rect(time, pulse_duration);
/* Antenn beam pattern */
time = azimuth_time - beam_center_time;
antenna_beam_pattern = rect(time, pulse_duration);
/* Impulse response function -
Straight out of Ian Cumming's book (4-42), written in polar coordinates.
For complex data, we have z = r * exp(i*theta). The real part out of that
is r*cos(theta), the imaginary part is r*sin(theta).*/
r = pulse_envelope * antenna_beam_pattern;
theta = (-4*PI * slant_range * wavelength) +
(PI * chirp_slope * SQR(range_time - 2*slant_range / speedOfLight));
/* Real and imaginary part of impulse response function */
impulse_response.real = r * cos(theta);
impulse_response.imag = r * sin(theta);
/* Multiplication of raw image with time reversed complex conjugate
impulse response function */
sum.real +=
image_in[offset + ll*filter_range*2 + mm].real * impulse_response.real +
image_in[offset + ll*filter_range*2 + mm].imag * impulse_response.imag;
sum.imag +=
image_in[offset + ll*filter_range*2 + mm].imag * impulse_response.real -
image_in[offset + ll*filter_range*2 + mm].real * impulse_response.imag;
}
}
image_out[kk].real = sum.real / filter_size;
image_out[kk].imag = sum.imag / filter_size;
//printf(" image: line = %5i, sample = %5i\r", ii, kk);
}
put_complexFloat_line(fp, meta, ii, image_out);
if (ii%200 == 0)
printf(" Processed line %5d\n", ii);
}
FCLOSE(fp);
return(0);
}