KJ135
/
ISCE_INSAR
mirror of http://172.16.0.12:5000/WBJY/ISCE_INSAR.git
4
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ISCE_INSAR/contrib/Snaphu/src/snaphu_io.c

3037 lines
98 KiB
C
Raw Blame History

/*************************************************************************
snaphu input/output source file
Written by Curtis W. Chen
Copyright 2002 Board of Trustees, Leland Stanford Jr. University
Please see the supporting documentation for terms of use.
No warranty.
*************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <signal.h>
#include <limits.h>
#include <float.h>
#include <string.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "snaphu.h"
/* function: SetDefaults()
* -----------------------
* Sets all parameters to their initial default values.
*/
void SetDefaults(infileT *infiles, outfileT *outfiles, paramT *params){
/* input files */
StrNCopy(infiles->weightfile,DEF_WEIGHTFILE,MAXSTRLEN);
StrNCopy(infiles->corrfile,DEF_CORRFILE,MAXSTRLEN);
StrNCopy(infiles->ampfile,DEF_AMPFILE,MAXSTRLEN);
StrNCopy(infiles->ampfile2,DEF_AMPFILE2,MAXSTRLEN);
StrNCopy(infiles->estfile,DEF_ESTFILE,MAXSTRLEN);
StrNCopy(infiles->magfile,DEF_MAGFILE,MAXSTRLEN);
StrNCopy(infiles->costinfile,DEF_COSTINFILE,MAXSTRLEN);
/* output and dump files */
StrNCopy(outfiles->initfile,DEF_INITFILE,MAXSTRLEN);
StrNCopy(outfiles->flowfile,DEF_FLOWFILE,MAXSTRLEN);
StrNCopy(outfiles->eifile,DEF_EIFILE,MAXSTRLEN);
StrNCopy(outfiles->rowcostfile,DEF_ROWCOSTFILE,MAXSTRLEN);
StrNCopy(outfiles->colcostfile,DEF_COLCOSTFILE,MAXSTRLEN);
StrNCopy(outfiles->mstrowcostfile,DEF_MSTROWCOSTFILE,MAXSTRLEN);
StrNCopy(outfiles->mstcolcostfile,DEF_MSTCOLCOSTFILE,MAXSTRLEN);
StrNCopy(outfiles->mstcostsfile,DEF_MSTCOSTSFILE,MAXSTRLEN);
StrNCopy(outfiles->corrdumpfile,DEF_CORRDUMPFILE,MAXSTRLEN);
StrNCopy(outfiles->rawcorrdumpfile,DEF_RAWCORRDUMPFILE,MAXSTRLEN);
StrNCopy(outfiles->costoutfile,DEF_COSTOUTFILE,MAXSTRLEN);
StrNCopy(outfiles->conncompfile,DEF_CONNCOMPFILE,MAXSTRLEN);
StrNCopy(outfiles->outfile,DEF_OUTFILE,MAXSTRLEN);
StrNCopy(outfiles->logfile,DEF_LOGFILE,MAXSTRLEN);
/* file formats */
infiles->infileformat=DEF_INFILEFORMAT;
infiles->unwrappedinfileformat=DEF_UNWRAPPEDINFILEFORMAT;
infiles->magfileformat=DEF_MAGFILEFORMAT;
infiles->corrfileformat=DEF_CORRFILEFORMAT;
infiles->estfileformat=DEF_ESTFILEFORMAT;
infiles->ampfileformat=DEF_AMPFILEFORMAT;
outfiles->outfileformat=DEF_OUTFILEFORMAT;
/* options and such */
params->unwrapped=DEF_UNWRAPPED;
params->regrowconncomps=DEF_REGROWCONNCOMPS;
params->eval=DEF_EVAL;
params->initonly=DEF_INITONLY;
params->initmethod=DEF_INITMETHOD;
params->costmode=DEF_COSTMODE;
params->amplitude=DEF_AMPLITUDE;
params->verbose=DEF_VERBOSE;
/* SAR and geometry parameters */
params->orbitradius=DEF_ORBITRADIUS;
params->altitude=DEF_ALTITUDE;
params->earthradius=DEF_EARTHRADIUS;
params->bperp=DEF_BPERP;
params->transmitmode=DEF_TRANSMITMODE;
params->baseline=DEF_BASELINE;
params->baselineangle=DEF_BASELINEANGLE;
params->nlooksrange=DEF_NLOOKSRANGE;
params->nlooksaz=DEF_NLOOKSAZ;
params->nlooksother=DEF_NLOOKSOTHER;
params->ncorrlooks=DEF_NCORRLOOKS;
params->ncorrlooksrange=DEF_NCORRLOOKSRANGE;
params->ncorrlooksaz=DEF_NCORRLOOKSAZ;
params->nearrange=DEF_NEARRANGE;
params->dr=DEF_DR;
params->da=DEF_DA;
params->rangeres=DEF_RANGERES;
params->azres=DEF_AZRES;
params->lambda=DEF_LAMBDA;
/* scattering model parameters */
params->kds=DEF_KDS;
params->specularexp=DEF_SPECULAREXP;
params->dzrcritfactor=DEF_DZRCRITFACTOR;
params->shadow=DEF_SHADOW;
params->dzeimin=DEF_DZEIMIN;
params->laywidth=DEF_LAYWIDTH;
params->layminei=DEF_LAYMINEI;
params->sloperatiofactor=DEF_SLOPERATIOFACTOR;
params->sigsqei=DEF_SIGSQEI;
/* decorrelation model parameters */
params->drho=DEF_DRHO;
params->rhosconst1=DEF_RHOSCONST1;
params->rhosconst2=DEF_RHOSCONST2;
params->cstd1=DEF_CSTD1;
params->cstd2=DEF_CSTD2;
params->cstd3=DEF_CSTD3;
params->defaultcorr=DEF_DEFAULTCORR;
params->rhominfactor=DEF_RHOMINFACTOR;
/* pdf model parameters */
params->dzlaypeak=DEF_DZLAYPEAK;
params->azdzfactor=DEF_AZDZFACTOR;
params->dzeifactor=DEF_DZEIFACTOR;
params->dzeiweight=DEF_DZEIWEIGHT;
params->dzlayfactor=DEF_DZLAYFACTOR;
params->layconst=DEF_LAYCONST;
params->layfalloffconst=DEF_LAYFALLOFFCONST;
params->sigsqshortmin=DEF_SIGSQSHORTMIN;
params->sigsqlayfactor=DEF_SIGSQLAYFACTOR;
/* deformation mode parameters */
params->defoazdzfactor=DEF_DEFOAZDZFACTOR;
params->defothreshfactor=DEF_DEFOTHRESHFACTOR;
params->defomax=DEF_DEFOMAX;
params->sigsqcorr=DEF_SIGSQCORR;
params->defolayconst=DEF_DEFOLAYCONST;
/* algorithm parameters */
params->flipphasesign=DEF_FLIPPHASESIGN;
params->initmaxflow=DEF_INITMAXFLOW;
params->arcmaxflowconst=DEF_ARCMAXFLOWCONST;
params->maxflow=DEF_MAXFLOW;
params->krowei=DEF_KROWEI;
params->kcolei=DEF_KCOLEI;
params->kperpdpsi=DEF_KPERPDPSI;
params->kpardpsi=DEF_KPARDPSI;
params->threshold=DEF_THRESHOLD;
params->initdzr=DEF_INITDZR;
params->initdzstep=DEF_INITDZSTEP;
params->maxcost=DEF_MAXCOST;
params->costscale=DEF_COSTSCALE;
params->costscaleambight=DEF_COSTSCALEAMBIGHT;
params->dnomincangle=DEF_DNOMINCANGLE;
params->srcrow=DEF_SRCROW;
params->srccol=DEF_SRCCOL;
params->p=DEF_P;
params->nshortcycle=DEF_NSHORTCYCLE;
params->maxnewnodeconst=DEF_MAXNEWNODECONST;
params->maxcyclefraction=DEF_MAXCYCLEFRACTION;
params->sourcemode=DEF_SOURCEMODE;
params->maxnflowcycles=DEF_MAXNFLOWCYCLES;
params->dumpall=DEF_DUMPALL;
params->cs2scalefactor=DEF_CS2SCALEFACTOR;
/* tile parameters */
params->ntilerow=DEF_NTILEROW;
params->ntilecol=DEF_NTILECOL;
params->rowovrlp=DEF_ROWOVRLP;
params->colovrlp=DEF_COLOVRLP;
params->piecefirstrow=DEF_PIECEFIRSTROW;
params->piecefirstcol=DEF_PIECEFIRSTCOL;
params->piecenrow=DEF_PIECENROW;
params->piecencol=DEF_PIECENCOL;
params->tilecostthresh=DEF_TILECOSTTHRESH;
params->minregionsize=DEF_MINREGIONSIZE;
params->nthreads=DEF_NTHREADS;
params->scndryarcflowmax=DEF_SCNDRYARCFLOWMAX;
params->assembleonly=DEF_ASSEMBLEONLY;
params->rmtmptile=DEF_RMTMPTILE;
params->tileedgeweight=DEF_TILEEDGEWEIGHT;
/* connected component parameters */
params->minconncompfrac=DEF_MINCONNCOMPFRAC;
params->conncompthresh=DEF_CONNCOMPTHRESH;
params->maxncomps=DEF_MAXNCOMPS;
}
/* function: ProcessArgs()
* -----------------------
* Parses command line inputs passed to main().
*/
void ProcessArgs(int argc, char *argv[], infileT *infiles, outfileT *outfiles,
long *linelenptr, paramT *params){
long i,j;
signed char noarg_exit;
/* required inputs */
noarg_exit=FALSE;
StrNCopy(infiles->infile,"",MAXSTRLEN);
*linelenptr=0;
/* loop over inputs */
if(argc<2){ /* catch zero arguments in */
fprintf(sp1,OPTIONSHELPBRIEF);
exit(ABNORMAL_EXIT);
}
for(i=1;i<argc;i++){
/* if argument is an option */
if(argv[i][0]=='-'){
if(strlen(argv[i])==1){
fprintf(sp0,"invalid command line argument -\n");
exit(ABNORMAL_EXIT);
}else if(argv[i][1]!='-'){
for(j=1;j<strlen(argv[i]);j++){
if(argv[i][j]=='h'){
fprintf(sp1,OPTIONSHELPFULL);
exit(ABNORMAL_EXIT);
}else if(argv[i][j]=='u'){
params->unwrapped=TRUE;
}else if(argv[i][j]=='t'){
params->costmode=TOPO;
}else if(argv[i][j]=='d'){
params->costmode=DEFO;
}else if(argv[i][j]=='s'){
params->costmode=SMOOTH;
params->defomax=0.0;
}else if(argv[i][j]=='q'){
params->eval=TRUE;
params->unwrapped=TRUE;
}else if(argv[i][j]=='f'){
if(++i<argc && j==strlen(argv[i-1])-1){
/* read user-supplied configuration file */
ReadConfigFile(argv[i],infiles,outfiles,linelenptr,params);
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='o'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(outfiles->outfile,argv[i],MAXSTRLEN);
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='c'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(infiles->corrfile,argv[i],MAXSTRLEN);
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='m'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(infiles->magfile,argv[i],MAXSTRLEN);
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='a'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(infiles->ampfile,argv[i],MAXSTRLEN);
params->amplitude=TRUE;
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='A'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(infiles->ampfile,argv[i],MAXSTRLEN);
params->amplitude=FALSE;
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='e'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(infiles->estfile,argv[i],MAXSTRLEN);
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='w'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(infiles->weightfile,argv[i],MAXSTRLEN);
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='g'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(outfiles->conncompfile,argv[i],MAXSTRLEN);
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='G'){
params->regrowconncomps=TRUE;
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(outfiles->conncompfile,argv[i],MAXSTRLEN);
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='b'){
if(++i<argc && j==strlen(argv[i-1])-1){
if(StringToDouble(argv[i],&(params->bperp)) || !(params->bperp)){
fprintf(sp0,"option -%c requires non-zero decimal argument\n",
argv[i-1][j]);
exit(ABNORMAL_EXIT);
}
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='p'){
if(++i<argc && j==strlen(argv[i-1])-1){
if(StringToDouble(argv[i],&(params->p))){
fprintf(sp0,"option -%c requires decimal argument\n",
argv[i-1][j]);
exit(ABNORMAL_EXIT);
}
break;
}else{
noarg_exit=TRUE;
}
}else if(argv[i][j]=='i'){
params->initonly=TRUE;
}else if(argv[i][j]=='n'){
params->costmode=NOSTATCOSTS;
}else if(argv[i][j]=='v'){
params->verbose=TRUE;
}else if(argv[i][j]=='l'){
if(++i<argc && j==strlen(argv[i-1])-1){
StrNCopy(outfiles->logfile,argv[i],MAXSTRLEN);
break;
}else{
noarg_exit=TRUE;
}
}else{
fprintf(sp0,"unrecognized option -%c\n",argv[i][j]);
exit(ABNORMAL_EXIT);
}
if(noarg_exit){
fprintf(sp0,"option -%c requires an argument\n",argv[i-1][j]);
exit(ABNORMAL_EXIT);
}
}
}else{
/* argument is a "--" option */
if(!strcmp(argv[i],"--costinfile")){
if(++i<argc){
StrNCopy(infiles->costinfile,argv[i],MAXSTRLEN);
}else{
noarg_exit=TRUE;
}
}else if(!strcmp(argv[i],"--costoutfile")){
if(++i<argc){
StrNCopy(outfiles->costoutfile,argv[i],MAXSTRLEN);
}else{
noarg_exit=TRUE;
}
}else if(!strcmp(argv[i],"--debug") || !strcmp(argv[i],"--dumpall")){
params->dumpall=TRUE;
}else if(!strcmp(argv[i],"--mst")){
params->initmethod=MSTINIT;
}else if(!strcmp(argv[i],"--mcf")){
params->initmethod=MCFINIT;
}else if(!strcmp(argv[i],"--aa")){
if(i+2<argc){
StrNCopy(infiles->ampfile,argv[++i],MAXSTRLEN);
StrNCopy(infiles->ampfile2,argv[++i],MAXSTRLEN);
infiles->ampfileformat=FLOAT_DATA;
params->amplitude=TRUE;
}else{
noarg_exit=TRUE;
}
}else if(!strcmp(argv[i],"--AA")){
if(++i+1<argc){
StrNCopy(infiles->ampfile,argv[i++],MAXSTRLEN);
StrNCopy(infiles->ampfile2,argv[i],MAXSTRLEN);
infiles->ampfileformat=FLOAT_DATA;
params->amplitude=FALSE;
}else{
noarg_exit=TRUE;
}
}else if(!strcmp(argv[i],"--tile")){
if(++i+3<argc){
if(StringToLong(argv[i++],&(params->ntilerow))
|| StringToLong(argv[i++],&(params->ntilecol))
|| StringToLong(argv[i++],&(params->rowovrlp))
|| StringToLong(argv[i],&(params->colovrlp))){
fprintf(sp0,"option %s requires four integer arguments\n",
argv[i-4]);
exit(ABNORMAL_EXIT);
}
}else{
noarg_exit=TRUE;
}
}else if(!strcmp(argv[i],"--piece")){
if(++i+3<argc){
if(StringToLong(argv[i++],&(params->piecefirstrow))
|| StringToLong(argv[i++],&(params->piecefirstcol))
|| StringToLong(argv[i++],&(params->piecenrow))
|| StringToLong(argv[i],&(params->piecencol))){
fprintf(sp0,"option %s requires four integer arguments\n",
argv[i-4]);
exit(ABNORMAL_EXIT);
}
}else{
noarg_exit=TRUE;
}
}else if(!strcmp(argv[i],"--nproc")){
if(++i<argc){
if(StringToLong(argv[i],&(params->nthreads))){
fprintf(sp0,"option %s requires an integer arguemnt\n",
argv[i-1]);
exit(ABNORMAL_EXIT);
}
}else{
noarg_exit=TRUE;
}
}else if(!strcmp(argv[i],"--assemble")){
params->assembleonly=TRUE;
if(++i<argc){
StrNCopy(params->tiledir,argv[i],MAXSTRLEN);
}else{
noarg_exit=TRUE;
}
}else if(!strcmp(argv[i],"--copyright") || !strcmp(argv[i],"--info")){
fprintf(sp1,COPYRIGHT);
exit(ABNORMAL_EXIT);
}else if(!strcmp(argv[i],"--help")){
fprintf(sp1,OPTIONSHELPFULL);
exit(ABNORMAL_EXIT);
}else{
fprintf(sp0,"unrecognized option %s\n",argv[i]);
exit(ABNORMAL_EXIT);
}
if(noarg_exit){
fprintf(sp0,"incorrect number of arguments for option %s\n",
argv[i-1]);
exit(ABNORMAL_EXIT);
}
}
}else{
/* argument is not an option */
if(!strlen(infiles->infile)){
StrNCopy(infiles->infile,argv[i],MAXSTRLEN);
}else if(*linelenptr==0){
if(StringToLong(argv[i],linelenptr) || *linelenptr<=0){
fprintf(sp0,"line length must be positive integer\n");
exit(ABNORMAL_EXIT);
}
}else{
fprintf(sp0,"multiple input files: %s and %s\n",
infiles->infile,argv[i]);
exit(ABNORMAL_EXIT);
}
}
} /* end for loop over arguments */
/* check to make sure we have required arguments */
if(!strlen(infiles->infile) || !(*linelenptr)){
fprintf(sp0,"not enough input arguments. type %s -h for help\n",
PROGRAMNAME);
exit(ABNORMAL_EXIT);
}
} /* end of ProcessArgs */
/* function: CheckParams()
* -----------------------
* Checks all parameters to make sure they are valid. This is just a boring
* function with lots of checks in it.
*/
void CheckParams(infileT *infiles, outfileT *outfiles,
long linelen, long nlines, paramT *params){
long ni, nj, n;
FILE *fp;
/* make sure output file is writable (try opening in append mode) */
/* file will be opened in write mode later, clobbering existing file */
if((fp=fopen(outfiles->outfile,"a"))==NULL){
fprintf(sp0,"file %s is not writable\n",outfiles->outfile);
exit(ABNORMAL_EXIT);
}else{
if(ftell(fp)){
fclose(fp);
}else{
fclose(fp);
remove(outfiles->outfile);
}
if(!strcmp(outfiles->outfile,infiles->infile)
&& !params->eval && !params->regrowconncomps){
fprintf(sp0,"WARNING: output will overwrite input\n");
}
}
/* make sure options aren't contradictory */
if(params->initonly && params->unwrapped){
fprintf(sp0,"cannot use initialize-only mode with unwrapped input\n");
exit(ABNORMAL_EXIT);
}
if(params->initonly && params->p>=0){
fprintf(sp0,"cannot use initialize-only mode with Lp costs\n");
exit(ABNORMAL_EXIT);
}
if(params->costmode==NOSTATCOSTS && !(params->initonly || params->p>=0)){
fprintf(sp0,"no-statistical-costs option can only be used in\n");
fprintf(sp0," initialize-only or Lp-norm modes\n");
exit(ABNORMAL_EXIT);
}
if(strlen(infiles->costinfile) && params->costmode==NOSTATCOSTS){
fprintf(sp0,"no-statistical-costs option cannot be given\n");
fprintf(sp0," if input cost file is specified\n");
exit(ABNORMAL_EXIT);
}
if(strlen(outfiles->costoutfile) && params->costmode==NOSTATCOSTS){
fprintf(sp0,"no-statistical-costs option cannot be given\n");
fprintf(sp0," if output cost file is specified\n");
exit(ABNORMAL_EXIT);
}
/* check geometry parameters */
if(params->earthradius<=0){
fprintf(sp0,"earth radius must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->altitude){
if(params->altitude>0){
params->orbitradius=params->earthradius+params->altitude;
}else{
fprintf(sp0,"platform altitude must be positive\n");
exit(ABNORMAL_EXIT);
}
}else if(params->orbitradius < params->earthradius){
fprintf(sp0,"platform orbit radius must be greater than earth radius\n");
exit(ABNORMAL_EXIT);
}
if(params->costmode==TOPO && params->baseline<0){
fprintf(sp0,"baseline length must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->costmode==TOPO && params->baseline==0){
fprintf(sp0,"WARNING: zero baseline may give unpredictable results\n");
}
if(params->ncorrlooks<=0){
fprintf(sp0,"number of looks ncorrlooks must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->nearrange<=0){
fprintf(sp0,"slant range parameter nearrange must be positive (meters)\n");
exit(ABNORMAL_EXIT);
}
if(params->dr<=0 || params->da<=0){
fprintf(sp0,"pixel spacings dr and da must be positive (meters)\n");
exit(ABNORMAL_EXIT);
}
/* dr and da after multilooking can be larger than rangeres, azres */
/*
if(params->rangeres<=(params->dr)
|| params->azres<=(params->da)){
fprintf(sp0,"resolutions parameters must be larger than pixel spacings\n");
exit(ABNORMAL_EXIT);
}
*/
if(params->lambda<=0){
fprintf(sp0,"wavelength lambda must be positive (meters)\n");
exit(ABNORMAL_EXIT);
}
/* check scattering model defaults */
if(params->kds<=0){
fprintf(sp0,"scattering model parameter kds must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->specularexp<=0){
fprintf(sp0,"scattering model parameter SPECULAREXP must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->dzrcritfactor<0){
fprintf(sp0,"dzrcritfactor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->laywidth<1){
fprintf(sp0,"layover window width laywidth must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->layminei<0){
fprintf(sp0,"layover minimum brightness must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->sloperatiofactor<0){
fprintf(sp0,"slope ratio fudge factor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->sigsqei<=0){
fprintf(sp0,"intensity estimate variance must be positive\n");
exit(ABNORMAL_EXIT);
}
/* check decorrelation model defaults */
if(params->drho<=0){
fprintf(sp0,"correlation step size drho must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->rhosconst1<=0 || params->rhosconst2<=0){
fprintf(sp0,"parameters rhosconst1 and rhosconst2 must be positive\n");
exit(ABNORMAL_EXIT);
}
if(!strlen(infiles->corrfile)
&& (params->defaultcorr<0 || params->defaultcorr>1)){
fprintf(sp0,"default correlation must be between 0 and 1\n");
exit(ABNORMAL_EXIT);
}
if(params->rhominfactor<0){
fprintf(sp0,"parameter rhominfactor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->ncorrlooksaz<1 || params->ncorrlooksrange<1
|| params->nlooksaz<1 || params->nlooksrange<1
|| params->nlooksother<1){
fprintf(sp0,"numbers of looks must be positive integer\n");
exit(ABNORMAL_EXIT);
}
if(!strlen(infiles->corrfile)){
if(params->ncorrlooksaz<params->nlooksaz){
fprintf(sp0,"NCORRLOOKSAZ cannot be smaller than NLOOKSAZ\n");
fprintf(sp0," setting NCORRLOOKSAZ to equal NLOOKSAZ\n");
params->ncorrlooksaz=params->nlooksaz;
}
if(params->ncorrlooksrange<params->nlooksrange){
fprintf(sp0,"NCORRLOOKSRANGE cannot be smaller than NLOOKSRANGE\n");
fprintf(sp0," setting NCORRLOOKSRANGE to equal NLOOKSRANGE\n");
params->ncorrlooksrange=params->nlooksrange;
}
}
/* check pdf model parameters */
if(params->azdzfactor<0){
fprintf(sp0,"parameter azdzfactor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->dzeifactor<0){
fprintf(sp0,"parameter dzeifactor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->dzeiweight<0 || params->dzeiweight>1.0){
fprintf(sp0,"parameter dzeiweight must be between 0 and 1\n");
exit(ABNORMAL_EXIT);
}
if(params->dzlayfactor<0){
fprintf(sp0,"parameter dzlayfactor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->layconst<=0){
fprintf(sp0,"parameter layconst must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->layfalloffconst<0){
fprintf(sp0,"parameter layfalloffconst must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->sigsqshortmin<=0){
fprintf(sp0,"parameter sigsqshortmin must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->sigsqlayfactor<0){
fprintf(sp0,"parameter sigsqlayfactor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
/* check deformation mode parameters */
if(params->defoazdzfactor<0){
fprintf(sp0,"parameter defoazdzfactor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->defothreshfactor<0){
fprintf(sp0,"parameter defothreshfactor must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->defomax<0){
fprintf(sp0,"parameter defomax must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->sigsqcorr<0){
fprintf(sp0,"parameter sigsqcorr must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->defolayconst<=0){
fprintf(sp0,"parameter defolayconst must be positive\n");
exit(ABNORMAL_EXIT);
}
/* check algorithm parameters */
/* be sure to check for things that will cause type overflow */
/* or floating point exception */
if((params->initmaxflow)<1 && (params->initmaxflow)!=AUTOCALCSTATMAX){
fprintf(sp0,"initialization maximum flow must be positive\n");
exit(ABNORMAL_EXIT);
}
if((params->arcmaxflowconst)<1){
fprintf(sp0,"arcmaxflowconst must be positive\n");
exit(ABNORMAL_EXIT);
}
if((params->maxflow)<1){
fprintf(sp0,"maxflow must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->krowei<=0 || params->kcolei<=0){
fprintf(sp0,"averaging window sizes krowei and kcolei must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->kperpdpsi<=0 || params->kpardpsi<=0){
fprintf(sp0,
"averaging window sizes kperpdpsi and kpardpsi must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->threshold<=0){
fprintf(sp0,"numerical solver threshold must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->initdzr<=0){
fprintf(sp0,"initdzr must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->initdzstep<=0){
fprintf(sp0,"initdzstep must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->maxcost>POSSHORTRANGE || params->maxcost<=0){
fprintf(sp0,"maxcost must be positive and within range or short int\n");
exit(ABNORMAL_EXIT);
}
if(params->costscale<=0){
fprintf(sp0,"cost scale factor costscale must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->p<0 && params->p!=PROBCOSTP){
fprintf(sp0,"Lp-norm parameter p should be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if((params->costmode==TOPO && params->maxflow*params->nshortcycle)
>POSSHORTRANGE){
fprintf(sp0,"maxflow exceeds range of short int for given nshortcycle\n");
exit(ABNORMAL_EXIT);
}
if(params->costmode==DEFO && ceil(params->defomax*params->nshortcycle)
>POSSHORTRANGE){
fprintf(sp0,"defomax exceeds range of short int for given nshortcycle\n");
exit(ABNORMAL_EXIT);
}
if(params->maxnewnodeconst<=0 || params->maxnewnodeconst>1){
fprintf(sp0,"maxnewnodeconst must be between 0 and 1\n");
exit(ABNORMAL_EXIT);
}
if(params->sourcemode>1 || params->sourcemode<-1){
fprintf(sp0,"sourcemode must be -1, 0, or 1\n");
exit(ABNORMAL_EXIT);
}
if(infiles->infileformat!=FLOAT_DATA || strlen(infiles->magfile)){
params->havemagnitude=TRUE;
}else{
params->havemagnitude=FALSE;
}
if(params->maxnflowcycles==USEMAXCYCLEFRACTION){
params->maxnflowcycles=LRound(params->maxcyclefraction
*nlines/(double )params->ntilerow
*linelen/(double )params->ntilecol);
}
if(params->initmaxflow==AUTOCALCSTATMAX
&& !(params->ntilerow==1 && params->ntilecol==1)){
fprintf(sp0,"initial maximum flow cannot be calculated automatically in "
"tile mode\n");
exit(ABNORMAL_EXIT);
}
#ifdef NO_CS2
if(params->initmethod==MCFINIT && !params->unwrapped){
fprintf(sp0,"program not compiled with cs2 MCF solver module\n");
exit(ABNORMAL_EXIT);
}
#endif
/* tile parameters */
if(params->ntilerow<1 || params->ntilecol<1){
fprintf(sp0,"numbers of tile rows and columns must be positive\n");
exit(ABNORMAL_EXIT);
}
if(params->rowovrlp<0 || params->colovrlp<0){
fprintf(sp0,"tile overlaps must be nonnegative\n");
exit(ABNORMAL_EXIT);
}
if(params->ntilerow>1 || params->ntilecol>1){
ni=ceil((nlines+(params->ntilerow-1)*params->rowovrlp)
/(double )params->ntilerow);
nj=ceil((linelen+(params->ntilecol-1)*params->colovrlp)
/(double )params->ntilecol);
if(params->p>=0){
fprintf(sp0,"tile mode not enabled for Lp costs\n");
exit(ABNORMAL_EXIT);
}
if(params->ntilerow+params->rowovrlp > nlines
|| params->ntilecol+params->colovrlp > linelen
|| params->ntilerow*params->ntilerow > nlines
|| params->ntilecol*params->ntilecol > linelen){
fprintf(sp0,"tiles too small or overlap too large for given input\n");
exit(ABNORMAL_EXIT);
}
if(params->minregionsize
> ((nlines-(params->ntilerow-1)*(ni-params->rowovrlp))
*(linelen-(params->ntilecol-1)*(nj-params->colovrlp)))){
fprintf(sp0,"minimum region size too large for given tile parameters\n");
exit(ABNORMAL_EXIT);
}
if(TMPTILEOUTFORMAT!=ALT_LINE_DATA && TMPTILEOUTFORMAT!=FLOAT_DATA){
fprintf(sp0,"unsupported TMPTILEOUTFORMAT value in complied binary\n");
exit(ABNORMAL_EXIT);
}
if(TMPTILEOUTFORMAT==FLOAT_DATA && outfiles->outfileformat!=FLOAT_DATA){
fprintf(sp0,"precompiled tile format precludes given output format\n");
exit(ABNORMAL_EXIT);
}
if(params->scndryarcflowmax<1){
fprintf(sp0,"parameter scndryarcflowmax too small\n");
exit(ABNORMAL_EXIT);
}
if(params->initonly){
fprintf(sp0,
"initialize-only mode and tile mode are mutually exclusive\n");
exit(ABNORMAL_EXIT);
}
if(strlen(outfiles->conncompfile)){
fprintf(sp0,
"connected components output not yet supported for tile mode\n");
exit(ABNORMAL_EXIT);
}
if(params->assembleonly){
n=strlen(params->tiledir);
while(--n>0 && params->tiledir[n]=='/'){
params->tiledir[n]='\0';
}
if(!strlen(params->tiledir)){
fprintf(sp0,"tile directory name cannot have zero length\n");
exit(ABNORMAL_EXIT);
}
if(!strcmp(params->tiledir,"/")){
StrNCopy(params->tiledir,"",MAXSTRLEN);
}
}
if(params->piecefirstrow!=DEF_PIECEFIRSTROW
|| params->piecefirstcol!=DEF_PIECEFIRSTCOL
|| params->piecenrow!=DEF_PIECENROW
|| params->piecencol!=DEF_PIECENCOL){
fprintf(sp0,"piece-only mode cannot be used with multiple tiles\n");
exit(ABNORMAL_EXIT);
}
}else{
if(params->assembleonly){
fprintf(sp0,"assemble-only mode can only be used with multiple tiles\n");
exit(ABNORMAL_EXIT);
}
if(params->nthreads>1){
fprintf(sp0,"only one tile--disregarding multiprocessor option\n");
}
if(params->rowovrlp || params->colovrlp){
fprintf(sp0,"only one tile--disregarding tile overlap values\n");
}
params->piecefirstrow--; /* index from 0 instead of 1 */
params->piecefirstcol--; /* index from 0 instead of 1 */
if(!params->piecenrow){
params->piecenrow=nlines;
}
if(!params->piecencol){
params->piecencol=linelen;
}
if(params->piecefirstrow<0 || params->piecefirstcol<0
|| params->piecenrow<1 || params->piecencol<1
|| params->piecefirstrow+params->piecenrow>nlines
|| params->piecefirstcol+params->piecencol>linelen){
fprintf(sp0,"illegal values for piece of interferogram to unwrap\n");
exit(ABNORMAL_EXIT);
}
}
if(params->nthreads<1){
fprintf(sp0,"number of processors must be at least one\n");
exit(ABNORMAL_EXIT);
}else if(params->nthreads>MAXTHREADS){
fprintf(sp0,"number of processors exceeds precomplied limit of %d\n",
MAXTHREADS);
exit(ABNORMAL_EXIT);
}
/* connected component parameters */
if(params->regrowconncomps){
if(!strlen(outfiles->conncompfile)){
fprintf(sp0,"no connected component output file specified\n");
exit(ABNORMAL_EXIT);
}
params->unwrapped=TRUE;
}
if(params->minconncompfrac<0 || params->minconncompfrac>1){
fprintf(sp0,"illegal value for minimum connected component fraction\n");
exit(ABNORMAL_EXIT);
}
if(params->maxncomps<=0){
fprintf(sp0,"illegal value for maximum number of connected components\n");
exit(ABNORMAL_EXIT);
}
if(strlen(outfiles->conncompfile)){
if(params->initonly){
fprintf(sp0,"WARNING: connected component mask cannot be generated "
"in initialize-only mode\n mask will not be output\n");
StrNCopy(outfiles->conncompfile,"",MAXSTRLEN);
}
if(params->costmode==NOSTATCOSTS){
fprintf(sp0,"WARNING: connected component mask cannot be generated "
"without statistical costs\n mask will not be output\n");
StrNCopy(outfiles->conncompfile,"",MAXSTRLEN);
}
}
/* set global pointers to functions for calculating and evaluating costs */
if(params->p<0){
if(params->costmode==TOPO){
CalcCost=CalcCostTopo;
EvalCost=EvalCostTopo;
}else if(params->costmode==DEFO){
CalcCost=CalcCostDefo;
EvalCost=EvalCostDefo;
}else if(params->costmode==SMOOTH){
CalcCost=CalcCostSmooth;
EvalCost=EvalCostSmooth;
}
}else{
if(params->p==0){
CalcCost=CalcCostL0;
EvalCost=EvalCostL0;
}else if(params->p==1){
CalcCost=CalcCostL1;
EvalCost=EvalCostL1;
}else if(params->p==2){
CalcCost=CalcCostL2;
EvalCost=EvalCostL2;
}else{
CalcCost=CalcCostLP;
EvalCost=EvalCostLP;
}
}
}
/* function: ReadConfigFile()
* --------------------------
* Read in parameter values from a file, overriding existing parameters.
*/
void ReadConfigFile(char *conffile, infileT *infiles, outfileT *outfiles,
long *linelenptr, paramT *params){
long nlines, nparams, nfields;
FILE *fp;
char buf[MAXLINELEN];
char str1[MAXLINELEN], str2[MAXLINELEN];
char *ptr;
signed char badparam;
/* open input config file */
if(strlen(conffile)){
if((fp=fopen(conffile,"r"))==NULL){
/* abort if we were given a non-zero length name that is unreadable */
fprintf(sp0,"unable to read configuration file %s\n",conffile);
exit(ABNORMAL_EXIT);
}
}else{
/* if we were given a zero-length name, just ignore it and go on */
return;
}
/* read each line and convert the first two fields */
nlines=0;
nparams=0;
badparam=FALSE;
while(TRUE){
/* read a line from the file and store it in buffer buf */
buf[0]='\0';
ptr=fgets(buf,MAXLINELEN,fp);
/* break when we read EOF without reading any text */
if(ptr==NULL && !strlen(buf)){
break;
}
nlines++;
/* make sure we got the whole line */
if(strlen(buf)>=MAXLINELEN-1){
fprintf(sp0,"line %ld in file %s exceeds maximum line length\n",
nlines,conffile);
exit(ABNORMAL_EXIT);
}
/* read the first two fields */
/* (str1, str2 same size as buf, so can't overflow them */
nfields=sscanf(buf,"%s %s",str1,str2);
/* if only one field is read, and it is not a comment, we have an error */
if(nfields==1 && isalnum(str1[0])){
fprintf(sp0,"unrecognized configuration parameter '%s' (%s:%ld)\n",
str1,conffile,nlines);
exit(ABNORMAL_EXIT);
}
/* if we have (at least) two non-comment fields */
if(nfields==2 && isalnum(str1[0])){
/* do the conversions */
nparams++;
if(!strcmp(str1,"INFILE")){
StrNCopy(infiles->infile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"OUTFILE")){
StrNCopy(outfiles->outfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"WEIGHTFILE")){
StrNCopy(infiles->weightfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"AMPFILE") || !strcmp(str1,"AMPFILE1")){
if(strlen(infiles->ampfile2) && !params->amplitude){
fprintf(sp0,"cannot specify both amplitude and power\n");
exit(ABNORMAL_EXIT);
}
StrNCopy(infiles->ampfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"AMPFILE2")){
if(strlen(infiles->ampfile) && !params->amplitude){
fprintf(sp0,"cannot specify both amplitude and power\n");
exit(ABNORMAL_EXIT);
}
StrNCopy(infiles->ampfile2,str2,MAXSTRLEN);
infiles->ampfileformat=FLOAT_DATA;
}else if(!strcmp(str1,"PWRFILE") || !strcmp(str1,"PWRFILE1")){
if(strlen(infiles->ampfile2) && params->amplitude){
fprintf(sp0,"cannot specify both amplitude and power\n");
exit(ABNORMAL_EXIT);
}
StrNCopy(infiles->ampfile,str2,MAXSTRLEN);
params->amplitude=FALSE;
}else if(!strcmp(str1,"PWRFILE2")){
if(strlen(infiles->ampfile) && params->amplitude){
fprintf(sp0,"cannot specify both amplitude and power\n");
exit(ABNORMAL_EXIT);
}
StrNCopy(infiles->ampfile2,str2,MAXSTRLEN);
params->amplitude=FALSE;
infiles->ampfileformat=FLOAT_DATA;
}else if(!strcmp(str1,"MAGFILE")){
StrNCopy(infiles->magfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"CORRFILE")){
StrNCopy(infiles->corrfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"ESTIMATEFILE")){
StrNCopy(infiles->estfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"LINELENGTH") || !strcmp(str1,"LINELEN")){
badparam=StringToLong(str2,linelenptr);
}else if(!strcmp(str1,"STATCOSTMODE")){
if(!strcmp(str2,"TOPO")){
params->costmode=TOPO;
}else if(!strcmp(str2,"DEFO")){
params->costmode=DEFO;
}else if(!strcmp(str2,"SMOOTH")){
params->costmode=SMOOTH;
}else if(!strcmp(str2,"NOSTATCOSTS")){
params->costmode=NOSTATCOSTS;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"INITONLY")){
badparam=SetBooleanSignedChar(&(params->initonly),str2);
}else if(!strcmp(str1,"UNWRAPPED_IN")){
badparam=SetBooleanSignedChar(&(params->unwrapped),str2);
}else if(!strcmp(str1,"DEBUG") || !strcmp(str1,"DUMPALL")){
badparam=SetBooleanSignedChar(&(params->dumpall),str2);
}else if(!strcmp(str1,"VERBOSE")){
badparam=SetBooleanSignedChar(&(params->verbose),str2);
}else if(!strcmp(str1,"INITMETHOD")){
if(!strcmp(str2,"MST") || !strcmp(str2,"mst")){
params->initmethod=MSTINIT;
}else if(!strcmp(str2,"MCF") || !strcmp(str2,"mcf")
|| !strcmp(str2,"CS2") || !strcmp(str2,"cs2")){
params->initmethod=MCFINIT;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"ORBITRADIUS")){
if(!(badparam=StringToDouble(str2,&(params->orbitradius)))){
params->altitude=0;
}
}else if(!strcmp(str1,"ALTITUDE")){
if(!(badparam=StringToDouble(str2,&(params->altitude)))){
params->orbitradius=0;
}
}else if(!strcmp(str1,"EARTHRADIUS")){
badparam=StringToDouble(str2,&(params->earthradius));
}else if(!strcmp(str1,"BPERP")){
badparam=StringToDouble(str2,&(params->bperp));
}else if(!strcmp(str1,"TRANSMITMODE")){
if(!strcmp(str2,"PINGPONG") || !strcmp(str2,"REPEATPASS")){
params->transmitmode=PINGPONG;
}else if(!strcmp(str2,"SINGLEANTENNATRANSMIT") || !strcmp(str2,"SAT")
|| !strcmp(str2,"SINGLEANTTRANSMIT")){
params->transmitmode=SINGLEANTTRANSMIT;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"BASELINE")){
if(!(badparam=StringToDouble(str2,&(params->baseline)))){
params->bperp=0;
}
}else if(!strcmp(str1,"BASELINEANGLE_RAD")){
if(!(badparam=StringToDouble(str2,&(params->baselineangle)))){
params->bperp=0;
}
}else if(!strcmp(str1,"BASELINEANGLE_DEG")){
if(!(badparam=StringToDouble(str2,&(params->baselineangle)))){
(params->baselineangle)*=(PI/180.0);
params->bperp=0;
}
}else if(!strcmp(str1,"NLOOKSRANGE")){
badparam=StringToLong(str2,&(params->nlooksrange));
}else if(!strcmp(str1,"NLOOKSAZ")){
badparam=StringToLong(str2,&(params->nlooksaz));
}else if(!strcmp(str1,"NLOOKSOTHER")){
badparam=StringToLong(str2,&(params->nlooksother));
}else if(!strcmp(str1,"NCORRLOOKS")){
badparam=StringToDouble(str2,&(params->ncorrlooks));
}else if(!strcmp(str1,"NCORRLOOKSRANGE")){
badparam=StringToLong(str2,&(params->ncorrlooksrange));
}else if(!strcmp(str1,"NCORRLOOKSAZ")){
badparam=StringToLong(str2,&(params->ncorrlooksaz));
}else if(!strcmp(str1,"NEARRANGE") || !strcmp(str1,"NOMRANGE")){
badparam=StringToDouble(str2,&(params->nearrange));
}else if(!strcmp(str1,"DR")){
badparam=StringToDouble(str2,&(params->dr));
}else if(!strcmp(str1,"DA")){
badparam=StringToDouble(str2,&(params->da));
}else if(!strcmp(str1,"RANGERES")){
badparam=StringToDouble(str2,&(params->rangeres));
}else if(!strcmp(str1,"AZRES")){
badparam=StringToDouble(str2,&(params->azres));
}else if(!strcmp(str1,"LAMBDA")){
badparam=StringToDouble(str2,&(params->lambda));
}else if(!strcmp(str1,"KDS") || !strcmp(str1,"KSD")){
if(!strcmp(str1,"KSD")){
fprintf(sp0,"WARNING: parameter KSD interpreted as KDS (%s:%ld)\n",
conffile,nlines);
}
badparam=StringToDouble(str2,&(params->kds));
}else if(!strcmp(str1,"SPECULAREXP") || !strcmp(str1,"N")){
badparam=StringToDouble(str2,&(params->specularexp));
}else if(!strcmp(str1,"DZRCRITFACTOR")){
badparam=StringToDouble(str2,&(params->dzrcritfactor));
}else if(!strcmp(str1,"SHADOW")){
badparam=SetBooleanSignedChar(&(params->shadow),str2);
}else if(!strcmp(str1,"DZEIMIN")){
badparam=StringToDouble(str2,&(params->dzeimin));
}else if(!strcmp(str1,"LAYWIDTH")){
badparam=StringToLong(str2,&(params->laywidth));
}else if(!strcmp(str1,"LAYMINEI")){
badparam=StringToDouble(str2,&(params->layminei));
}else if(!strcmp(str1,"SLOPERATIOFACTOR")){
badparam=StringToDouble(str2,&(params->sloperatiofactor));
}else if(!strcmp(str1,"SIGSQEI")){
badparam=StringToDouble(str2,&(params->sigsqei));
}else if(!strcmp(str1,"DRHO")){
badparam=StringToDouble(str2,&(params->drho));
}else if(!strcmp(str1,"RHOSCONST1")){
badparam=StringToDouble(str2,&(params->rhosconst1));
}else if(!strcmp(str1,"RHOSCONST2")){
badparam=StringToDouble(str2,&(params->rhosconst2));
}else if(!strcmp(str1,"CSTD1")){
badparam=StringToDouble(str2,&(params->cstd1));
}else if(!strcmp(str1,"CSTD2")){
badparam=StringToDouble(str2,&(params->cstd2));
}else if(!strcmp(str1,"CSTD3")){
badparam=StringToDouble(str2,&(params->cstd3));
}else if(!strcmp(str1,"DEFAULTCORR")){
badparam=StringToDouble(str2,&(params->defaultcorr));
}else if(!strcmp(str1,"RHOMINFACTOR")){
badparam=StringToDouble(str2,&(params->rhominfactor));
}else if(!strcmp(str1,"DZLAYPEAK")){
badparam=StringToDouble(str2,&(params->dzlaypeak));
}else if(!strcmp(str1,"AZDZFACTOR")){
badparam=StringToDouble(str2,&(params->azdzfactor));
}else if(!strcmp(str1,"DZEIFACTOR")){
badparam=StringToDouble(str2,&(params->dzeifactor));
}else if(!strcmp(str1,"DZEIWEIGHT")){
badparam=StringToDouble(str2,&(params->dzeiweight));
}else if(!strcmp(str1,"DZLAYFACTOR")){
badparam=StringToDouble(str2,&(params->dzlayfactor));
}else if(!strcmp(str1,"LAYCONST")){
badparam=StringToDouble(str2,&(params->layconst));
}else if(!strcmp(str1,"LAYFALLOFFCONST")){
badparam=StringToDouble(str2,&(params->layfalloffconst));
}else if(!strcmp(str1,"SIGSQSHORTMIN")){
badparam=StringToLong(str2,&(params->sigsqshortmin));
}else if(!strcmp(str1,"SIGSQLAYFACTOR")){
badparam=StringToDouble(str2,&(params->sigsqlayfactor));
}else if(!strcmp(str1,"DEFOAZDZFACTOR")){
badparam=StringToDouble(str2,&(params->defoazdzfactor));
}else if(!strcmp(str1,"DEFOTHRESHFACTOR")){
badparam=StringToDouble(str2,&(params->defothreshfactor));
}else if(!strcmp(str1,"DEFOMAX_CYCLE")){
badparam=StringToDouble(str2,&(params->defomax));
}else if(!strcmp(str1,"DEFOMAX_RAD")){
if(!(badparam=StringToDouble(str2,&(params->defomax)))){
params->defomax/=TWOPI;
}
}else if(!strcmp(str1,"SIGSQCORR")){
badparam=StringToDouble(str2,&(params->sigsqcorr));
}else if(!strcmp(str1,"DEFOLAYCONST") || !strcmp(str1,"DEFOCONST")){
badparam=StringToDouble(str2,&(params->defolayconst));
}else if(!strcmp(str1,"INITMAXFLOW")){
badparam=StringToLong(str2,&(params->initmaxflow));
}else if(!strcmp(str1,"ARCMAXFLOWCONST")){
badparam=StringToLong(str2,&(params->arcmaxflowconst));
}else if(!strcmp(str1,"MAXFLOW")){
badparam=StringToLong(str2,&(params->maxflow));
}else if(!strcmp(str1,"KROWEI") || !strcmp(str1,"KROW")){
badparam=StringToLong(str2,&(params->krowei));
}else if(!strcmp(str1,"KCOLEI") || !strcmp(str1,"KCOL")){
badparam=StringToLong(str2,&(params->kcolei));
}else if(!strcmp(str1,"KPERPDPSI")){
badparam=StringToLong(str2,&(params->kperpdpsi));
}else if(!strcmp(str1,"KPARDPSI")){
badparam=StringToLong(str2,&(params->kpardpsi));
}else if(!strcmp(str1,"THRESHOLD")){
badparam=StringToDouble(str2,&(params->threshold));
}else if(!strcmp(str1,"INITDZR")){
badparam=StringToDouble(str2,&(params->initdzr));
}else if(!strcmp(str1,"INITDZSTEP")){
badparam=StringToDouble(str2,&(params->initdzstep));
}else if(!strcmp(str1,"MAXCOST")){
badparam=StringToDouble(str2,&(params->maxcost));
}else if(!strcmp(str1,"COSTSCALE")){
badparam=StringToDouble(str2,&(params->costscale));
}else if(!strcmp(str1,"COSTSCALEAMBIGHT")){
badparam=StringToDouble(str2,&(params->costscaleambight));
}else if(!strcmp(str1,"DNOMINCANGLE")){
badparam=StringToDouble(str2,&(params->dnomincangle));
}else if(!strcmp(str1,"CS2SCALEFACTOR")){
badparam=StringToLong(str2,&(params->cs2scalefactor));
}else if(!strcmp(str1,"PIECEFIRSTROW")){
badparam=StringToLong(str2,&(params->piecefirstrow));
}else if(!strcmp(str1,"PIECEFIRSTCOL")){
badparam=StringToLong(str2,&(params->piecefirstcol));
}else if(!strcmp(str1,"PIECENROW")){
badparam=StringToLong(str2,&(params->piecenrow));
}else if(!strcmp(str1,"PIECENCOL")){
badparam=StringToLong(str2,&(params->piecencol));
}else if(!strcmp(str1,"NTILEROW")){
badparam=StringToLong(str2,&(params->ntilerow));
}else if(!strcmp(str1,"NTILECOL")){
badparam=StringToLong(str2,&(params->ntilecol));
}else if(!strcmp(str1,"ROWOVRLP")){
badparam=StringToLong(str2,&(params->rowovrlp));
}else if(!strcmp(str1,"COLOVRLP")){
badparam=StringToLong(str2,&(params->colovrlp));
}else if(!strcmp(str1,"TILECOSTTHRESH")){
badparam=StringToLong(str2,&(params->tilecostthresh));
}else if(!strcmp(str1,"MINREGIONSIZE")){
badparam=StringToLong(str2,&(params->minregionsize));
}else if(!strcmp(str1,"TILEEDGEWEIGHT")){
badparam=StringToDouble(str2,&(params->tileedgeweight));
}else if(!strcmp(str1,"SCNDRYARCFLOWMAX")){
badparam=StringToLong(str2,&(params->scndryarcflowmax));
}else if(!strcmp(str1,"ASSEMBLEONLY")){
if(!strcmp(str2,"FALSE")){
params->assembleonly=FALSE;
}else{
params->assembleonly=TRUE;
StrNCopy(params->tiledir,str2,MAXSTRLEN);
}
}else if(!strcmp(str1,"RMTMPTILE")){
badparam=SetBooleanSignedChar(&(params->rmtmptile),str2);
}else if(!strcmp(str1,"MINCONNCOMPFRAC")){
badparam=StringToDouble(str2,&(params->minconncompfrac));
}else if(!strcmp(str1,"CONNCOMPTHRESH")){
badparam=StringToLong(str2,&(params->conncompthresh));
}else if(!strcmp(str1,"MAXNCOMPS")){
badparam=StringToLong(str2,&(params->maxncomps));
}else if(!strcmp(str1,"NSHORTCYCLE")){
badparam=StringToLong(str2,&(params->nshortcycle));
}else if(!strcmp(str1,"MAXNEWNODECONST")){
badparam=StringToDouble(str2,&(params->maxnewnodeconst));
}else if(!strcmp(str1,"MAXNFLOWCYCLES")){
badparam=StringToLong(str2,&(params->maxnflowcycles));
}else if(!strcmp(str1,"MAXCYCLEFRACTION")){
badparam=StringToDouble(str2,&(params->maxcyclefraction));
params->maxnflowcycles=USEMAXCYCLEFRACTION;
}else if(!strcmp(str1,"SOURCEMODE")){
badparam=StringToLong(str2,&(params->sourcemode));
}else if(!strcmp(str1,"NPROC") || !strcmp(str1,"NTHREADS")){
badparam=StringToLong(str2,&(params->nthreads));
}else if(!strcmp(str1,"COSTINFILE")){
StrNCopy(infiles->costinfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"COSTOUTFILE")){
StrNCopy(outfiles->costoutfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"LOGFILE")){
StrNCopy(outfiles->logfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"INFILEFORMAT")){
if(!strcmp(str2,"COMPLEX_DATA")){
infiles->infileformat=COMPLEX_DATA;
}else if(!strcmp(str2,"FLOAT_DATA")){
infiles->infileformat=FLOAT_DATA;
}else if(!strcmp(str2,"ALT_LINE_DATA")){
infiles->infileformat=ALT_LINE_DATA;
}else if(!strcmp(str2,"ALT_SAMPLE_DATA")){
infiles->infileformat=ALT_SAMPLE_DATA;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"UNWRAPPEDINFILEFORMAT")){
if(!strcmp(str2,"ALT_LINE_DATA")){
infiles->unwrappedinfileformat=ALT_LINE_DATA;
}else if(!strcmp(str2,"ALT_SAMPLE_DATA")){
infiles->unwrappedinfileformat=ALT_SAMPLE_DATA;
}else if(!strcmp(str2,"FLOAT_DATA")){
infiles->unwrappedinfileformat=FLOAT_DATA;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"MAGFILEFORMAT")){
if(!strcmp(str2,"ALT_LINE_DATA")){
infiles->magfileformat=ALT_LINE_DATA;
}else if(!strcmp(str2,"ALT_SAMPLE_DATA")){
infiles->magfileformat=ALT_SAMPLE_DATA;
}else if(!strcmp(str2,"FLOAT_DATA")){
infiles->magfileformat=FLOAT_DATA;
}else if(!strcmp(str2,"COMPLEX_DATA")){
infiles->magfileformat=COMPLEX_DATA;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"OUTFILEFORMAT")){
if(!strcmp(str2,"ALT_LINE_DATA")){
outfiles->outfileformat=ALT_LINE_DATA;
}else if(!strcmp(str2,"ALT_SAMPLE_DATA")){
outfiles->outfileformat=ALT_SAMPLE_DATA;
}else if(!strcmp(str2,"FLOAT_DATA")){
outfiles->outfileformat=FLOAT_DATA;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"CORRFILEFORMAT")){
if(!strcmp(str2,"ALT_LINE_DATA")){
infiles->corrfileformat=ALT_LINE_DATA;
}else if(!strcmp(str2,"ALT_SAMPLE_DATA")){
infiles->corrfileformat=ALT_SAMPLE_DATA;
}else if(!strcmp(str2,"FLOAT_DATA")){
infiles->corrfileformat=FLOAT_DATA;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"AMPFILEFORMAT")){
if(!strcmp(str2,"ALT_LINE_DATA")){
infiles->ampfileformat=ALT_LINE_DATA;
}else if(!strcmp(str2,"ALT_SAMPLE_DATA")){
infiles->ampfileformat=ALT_SAMPLE_DATA;
}else if(!strcmp(str2,"FLOAT_DATA")){
infiles->ampfileformat=FLOAT_DATA;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"ESTFILEFORMAT")){
if(!strcmp(str2,"ALT_LINE_DATA")){
infiles->estfileformat=ALT_LINE_DATA;
}else if(!strcmp(str2,"ALT_SAMPLE_DATA")){
infiles->estfileformat=ALT_SAMPLE_DATA;
}else if(!strcmp(str2,"FLOAT_DATA")){
infiles->estfileformat=FLOAT_DATA;
}else{
badparam=TRUE;
}
}else if(!strcmp(str1,"INITFILE")){
StrNCopy(outfiles->initfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"FLOWFILE")){
StrNCopy(outfiles->flowfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"EIFILE")){
StrNCopy(outfiles->eifile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"ROWCOSTFILE")){
StrNCopy(outfiles->rowcostfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"COLCOSTFILE")){
StrNCopy(outfiles->colcostfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"MSTROWCOSTFILE")){
StrNCopy(outfiles->mstrowcostfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"MSTCOLCOSTFILE")){
StrNCopy(outfiles->mstcolcostfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"MSTCOSTSFILE")){
StrNCopy(outfiles->mstcostsfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"CORRDUMPFILE")){
StrNCopy(outfiles->corrdumpfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"RAWCORRDUMPFILE")){
StrNCopy(outfiles->rawcorrdumpfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"CONNCOMPFILE")){
StrNCopy(outfiles->conncompfile,str2,MAXSTRLEN);
}else if(!strcmp(str1,"REGROWCONNCOMPS")){
badparam=SetBooleanSignedChar(&(params->regrowconncomps),str2);
}else{
fprintf(sp0,"unrecognized configuration parameter '%s' (%s:%ld)\n",
str1,conffile,nlines);
exit(ABNORMAL_EXIT);
}
/* give an error if we had trouble interpreting the line */
if(badparam){
fprintf(sp0,"illegal argument %s for parameter %s (%s:%ld)\n",
str2,str1,conffile,nlines);
exit(ABNORMAL_EXIT);
}
}
}
/* finish up */
fclose(fp);
if(nparams>1){
fprintf(sp1,"%ld parameters input from file %s (%ld lines total)\n",
nparams,conffile,nlines);
}else{
if(nlines>1){
fprintf(sp1,"%ld parameter input from file %s (%ld lines total)\n",
nparams,conffile,nlines);
}else{
fprintf(sp1,"%ld parameter input from file %s (%ld line total)\n",
nparams,conffile,nlines);
}
}
}
/* function: WriteConfigLogFile()
* ------------------------------
* Writes a text log file of configuration parameters and other
* information. The log file is in a format compatible to be used as
* a configuration file.
*/
void WriteConfigLogFile(int argc, char *argv[], infileT *infiles,
outfileT *outfiles, long linelen, paramT *params){
FILE *fp;
time_t t[1];
long k;
char buf[MAXSTRLEN], *ptr;
/* see if we need to write a log file */
if(strlen(outfiles->logfile)){
/* open the log file */
if((fp=fopen(outfiles->logfile,"w"))==NULL){
fprintf(sp0,"unable to write to log file %s\n",outfiles->logfile);
exit(ABNORMAL_EXIT);
}
fprintf(sp1,"Logging run-time parameters to file %s\n",outfiles->logfile);
/* print some run-time environment information */
fprintf(fp,"# %s v%s\n",PROGRAMNAME,VERSION);
time(t);
fprintf(fp,"# Log file generated %s",ctime(t));
ptr=getcwd(buf,MAXSTRLEN);
if(ptr!=NULL){
fprintf(fp,"# Current working directory: %s\n",buf);
}else{
fprintf(fp,"# Could not determine current working directory\n");
}
fprintf(fp,"# Command line call:");
for(k=0;k<argc;k++){
fprintf(fp," %s",argv[k]);
}
fprintf(fp,"\n\n");
/* print an entry for each run-time parameter */
/* input and output files and main runtime options */
fprintf(fp,"# File input and output and runtime options\n");
LogStringParam(fp,"INFILE",infiles->infile);
fprintf(fp,"LINELENGTH %ld\n",linelen);
LogStringParam(fp,"OUTFILE",outfiles->outfile);
LogStringParam(fp,"WEIGHTFILE",infiles->weightfile);
if(params->amplitude){
if(strlen(infiles->ampfile2)){
LogStringParam(fp,"AMPFILE1",infiles->ampfile);
LogStringParam(fp,"AMPFILE2",infiles->ampfile2);
}else{
LogStringParam(fp,"AMPFILE",infiles->ampfile);
}
}else{
if(strlen(infiles->ampfile2)){
LogStringParam(fp,"PWRFILE1",infiles->ampfile);
LogStringParam(fp,"PWRFILE2",infiles->ampfile2);
}else{
LogStringParam(fp,"PWRFILE",infiles->ampfile);
}
}
LogStringParam(fp,"MAGFILE",infiles->magfile);
LogStringParam(fp,"CORRFILE",infiles->corrfile);
LogStringParam(fp,"ESTIMATEFILE",infiles->estfile);
LogStringParam(fp,"COSTINFILE",infiles->costinfile);
LogStringParam(fp,"COSTOUTFILE",outfiles->costoutfile);
LogStringParam(fp,"LOGFILE",outfiles->logfile);
if(params->costmode==TOPO){
fprintf(fp,"STATCOSTMODE TOPO\n");
}else if(params->costmode==DEFO){
fprintf(fp,"STATCOSTMODE DEFO\n");
}else if(params->costmode==SMOOTH){
fprintf(fp,"STATCOSTMODE SMOOTH\n");
}else if(params->costmode==NOSTATCOSTS){
fprintf(fp,"STATCOSTMODE NOSTATCOSTS\n");
}
LogBoolParam(fp,"INITONLY",params->initonly);
LogBoolParam(fp,"UNWRAPPED_IN",params->unwrapped);
LogBoolParam(fp,"DEBUG",params->dumpall);
if(params->initmethod==MSTINIT){
fprintf(fp,"INITMETHOD MST\n");
}else if(params->initmethod==MCFINIT){
fprintf(fp,"INITMETHOD MCF\n");
}
LogBoolParam(fp,"VERBOSE",params->verbose);
/* file formats */
fprintf(fp,"\n# File Formats\n");
LogFileFormat(fp,"INFILEFORMAT",infiles->infileformat);
LogFileFormat(fp,"OUTFILEFORMAT",outfiles->outfileformat);
LogFileFormat(fp,"AMPFILEFORMAT",infiles->ampfileformat);
LogFileFormat(fp,"MAGFILEFORMAT",infiles->magfileformat);
LogFileFormat(fp,"CORRFILEFORMAT",infiles->corrfileformat);
LogFileFormat(fp,"ESTFILEFORMAT",infiles->estfileformat);
LogFileFormat(fp,"UNWRAPPEDINFILEFORMAT",infiles->unwrappedinfileformat);
/* SAR and geometry parameters */
fprintf(fp,"\n# SAR and Geometry Parameters\n");
fprintf(fp,"ALTITUDE %.8f\n",
params->orbitradius-params->earthradius);
fprintf(fp,"# ORBITRADIUS %.8f\n",params->orbitradius);
fprintf(fp,"EARTHRADIUS %.8f\n",params->earthradius);
if(params->bperp){
fprintf(fp,"BPERP %.8f\n",params->bperp);
}else{
fprintf(fp,"BASELINE %.8f\n",params->baseline);
fprintf(fp,"BASELINEANGLE_DEG %.8f\n",
params->baselineangle*(180.0/PI));
}
if(params->transmitmode==PINGPONG){
fprintf(fp,"TRANSMITMODE REPEATPASS\n");
}else if(params->transmitmode==SINGLEANTTRANSMIT){
fprintf(fp,"TRANSMITMODE SINGLEANTENNATRANSMIT\n");
}
fprintf(fp,"NEARRANGE %.8f\n",params->nearrange);
fprintf(fp,"DR %.8f\n",params->dr);
fprintf(fp,"DA %.8f\n",params->da);
fprintf(fp,"RANGERES %.8f\n",params->rangeres);
fprintf(fp,"AZRES %.8f\n",params->azres);
fprintf(fp,"LAMBDA %.8f\n",params->lambda);
fprintf(fp,"NLOOKSRANGE %ld\n",params->nlooksrange);
fprintf(fp,"NLOOKSAZ %ld\n",params->nlooksaz);
fprintf(fp,"NLOOKSOTHER %ld\n",params->nlooksother);
fprintf(fp,"NCORRLOOKS %.8f\n",params->ncorrlooks);
fprintf(fp,"NCORRLOOKSRANGE %ld\n",params->ncorrlooksrange);
fprintf(fp,"NCORRLOOKSAZ %ld\n",params->ncorrlooksaz);
/* scattering model parameters */
fprintf(fp,"\n# Scattering model parameters\n");
fprintf(fp,"KDS %.8f\n",params->kds);
fprintf(fp,"SPECULAREXP %.8f\n",params->specularexp);
fprintf(fp,"DZRCRITFACTOR %.8f\n",params->dzrcritfactor);
LogBoolParam(fp,"SHADOW",params->shadow);
fprintf(fp,"DZEIMIN %.8f\n",params->dzeimin);
fprintf(fp,"LAYWIDTH %ld\n",params->laywidth);
fprintf(fp,"LAYMINEI %.8f\n",params->layminei);
fprintf(fp,"SLOPERATIOFACTOR %.8f\n",params->sloperatiofactor);
fprintf(fp,"SIGSQEI %.8f\n",params->sigsqei);
/* decorrelation model paramters */
fprintf(fp,"\n# Decorrelation model parameters\n");
fprintf(fp,"DRHO %.8f\n",params->drho);
fprintf(fp,"RHOSCONST1 %.8f\n",params->rhosconst1);
fprintf(fp,"RHOSCONST2 %.8f\n",params->rhosconst2);
fprintf(fp,"CSTD1 %.8f\n",params->cstd1);
fprintf(fp,"CSTD2 %.8f\n",params->cstd2);
fprintf(fp,"CSTD3 %.8f\n",params->cstd3);
fprintf(fp,"DEFAULTCORR %.8f\n",params->defaultcorr);
fprintf(fp,"RHOMINFACTOR %.8f\n",params->rhominfactor);
/* PDF model paramters */
fprintf(fp,"\n# PDF model parameters\n");
fprintf(fp,"DZLAYPEAK %.8f\n",params->dzlaypeak);
fprintf(fp,"AZDZFACTOR %.8f\n",params->azdzfactor);
fprintf(fp,"DZEIFACTOR %.8f\n",params->dzeifactor);
fprintf(fp,"DZEIWEIGHT %.8f\n",params->dzeiweight);
fprintf(fp,"DZLAYFACTOR %.8f\n",params->dzlayfactor);
fprintf(fp,"LAYCONST %.8f\n",params->layconst);
fprintf(fp,"LAYFALLOFFCONST %.8f\n",params->layfalloffconst);
fprintf(fp,"SIGSQSHORTMIN %ld\n",params->sigsqshortmin);
fprintf(fp,"SIGSQLAYFACTOR %.8f\n",params->sigsqlayfactor);
/* deformation mode paramters */
fprintf(fp,"\n# Deformation mode parameters\n");
fprintf(fp,"DEFOAZDZFACTOR %.8f\n",params->defoazdzfactor);
fprintf(fp,"DEFOTHRESHFACTOR %.8f\n",params->defothreshfactor);
fprintf(fp,"DEFOMAX_CYCLE %.8f\n",params->defomax);
fprintf(fp,"SIGSQCORR %.8f\n",params->sigsqcorr);
fprintf(fp,"DEFOCONST %.8f\n",params->defolayconst);
/* algorithm parameters */
fprintf(fp,"\n# Algorithm parameters\n");
fprintf(fp,"INITMAXFLOW %ld\n",params->initmaxflow);
fprintf(fp,"ARCMAXFLOWCONST %ld\n",params->arcmaxflowconst);
fprintf(fp,"MAXFLOW %ld\n",params->maxflow);
fprintf(fp,"KROWEI %ld\n",params->krowei);
fprintf(fp,"KCOLEI %ld\n",params->kcolei);
fprintf(fp,"KPARDPSI %ld\n",params->kpardpsi);
fprintf(fp,"KPERPDPSI %ld\n",params->kperpdpsi);
fprintf(fp,"THRESHOLD %.8f\n",params->threshold);
fprintf(fp,"INITDZR %.8f\n",params->initdzr);
fprintf(fp,"INITDZSTEP %.8f\n",params->initdzstep);
fprintf(fp,"MAXCOST %.8f\n",params->maxcost);
fprintf(fp,"COSTSCALE %.8f\n",params->costscale);
fprintf(fp,"COSTSCALEAMBIGHT %.8f\n",params->costscaleambight);
fprintf(fp,"DNOMINCANGLE %.8f\n",params->dnomincangle);
fprintf(fp,"NSHORTCYCLE %ld\n",params->nshortcycle);
fprintf(fp,"MAXNEWNODECONST %.8f\n",params->maxnewnodeconst);
if(params->maxnflowcycles==USEMAXCYCLEFRACTION){
fprintf(fp,"MAXCYCLEFRACTION %.8f\n",params->maxcyclefraction);
}else{
fprintf(fp,"MAXNFLOWCYCLES %ld\n",params->maxnflowcycles);
}
fprintf(fp,"SOURCEMODE %ld\n",params->sourcemode);
fprintf(fp,"CS2SCALEFACTOR %ld\n",params->cs2scalefactor);
/* file names for dumping intermediate arrays */
fprintf(fp,"\n# File names for dumping intermediate arrays\n");
LogStringParam(fp,"INITFILE",outfiles->initfile);
LogStringParam(fp,"FLOWFILE",outfiles->flowfile);
LogStringParam(fp,"EIFILE",outfiles->eifile);
LogStringParam(fp,"ROWCOSTFILE",outfiles->rowcostfile);
LogStringParam(fp,"COLCOSTFILE",outfiles->colcostfile);
LogStringParam(fp,"MSTROWCOSTFILE",outfiles->mstrowcostfile);
LogStringParam(fp,"MSTCOLCOSTFILE",outfiles->mstcolcostfile);
LogStringParam(fp,"MSTCOSTSFILE",outfiles->mstcostsfile);
LogStringParam(fp,"RAWCORRDUMPFILE",outfiles->rawcorrdumpfile);
LogStringParam(fp,"CORRDUMPFILE",outfiles->corrdumpfile);
/* piece extraction parameters */
if(params->ntilerow==1 && params->ntilecol==1){
fprintf(fp,"\n# Piece extraction parameters\n");
fprintf(fp,"PIECEFIRSTROW %ld\n",params->piecefirstrow+1);
fprintf(fp,"PIECEFIRSTCOL %ld\n",params->piecefirstcol+1);
fprintf(fp,"PIECENROW %ld\n",params->piecenrow);
fprintf(fp,"PIECENCOL %ld\n",params->piecencol);
}else{
fprintf(fp,"\n# Piece extraction parameters\n");
fprintf(fp,"# Parameters ignored because of tile mode\n");
fprintf(fp,"# PIECEFIRSTROW %ld\n",params->piecefirstrow);
fprintf(fp,"# PIECEFIRSTCOL %ld\n",params->piecefirstcol);
fprintf(fp,"# PIECENROW %ld\n",params->piecenrow);
fprintf(fp,"# PIECENCOL %ld\n",params->piecencol);
}
/* tile control */
fprintf(fp,"\n# Tile control\n");
fprintf(fp,"NTILEROW %ld\n",params->ntilerow);
fprintf(fp,"NTILECOL %ld\n",params->ntilecol);
fprintf(fp,"ROWOVRLP %ld\n",params->rowovrlp);
fprintf(fp,"COLOVRLP %ld\n",params->colovrlp);
fprintf(fp,"NPROC %ld\n",params->nthreads);
fprintf(fp,"TILECOSTTHRESH %ld\n",params->tilecostthresh);
fprintf(fp,"MINREGIONSIZE %ld\n",params->minregionsize);
fprintf(fp,"TILEEDGEWEIGHT %.8f\n",params->tileedgeweight);
fprintf(fp,"SCNDRYARCFLOWMAX %ld\n",params->scndryarcflowmax);
LogBoolParam(fp,"RMTMPTILE",params->rmtmptile);
if(params->assembleonly){
LogStringParam(fp,"ASSEMBLEONLY",params->tiledir);
}else{
fprintf(fp,"ASSEMBLEONLY FALSE\n");
}
/* connected component control */
fprintf(fp,"\n# Connected component control\n");
LogStringParam(fp,"CONNCOMPFILE",outfiles->conncompfile);
LogBoolParam(fp,"REGROWCONNCOMPS",params->regrowconncomps);
fprintf(fp,"MINCONNCOMPFRAC %.8f\n",params->minconncompfrac);
fprintf(fp,"CONNCOMPTHRESH %ld\n",params->conncompthresh);
fprintf(fp,"MAXNCOMPS %ld\n",params->maxncomps);
/* close the log file */
fclose(fp);
}
}
/* function: LogStringParam()
* --------------------------
* Writes a line to the log file stream for the given keyword/value
* pair.
*/
void LogStringParam(FILE *fp, char *key, char *value){
/* see if we were passed a zero length value string */
if(strlen(value)){
fprintf(fp,"%s %s\n",key,value);
fflush(fp);
}else{
fprintf(fp,"# Empty value for parameter %s\n",key);
}
}
/* LogBoolParam()
* --------------
* Writes a line to the log file stream for the given keyword/bool
* pair.
*/
void LogBoolParam(FILE *fp, char *key, signed char boolvalue){
if(boolvalue){
fprintf(fp,"%s TRUE\n",key);
}else{
fprintf(fp,"%s FALSE\n",key);
}
}
/* LogFileFormat()
* ---------------
* Writes a line to the log file stream for the given keyword/
* file format pair.
*/
void LogFileFormat(FILE *fp, char *key, signed char fileformat){
if(fileformat==COMPLEX_DATA){
fprintf(fp,"%s COMPLEX_DATA\n",key);
}else if(fileformat==FLOAT_DATA){
fprintf(fp,"%s FLOAT_DATA\n",key);
}else if(fileformat==ALT_LINE_DATA){
fprintf(fp,"%s ALT_LINE_DATA\n",key);
}else if(fileformat==ALT_SAMPLE_DATA){
fprintf(fp,"%s ALT_SAMPLE_DATA\n",key);
}
}
/* function: GetNLines()
* ---------------------
* Gets the number of lines of data in the input file based on the file
* size.
*/
long GetNLines(infileT *infiles, long linelen){
FILE *fp;
long filesize, datasize;
/* get size of input file in rows and columns */
if((fp=fopen(infiles->infile,"r"))==NULL){
fprintf(sp0,"can't open file %s\n",infiles->infile);
exit(ABNORMAL_EXIT);
}
fseek(fp,0,SEEK_END);
filesize=ftell(fp);
fclose(fp);
if(infiles->infileformat==FLOAT_DATA){
datasize=sizeof(float);
}else{
datasize=2*sizeof(float);
}
if(filesize % (datasize*linelen)){
fprintf(sp0,"extra data in file %s (bad linelength?)\n",
infiles->infile);
exit(ABNORMAL_EXIT);
}
return(filesize/(datasize*linelen)); /* implicit floor */
}
/* function: WriteOutputFile()
* ---------------------------
* Writes the unwrapped phase to the output file specified, in the
* format given in the parameter structure.
*/
void WriteOutputFile(float **mag, float **unwrappedphase, char *outfile,
outfileT *outfiles, long nrow, long ncol){
if(outfiles->outfileformat==ALT_LINE_DATA){
WriteAltLineFile(mag,unwrappedphase,outfile,nrow,ncol);
}else if(outfiles->outfileformat==ALT_SAMPLE_DATA){
WriteAltSampFile(mag,unwrappedphase,outfile,nrow,ncol);
}else if(outfiles->outfileformat==FLOAT_DATA){
Write2DArray((void **)unwrappedphase,outfile,
nrow,ncol,sizeof(float));
}else{
fprintf(sp0,"WARNING: Illegal format specified for output file\n");
fprintf(sp0," using default floating-point format\n");
Write2DArray((void **)unwrappedphase,outfile,
nrow,ncol,sizeof(float));
}
}
/* function: OpenOutputFile()
* --------------------------
* Opens a file for writing. If unable to open the file, tries to
* open a file in a dump path. The name of the opened output file
* is written into the string realoutfile, for which at least
* MAXSTRLEN bytes should already be allocated.
*/
FILE *OpenOutputFile(char *outfile, char *realoutfile){
char path[MAXSTRLEN], basename[MAXSTRLEN], dumpfile[MAXSTRLEN];
FILE *fp;
if((fp=fopen(outfile,"w"))==NULL){
/* if we can't write to the out file, get the file name from the path */
/* and dump to the default path */
ParseFilename(outfile,path,basename);
StrNCopy(dumpfile,DUMP_PATH,MAXSTRLEN);
strcat(dumpfile,basename);
if((fp=fopen(dumpfile,"w"))!=NULL){
fprintf(sp0,"WARNING: Can't write to file %s. Dumping to file %s\n",
outfile,dumpfile);
StrNCopy(realoutfile,dumpfile,MAXSTRLEN);
}else{
fprintf(sp0,"Unable to write to file %s or dump to file %s\nAbort\n",
outfile,dumpfile);
exit(ABNORMAL_EXIT);
}
}else{
StrNCopy(realoutfile,outfile,MAXSTRLEN);
}
return(fp);
}
/* function: WriteAltLineFile()
* ----------------------------
* Writes magnitude and phase data from separate arrays to file.
* Data type is float. For each line of data, a full line of magnitude data
* is written, then a full line of phase data. Dumps the file to a
* default directory if the file name/path passed in cannot be used.
*/
void WriteAltLineFile(float **mag, float **phase, char *outfile,
long nrow, long ncol){
int row;
FILE *fp;
char realoutfile[MAXSTRLEN];
fp=OpenOutputFile(outfile,realoutfile);
for(row=0; row<nrow; row++){
if(fwrite(mag[row],sizeof(float),ncol,fp)!=ncol
|| fwrite(phase[row],sizeof(float),ncol,fp)!=ncol){
fprintf(sp0,"Error while writing to file %s (device full?)\nAbort\n",
realoutfile);
exit(ABNORMAL_EXIT);
}
}
fclose(fp);
}
/* function: WriteAltSampFile()
* ----------------------------
* Writes data from separate arrays to file, alternating samples.
* Data type is float. nrow and ncol are the sizes of each input
* array. Dumps the file to a default directory if the file name/path
* passed in cannot be used.
*/
void WriteAltSampFile(float **arr1, float **arr2, char *outfile,
long nrow, long ncol){
long row, col;
FILE *fp;
float *outline;
char realoutfile[MAXSTRLEN];
outline=MAlloc(2*ncol*sizeof(float));
fp=OpenOutputFile(outfile,realoutfile);
for(row=0; row<nrow; row++){
for(col=0;col<ncol;col++){
outline[2*col]=arr1[row][col];
outline[2*col+1]=arr2[row][col];
}
if(fwrite(outline,sizeof(float),2*ncol,fp)!=2*ncol){
fprintf(sp0,"Error while writing to file %s (device full?)\nAbort\n",
realoutfile);
exit(ABNORMAL_EXIT);
}
}
fclose(fp);
}
/* function: Write2DArray()
* ------------------------
* Write data in a two dimensional array to a file. Data elements are
* have the number of bytes specified by size (use sizeof() when
* calling this function.
*/
void Write2DArray(void **array, char *filename, long nrow, long ncol,
size_t size){
int row;
FILE *fp;
char realoutfile[MAXSTRLEN];
fp=OpenOutputFile(filename,realoutfile);
for(row=0; row<nrow; row++){
if(fwrite(array[row],size,ncol,fp)!=ncol){
fprintf(sp0,"Error while writing to file %s (device full?)\nAbort\n",
realoutfile);
exit(ABNORMAL_EXIT);
}
}
fclose(fp);
}
/* function: Write2DRowColArray()
* ------------------------------
* Write data in a 2-D row-and-column array to a file. Data elements
* have the number of bytes specified by size (use sizeof() when
* calling this function. The format of the array is nrow-1 rows
* of ncol elements, followed by nrow rows of ncol-1 elements each.
*/
void Write2DRowColArray(void **array, char *filename, long nrow,
long ncol, size_t size){
int row;
FILE *fp;
char realoutfile[MAXSTRLEN];
fp=OpenOutputFile(filename,realoutfile);
for(row=0; row<nrow-1; row++){
if(fwrite(array[row],size,ncol,fp)!=ncol){
fprintf(sp0,"Error while writing to file %s (device full?)\nAbort\n",
realoutfile);
exit(ABNORMAL_EXIT);
}
}
for(row=nrow-1; row<2*nrow-1; row++){
if(fwrite(array[row],size,ncol-1,fp)!=ncol-1){
fprintf(sp0,"Error while writing to file %s (device full?)\nAbort\n",
realoutfile);
exit(ABNORMAL_EXIT);
}
}
fclose(fp);
}
/* function: ReadInputFile()
* -------------------------
* Reads the input file specified on the command line.
*/
void ReadInputFile(infileT *infiles, float ***magptr, float ***wrappedphaseptr,
short ***flowsptr, long linelen, long nlines,
paramT *params, tileparamT *tileparams){
long row, col, nrow, ncol;
float **mag, **wrappedphase, **unwrappedphase;
short **flows;
/* initialize */
mag=NULL;
wrappedphase=NULL;
unwrappedphase=NULL;
flows=NULL;
nrow=tileparams->nrow;
ncol=tileparams->ncol;
/* check data size */
if(tileparams->ncol>LARGESHORT || tileparams->nrow>LARGESHORT){
fprintf(sp0,"one or more interferogram dimensions too large\n");
exit(ABNORMAL_EXIT);
}
if(tileparams->ncol<2 || tileparams->nrow<2){
fprintf(sp0,"input interferogram must be at least 2x2\n");
exit(ABNORMAL_EXIT);
}
/* is the input file already unwrapped? */
if(!params->unwrapped){
/* read wrapped phase and possibly interferogram magnitude data */
fprintf(sp1,"Reading wrapped phase from file %s\n",infiles->infile);
if(infiles->infileformat==COMPLEX_DATA){
ReadComplexFile(&mag,&wrappedphase,infiles->infile,
linelen,nlines,tileparams);
}else if(infiles->infileformat==ALT_LINE_DATA){
ReadAltLineFile(&mag,&wrappedphase,infiles->infile,
linelen,nlines,tileparams);
}else if(infiles->infileformat==ALT_SAMPLE_DATA){
ReadAltSampFile(&mag,&wrappedphase,infiles->infile,
linelen,nlines,tileparams);
}else if(infiles->infileformat==FLOAT_DATA){
Read2DArray((void ***)&wrappedphase,infiles->infile,linelen,nlines,
tileparams,sizeof(float *),sizeof(float));
}else{
fprintf(sp0,"illegal input file format specification\n");
exit(ABNORMAL_EXIT);
}
/* check to make sure the input data doesn't contain NaNs or infs */
if(!ValidDataArray(wrappedphase,nrow,ncol)
|| (mag!=NULL && !ValidDataArray(mag,nrow,ncol))){
fprintf(sp0,"NaN or infinity found in input float data\nAbort\n");
exit(ABNORMAL_EXIT);
}
/* flip the sign of the wrapped phase if flip flag is set */
FlipPhaseArraySign(wrappedphase,params,nrow,ncol);
/* make sure the wrapped phase is properly wrapped */
WrapPhase(wrappedphase,nrow,ncol);
}else{
/* read unwrapped phase input */
fprintf(sp1,"Reading unwrapped phase from file %s\n",infiles->infile);
if(infiles->unwrappedinfileformat==ALT_LINE_DATA){
ReadAltLineFile(&mag,&unwrappedphase,infiles->infile,
linelen,nlines,tileparams);
}else if(infiles->unwrappedinfileformat==ALT_SAMPLE_DATA){
ReadAltSampFile(&mag,&unwrappedphase,infiles->infile,
linelen,nlines,tileparams);
}else if(infiles->unwrappedinfileformat==FLOAT_DATA){
Read2DArray((void ***)&unwrappedphase,infiles->infile,linelen,nlines,
tileparams,sizeof(float *),sizeof(float));
}else{
fprintf(sp0,"Illegal input file format specification\nAbort\n");
exit(ABNORMAL_EXIT);
}
/* check to make sure the input data doesn't contain NaNs or infs */
if(!ValidDataArray(unwrappedphase,nrow,ncol)
|| (mag!=NULL && !ValidDataArray(mag,nrow,ncol))){
fprintf(sp0,"NaN or infinity found in input float data\nAbort\n");
exit(ABNORMAL_EXIT);
}
/* flip the sign of the input unwrapped phase if flip flag is set */
FlipPhaseArraySign(unwrappedphase,params,nrow,ncol);
/* parse flows of unwrapped phase */
wrappedphase=ExtractFlow(unwrappedphase,&flows,nrow,ncol);
/* free unwrapped phase array to save memory */
Free2DArray((void **)unwrappedphase,nrow);
}
/* get memory for mag (power) image and set to unity if not passed */
if(mag==NULL){
mag=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
for(row=0;row<nrow;row++){
for(col=0;col<ncol;col++){
mag[row][col]=1.0;
}
}
}
/* set passed pointers and return the number of rows in data */
*wrappedphaseptr=wrappedphase;
*magptr=mag;
*flowsptr=flows;
}
/* function: ReadMagnitude()
* -------------------------
* Reads the interferogram magnitude in the specfied file if it exists.
* Memory for the magnitude array should already have been allocated by
* ReadInputFile().
*/
void ReadMagnitude(float **mag, infileT *infiles, long linelen, long nlines,
tileparamT *tileparams){
float **dummy;
dummy=NULL;
if(strlen(infiles->magfile)){
fprintf(sp1,"Reading interferogram magnitude from file %s\n",
infiles->magfile);
if(infiles->magfileformat==FLOAT_DATA){
Read2DArray((void ***)&mag,infiles->magfile,linelen,nlines,tileparams,
sizeof(float *),sizeof(float));
}else if(infiles->magfileformat==COMPLEX_DATA){
ReadComplexFile(&mag,&dummy,infiles->magfile,linelen,nlines,
tileparams);
}else if(infiles->magfileformat==ALT_LINE_DATA){
ReadAltLineFile(&mag,&dummy,infiles->magfile,linelen,nlines,
tileparams);
}else if(infiles->magfileformat==ALT_SAMPLE_DATA){
ReadAltSampFile(&mag,&dummy,infiles->magfile,linelen,nlines,
tileparams);
}
}
if(dummy!=NULL){
Free2DArray((void **)dummy,tileparams->nrow);
}
}
/* function: ReadUnwrappedEstimateFile()
* -------------------------------------
* Reads the unwrapped-phase estimate from a file (assumes file name exists).
*/
void ReadUnwrappedEstimateFile(float ***unwrappedestptr, infileT *infiles,
long linelen, long nlines,
paramT *params, tileparamT *tileparams){
float **dummy;
long nrow, ncol;
/* initialize */
dummy=NULL;
nrow=tileparams->nrow;
ncol=tileparams->ncol;
/* read data */
fprintf(sp1,"Reading coarse unwrapped estimate from file %s\n",
infiles->estfile);
if(infiles->estfileformat==ALT_LINE_DATA){
ReadAltLineFilePhase(unwrappedestptr,infiles->estfile,
linelen,nlines,tileparams);
}else if(infiles->estfileformat==FLOAT_DATA){
Read2DArray((void ***)unwrappedestptr,infiles->estfile,linelen,nlines,
tileparams,sizeof(float *),sizeof(float));
}else if(infiles->estfileformat==ALT_SAMPLE_DATA){
ReadAltSampFile(&dummy,unwrappedestptr,infiles->estfile,
linelen,nlines,tileparams);
}else{
fprintf(sp0,"Illegal file format specification for file %s\nAbort\n",
infiles->estfile);
}
if(dummy!=NULL){
Free2DArray((void **)dummy,nrow);
}
/* make sure data is valid */
if(!ValidDataArray(*unwrappedestptr,nrow,ncol)){
fprintf(sp0,"Infinity or NaN found in file %s\nAbort\n",infiles->estfile);
exit(ABNORMAL_EXIT);
}
/* flip the sign of the unwrapped estimate if the flip flag is set */
FlipPhaseArraySign(*unwrappedestptr,params,nrow,ncol);
}
/* function: ReadWeightsFile()
* ---------------------------
* Read in weights form rowcol format file of short ints.
*/
void ReadWeightsFile(short ***weightsptr,char *weightfile,
long linelen, long nlines, tileparamT *tileparams){
long row, col, nrow, ncol;
short **rowweight, **colweight;
signed char printwarning;
/* set up and read data */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
if(strlen(weightfile)){
fprintf(sp1,"Reading weights from file %s\n",weightfile);
Read2DRowColFile((void ***)weightsptr,weightfile,linelen,nlines,
tileparams,sizeof(short));
rowweight=*weightsptr;
colweight=&(*weightsptr)[nrow-1];
printwarning=FALSE;
for(row=0;row<nrow-1;row++){
for(col=0;col<ncol;col++){
if(rowweight[row][col]<0){
rowweight[row][col]=0;
printwarning=TRUE;
}
}
}
for(row=0;row<nrow;row++){
for(col=0;col<ncol-1;col++){
if(colweight[row][col]<0){
colweight[row][col]=0;
printwarning=TRUE;
}
}
}
if(printwarning){
fprintf(sp0,"WARNING: Weights cannot be negative. Clipping to 0\n");
}
}else{
fprintf(sp1,"No weight file specified. Assuming uniform weights\n");
*weightsptr=(short **)Get2DRowColMem(nrow,ncol,
sizeof(short *),sizeof(short));
rowweight=*weightsptr;
colweight=&(*weightsptr)[nrow-1];
Set2DShortArray(rowweight,nrow-1,ncol,DEF_WEIGHT);
Set2DShortArray(colweight,nrow,ncol-1,DEF_WEIGHT);
}
}
/* function: ReadIntensity()
* -------------------------
* Reads the intensity information from specified file(s). If possilbe,
* sets arrays for average power and individual powers of single-pass
* SAR images.
*/
void ReadIntensity(float ***pwrptr, float ***pwr1ptr, float ***pwr2ptr,
infileT *infiles, long linelen, long nlines,
paramT *params, tileparamT *tileparams){
float **pwr, **pwr1, **pwr2;
long row, col, nrow, ncol;
/* initialize */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
pwr=NULL;
pwr1=NULL;
pwr2=NULL;
/* read the data */
if(strlen(infiles->ampfile2)){
/* data is given in two separate files */
fprintf(sp1,"Reading brightness data from files %s and %s\n",
infiles->ampfile,infiles->ampfile2);
if(infiles->ampfileformat==FLOAT_DATA){
Read2DArray((void ***)&pwr1,infiles->ampfile,linelen,nlines,tileparams,
sizeof(float *),sizeof(float));
Read2DArray((void ***)&pwr2,infiles->ampfile2,linelen,nlines,tileparams,
sizeof(float *),sizeof(float));
}else{
fprintf(sp0,"Illegal file formats specified for files %s, %s\nAbort\n",
infiles->ampfile,infiles->ampfile2);
exit(ABNORMAL_EXIT);
}
}else{
/* data is in single file */
fprintf(sp1,"Reading brightness data from file %s\n",infiles->ampfile);
if(infiles->ampfileformat==ALT_SAMPLE_DATA){
ReadAltSampFile(&pwr1,&pwr2,infiles->ampfile,linelen,nlines,
tileparams);
}else if(infiles->ampfileformat==ALT_LINE_DATA){
ReadAltLineFile(&pwr1,&pwr2,infiles->ampfile,linelen,nlines,
tileparams);
}else if(infiles->ampfileformat==FLOAT_DATA){
Read2DArray((void ***)&pwr,infiles->ampfile,linelen,nlines,tileparams,
sizeof(float *),sizeof(float));
pwr1=NULL;
pwr2=NULL;
}else{
fprintf(sp0,"Illegal file format specified for file %s\nAbort\n",
infiles->ampfile);
exit(ABNORMAL_EXIT);
}
}
/* check data validity */
if((pwr1!=NULL && !ValidDataArray(pwr1,nrow,ncol))
|| (pwr2!=NULL && !ValidDataArray(pwr2,nrow,ncol))
|| (pwr!=NULL && !ValidDataArray(pwr,nrow,ncol))){
fprintf(sp0,"Infinity or NaN found in amplitude or power data\nAbort\n");
exit(ABNORMAL_EXIT);
}
/* if data is amplitude, square to get power */
if(params->amplitude){
for(row=0;row<nrow;row++){
for(col=0;col<ncol;col++){
if(pwr1!=NULL && pwr2!=NULL){
pwr1[row][col]*=pwr1[row][col];
pwr2[row][col]*=pwr2[row][col];
}else{
pwr[row][col]*=pwr[row][col];
}
}
}
}
/* get the average power */
if(pwr1!=NULL && pwr2!=NULL){
if(pwr==NULL){
pwr=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
}
for(row=0;row<nrow;row++){
for(col=0;col<ncol;col++){
pwr[row][col]=(pwr1[row][col]+pwr2[row][col])/2.0;
}
}
}
/* set output pointers */
*pwrptr=pwr;
*pwr1ptr=pwr1;
*pwr2ptr=pwr2;
}
/* function: ReadCorrelation()
* ---------------------------
* Reads the correlation information from specified file.
*/
void ReadCorrelation(float ***corrptr, infileT *infiles,
long linelen, long nlines, tileparamT *tileparams){
float **corr, **dummy;
long nrow;
/* initialize */
nrow=tileparams->nrow;
dummy=NULL;
corr=NULL;
/* read the data */
fprintf(sp1,"Reading correlation data from file %s\n",infiles->corrfile);
if(infiles->corrfileformat==ALT_SAMPLE_DATA){
ReadAltSampFile(&dummy,&corr,infiles->corrfile,linelen,nlines,tileparams);
}else if(infiles->corrfileformat==ALT_LINE_DATA){
ReadAltLineFilePhase(&corr,infiles->corrfile,linelen,nlines,tileparams);
}else if(infiles->corrfileformat==FLOAT_DATA){
Read2DArray((void ***)&corr,infiles->corrfile,linelen,nlines,tileparams,
sizeof(float *),sizeof(float));
}else{
fprintf(sp0,"Illegal file format specified for file %s\nAbort\n",
infiles->corrfile);
exit(ABNORMAL_EXIT);
}
/* set output pointer and free memory */
if(dummy!=NULL){
Free2DArray((void **)dummy,nrow);
}
*corrptr=corr;
}
/* function: ReadAltLineFile()
* ---------------------------
* Read in the data from a file containing magnitude and phase
* data. File should have one line of magnitude data, one line
* of phase data, another line of magnitude data, etc.
* ncol refers to the number of complex elements in one line of
* data.
*/
void ReadAltLineFile(float ***mag, float ***phase, char *alfile,
long linelen, long nlines, tileparamT *tileparams){
FILE *fp;
long filesize,row,nrow,ncol,padlen;
/* open the file */
if((fp=fopen(alfile,"r"))==NULL){
fprintf(sp0,"Can't open file %s\nAbort\n",alfile);
exit(ABNORMAL_EXIT);
}
/* get number of lines based on file size and line length */
fseek(fp,0,SEEK_END);
filesize=ftell(fp);
if(filesize!=(2*nlines*linelen*sizeof(float))){
fprintf(sp0,"File %s wrong size (%ldx%ld array expected)\nAbort\n",
alfile,nlines,linelen);
exit(ABNORMAL_EXIT);
}
fseek(fp,0,SEEK_SET);
/* get memory */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
if(*mag==NULL){
(*mag)=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
}
if(*phase==NULL){
(*phase)=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
}
/* read the data */
fseek(fp,(tileparams->firstrow*2*linelen+tileparams->firstcol)
*sizeof(float),SEEK_CUR);
padlen=(linelen-ncol)*sizeof(float);
for(row=0; row<nrow; row++){
if(fread((*mag)[row],sizeof(float),ncol,fp)!=ncol){
fprintf(sp0,"Error while reading from file %s\nAbort\n",alfile);
exit(ABNORMAL_EXIT);
}
fseek(fp,padlen,SEEK_CUR);
if(fread((*phase)[row],sizeof(float),ncol,fp)!=ncol){
fprintf(sp0,"Error while reading from file %s\nAbort\n",alfile);
exit(ABNORMAL_EXIT);
}
fseek(fp,padlen,SEEK_CUR);
}
fclose(fp);
}
/* function: ReadAltLineFilePhase()
* --------------------------------
* Read only the phase data from a file containing magnitude and phase
* data. File should have one line of magnitude data, one line
* of phase data, another line of magnitude data, etc.
* ncol refers to the number of complex elements in one line of
* data.
*/
void ReadAltLineFilePhase(float ***phase, char *alfile,
long linelen, long nlines, tileparamT *tileparams){
FILE *fp;
long filesize,row,nrow,ncol,padlen;
/* open the file */
if((fp=fopen(alfile,"r"))==NULL){
fprintf(sp0,"Can't open file %s\nAbort\n",alfile);
exit(ABNORMAL_EXIT);
}
/* get number of lines based on file size and line length */
fseek(fp,0,SEEK_END);
filesize=ftell(fp);
if(filesize!=(2*nlines*linelen*sizeof(float))){
fprintf(sp0,"File %s wrong size (%ldx%ld array expected)\nAbort\n",
alfile,nlines,linelen);
exit(ABNORMAL_EXIT);
}
fseek(fp,0,SEEK_SET);
/* get memory */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
if(*phase==NULL){
(*phase)=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
}
/* read the phase data */
fseek(fp,(tileparams->firstrow*2*linelen+linelen
+tileparams->firstcol)*sizeof(float),SEEK_CUR);
padlen=(2*linelen-ncol)*sizeof(float);
for(row=0; row<nrow; row++){
if(fread((*phase)[row],sizeof(float),ncol,fp)!=ncol){
fprintf(sp0,"Error while reading from file %s\nAbort\n",alfile);
exit(ABNORMAL_EXIT);
}
fseek(fp,padlen,SEEK_CUR);
}
fclose(fp);
}
/* function: ReadComplexFile()
* ---------------------------
* Reads file of complex floats of the form real,imag,real,imag...
* ncol is the number of complex samples (half the number of real
* floats per line). Ensures that phase values are in the range
* [0,2pi).
*/
void ReadComplexFile(float ***mag, float ***phase, char *rifile,
long linelen, long nlines, tileparamT *tileparams){
FILE *fp;
long filesize,ncol,nrow,row,col,padlen;
float *inpline;
/* open the file */
if((fp=fopen(rifile,"r"))==NULL){
fprintf(sp0,"Can't open file %s\nAbort\n",rifile);
exit(ABNORMAL_EXIT);
}
/* get number of lines based on file size and line length */
fseek(fp,0,SEEK_END);
filesize=ftell(fp);
if(filesize!=(2*nlines*linelen*sizeof(float))){
fprintf(sp0,"File %s wrong size (%ldx%ld array expected)\nAbort\n",
rifile,nlines,linelen);
exit(ABNORMAL_EXIT);
}
fseek(fp,0,SEEK_SET);
/* get memory */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
if(*mag==NULL){
(*mag)=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
}
if(*phase==NULL){
(*phase)=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
}
inpline=(float *)MAlloc(2*ncol*sizeof(float));
/* read the data and convert to magnitude and phase */
fseek(fp,(tileparams->firstrow*linelen+tileparams->firstcol)
*2*sizeof(float),SEEK_CUR);
padlen=(linelen-ncol)*2*sizeof(float);
for(row=0; row<nrow; row++){
if(fread(inpline,sizeof(float),2*ncol,fp)!=2*ncol){
fprintf(sp0,"Error while reading from file %s\nAbort\n",rifile);
exit(ABNORMAL_EXIT);
}
for(col=0; col<ncol; col++){
(*mag)[row][col]=sqrt(inpline[2*col]*inpline[2*col]
+inpline[2*col+1]*inpline[2*col+1]);
if(!IsFinite((*phase)[row][col]=atan2(inpline[2*col+1],inpline[2*col]))){
(*phase)[row][col]=0;
}else if((*phase)[row][col]<0){
(*phase)[row][col]+=TWOPI;
}else if((*phase)[row][col]>=TWOPI){
(*phase)[row][col]-=TWOPI;
}
}
fseek(fp,padlen,SEEK_CUR);
}
free(inpline);
fclose(fp);
}
/* function: Read2DArray()
* -------------------------
* Reads file of real data of size elsize. Assumes the native byte order
* of the platform.
*/
void Read2DArray(void ***arr, char *infile, long linelen, long nlines,
tileparamT *tileparams, size_t elptrsize, size_t elsize){
FILE *fp;
long filesize,row,nrow,ncol,padlen;
/* open the file */
if((fp=fopen(infile,"r"))==NULL){
fprintf(sp0,"Can't open file %s\nAbort\n",infile);
exit(ABNORMAL_EXIT);
}
/* get number of lines based on file size and line length */
fseek(fp,0,SEEK_END);
filesize=ftell(fp);
if(filesize!=(nlines*linelen*elsize)){
fprintf(sp0,"File %s wrong size (%ldx%ld array expected)\nAbort\n",
infile,nlines,linelen);
exit(ABNORMAL_EXIT);
}
fseek(fp,0,SEEK_SET);
/* get memory */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
if(*arr==NULL){
(*arr)=(void **)Get2DMem(nrow,ncol,elptrsize,elsize);
}
/* read the data */
fseek(fp,(linelen*tileparams->firstrow+tileparams->firstcol)
*elsize,SEEK_CUR);
padlen=(linelen-ncol)*elsize;
for(row=0; row<nrow; row++){
if(fread((*arr)[row],elsize,ncol,fp)!=ncol){
fprintf(sp0,"Error while reading from file %s\nAbort\n",infile);
exit(ABNORMAL_EXIT);
}
fseek(fp,padlen,SEEK_CUR);
}
fclose(fp);
}
/* function: ReadAltSampFile()
* ---------------------------
* Reads file of real alternating floats from separate images. Format is
* real0A, real0B, real1A, real1B, real2A, real2B,...
* ncol is the number of samples in each image (note the number of
* floats per line in the specified file).
*/
void ReadAltSampFile(float ***arr1, float ***arr2, char *infile,
long linelen, long nlines, tileparamT *tileparams){
FILE *fp;
long filesize,row,col,nrow,ncol,padlen;
float *inpline;
/* open the file */
if((fp=fopen(infile,"r"))==NULL){
fprintf(sp0,"Can't open file %s\nAbort\n",infile);
exit(ABNORMAL_EXIT);
}
/* get number of lines based on file size and line length */
fseek(fp,0,SEEK_END);
filesize=ftell(fp);
if(filesize!=(2*nlines*linelen*sizeof(float))){
fprintf(sp0,"File %s wrong size (%ldx%ld array expected)\nAbort\n",
infile,nlines,linelen);
exit(ABNORMAL_EXIT);
}
fseek(fp,0,SEEK_SET);
/* get memory */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
if(*arr1==NULL){
(*arr1)=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
}
if(*arr2==NULL){
(*arr2)=(float **)Get2DMem(nrow,ncol,sizeof(float *),sizeof(float));
}
inpline=(float *)MAlloc(2*ncol*sizeof(float));
/* read the data */
fseek(fp,(tileparams->firstrow*linelen+tileparams->firstcol)
*2*sizeof(float),SEEK_CUR);
padlen=(linelen-ncol)*2*sizeof(float);
for(row=0; row<nrow; row++){
if(fread(inpline,sizeof(float),2*ncol,fp)!=2*ncol){
fprintf(sp0,"Error while reading from file %s\nAbort\n",infile);
exit(ABNORMAL_EXIT);
}
for(col=0; col<ncol; col++){
(*arr1)[row][col]=inpline[2*col];
(*arr2)[row][col]=inpline[2*col+1];
}
fseek(fp,padlen,SEEK_CUR);
}
free(inpline);
fclose(fp);
}
/* function: Read2DRowColFile()
* ----------------------------
* Gets memory and reads single array from a file. Array should be in the
* file line by line starting with the row array (size nrow-1 x ncol) and
* followed by the column array (size nrow x ncol-1). Both arrays
* are placed into the passed array as they were in the file.
*/
void Read2DRowColFile(void ***arr, char *filename, long linelen, long nlines,
tileparamT *tileparams, size_t size){
FILE *fp;
long row, nel, nrow, ncol, padlen, filelen;
/* open the file */
if((fp=fopen(filename,"r"))==NULL){
fprintf(sp0,"Can't open file %s\nAbort\n",filename);
exit(ABNORMAL_EXIT);
}
/* get number of data elements in file */
fseek(fp,0,SEEK_END);
filelen=ftell(fp);
fseek(fp,0,SEEK_SET);
nel=(long )(filelen/size);
/* check file size */
if(2*linelen*nlines-nlines-linelen != nel || (filelen % size)){
fprintf(sp0,"File %s wrong size (%ld elements expected)\nAbort\n",
filename,2*linelen*nlines-nlines-linelen);
exit(ABNORMAL_EXIT);
}
/* get memory if passed pointer is NULL */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
if(*arr==NULL){
(*arr)=Get2DRowColMem(nrow,ncol,sizeof(void *),size);
}
/* read arrays */
fseek(fp,(linelen*tileparams->firstrow+tileparams->firstcol)
*size,SEEK_SET);
padlen=(linelen-ncol)*size;
for(row=0; row<nrow-1; row++){
if(fread((*arr)[row],size,ncol,fp)!=ncol){
fprintf(sp0,"Error while reading from file %s\nAbort\n",filename);
exit(ABNORMAL_EXIT);
}
fseek(fp,padlen,SEEK_CUR);
}
fseek(fp,(linelen*(nlines-1)+(linelen-1)*tileparams->firstrow
+tileparams->firstcol)*size,SEEK_SET);
for(row=nrow-1; row<2*nrow-1; row++){
if(fread((*arr)[row],size,ncol-1,fp)!=ncol-1){
fprintf(sp0,"Error while reading from file %s\nAbort\n",filename);
exit(ABNORMAL_EXIT);
}
fseek(fp,padlen,SEEK_CUR);
}
fclose(fp);
}
/* function: Read2DRowColFileRows()
* --------------------------------
* Similar to Read2DRowColFile(), except reads only row (horizontal) data
* at specified locations. tileparams->nrow is treated as the number of
* rows of data to be read from the RowCol file, not the number of
* equivalent rows in the orginal pixel file (whose arcs are represented
* in the RowCol file).
*/
void Read2DRowColFileRows(void ***arr, char *filename, long linelen,
long nlines, tileparamT *tileparams, size_t size){
FILE *fp;
long row, nel, nrow, ncol, padlen, filelen;
/* open the file */
if((fp=fopen(filename,"r"))==NULL){
fprintf(sp0,"Can't open file %s\nAbort\n",filename);
exit(ABNORMAL_EXIT);
}
/* get number of data elements in file */
fseek(fp,0,SEEK_END);
filelen=ftell(fp);
fseek(fp,0,SEEK_SET);
nel=(long )(filelen/size);
/* check file size */
if(2*linelen*nlines-nlines-linelen != nel || (filelen % size)){
fprintf(sp0,"File %s wrong size (%ld elements expected)\nAbort\n",
filename,2*linelen*nlines-nlines-linelen);
exit(ABNORMAL_EXIT);
}
/* get memory if passed pointer is NULL */
nrow=tileparams->nrow;
ncol=tileparams->ncol;
if(*arr==NULL){
(*arr)=Get2DMem(nrow,ncol,sizeof(void *),size);
}
/* read arrays */
fseek(fp,(linelen*tileparams->firstrow+tileparams->firstcol)
*size,SEEK_SET);
padlen=(linelen-ncol)*size;
for(row=0; row<nrow; row++){
if(fread((*arr)[row],size,ncol,fp)!=ncol){
fprintf(sp0,"Error while reading from file %s\nAbort\n",filename);
exit(ABNORMAL_EXIT);
}
fseek(fp,padlen,SEEK_CUR);
}
fclose(fp);
}
/* function: SetDumpAll()
* ----------------------
* Sets names of output files so that the program will dump intermediate
* arrays. Only sets names if they are not set already.
*/
void SetDumpAll(outfileT *outfiles, paramT *params){
if(params->dumpall){
if(!strlen(outfiles->initfile)){
StrNCopy(outfiles->initfile,DUMP_INITFILE,MAXSTRLEN);
}
if(!strlen(outfiles->flowfile)){
StrNCopy(outfiles->flowfile,DUMP_FLOWFILE,MAXSTRLEN);
}
if(!strlen(outfiles->eifile)){
StrNCopy(outfiles->eifile,DUMP_EIFILE,MAXSTRLEN);
}
if(!strlen(outfiles->rowcostfile)){
StrNCopy(outfiles->rowcostfile,DUMP_ROWCOSTFILE,MAXSTRLEN);
}
if(!strlen(outfiles->colcostfile)){
StrNCopy(outfiles->colcostfile,DUMP_COLCOSTFILE,MAXSTRLEN);
}
if(!strlen(outfiles->mstrowcostfile)){
StrNCopy(outfiles->mstrowcostfile,DUMP_MSTROWCOSTFILE,MAXSTRLEN);
}
if(!strlen(outfiles->mstcolcostfile)){
StrNCopy(outfiles->mstcolcostfile,DUMP_MSTCOLCOSTFILE,MAXSTRLEN);
}
if(!strlen(outfiles->mstcostsfile)){
StrNCopy(outfiles->mstcostsfile,DUMP_MSTCOSTSFILE,MAXSTRLEN);
}
if(!strlen(outfiles->corrdumpfile)){
StrNCopy(outfiles->corrdumpfile,DUMP_CORRDUMPFILE,MAXSTRLEN);
}
if(!strlen(outfiles->rawcorrdumpfile)){
StrNCopy(outfiles->rawcorrdumpfile,DUMP_RAWCORRDUMPFILE,MAXSTRLEN);
}
}
}
/* function: SetStreamPointers()
* -----------------------------
* Sets the default stream pointers (global variables).
*/
void SetStreamPointers(void){
fflush(NULL);
if((sp0=DEF_ERRORSTREAM)==NULL){
if((sp0=fopen(NULLFILE,"w"))==NULL){
fprintf(sp0,"unable to open null file %s\n",NULLFILE);
exit(ABNORMAL_EXIT);
}
}
if((sp1=DEF_OUTPUTSTREAM)==NULL){
if((sp1=fopen(NULLFILE,"w"))==NULL){
fprintf(sp0,"unable to open null file %s\n",NULLFILE);
exit(ABNORMAL_EXIT);
}
}
if((sp2=DEF_VERBOSESTREAM)==NULL){
if((sp2=fopen(NULLFILE,"w"))==NULL){
fprintf(sp0,"unable to open null file %s\n",NULLFILE);
exit(ABNORMAL_EXIT);
}
}
if((sp3=DEF_COUNTERSTREAM)==NULL){
if((sp3=fopen(NULLFILE,"w"))==NULL){
fprintf(sp0,"unable to open null file %s\n",NULLFILE);
exit(ABNORMAL_EXIT);
}
}
}
/* function: SetVerboseOut()
* -------------------------
* Set the global stream pointer sp2 to be stdout if the verbose flag
* is set in the parameter data type.
*/
void SetVerboseOut(paramT *params){
fflush(NULL);
if(params->verbose){
if(sp2!=stdout && sp2!=stderr && sp2!=stdin && sp2!=NULL){
fclose(sp2);
}
sp2=stdout;
if(sp3!=stdout && sp3!=stderr && sp3!=stdin && sp3!=NULL){
fclose(sp3);
}
sp3=stdout;
}
}
/* function: ChildResetStreamPointers()
* -----------------------------------
* Reset the global stream pointers for a child. Streams equal to stdout
* are directed to a log file, and errors are written to the screen.
*/
void ChildResetStreamPointers(pid_t pid, long tilerow, long tilecol,
paramT *params){
FILE *logfp;
char logfile[MAXSTRLEN], cwd[MAXSTRLEN];
fflush(NULL);
sprintf(logfile,"%s/%s%ld_%ld",params->tiledir,LOGFILEROOT,tilerow,tilecol);
if((logfp=fopen(logfile,"w"))==NULL){
fprintf(sp0,"Unable to open log file %s\nAbort\n",logfile);
exit(ABNORMAL_EXIT);
}
fprintf(logfp,"%s (pid %ld): unwrapping tile at row %ld, column %ld\n\n",
PROGRAMNAME,(long )pid,tilerow,tilecol);
if(getcwd(cwd,MAXSTRLEN)!=NULL){
fprintf(logfp,"Current working directory is %s\n",cwd);
}
if(sp2==stdout || sp2==stderr){
sp2=logfp;
}
if(sp1==stdout || sp1==stderr){
sp1=logfp;
}
if(sp0==stdout || sp0==stderr){
sp0=logfp;
}
if(sp3!=stdout && sp3!=stderr && sp3!=stdin && sp3!=NULL){
fclose(sp3);
}
if((sp3=fopen(NULLFILE,"w"))==NULL){
fprintf(sp0,"Unable to open null file %s\n",NULLFILE);
exit(ABNORMAL_EXIT);
}
}
/* function: DumpIncrCostFiles()
* -----------------------------
* Dumps incremental cost arrays, creating file names for them.
*/
void DumpIncrCostFiles(incrcostT **incrcosts, long iincrcostfile,
long nflow, long nrow, long ncol){
long row, col, maxcol;
char incrcostfile[MAXSTRLEN];
char tempstr[MAXSTRLEN];
short **tempcosts;
/* get memory for tempcosts */
tempcosts=(short **)Get2DRowColMem(nrow,ncol,sizeof(short *),sizeof(short));
/* create the file names and dump the files */
/* snprintf() is more elegant, but its unavailable on some machines */
for(row=0;row<2*nrow-1;row++){
if(row<nrow-1){
maxcol=ncol;
}else{
maxcol=ncol-1;
}
for(col=0;col<maxcol;col++){
tempcosts[row][col]=incrcosts[row][col].poscost;
}
}
strncpy(incrcostfile,INCRCOSTFILEPOS,MAXSTRLEN-1);
sprintf(tempstr,".%ld_%ld",iincrcostfile,nflow);
strncat(incrcostfile,tempstr,MAXSTRLEN-strlen(incrcostfile)-1);
Write2DRowColArray((void **)tempcosts,incrcostfile,
nrow,ncol,sizeof(short));
for(row=0;row<2*nrow-1;row++){
if(row<nrow-1){
maxcol=ncol;
}else{
maxcol=ncol-1;
}
for(col=0;col<maxcol;col++){
tempcosts[row][col]=incrcosts[row][col].negcost;
}
}
strncpy(incrcostfile,INCRCOSTFILENEG,MAXSTRLEN-1);
sprintf(tempstr,".%ld_%ld",iincrcostfile,nflow);
strncat(incrcostfile,tempstr,MAXSTRLEN-strlen(incrcostfile)-1);
Write2DRowColArray((void **)tempcosts,incrcostfile,
nrow,ncol,sizeof(short));
/* free memory */
Free2DArray((void **)tempcosts,2*nrow-1);
}
/* function: MakeTileDir()
* ---------------------------
* Create a temporary directory for tile files in directory of output file.
* Save directory name in buffer in paramT structure.
*/
void MakeTileDir(paramT *params, outfileT *outfiles){
char path[MAXSTRLEN], basename[MAXSTRLEN];
/* create name for tile directory (use pid to make unique) */
ParseFilename(outfiles->outfile,path,basename);
sprintf(params->tiledir,"%s%s%ld",path,TMPTILEDIRROOT,(long )getpid());
/* create tile directory */
fprintf(sp1,"Creating temporary directory %s\n",params->tiledir);
if(mkdir(params->tiledir,TILEDIRMODE)){
fprintf(sp0,"Error creating directory %s\nAbort\n",params->tiledir);
exit(ABNORMAL_EXIT);
}
}
/* function: ParseFilename()
* -------------------------
* Given a filename, separates it into path and base filename. Output
* buffers should be at least MAXSTRLEN characters, and filename buffer
* should be no more than MAXSTRLEN characters. The output path
* has a trailing "/" character.
*/
void ParseFilename(char *filename, char *path, char *basename){
char tempstring[MAXSTRLEN];
char *tempouttok;
/* make sure we have a nonzero filename */
if(!strlen(filename)){
fprintf(sp0,"Zero-length filename passed to ParseFilename()\nAbort\n");
exit(ABNORMAL_EXIT);
}
/* initialize path */
if(filename[0]=='/'){
StrNCopy(path,"/",MAXSTRLEN);
}else{
StrNCopy(path,"",MAXSTRLEN);
}
/* parse the filename */
StrNCopy(tempstring,filename,MAXSTRLEN);
tempouttok=strtok(tempstring,"/");
while(TRUE){
StrNCopy(basename,tempouttok,MAXSTRLEN);
if((tempouttok=strtok(NULL,"/"))==NULL){
break;
}
strcat(path,basename);
strcat(path,"/");
}
/* make sure we have a nonzero base filename */
if(!strlen(basename)){
fprintf(sp0,"Zero-length base filename found in ParseFilename()\nAbort\n");
exit(ABNORMAL_EXIT);
}
}
Reference in New Issue View Git Blame Copy Permalink