snaphu.h

phase unwrapping algorithm for SAR interferometry

  double maxcyclefraction;/* ratio of max cycles to pixels */
  long sourcemode;        /* 0, -1, or 1, determines how tree root is chosen */
  long cs2scalefactor;    /* scale factor for cs2 initialization (eg, 3-30) */

  /* tiling parameters */
  long ntilerow;          /* number of tiles in azimuth */
  long ntilecol;          /* number of tiles in range */
  long rowovrlp;          /* pixels of overlap between row tiles */
  long colovrlp;          /* pixels of overlap between column tiles */
  long piecefirstrow;     /* first row (indexed from 1) for piece mode */
  long piecefirstcol;     /* first column (indexed from 1) for piece mode */
  long piecenrow;         /* number of rows for piece mode */
  long piecencol;         /* number of rows for piece mode */
  long tilecostthresh;    /* maximum cost within single reliable tile region */
  long minregionsize;     /* minimum number of pixels in a region */
  long nthreads;          /* number of parallel processes to run */
  long scndryarcflowmax;  /* max flow increment for which to keep cost data */
  double tileedgeweight;  /* weight applied to tile-edge secondary arc costs */
  signed char assembleonly; /* flag for assemble-only (no unwrap) mode */
  signed char rmtmptile;  /* flag for removing temporary tile files */
  char tiledir[MAXSTRLEN];/* directory for temporary tile files */

  /* connected component parameters */
  double minconncompfrac; /* min fraction of pixels in connected component */
  long conncompthresh;    /* cost threshold for connected component */
  long maxncomps;         /* max number of connected components */

  
}paramT;


/* input file name data structure */
typedef struct infileST{
  char infile[MAXSTRLEN];             /* input interferogram */
  char magfile[MAXSTRLEN];            /* interferogram magnitude (optional) */
  char ampfile[MAXSTRLEN];            /* image amplitude or power file */
  char ampfile2[MAXSTRLEN];           /* second amplitude or power file */
  char weightfile[MAXSTRLEN];         /* arc weights */
  char corrfile[MAXSTRLEN];           /* correlation file */
  char estfile[MAXSTRLEN];            /* unwrapped estimate */
  char costinfile[MAXSTRLEN];         /* file from which cost data is read */
  signed char infileformat;           /* input file format */
  signed char unwrappedinfileformat;  /* input file format if unwrapped */
  signed char magfileformat;          /* interferogram magnitude file format */
  signed char corrfileformat;         /* correlation file format */
  signed char weightfileformat;       /* weight file format */
  signed char ampfileformat;          /* amplitude file format */
  signed char estfileformat;          /* unwrapped-estimate file format */
}infileT;


/* output file name data structure */
typedef struct outfileST{
  char outfile[MAXSTRLEN];            /* unwrapped output */
  char initfile[MAXSTRLEN];           /* unwrapped initialization */
  char flowfile[MAXSTRLEN];           /* flows of unwrapped solution */
  char eifile[MAXSTRLEN];             /* despckled, normalized intensity */
  char rowcostfile[MAXSTRLEN];        /* statistical azimuth cost array */
  char colcostfile[MAXSTRLEN];        /* statistical range cost array */
  char mstrowcostfile[MAXSTRLEN];     /* scalar initialization azimuth costs */
  char mstcolcostfile[MAXSTRLEN];     /* scalar initialization range costs */
  char mstcostsfile[MAXSTRLEN];       /* scalar initialization costs (all) */
  char corrdumpfile[MAXSTRLEN];       /* correlation coefficient magnitude */
  char rawcorrdumpfile[MAXSTRLEN];    /* correlation coefficient magnitude */
  char conncompfile[MAXSTRLEN];       /* connected component map or mask */
  char costoutfile[MAXSTRLEN];        /* file to which cost data is written */
  char logfile[MAXSTRLEN];            /* file to which parmeters are logged */
  signed char outfileformat;          /* output file format */
}outfileT;


