snaphu.h

phase unwrapping algorithm for SAR interferometry

nodeT *ClosestNodeCircular(bucketT *bkts);
nodeT *MinOutCostNode(bucketT *bkts);
nodeT *SelectSource(nodeT **nodes, nodeT *ground, long nflow, 
		    short **flows, long ngroundarcs, 
		    long nrow, long ncol, paramT *params);
short GetCost(incrcostT **incrcosts, long arcrow, long arccol, 
	      long arcdir);
long ReCalcCost(void **costs, incrcostT **incrcosts, long flow, 
		long arcrow, long arccol, long nflow, long nrow, 
		paramT *params);
void SetupIncrFlowCosts(void **costs, incrcostT **incrcosts, short **flows,
			long nflow, long nrow, long narcrow, 
			short *narcsperrow, paramT *params);
totalcostT EvaluateTotalCost(void **costs, short **flows, long nrow, long ncol,
			     short *narcsperrow,paramT *params);
void MSTInitFlows(float **wrappedphase, short ***flowsptr, 
		  short **mstcosts, long nrow, long ncol, 
		  nodeT ***nodes, nodeT *ground, long maxflow);
void SolveMST(nodeT **nodes, nodeT *source, nodeT *ground, 
	      bucketT *bkts, short **mstcosts, signed char **residue, 
	      signed char **arcstatus, long nrow, long ncol);
long DischargeTree(nodeT *source, short **mstcosts, short **flows,
		   signed char **residue, signed char **arcstatus, 
		   nodeT **nodes, nodeT *ground, long nrow, long ncol);
signed char ClipFlow(signed char **residue, short **flows, 
		     short **mstcosts, long nrow, long ncol, 
		     long maxflow);
void MCFInitFlows(float **wrappedphase, short ***flowsptr, short **mstcosts, 
		  long nrow, long ncol, long cs2scalefactor);


/* functions in snaphu_cost.c */

void BuildCostArrays(void ***costsptr, short ***mstcostsptr, 
		     float **mag, float **wrappedphase, 
		     float **unwrappedest, long linelen, long nlines, 
		     long nrow, long ncol, paramT *params, 
		     tileparamT *tileparams, infileT *infiles, 
		     outfileT *outfiles);
void **BuildStatCostsTopo(float **wrappedphase, float **mag, 
			  float **unwrappedest, float **pwr, 
			  float **corr, short **rowweight, short **colweight,
			  long nrow, long ncol, tileparamT *tileparams, 
			  outfileT *outfiles, paramT *params);
void **BuildStatCostsDefo(float **wrappedphase, float **mag, 
			  float **unwrappedest, float **corr, 
			  short **rowweight, short **colweight,
			  long nrow, long ncol, tileparamT *tileparams, 
			  outfileT *outfiles, paramT *params);
void **BuildStatCostsSmooth(float **wrappedphase, float **mag, 
			    float **unwrappedest, float **corr, 
			    short **rowweight, short **colweight,
			    long nrow, long ncol, tileparamT *tileparams, 
			    outfileT *outfiles, paramT *params);
void GetIntensityAndCorrelation(float **mag, float **wrappedphase, 
				float ***pwrptr, float ***corrptr, 
				infileT *infiles, long linelen, long nlines,
				long nrow, long ncol, outfileT *outfiles, 
				paramT *params, tileparamT *tileparams);
void RemoveMean(float **ei, long nrow, long ncol, 
                long krowei, long kcolei);
float *BuildDZRCritLookupTable(double *nominc0ptr, double *dnomincptr, 
			       long *tablesizeptr, tileparamT *tileparams,
			       paramT *params);
double SolveDZRCrit(double sinnomincangle, double cosnomincangle, 
		    paramT *params, double threshold);
void SolveEIModelParams(double *slope1ptr, double *slope2ptr, 
			double *const1ptr, double *const2ptr, 
			double dzrcrit, double dzr0, double sinnomincangle, 
			double cosnomincangle, paramT *params);
double EIofDZR(double dzr, double sinnomincangle, double cosnomincangle,
	       paramT *params);
float **BuildDZRhoMaxLookupTable(double nominc0, double dnominc, 
				 long nominctablesize, double rhomin, 
				 double drho, long nrho, paramT *params);
double CalcDZRhoMax(double rho, double nominc, paramT *params, 
		    double threshold);
void CalcCostTopo(void **costs, long flow, long arcrow, long arccol, 
		  long nflow, long nrow, paramT *params, 
		  long *poscostptr, long *negcostptr);
void CalcCostDefo(void **costs, long flow, long arcrow, long arccol, 
		  long nflow, long nrow, paramT *params, 
		  long *poscostptr, long *negcostptr);
void CalcCostSmooth(void **costs, long flow, long arcrow, long arccol, 
		    long nflow, long nrow, paramT *params, 
		    long *poscostptr, long *negcostptr);
