int main(void)
{
fcomplex y[NTRY1],x;
static fcomplex a[MP1]={{0.0,2.0},
{0.0,0.0},
{-1.0,-2.0},
{0.0,0.0},
{1.0,0.0} };
int i,iflag,its,j,n=0;
printf("\nRoots of polynomial x^4-(1+2i)*x^2+2i\n");
printf("\n%15s %15s %7s\n","Real","Complex","#iter");
for (i=1;i<=NTRY;i++) {
x=Complex((i-11.0)/10.0,(i-11.0)/10.0);
laguer(a,M,&x,&its);
if (n == 0) {
n=1;
y[1]=x;
printf("%5d %12.6f %12.6f %5d\n",n,x.r,x.i,its);
} else {
iflag=0;
for (j=1;j<=n;j++)
if (Cabs(Csub(x,y[j])) <= EPS*Cabs(x)) iflag=1;
if (iflag == 0) {
y[++n]=x;
printf("%5d %12.6f %12.6f %5d\n",n,x.r,x.i,its);
}
}
}
return 0;
}
void BI_zvvamx(int N, char *vec1, char *vec2)
{
DCOMPLEX *v1=(DCOMPLEX*)vec1, *v2=(DCOMPLEX*)vec2;
double diff;
BI_DistType *dist1, *dist2;
int i, k;
k = N * sizeof(DCOMPLEX);
i = k % sizeof(BI_DistType);
if (i) k += sizeof(BI_DistType) - i;
dist1 = (BI_DistType *) &vec1[k];
dist2 = (BI_DistType *) &vec2[k];
for (k=0; k < N; k++)
{
diff = Cabs(v1[k]) - Cabs(v2[k]);
if (diff < 0)
{
v1[k].r = v2[k].r;
v1[k].i = v2[k].i;
dist1[k] = dist2[k];
}
else if (diff == 0)
{
if (dist1[k] > dist2[k])
{
v1[k].r = v2[k].r;
v1[k].i = v2[k].i;
dist1[k] = dist2[k];
}
}
}
}
void fixrts(float d[], int m)
{
void zroots(fcomplex a[], int m, fcomplex roots[], int polish);
int i,j,polish;
fcomplex a[NMAX],roots[NMAX];
a[m]=ONE;
for (j=m-1;j>=0;j--)
a[j]=Complex(-d[m-j],0.0);
polish=1;
zroots(a,m,roots,polish);
for (j=1;j<=m;j++)
if (Cabs(roots[j]) > 1.0)
roots[j]=Cdiv(ONE,Conjg(roots[j]));
a[0]=Csub(ZERO,roots[1]);
a[1]=ONE;
for (j=2;j<=m;j++) {
a[j]=ONE;
for (i=j;i>=2;i--)
a[i-1]=Csub(a[i-2],Cmul(roots[j],a[i-1]));
a[0]=Csub(ZERO,Cmul(roots[j],a[0]));
}
for (j=0;j<=m-1;j++)
d[m-j] = -a[j].r;
}
/*Filters the given float array to the low "keepSamples"
spectral components (low-pass filter). If keepSamples
is small, the filter is strong (only lets the lowest
freqencies by)*/
void filter_lowPass(float *arr,int fftLen,int keepSamples)
{
int i;
/*Init.*/
complexFloat *fft=(complexFloat *)MALLOC(sizeof(complexFloat)*fftLen);
cfft1d(fftLen,NULL,0);
/*Copy arr into fft buffer.*/
for (i=0;i<fftLen;i++)
{
fft[i].real = arr[i];
fft[i].imag = 0;
}
cfft1d(fftLen,fft,-1);/*Forward FFT.*/
/*Filter out high frequencies.*/
for (i=1+keepSamples;i<fftLen-keepSamples;i++)
{
fft[i].real = 0;
fft[i].imag = 0;
}
cfft1d(fftLen,fft,1);/*Reverse FFT.*/
/*Copy (smoothed) fft buffer back into arr.*/
for (i=0;i<fftLen;i++)
arr[i]=Cabs(fft[i]);
FREE(fft);
}
REAL
normalize_vec_COMPLEX (COMPLEX * z, int n)
{
if (z && (n > 0))
{
int i;
REAL big = -(REAL) MONDO;
for (i = 0; i < n; i++)
{
REAL a = Cabs (z[i]);
big = max (big, a);
}
if (big > 0.0)
{
REAL scl = (REAL) (1.0 / big);
for (i = 0; i < n; i++)
z[i] = Cscl (z[i], scl);
return scl;
}
else
return 0.0;
}
else
return 0.0;
}
pcomplex Clog(pcomplex a)
{
pcomplex c;
c.re = log(Cabs(a));
if(a.re == 0.0) {
c.im = PIOVER2;
} else {
c.im = atan2(a.im, a.re);
}
return c;
}
int ComplexLUDecompose(pcomplex **a, int n, double *vv, int *indx, double *pd)
// pcomplex **a; the matrix whose LU-decomposition is wanted
// int n; order of a
// double *vv; work vector of size n (stores implicit
// scaling of each row)
// int *indx; => row permutation according to partial
// pivoting sequence
// double *pd; => 1 if number of row interchanges was even,
// -1 if odd (NULL OK)
{
int i, imax, j, k;
double big, dum, temp, d;
pcomplex sum, cdum;
d = 1.0;
imax = 0; // only to shut the compiler up.
for (i = 0; i < n; i++) {
big = 0.0;
for (j = 0; j < n; j++) {
if ((temp = Cabs(a[i][j])) > big)
big = temp;
}
if (big == 0.0) {
printf("singular matrix in routine ComplexLUDecompose\n");
return 1;
}
vv[i] = 1.0 / big;
}
for (j = 0; j < n; j++) {
for (i = 0; i < j; i++) {
sum = a[i][j];
for (k = 0; k < i; k++)
sum = Csub(sum, Cmul(a[i][k], a[k][j]));
a[i][j] = sum;
}
big = 0.0;
for (i = j; i < n; i++) {
sum = a[i][j];
for (k = 0; k < j; k++)
sum = Csub(sum, Cmul(a[i][k], a[k][j]));
a[i][j] = sum;
dum = vv[i] * Cabs(sum);
if (dum >= big) {
big = dum;
imax = i;
}
}
if (j != imax) {
for (k = 0; k < n; k++) {
cdum = a[imax][k];
a[imax][k] = a[j][k];
a[j][k] = cdum;
}
d = -d;
vv[imax] = vv[j];
}
indx[j] = imax;
if (a[j][j].re == 0.0 && a[j][j].im == 0.0)
a[j][j] = Complex(1.0e-20, 1.0e-20);
if (j != n - 1){
cdum = Cdiv(Complex(1.0, 0.0), a[j][j]);
for (i = j + 1; i < n; i++)
a[i][j] = Cmul(a[i][j], cdum);
}
}
if (pd != NULL)
*pd = d;
return 0;
}
int main(int argc, char *argv[])
{
meta_parameters *meta, *meta_old, *meta_stat;
char fnm1[BUF],fnm2[BUF],fnm3[BUF],fnm4[BUF];
char imgfile[BUF],metaFile[BUF],cmd[BUF],metaIn[BUF],metaOut[BUF];
FILE *fiamp, *fiphase, *foamp, *fophase, *flas;
int ll=0, ls=1; /* look line and sample */
int sl=STEPLINE, ss=STEPSAMPLE; /* step line and sample */
int i,line, sample;
int row, col, ampFlag = 0;
long long nitems, newitems, inWid, inLen, outWid, outLen;
long long ds/*,samplesRead*/; /* input data size, number of samples read so far.*/
long long red_offset, grn_offset, blu_offset;
register float *ampIn, *phaseIn, ampScale;
float *ampOut, *phaseOut,*ampBuf,Sin[256],Cos[256];
float avg, percent=5.0;
RGBDATA *table, *imgData;
Uchar *redPtr, *grnPtr, *bluPtr;
complexFloat z;
struct DDR newddr;
register float tmp,zImag,zReal,ampI;
register int index,offset;
const float convers=256.0/(2*3.14159265358979);
logflag = 0;
/* parse command line */
while (currArg < (argc-2)) {
char *key = argv[currArg++];
if (strmatch(key,"-log")) {
CHECK_ARG(1);
strcpy(logFile,GET_ARG(1));
fLog = FOPEN(logFile, "a");
logflag = 1;
}
else if (strmatch(key,"-look")) {
CHECK_ARG(1);
if (2!=sscanf(GET_ARG(1),"%dx%d",&ll,&ls)) {
printf(" ***ERROR: -look '%s' does not look like line x sample (e.g. '10x2').\n",GET_ARG(1));
usage(argv[0]);
}
}
else if (strmatch(key,"-step")) {
CHECK_ARG(1);
if (2!=sscanf(GET_ARG(1),"%dx%d",&sl,&ss)) {
printf(" ***ERROR: -step '%s' does not look like line x sample (e.g. '5x1').\n",GET_ARG(1));
usage(argv[0]);
}
}
else if (strmatch(key,"-meta")) {
CHECK_ARG(1);
if (1!=sscanf(GET_ARG(1),"%s",metaFile)) {
printf(" ***ERROR: Could not open '%s'.\n",GET_ARG(1));
usage(argv[0]);
}
strcat(metaFile, "");
ls = ss = 1;
ll = sl = lzInt(metaFile, "sar.look_count:", NULL);
}
else if (strmatch(key,"-amplitude")) {
printf(" Will remove amplitude part of color image\n");
ampFlag = 1;
}
else {printf("\n ***Invalid option: %s\n",argv[currArg-1]); usage(argv[0]);}
}
if ((argc-currArg) < 2) {printf(" Insufficient arguments.\n"); usage(argv[0]);}
system("date");
printf("Program: multilook\n\n");
if (logflag) {
StartWatchLog(fLog);
printLog("Program: multilook\n\n");
}
/* Create filenames and open files for reading */
create_name(fnm1,argv[currArg],"_amp.img");
create_name(fnm2,argv[currArg],"_phase.img");
meta_stat = meta_read(fnm1);
meta_old = meta_read(fnm2);
meta = meta_read(fnm2);
create_name(fnm3,argv[++currArg],"_amp.img");
create_name(fnm4,argv[currArg],"_phase.img");
create_name(imgfile,argv[currArg],"_rgb.img");
create_name(metaOut,argv[currArg],"_rgb.meta");
inWid = meta->general->sample_count;
inLen = meta->general->line_count;
meta->general->sample_count /= ss;
meta->general->line_count /= sl;
outWid = meta->general->sample_count;
outLen = meta->general->line_count;
/* Create new metadata file for the amplitude and phase.*/
meta->sar->line_increment = 1;
meta->sar->sample_increment = 1;
meta->sar->azimuth_time_per_pixel *= sl;
meta->general->x_pixel_size *= ss;
meta->general->y_pixel_size *= sl;
create_name(metaIn,argv[currArg],"_amp.meta");
meta_write(meta, metaIn);
create_name(metaIn,argv[currArg],"_phase.meta");
meta_write(meta, metaIn);
meta2ddr(meta, &newddr);
/* Create 3-band image's DDR.
Currently metadata file don't know anything about multiband imagery.
We will need to convert the current version for single band amplitude
image back to metadata version 0.9 and change a couple of values
sprintf(cmd, "convert_meta %s 1.3 %s 0.9", metaIn, metaOut);
asfSystem(cmd);
*/
newddr.dtype=EBYTE;
newddr.nbands=3;
c_putddr(imgfile,&newddr);
fiamp = fopenImage(fnm1,"rb");
fiphase = fopenImage(fnm2,"rb");
foamp = fopenImage(fnm3,"wb");
fophase = fopenImage(fnm4,"wb");
flas = fopenImage(imgfile,"wb");
/*
* create data buffers
*/
for (i=0;i<256;i++)
{
float phas=((float)i)/256.0*(2*3.14159265358979);
Sin[i]=sin(phas);
Cos[i]=cos(phas);
}
/* set data variables */
ampScale = 1.0/(ll*ls);
nitems = (ll-sl)*inWid;
newitems = sl*inWid;
ds = sizeof(float);
ampIn = (float *)MALLOC(ds*(newitems+nitems+ls));
phaseIn = (float *)MALLOC(ds*(newitems+nitems+ls));
ampOut = (float *)MALLOC(ds*outWid);
ampBuf = (float *)MALLOC(ds*outWid);
phaseOut = (float *)MALLOC(ds*outWid);
table = (RGBDATA *)MALLOC(sizeof(RGBDATA)*MAXENTRIES);
imgData = (RGBDATA *)MALLOC(sizeof(RGBDATA)*outWid);
redPtr = (Uchar *)MALLOC(sizeof(Uchar)*outWid);
grnPtr = (Uchar *)MALLOC(sizeof(Uchar)*outWid);
bluPtr = (Uchar *)MALLOC(sizeof(Uchar)*outWid);
/* calculate mean value */
if (meta_stat->stats)
avg = meta_stat->stats->band_stats[0].mean;
else {
sprintf(cmd, "stats -overmeta -overstat \"%s\"\n", fnm1);
asfSystem(cmd);
meta_free(meta_stat);
meta_stat = meta_read(fnm1);
avg = meta_stat->stats->band_stats[0].mean;
}
/* create a colortable to be used with c2i */
colortable(table);
/* start conversion */
/* printf(" Skipping every %d col and %d row\n",ss,sl);
printf(" Looking at every %d col and %d row\n",ls,ll);*/
printf(" Input is %lld lines by %lld samples\n",inLen,inWid);
printf(" Ouput is %lld lines by %lld samples\n\n",outLen,outWid);
if (logflag) {
sprintf(logbuf, " Input is %lld lines by %lld samples\n",inLen,inWid);
printLog(logbuf);
sprintf(logbuf, " Ouput is %lld lines by %lld samples\n\n",outLen,outWid);
printLog(logbuf);
}
/*
* Run through all lines in which data needs to be read so that
* amount of data will be equal to ll * inWid.
*/
for(line=0; line<outLen; line++)
{
/* Read in a ll*inWid size chunk */
get_float_lines(fiamp, meta_old, line*sl, ll, ampIn);
get_float_lines(fiphase, meta_old, line*sl, ll, phaseIn);
/* begin adding data */
for (sample=0; sample<outWid; sample++)
{
tmp = 0.0, zReal=0.0, zImag=0.0;
/* add up looking area */
for (col=0;col<ls;col++)
{
offset=sample*ss+col;
for (row=0;row<ll;row++)
{
ampI=ampIn[offset];
index=0xFF&((int)(phaseIn[offset]*convers));
tmp += ampI * ampI;
zReal += ampI * Cos[index];
zImag += ampI * Sin[index];
offset+=inWid;
}
}
/* get phase from complex values */
z.real=zReal;
z.imag=zImag;
/* place in output buffer */
/* ampOut[sample] = sqrt(tmp*ampScale); */
ampOut[sample] = Cabs(z)*ampScale;
phaseOut[sample] = Cphase(z);
if(!ampFlag)
ampBuf[sample]=ampOut[sample];
else
ampBuf[sample]=avg*1.5;
}
/* convert amp & phase to RGB. */
if (!c2i(ampBuf,phaseOut,imgData,table,outWid,avg))
Exit("ml: Error in c2i()");
/* write out data to file */
put_float_line(foamp, meta, line, ampOut);
put_float_line(fophase, meta, line, phaseOut);
if ((line*100/outLen)>percent) {
printf(" Completed %3.0f percent\n", percent);
percent+=5.0;
}
for (i=0;i<outWid;i++)
{
redPtr[i] = imgData[i].red;
grnPtr[i] = imgData[i].green;
bluPtr[i] = imgData[i].blue;
}
red_offset=(long long)(line*outWid);
grn_offset=(long long)(line*outWid+outWid*outLen);
blu_offset=(long long)(line*outWid+(2*outWid*outLen));
FSEEK64(flas,red_offset,SEEK_SET);
ASF_FWRITE(redPtr,1,outWid,flas);
FSEEK64(flas,grn_offset,SEEK_SET);
ASF_FWRITE(grnPtr,1,outWid,flas);
FSEEK64(flas,blu_offset,SEEK_SET);
ASF_FWRITE(bluPtr,1,outWid,flas);
/* reposition data for next read */
for (i=0;i<nitems;i++)
{
ampIn[i] = ampIn[i + newitems];
phaseIn[i] = phaseIn[i + newitems];
}
}
/*
* free up unneeded memory and prepare to write
* a 3 sequential band image
*/
/* printf("\n\tdone with multilook\n");
printf("writing out LAS/RGB image file\n");*
printf(" Completed 100 percent\n\n Wrote %lld bytes of data\n\n",
(long long)(outLen*outWid*4));
if (logflag) {
sprintf(logbuf, " Wrote %lld bytes of data\n\n",
(long long)(outLen*outWid*4));
printLog(logbuf);
StopWatchLog(fLog);
FCLOSE(fLog);
}
*/
FREE(ampIn);
FREE(phaseIn);
FREE(ampOut);
FREE(ampBuf);
FREE(phaseOut);
FREE(table);
FCLOSE(fiamp);
FCLOSE(fiphase);
FCLOSE(foamp);
FCLOSE(fophase);
/* free all memory, close files, print out time elapsed */
FREE(redPtr);
FREE(grnPtr);
FREE(bluPtr);
FREE(imgData);
FCLOSE(flas);
meta_free(meta);
meta_free(meta_stat);
meta_free(meta_old);
return 0;
}
/*******
amp_corr:
Given two patches, p1 containing the echos from
ahead of beam center, p2 containing echos from behind beam
center; performs an amplitude cross-correlation in range
and returns the range offset, in pixels, between
these two images.
*/
double amp_corr(patch *p1,patch *p2,file *f)
{
int clip=20;/*Remove this from the far-range end of the images*/
int overlap=30;/*Overlap is the maximum shift we ever expect.*/
FILE *fout;
int x,y;
int fftLen=smallestPow2(p1->n_range);
float scale=1.0/fftLen;
complexFloat *amp1,*amp2;
float *corr;
double ret;
amp1=(complexFloat *)MALLOC(sizeof(complexFloat)*fftLen);
amp2=(complexFloat *)MALLOC(sizeof(complexFloat)*fftLen);
corr=(float *)MALLOC(sizeof(float)*(fftLen+overlap));
if (!quietflag) printf(" Performing amplitude correlation.\n");
for (x=0;x<fftLen+overlap;x++)
corr[x]=0.0;
cfft1d(fftLen,NULL,0);
p1->n_range-=clip;
p2->n_range-=clip;
for (y=f->firstOutputLine;y<f->firstOutputLine+f->n_az_valid;y++)
{
for (x=0;x<overlap;x++)
{
amp1[x]=Czero();
amp2[x].r=Cabs(p2->trans[x*p2->n_az+y])*scale;
amp2[x].i=0.0;
}
for (;x<p1->n_range-overlap;x++)
{
amp1[x].r=Cabs(p1->trans[x*p1->n_az+y])*scale;
amp1[x].i=0.0;
amp2[x].r=Cabs(p2->trans[x*p2->n_az+y])*scale;
amp2[x].i=0.0;
}
for (;x<p1->n_range;x++)
{
amp1[x]=Czero();
amp2[x].r=Cabs(p2->trans[x*p2->n_az+y])*scale;
amp2[x].i=0.0;
}
for (;x<fftLen;x++)
amp1[x]=amp2[x]=Czero();
cfft1d(fftLen,amp1,-1);
cfft1d(fftLen,amp2,-1);
for (x=0;x<fftLen;x++)
amp2[x]=Cmul(amp2[x],Cconj(amp1[x]));
cfft1d(fftLen,amp2,1);
for (x=0;x<fftLen;x++)
corr[x]+=Cabs(amp2[x]);
}
fout=FOPEN(f->out_cpx,"w");
for (x=-overlap;x<overlap;x++)
{
corr[x+fftLen]=corr[(x+fftLen)%fftLen];
if (corr[x+fftLen]<10000000000000000000000.0)
/*Is a good value-- print it out*/
fprintf(fout,"%d %f\n",x,corr[x+fftLen]);
else/*Must be an infinity or NaN*/
{
fprintf(stderr, " WARNING!! Found infinity at offset %d!\n",x);
if (logflag) {
sprintf(logbuf," WARNING!! Found infinity at offset %d!\n",x);
printLog(logbuf);
}
corr[x+fftLen]=0.0;
}
}
FCLOSE(fout);
FREE(amp1);
FREE(amp2);
ret = dop_findPeak(corr,fftLen-overlap,2*overlap)-fftLen;
FREE(corr);
return ret;
}
int multilook(char *inFile, char *outFile, char *metaFile, char *overlay)
{
meta_parameters *metaIn, *metaOut;
char inAmp[255], inPhase[255], outAmp[255], outPhase[255], outRGB[255];
FILE *fpAmpIn, *fpPhaseIn, *fpAmpOut, *fpPhaseOut, *fpRGB, *fpOverlay;
int look_line, look_sample, step_line, step_sample, i,line, sample, row, col;
long long nitems, newitems, in_sample_count, in_line_count, out_sample_count;
long long out_line_count, ds;
register float *ampIn, *phaseIn, ampScale;
float *ampOut, *phaseOut, *rgb, *scaleIn, Sin[256],Cos[256], scale;
complexFloat z;
register float tmp,zImag,zReal,ampI;
register int index,offset;
const float convers=256.0/(2*3.14159265358979);
// Create filenames and open files for reading
create_name(inAmp, inFile, "_amp.img");
create_name(inPhase, inFile, "_phase.img");
metaIn = meta_read(inPhase);
metaOut = meta_read(inPhase);
// FIXME: Should write out two-banded file. Too much to fix in the rest of
// the unwrapping code. Leaving that for clean up after the course.
create_name(outAmp, outFile, "_amp.img");
create_name(outPhase, outFile, "_phase.img");
create_name(outRGB, outFile, "_phase_rgb.img");
metaIn = meta_read(inFile);
metaOut = meta_read(inFile);
// Create new metadata file for the amplitude and phase.
look_sample = step_sample = 1;
look_line = step_line = metaOut->sar->look_count;
in_sample_count = metaIn->general->sample_count;
in_line_count = metaIn->general->line_count;
metaOut->general->sample_count /= step_sample;
metaOut->general->line_count /= step_line;
out_sample_count = metaOut->general->sample_count;
out_line_count = metaOut->general->line_count;
metaOut->sar->multilook = 1;
metaOut->sar->line_increment = 1;
metaOut->sar->sample_increment = 1;
metaOut->sar->azimuth_time_per_pixel *= step_line;
metaOut->general->x_pixel_size *= step_sample;
metaOut->general->y_pixel_size *= step_line;
meta_write(metaOut, outAmp);
meta_write(metaOut, outPhase);
//meta_write(metaOut, outFile);
meta_write(metaOut, outRGB);
// Open the files
fpAmpIn = fopenImage(inAmp, "rb");
fpPhaseIn = fopenImage(inPhase, "rb");
fpAmpOut = fopenImage(outAmp, "wb");
fpPhaseOut = fopenImage(outPhase, "wb");
//FILE *fpIn = fopenImage(inFile, "rb");
//FILE *fpOut = fopenImage(outFile, "wb");
fpRGB = fopenImage(outRGB, "wb");
if (overlay)
fpOverlay = fopenImage(overlay, "rb");
for (i=0;i<256;i++) {
float phas=((float)i)/256.0*(2*3.14159265358979);
Sin[i]=sin(phas);
Cos[i]=cos(phas);
}
// Set data variables
ampScale = 1.0/(look_line*look_sample);
nitems = (look_line-step_line)*in_sample_count;
newitems = step_line*in_sample_count;
ds = sizeof(float);
ampIn = (float *)MALLOC(ds*(newitems+nitems+look_sample));
phaseIn = (float *)MALLOC(ds*(newitems+nitems+look_sample));
if (overlay)
scaleIn = (float *)MALLOC(ds*(newitems+nitems+look_sample));
ampOut = (float *)MALLOC(ds*out_sample_count);
rgb = (float *)MALLOC(ds*out_sample_count);
phaseOut = (float *)MALLOC(ds*out_sample_count);
// Let the user know what's happening
asfPrintStatus("Input is %lld lines by %lld samples\n",
in_line_count, in_sample_count);
asfPrintStatus("Ouput is %lld lines by %lld samples\n\n",
out_line_count,out_sample_count);
// Get to work
for(line=0; line<out_line_count; line++) {
get_float_lines(fpAmpIn, metaIn, line*step_line, look_line, ampIn);
get_float_lines(fpPhaseIn, metaIn, line*step_line, look_line, phaseIn);
//get_band_float_lines(fpIn, metaIn, 0, line*step_line, look_line, ampIn);
//get_band_float_lines(fpIn, metaIn, 1, line*step_line, look_line,
// phaseIn);
if (overlay)
get_float_lines(fpOverlay, metaOut, line, 1, scaleIn);
// Begin adding data
for (sample=0; sample<out_sample_count; sample++) {
tmp = 0.0, zReal=0.0, zImag=0.0;
// Add up looking area
for (col=0; col<look_sample; col++) {
offset=sample*step_sample+col;
for (row=0; row<look_line; row++) {
ampI = ampIn[offset];
index = 0xFF&((int)(phaseIn[offset]*convers));
tmp += ampI * ampI;
zReal += ampI * Cos[index];
zImag += ampI * Sin[index];
offset += in_sample_count;
}
}
// Get phase from complex values
z.real = zReal;
z.imag = zImag;
ampOut[sample] = Cabs(z)*ampScale;
phaseOut[sample] = Cphase(z);
if (overlay)
scale = scaleIn[sample];
else
scale = 1.0;
if (phaseOut[sample] < 0.0)
rgb[sample] = (phaseOut[sample] + M_PI) * scale;
else
rgb[sample] = phaseOut[sample] * scale;
}
// Write out data to file
//put_band_float_line(fpOut, metaOut, 0, line, ampOut);
//put_band_float_line(fpOut, metaOut, 1, line, phaseOut);
put_float_line(fpAmpOut, metaOut, line, ampOut);
put_float_line(fpPhaseOut, metaOut, line, phaseOut);
put_float_line(fpRGB, metaOut, line, rgb);
asfLineMeter(line, out_line_count);
// Reposition data for next read
for (i=0;i<nitems;i++) {
ampIn[i] = ampIn[i + newitems];
phaseIn[i] = phaseIn[i + newitems];
}
}
// Clean up
FREE(ampIn);
FREE(phaseIn);
FREE(ampOut);
FREE(rgb);
FREE(phaseOut);
if (overlay) {
FREE(scaleIn);
FCLOSE(fpOverlay);
}
FCLOSE(fpAmpIn);
FCLOSE(fpPhaseIn);
FCLOSE(fpAmpOut);
FCLOSE(fpPhaseOut);
//FCLOSE(fpIn);
//FCLOSE(fpOut);
FCLOSE(fpRGB);
meta_free(metaIn);
meta_free(metaOut);
// Export a color version of the interferogram to JPEG
create_name(outPhase, outFile, "_phase_rgb");
check_return(asf_export_with_lut(JPEG, SIGMA, "interferogram.lut",
outPhase, outPhase),
"colorized interferogram (asf_export)");
return 0;
}