/* tile parameter data structure */
typedef struct tileparamST{
  long firstcol;          /* first column of tile to process (index from 0) */
  long ncol;              /* number of columns in tile to process */
  long firstrow;          /* first row of tile to process (index from 0) */
  long nrow;              /* number of rows in tile to process */
}tileparamT;


/* type for total cost of solution (may overflow long) */
typedef double totalcostT;            /* typedef long long totalcostT; */
#define INITTOTALCOST LARGEFLOAT      /* #define INITTOTALCOST LARGELONGLONG */



/***********************/
/* function prototypes */
/***********************/

/* functions in snaphu.c */

void Unwrap(infileT *infiles, outfileT *outfiles, paramT *params, 
	    long linelen, long nlines);
void UnwrapTile(infileT *infiles, outfileT *outfiles, paramT *params, 
		tileparamT *tileparams, long nlines, long linelen);


/* functions in snaphu_tile.c */

void SetupTile(long nlines, long linelen, paramT *params, 
	       tileparamT *tileparams, outfileT *outfiles, 
	       outfileT *tileoutfiles, long tilerow, long tilecol);
void GrowRegions(void **costs, short **flows, long nrow, long ncol, 
		 incrcostT **incrcosts, outfileT *outfiles, paramT *params);
void GrowConnCompsMask(void **costs, short **flows, long nrow, long ncol, 
		       incrcostT **incrcosts, outfileT *outfiles, 
		       paramT *params);
long ThickenCosts(incrcostT **incrcosts, long nrow, long ncol);
nodeT *RegionsNeighborNode(nodeT *node1, long *arcnumptr, nodeT **nodes, 
			   long *arcrowptr, long *arccolptr, 
			   long nrow, long ncol);
void ClearBuckets(bucketT *bkts);
void MergeRegions(nodeT **nodes, nodeT *source, long *regionsizes, 
		  long closestregion, long nrow, long ncol);
void RenumberRegion(nodeT **nodes, nodeT *source, long newnum, 
		    long nrow, long ncol);
void AssembleTiles(outfileT *outfiles, paramT *params, 
		   long nlines, long linelen);
void ReadNextRegion(long tilerow, long tilecol, long nlines, long linelen,
		    outfileT *outfiles, paramT *params, 
		    short ***nextregionsptr, float ***nextunwphaseptr,
		    void ***nextcostsptr, 
		    long *nextnrowptr, long *nextncolptr);
void SetTileReadParams(tileparamT *tileparams, long nexttilenlines, 
		       long nexttilelinelen, long tilerow, long tilecol, 
		       long nlines, long linelen, paramT *params);
void ReadEdgesAboveAndBelow(long tilerow, long tilecol, long nlines, 
			    long linelen, paramT *params, outfileT *outfiles, 
			    short *regionsabove, short *regionsbelow,
			    float *unwphaseabove, float *unwphasebelow,
			    void *costsabove, void *costsbelow);
void TraceRegions(short **regions, short **nextregions, short **lastregions, 
		  short *regionsabove, short *regionsbelow, float **unwphase, 
		  float **nextunwphase, float **lastunwphase, 
		  float *unwphaseabove, float *unwphasebelow, void **costs, 
		  void **nextcosts, void **lastcosts, void *costsabove, 
		  void *costsbelow, long prevnrow, long prevncol, long tilerow,
		  long tilecol, long nrow, long ncol, nodeT **scndrynodes,
		  nodesuppT **nodesupp, scndryarcT **scndryarcs, 
		  long ***scndrycosts, short *nscndrynodes, 
		  short *nscndryarcs, long *totarclens, short **bulkoffsets, 
		  paramT *params);
long FindNumPathsOut(nodeT *from, paramT *params, long tilerow, long tilecol, 
		     long nnrow, long nncol, short **regions, 
		     short **nextregions, short **lastregions,
		     short *regionsabove, short *regionsbelow, long prevncol);