void CalcCostL0(void **costs, long flow, long arcrow, long arccol, 
		long nflow, long nrow, paramT *params, 
		long *poscostptr, long *negcostptr);
void CalcCostL1(void **costs, long flow, long arcrow, long arccol, 
		long nflow, long nrow, paramT *params, 
		long *poscostptr, long *negcostptr);
void CalcCostL2(void **costs, long flow, long arcrow, long arccol, 
		long nflow, long nrow, paramT *params, 
		long *poscostptr, long *negcostptr);
void CalcCostLP(void **costs, long flow, long arcrow, long arccol, 
		long nflow, long nrow, paramT *params, 
		long *poscostptr, long *negcostptr);
void CalcCostNonGrid(void **costs, long flow, long arcrow, long arccol, 
		     long nflow, long nrow, paramT *params, 
		     long *poscostptr, long *negcostptr);
long EvalCostTopo(void **costs, short **flows, long arcrow, long arccol,
		  long nrow, paramT *params);
long EvalCostDefo(void **costs, short **flows, long arcrow, long arccol,
		  long nrow, paramT *params);
long EvalCostSmooth(void **costs, short **flows, long arcrow, long arccol,
		    long nrow, paramT *params);
long EvalCostL0(void **costs, short **flows, long arcrow, long arccol,
		long nrow, paramT *params);
long EvalCostL1(void **costs, short **flows, long arcrow, long arccol,
		long nrow, paramT *params);
long EvalCostL2(void **costs, short **flows, long arcrow, long arccol,
		long nrow, paramT *params);
long EvalCostLP(void **costs, short **flows, long arcrow, long arccol,
		long nrow, paramT *params);
long EvalCostNonGrid(void **costs, short **flows, long arcrow, long arccol, 
		     long nrow, paramT *params);
void CalcInitMaxFlow(paramT *params, void **costs, long nrow, long ncol);


/* functions in snaphu_util.c */

int IsTrue(char *str);
int IsFalse(char *str);
signed char SetBooleanSignedChar(signed char *boolptr, char *str);
double ModDiff(double f1, double f2);
void WrapPhase(float **wrappedphase, long nrow, long ncol);
void CalcWrappedRangeDiffs(float **dpsi, float **avgdpsi, float **wrappedphase,
			   long kperpdpsi, long kpardpsi,
			   long nrow, long ncol);
void CalcWrappedAzDiffs(float **dpsi, float **avgdpsi, float **wrappedphase,
			long kperpdpsi, long kpardpsi, long nrow, long ncol);
void CycleResidue(float **phase, signed char **residue, 
		  int nrow, int ncol);
void CalcFlow(float **phase, short ***flowsptr, long nrow, long ncol);
void IntegratePhase(float **psi, float **phi, short **flows,
		    long nrow, long ncol);
float **ExtractFlow(float **unwrappedphase, short ***flowsptr, 
		    long nrow, long ncol);
void FlipPhaseArraySign(float **arr, paramT *params, long nrow, long ncol);
void FlipFlowArraySign(short **arr, paramT *params, long nrow, long ncol);
void **Get2DMem(int nrow, int ncol, int psize, size_t size);
void **Get2DRowColMem(long nrow, long ncol, int psize, size_t size);
void **Get2DRowColZeroMem(long nrow, long ncol, int psize, size_t size);
void *MAlloc(size_t size);
void *CAlloc(size_t nitems, size_t size);
void *ReAlloc(void *ptr, size_t size);
void Free2DArray(void **array, unsigned int nrow);
void Set2DShortArray(short **arr, long nrow, long ncol, long value);
signed char ValidDataArray(float **arr, long nrow, long ncol);
signed char IsFinite(double d);
long LRound(double a);
long Short2DRowColAbsMax(short **arr, long nrow, long ncol);
float LinInterp1D(float *arr, double index, long nelem);
float LinInterp2D(float **arr, double rowind, double colind , 
                  long nrow, long ncol);
void Despeckle(float **mag, float ***ei, long nrow, long ncol);
float **MirrorPad(float **array1, long nrow, long ncol, long krow, long kcol);
void BoxCarAvg(float **avgarr, float **padarr, long nrow, long ncol, 
	       long krow, long kcol);
char *StrNCopy(char *dest, const char *src, size_t n);
void FlattenWrappedPhase(float **wrappedphase, float **unwrappedest, 
			 long nrow, long ncol);
void Add2DFloatArrays(float **arr1, float **arr2, long nrow, long ncol);
int StringToDouble(char *str, double *d);
int StringToLong(char *str, long *l);
void CatchSignals(void (*SigHandler)(int));
void SetDump(int signum);
void KillChildrenExit(int signum);
void SignalExit(int signum);
void StartTimers(time_t *tstart, double *cputimestart);
void DisplayElapsedTime(time_t tstart, double cputimestart);
int LongCompare(const void *c1, const void *c2);

/* functions in snaphu_io.c */

