int main(int argc, char **argv)
{
int x, y;
int maskflag=0;
unsigned char *mask;
double k;
double *phase2elevBase,*sinFlat,*cosFlat;
char datafile[256], basefile[256], outfile[256];
char maskfile[256];
int nrows,ncols;
float *f_coh;
float *f_eleverr;
float percent=0.0;
double init_err=DEFAULT_ERROR;
FILE *fdata, *fmask, *fout;
meta_parameters *meta;
baseline base;
/* Parse command line arguments */
logflag=FALSE;
while (currArg < (argc-NUM_ARGS)) {
char *key = argv[currArg++];
if (strmatch(key,"-log")) {
CHECK_ARG(1);
strcpy(logFile,GET_ARG(1));
fLog = FOPEN(logFile, "a");
logflag=TRUE;
}
else if (strmatch(key, "-mask")) {
CHECK_ARG(1);
strcpy(maskfile, GET_ARG(1));
maskflag = TRUE;
}
else if (strmatch(key,"-i")) {
CHECK_ARG(1);
init_err = atof(GET_ARG(1));
init_err *= init_err;
}
else {
printf("\n**Invalid option: %s\n",argv[currArg-1]);
usage(argv[0]);
}
}
if ((argc-currArg) < NUM_ARGS) {
printf("Insufficient arguments.\n");
usage(argv[0]);
}
create_name(datafile, argv[currArg], ".img");
strcpy(basefile, argv[currArg+1]);
strcpy(outfile, argv[currArg+2]);
asfSplashScreen(argc, argv);
/* Get appropriate metadata */
meta = meta_read(datafile);
nrows = meta->general->line_count;
ncols = meta->general->sample_count;
meta->general->data_type = REAL32;
meta_write(meta, outfile);
k = meta_get_k(meta); /* wave number*/
/* Allocate space for vectors, matricies, and stuff*/
mask = (unsigned char *)MALLOC(sizeof(unsigned char)*ncols);
f_coh = (float *)MALLOC(sizeof(float)*ncols);
f_eleverr = (float *)MALLOC(sizeof(float)*ncols);
sinFlat = (double *)MALLOC(sizeof(double)*ncols);
cosFlat = (double *)MALLOC(sizeof(double)*ncols);
phase2elevBase = (double *)MALLOC(sizeof(double)*ncols);
/* Open data file & get seed phase*/
fdata = fopenImage(datafile, "rb");
fout = fopenImage(outfile,"wb");
if (maskflag) fmask = fopenImage(maskfile,"rb");
/* Read in baseline values*/
base = read_baseline(basefile);
/* Obtain information from metadata*/
for (x=0;x<ncols;x++)
{
int img_x = x * meta->sar->sample_increment
+ meta->general->start_sample;
double incid=meta_incid(meta,0,img_x);
double flat=meta_flat(meta,0,img_x);
sinFlat[x]=sin(flat);
cosFlat[x]=cos(flat);
phase2elevBase[x]=meta_get_slant(meta,0,img_x)*sin(incid)/(2.0*k);
}
/* Loop through each row & calculate height*/
for (y=0;y<nrows;y++) {
double Bn_y,Bp_y;
/* Report progress */
if ((y*100/nrows)>percent) {
printf("\r Completed %3.0f percent", percent);
fflush(NULL);
percent+=5.0;
}
/* read in data */
if (maskflag)
ASF_FREAD(mask,sizeof(unsigned char),ncols,fmask);
get_float_line(fdata, meta, y, f_coh);
/* calculate baseline for this row*/
meta_interp_baseline(meta, base,
y*meta->sar->line_increment+meta->general->start_line+1,
&Bn_y, &Bp_y);
/* step through each pixel in row*/
for (x=0;x<ncols;x++) {
if ((mask[x] == 0x10 && maskflag) || (!maskflag)) {
double tmp,tmp1,sigma_height;
tmp = phase2elevBase[x]/(-Bp_y*sinFlat[x]-Bn_y*cosFlat[x]);
tmp1 = (FLOAT_EQUALS_ZERO(f_coh[x]))
? 0.0 : sqrt((1-f_coh[x])/f_coh[x]);
sigma_height = tmp*tmp1;
f_eleverr[x] = (float)sqrt( init_err +
sigma_height*sigma_height );
}
else
f_eleverr[x] = -1.0;
}
put_float_line(fout, meta, y, f_eleverr);
}
printf("\r Completed 100 percent\n\n");
sprintf(logbuf, " Wrote %lld bytes of data\n\n",
(long long)(nrows*ncols*4));
printf("%s", logbuf);
if (logflag) { printLog(logbuf); }
/* free memory & scram*/
meta_free(meta);
FREE(mask);
FREE(f_coh);
FREE(f_eleverr);
FREE(sinFlat);
FREE(cosFlat);
FREE(phase2elevBase);
FCLOSE(fdata);
FCLOSE(fout);
if (maskflag) FCLOSE(fmask);
exit(EXIT_SUCCESS);
}
int asf_elevation(char *unwrapped_phase, char *phase_mask,
char *baseFile, char *seeds, char *slant_elevation,
char *slant_elevation_error, char *slant_amplitude,
char *slant_coherence, char *ground_elevation,
char *ground_elevation_error, char *ground_amplitude,
char *ground_coherence)
{
int x, y, ss, sl, nrows, ncols;
double xScale, yScale, k, *phase2elevBase, *sinFlat, *cosFlat;
meta_parameters *meta;
baseline base;
FILE *fphase, *felev, *feleverr, *fseed, *fmask, *fcoh;
float *uwp, *coh, *elev, *eleverr;
unsigned char *mask;
double delta_phase, delta_height;
double seed_phase, seed_height;
printf("\nGenerating slant range elevation and elevation error ...\n\n");
/* Get input scene size and windowing info. Get datafile values*/
meta = meta_read(unwrapped_phase);
nrows = meta->general->line_count;
ncols = meta->general->sample_count;
sl = meta->general->start_line;
ss = meta->general->start_sample;
yScale = meta->sar->look_count;
xScale = meta->sar->sample_increment;
// Write metadata files for temporary slant range images
// meta->general->image_data_type = DEM;
meta_write(meta, slant_elevation);
meta_write(meta, slant_elevation_error);
/* Allocate space for vectors and matricies*/
uwp = (float *) MALLOC(sizeof(float)*ncols);
coh = (float *) MALLOC(sizeof(float)*ncols);
elev = (float *) MALLOC(sizeof(float)*ncols);
eleverr = (float *) MALLOC(sizeof(float)*ncols);
mask = (unsigned char *) MALLOC(sizeof(unsigned char)*ncols);
// Wavenumber K
k = meta_get_k(meta);
// Read in baseline values
base = read_baseline(baseFile);
// Open input files
fphase = fopenImage(unwrapped_phase, "rb");
fseed = FOPEN(seeds, "r");
fmask = fopenImage(phase_mask, "rb");
fcoh = fopenImage(slant_coherence, "rb");
/*Use least-squares fit to determine the optimal seed_phase and seed_height.*/
{
double x,xSum=0,xSqrSum=0,hSum=0,hxSum=0,pxSum=0,pxSqrSum=0;
double a,b,c,d,e,f,det;
int npts=0;
float *phase_line;
phase_line = (float *) MALLOC(sizeof(float)*meta->general->sample_count);
while (1)
{
float seed_x,seed_y,height,phase;
int seek_x,seek_y;
/*Read in each seed point*/
if (3!=fscanf(fseed,"%f%f%f",&seed_x,&seed_y,&height))
break;/*Break out when no more points.*/
seek_x=(int)((seed_x-ss)/xScale);
seek_y=(int)((seed_y-sl)/yScale);
get_float_line(fphase, meta, seek_y, phase_line);
phase = phase_line[seek_y];
if (phase==0)
continue;/*Escher couldn't unwrap this tie point.*/
// Calculate that seed point's impact on fit.
x = meta_phase_rate(meta,base,seed_y,seed_x);
xSum += x;
xSqrSum += x * x;
hSum += height;
hxSum += height * x;
pxSum += phase * x;
pxSqrSum += phase * x * x;
npts++;
}
if (!quietflag)
printf(" Read %d seed points\n",npts);
/* The least-squares fit above leaves us with a matrix equation
* [ a b ] [ seed_phase ] [ e ]
* [ ] * [ ] = [ ]
* [ c d ] [ seed_height ] [ f ]
*
* which has the solution
*
* [ d -b ] [ e ] 1 [ seed_phase ]
* [ ] * [ ] * --- = [ ]
* [ -c a ] [ f ] det [ seed_height ]
*/
a = -xSqrSum;
b = xSum;
c = -xSum;
d = npts;
e = hxSum-pxSqrSum;
f = hSum-pxSum;
det = a*d-b*c;
seed_phase = (e*d-f*b)/det;
seed_height = (e*(-c)+f*a)/det;
}
if (!quietflag)
printf(" Seed Phase: %f\n Elevation: %f\n\n",seed_phase,seed_height);
/* calculate the sine of the incidence angle across cols*/
sinFlat = (double *)MALLOC(sizeof(double)*ncols);
cosFlat = (double *)MALLOC(sizeof(double)*ncols);
phase2elevBase = (double *)MALLOC(sizeof(double)*ncols);
for (x=0;x<ncols;x++)
{
int img_x = x*xScale + ss;
double incid = meta_incid(meta, 0, img_x);
double flat = meta_flat(meta, 0, img_x);
sinFlat[x] = sin(flat);
cosFlat[x] = cos(flat);
phase2elevBase[x] = meta_get_slant(meta, 0, img_x)*sin(incid)/(2.0*k);
}
// Open intermediate output files
felev = fopenImage(slant_elevation, "wb");
feleverr = fopenImage(slant_elevation_error, "wb");
/* loop through each row & calculate height*/
/*Note:
To make this faster, we don't call
delta_height=delta_phase * meta_phase_rate(ceos,base,y*yScale+sl,x*xScale+ss).
Instead, we use the annoying temporary arrays
allocated above to calculate the same thing, quicker.
*/
for (y=0; y<nrows; y++) {
double Bn_y,Bp_y;
// Read in data
FREAD(mask, sizeof(unsigned char), ncols, fmask);
get_float_line(fphase, meta, y, uwp);
get_float_line(fcoh, meta, y, coh);
// Calculate baseline for this row
meta_interp_baseline(meta, base, y*yScale+sl+1, &Bn_y, &Bp_y);
// Step through each pixel in row
for (x=0; x<ncols; x++) {
// Calculate elevation
if (uwp[x] != 0.0) {
delta_phase = (double) uwp[x] - seed_phase;
delta_height = delta_phase * phase2elevBase[x]/
(-Bp_y*sinFlat[x] - Bn_y*cosFlat[x]);
elev[x] = delta_height + seed_height;
}
else
elev[x] = 0.0;
// Calculate elevation error
if (mask[x] == 0x10) {
double coh_factor, base_height, sigma_height;
coh_factor = (FLOAT_EQUALS_ZERO(coh[x])) ? 0.0 : sqrt((1-coh[x])/coh[x]);
base_height = phase2elevBase[x]/(-Bp_y*sinFlat[x] - Bn_y*cosFlat[x]);
sigma_height = base_height * coh_factor;
eleverr[x] = (float) fabs(base_height*coh_factor);
}
else
eleverr[x] = -1.0;
}
put_float_line(felev, meta, y, elev);
put_float_line(feleverr, meta, y, eleverr);
asfLineMeter(y, nrows);
}
// Free memory and close files
FREE(uwp);
FREE(mask);
FREE(coh);
FREE(elev);
FREE(eleverr);
FREE(sinFlat);
FREE(cosFlat);
FREE(phase2elevBase);
FCLOSE(felev);
FCLOSE(feleverr);
FCLOSE(fphase);
FCLOSE(fseed);
FCLOSE(fmask);
int fill_value=-1;
// Transform all the slant range products into ground range
printf("\nGenerating ground range elevation ...\n");
deskew_dem(slant_elevation, NULL, ground_elevation, NULL, 0, NULL, NULL, TRUE,
fill_value, 0);
printf("\nGenerating ground range amplitude image ...\n");
deskew_dem(slant_elevation, NULL, ground_amplitude, slant_amplitude, 1, NULL, NULL,
TRUE, fill_value, 0);
printf("\nGenerating ground range elevation error ...\n");
deskew_dem(slant_elevation, NULL, ground_elevation_error, slant_elevation_error, 1,
NULL, NULL, TRUE, fill_value, 0);
printf("\nGenerating ground range coherence image ...\n\n");
deskew_dem(slant_elevation, NULL, ground_coherence, slant_coherence, 0, NULL, NULL,
TRUE, fill_value, 0);
//meta_free(meta);
return 0;
}