void RegionTraceCheckNeighbors(nodeT *from, nodeT **nextnodeptr, 
			       nodeT **primarynodes, short **regions, 
			       short **nextregions, short **lastregions, 
			       short *regionsabove, short *regionsbelow,  
			       long tilerow, long tilecol, long nnrow, 
			       long nncol, nodeT **scndrynodes, 
			       nodesuppT **nodesupp, scndryarcT **scndryarcs, 
			       long *nnewnodesptr, long *nnewarcsptr, 
			       long flowmax, long nrow, long ncol, 
			       long prevnrow, long prevncol, paramT *params, 
			       void **costs, void **rightedgecosts, 
			       void **loweredgecosts, void **leftedgecosts, 
			       void **upperedgecosts, short **flows, 
			       short **rightedgeflows, short **loweredgeflows,
			       short **leftedgeflows, short **upperedgeflows,
			       long ***scndrycosts, 
			       nodeT ***updatednontilenodesptr, 
			       long *nupdatednontilenodesptr, 
			       long *updatednontilenodesizeptr,
			       short **inontilenodeoutarcptr, 
			       long *totarclenptr);
void SetUpperEdge(long ncol, long tilerow, long tilecol, void **voidcosts, 
		  void *voidcostsabove, float **unwphase, 
		  float *unwphaseabove, void **voidupperedgecosts, 
		  short **upperedgeflows, paramT *params, short **bulkoffsets);
void SetLowerEdge(long nrow, long ncol, long tilerow, long tilecol, 
		  void **voidcosts, void *voidcostsbelow, 
		  float **unwphase, float *unwphasebelow, 
		  void **voidloweredgecosts, short **loweredgeflows, 
		  paramT *params, short **bulkoffsets);
void SetLeftEdge(long nrow, long prevncol, long tilerow, long tilecol, 
		 void **voidcosts, void **voidlastcosts, float **unwphase, 
		 float **lastunwphase, void **voidleftedgecosts, 
		 short **leftedgeflows, paramT *params, short **bulkoffsets);
void SetRightEdge(long nrow, long ncol, long tilerow, long tilecol, 
		  void **voidcosts, void **voidnextcosts, 
		  float **unwphase, float **nextunwphase, 
		  void **voidrightedgecosts, short **rightedgeflows, 
		  paramT *params, short **bulkoffsets);
void TraceSecondaryArc(nodeT *primaryhead, nodeT **scndrynodes, 
		       nodesuppT **nodesupp, scndryarcT **scndryarcs, 
		       long ***scndrycosts, long *nnewnodesptr, 
		       long *nnewarcsptr, long tilerow, long tilecol, 
		       long flowmax, long nrow, long ncol, 
		       long prevnrow, long prevncol, paramT *params, 
		       void **tilecosts, void **rightedgecosts, 
		       void **loweredgecosts, void **leftedgecosts,
		       void **upperedgecosts, short **tileflows, 
		       short **rightedgeflows, short **loweredgeflows, 
		       short **leftedgeflows, short **upperedgeflows,
		       nodeT ***updatednontilenodesptr, 
		       long *nupdatednontilenodesptr, 
		       long *updatednontilenodesizeptr,
		       short **inontilenodeoutarcptr, long *totarclenptr);
nodeT *FindScndryNode(nodeT **scndrynodes, nodesuppT **nodesupp, 
		      long tilenum, long primaryrow, long primarycol);
void IntegrateSecondaryFlows(long linelen, long nlines, nodeT **scndrynodes, 
			     nodesuppT **nodesupp, scndryarcT **scndryarcs, 
			     short *nscndryarcs, short **scndryflows, 
			     short **bulkoffsets, outfileT *outfiles, 
			     paramT *params);
void ParseSecondaryFlows(long tilenum, short *nscndryarcs, short **tileflows, 
			 short **regions, short **scndryflows, 
			 nodesuppT **nodesupp, scndryarcT **scndryarcs, 
			 long nrow, long ncol, long ntilerow, long ntilecol,
			 paramT *params);


/* functions in snaphu_solver.c */

long TreeSolve(nodeT **nodes, nodesuppT **nodesupp, nodeT *ground, 
	       nodeT *source, candidateT **candidatelistptr, 
	       candidateT **candidatebagptr, long *candidatelistsizeptr,
	       long *candidatebagsizeptr, bucketT *bkts, short **flows, 
	       void **costs, incrcostT **incrcosts, nodeT ***apexes, 
	       signed char **iscandidate, long ngroundarcs, long nflow, 
	       float **mag, float **wrappedphase, char *outfile, 
	       long nnoderow, short *nnodesperrow, long narcrow, 
	       short *narcsperrow, long nrow, long ncol,
	       outfileT *outfiles, paramT *params);