void SetDefaults(infileT *infiles, outfileT *outfiles, paramT *params);
void ProcessArgs(int argc, char *argv[], infileT *infiles, outfileT *outfiles,
		 long *ncolptr, paramT *params);
void CheckParams(infileT *infiles, outfileT *outfiles, 
		 long linelen, long nlines, paramT *params);
void ReadConfigFile(char *conffile, infileT *infiles, outfileT *outfiles,
		    long *ncolptr, paramT *params);
void WriteConfigLogFile(int argc, char *argv[], infileT *infiles, 
			outfileT *outfiles, long linelen, paramT *params);
void LogStringParam(FILE *fp, char *key, char *value);
void LogBoolParam(FILE *fp, char *key, signed char boolvalue);
void LogFileFormat(FILE *fp, char *key, signed char fileformat);
long GetNLines(infileT *infiles, long linelen);
void WriteOutputFile(float **mag, float **unwrappedphase, char *outfile, 
		     outfileT *outfiles, long nrow, long ncol);
FILE *OpenOutputFile(char *outfile, char *realoutfile);
void WriteAltLineFile(float **mag, float **phase, char *outfile, 
		      long nrow, long ncol);
void WriteAltSampFile(float **arr1, float **arr2, char *outfile, 
		      long nrow, long ncol);
void Write2DArray(void **array, char *filename, long nrow, long ncol, 
		  size_t size);
void Write2DRowColArray(void **array, char *filename, long nrow, 
			long ncol, size_t size);
void ReadInputFile(infileT *infiles, float ***magptr, float ***wrappedphaseptr,
		   short ***flowsptr, long linelen, long nlines, 
		   paramT *params, tileparamT *tileparams);
void ReadMagnitude(float **mag, infileT *infiles, long linelen, long nlines, 
		   tileparamT *tileparams);
void ReadUnwrappedEstimateFile(float ***unwrappedestptr, infileT *infiles, 
			       long linelen, long nlines, 
			       paramT *params, tileparamT *tileparams);
void ReadWeightsFile(short ***weightsptr,char *weightfile, 
		     long linelen, long nlines, tileparamT *tileparams);
void ReadIntensity(float ***pwrptr, float ***pwr1ptr, float ***pwr2ptr, 
		   infileT *infiles, long linelen, long nlines, 
		   paramT *params, tileparamT *tileparams);
void ReadCorrelation(float ***corrptr, infileT *infiles,
		     long linelen, long nlines, tileparamT *tileparams);
void ReadAltLineFile(float ***mag, float ***phase, char *alfile, 
		     long linelen, long nlines, tileparamT *tileparams);
void ReadAltLineFilePhase(float ***phase, char *alfile, 
			  long linelen, long nlines, tileparamT *tileparams);
void ReadComplexFile(float ***mag, float ***phase, char *rifile, 
		     long linelen, long nlines, tileparamT *tileparams);
void Read2DArray(void ***arr, char *infile, long linelen, long nlines, 
		 tileparamT *tileparams, size_t elptrsize, size_t elsize);
void ReadAltSampFile(float ***arr1, float ***arr2, char *infile,
		     long linelen, long nlines, tileparamT *tileparams);
void Read2DRowColFile(void ***arr, char *filename, long linelen, long nlines, 
		      tileparamT *tileparams, size_t size);
void Read2DRowColFileRows(void ***arr, char *filename, long linelen, 
			  long nlines, tileparamT *tileparams, size_t size);
void SetDumpAll(outfileT *outfiles, paramT *params);
void SetStreamPointers(void);
void SetVerboseOut(paramT *params);
void ChildResetStreamPointers(pid_t pid, long tilerow, long tilecol,
			      paramT *params);
void DumpIncrCostFiles(incrcostT **incrcosts, long iincrcostfile, 
		       long nflow, long nrow, long ncol);
void MakeTileDir(paramT *params, outfileT *outfiles);
void ParseFilename(char *filename, char *path, char *basename);


/* functions in snaphu_cs2.c  */

void SolveCS2(signed char **residue, short **mstcosts, long nrow, long ncol, 
	      long cs2scalefactor, short ***flowsptr);



/*******************************************/
/* global (external) variable declarations */
/*******************************************/

/* flags used for signal handling */
extern char dumpresults_global;
extern char requestedstop_global;

/* ouput stream pointers */
/* sp0=error messages, sp1=status output, sp2=verbose, sp3=verbose counter */
extern FILE *sp0, *sp1, *sp2, *sp3;

/* node pointer for marking arc not on tree in apex array */
/* this should be treat as a constant */
extern nodeT NONTREEARC[1];

/* pointers to functions which calculate arc costs */
extern void (*CalcCost)();
extern long (*EvalCost)();

/* pointers to functions for tailoring network solver to specific topologies */
extern nodeT *(*NeighborNode)();
extern void (*GetArc)();

/* end of snaphu.h */