void AddNewNode(nodeT *from, nodeT *to, long arcdir, bucketT *bkts, 
		long nflow, incrcostT **incrcosts, long arcrow, long arccol, 
		paramT *params);
void CheckArcReducedCost(nodeT *from, nodeT *to, nodeT *apex, 
			 long arcrow, long arccol, long arcdir, 
			 long nflow, nodeT **nodes, nodeT *ground, 
			 candidateT **candidatebagptr, 
			 long *candidatebagnextptr, 
			 long *candidatebagsizeptr, incrcostT **incrcosts, 
			 signed char **iscandidate, paramT *params);
long InitTree(nodeT *source, nodeT **nodes, nodesuppT **nodesupp, 
	      nodeT *ground, long ngroundarcs, bucketT *bkts, long nflow, 
	      incrcostT **incrcosts, nodeT ***apexes, 
	      signed char **iscandidate, long nnoderow, short *nnodesperrow, 
	      long narcrow, short *narcsperrow, long nrow, long ncol, 
	      paramT *params);
nodeT *FindApex(nodeT *from, nodeT *to);
int CandidateCompare(const void *c1, const void *c2);
nodeT *NeighborNodeGrid(nodeT *node1, long arcnum, long *upperarcnumptr,
			nodeT **nodes, nodeT *ground, long *arcrowptr, 
			long *arccolptr, long *arcdirptr, long nrow, 
			long ncol, nodesuppT **nodesupp);
nodeT *NeighborNodeNonGrid(nodeT *node1, long arcnum, long *upperarcnumptr,
			   nodeT **nodes, nodeT *ground, long *arcrowptr, 
			   long *arccolptr, long *arcdirptr, long nrow, 
			   long ncol, nodesuppT **nodesupp);
void GetArcGrid(nodeT *from, nodeT *to, long *arcrow, long *arccol, 
		long *arcdir, long nrow, long ncol, nodesuppT **nodesupp);
void GetArcNonGrid(nodeT *from, nodeT *to, long *arcrow, long *arccol, 
		   long *arcdir, long nrow, long ncol, nodesuppT **nodesupp);
void NonDegenUpdateChildren(nodeT *startnode, nodeT *lastnode, 
			    nodeT *nextonpath, long dgroup, 
			    long ngroundarcs, long nflow, nodeT **nodes,
			    nodesuppT **nodesupp, nodeT *ground, 
			    nodeT ***apexes, incrcostT **incrcosts, 
			    long nrow, long ncol, paramT *params);
void InitNetwork(short **flows, long *ngroundarcsptr, long *ncycleptr, 
		 long *nflowdoneptr, long *mostflowptr, long *nflowptr, 
		 long *candidatebagsizeptr, candidateT **candidatebagptr, 
		 long *candidatelistsizeptr, candidateT **candidatelistptr, 
		 signed char ***iscandidateptr, nodeT ****apexesptr, 
		 bucketT **bktsptr, long *iincrcostfileptr, 
		 incrcostT ***incrcostsptr, nodeT ***nodesptr, nodeT *ground, 
		 long *nnoderowptr, short **nnodesperrowptr, long *narcrowptr,
		 short **narcsperrowptr, long nrow, long ncol, 
		 signed char *notfirstloopptr, totalcostT *totalcostptr,
		 paramT *params);
void InitNodeNums(long nrow, long ncol, nodeT **nodes, nodeT *ground);
void InitBuckets(bucketT *bkts, nodeT *source, long nbuckets);
void InitNodes(long nrow, long ncol, nodeT **nodes, nodeT *ground);
void BucketInsert(nodeT *node, long ind, bucketT *bkts);
void BucketRemove(nodeT *node, long ind, bucketT *bkts);
nodeT *ClosestNode(bucketT *bkts);