gsnake.h

snake算法

	/* I/O routines */
	int write( char *filename );

	CONTOUR *duplicate(CONTOUR *target=NULL, short snx=0);

	int expand( double ratio, int spacing = 0 );
	/* transformation routines */
	void affineTransform( double sx, double sy, double rt, 
			  double tx, double ty, double idx, double idy );

	void rotate( double angle )
		{ affineTransform( 1, 1, RADIAN(angle), 0, 0, 0, 0 ); }
	void translate( int dx, int dy )
		{ affineTransform( 1, 1, 0, dx, dy, 0, 0 ); }
	void scale( double sx, double sy )
		{ affineTransform( sx, sy, 0, 0, 0, 0, 0 ); }
	void dilate(double idx, double idy)
		{ affineTransform(1,1,0,0,0,idx,idy); }

	
	/* compute contour shape */
	void computeShape();		/* learn shape parameters */
	void computeCG();		/* compute center of gravity */
	void computeZ() ;		/* compute norm. constant Z */
	double computeAvgLength(); 	/* compute average length */
	int regenerate();		/* regenerate contour from A */
	void contourCentered() ;	/* V to U coordinate */
	void imageCentered() ;		/* U to V coordinate */


	/* interface */
	void display(short mag=1);	
	void print();
	void show(IMAGE *backgnd, unsigned char blowup=1,
		   int pt_Xoffset=0, int pt_Yoffset=0,short expand=1);


	SNAXEL *getHead(void) { return head; }
	SNAXEL *getTail(void) { return tail; }

	SNAKEMODE getMode(void) { return mode; }
	short getNumSnaxel(void) { return numsnaxel; }
	double getSigNuSqr(void) { return sig_nu_sqr; }
	double getZ(void)     { return Z ; }
	double getCgRow(void) { return cg_row; }
	double getCgCol(void) { return cg_col; }

	void putCgRow(double _row) { cg_row = _row;}
	void putCgCol(double _col) { cg_col = _col;}
	void putMode(SNAKEMODE _mode) { mode = _mode; }
	void putNumSnaxel(short _numsnaxel) {numsnaxel = _numsnaxel; }
	void putSigNuSqr(double _sig_nu_sqr){ sig_nu_sqr = _sig_nu_sqr; }
	void putDirection(short _direction){ direction = _direction; }
	void putZ(double _Z) { Z = _Z ; }
};

class LOCATIONS {

    protected :
	short  numpts;	/* number of points */
	short  numlocs;	/* number of assigned locations */
	double **row;	/* possible location to move around */
	double **col;
	double **OldSum;/* for classification purpose */
	double **NewSum;
	double **OldMax;   /* Energy minimisation purpose */
	double **NewMax;
	short  ***MaxInd;  /* for backtracking purpose */ 
	short  *MI;        
	double *normalX; /* normal vector */
	double *normalY;

    public :
	LOCATIONS(void) {;}
	~LOCATIONS(void) ;
	int init(short _numpts, short _numlocs);
	void clearLoc();
	void generateLoc(
		SNAKEMODE mode, SNAXEL *head, SNAXEL *tail, 
		int NhoodX, int NhoodY, int spacing, 
		int rotate,short verbose =0 );

	/* get interface */
	short getNumLoc(void) { return numlocs; }

	double getRow( short i, short j ) { return row[i][j]; }
	double getCol( short i, short j ) { return col[i][j]; }

	double getOldSum( short i, short j ) { return OldSum[i][j]; }
	double getNewSum( short i, short j ) { return NewSum[i][j]; }

	double getOldMax( short i, short j ) { return OldMax[i][j]; }
	double getNewMax( short i, short j ) { return NewMax[i][j]; }

	double getNormalX( short i ) { return normalX[i]; }
	double getNormalY( short i ) { return normalY[i]; }

	short getMI( short i ) { return MI[i]; }
	short getMaxInd( short i, short j, short k ) 
				{ return MaxInd[i][j][k]; }

	/* put interface */
	void putRow( short i, short j, double val ) { row[i][j] = val; }
	void putCol( short i, short j, double val ) { col[i][j] = val; }

	void putOldSum( short i, short j, double val ) { OldSum[i][j] = val; }
	void putNewSum( short i, short j, double val ) { NewSum[i][j] = val; }

	void putOldMax( short i, short j, double val ) { OldMax[i][j] = val; }
	void putNewMax( short i, short j, double val ) { NewMax[i][j] = val; }

	void putnormalX( short i, double val ) { normalX[i] = val; }
	void putnormalY( short i, double val ) { normalY[i] = val; }

	void putMI( short i, short val ) { MI[i] = val; }
	void putMaxInd( short i, short j, short k, short val )
					 { MaxInd[i][j][k] = val; }
};

class GHOUGH {

    protected :
         IMAGE **Planes;		/* Planes of accumulator cells */
        CONTOUR **Template;      	/* Templates under transformations */
        double **Angle;         	/* desired gradient angles */
        int NumPlane;           	/* actual # of planes */
        int Qx, Qy;        	        /* X, Y resolutions of planes */
        double QR, Qrxy;        	/* scale resolutions */
        double Qt;              	/* theta resolutions */
        double Qdx, Qdy;    		/* dilation resolutions */
        int NR, Nrxy, Nt, Ndx, Ndy; 	/* # of cells in each of the axis */
	double R;			/* scaling factor */
	double THETA;			/* initial angle for ref. line angle */
	int plane_max;			/* store index for blanking */
	int row_max;
	int col_max;

    protected :
        
        int init(int row, int col);
        void transform(CONTOUR *reference, char comAngleFlag=1);
    
        void correlate(EDGE *edgeMap);
	void correlate(IMAGE *gaussImg);

       CONTOUR *getMax(void);

       reset(void) ;

    public :
        GHOUGH(int _Qx=1, int _Qy=1, 
               int _NR=1, double  _QR=0.25, 
               int _Nrxy=1, double _Qrxy=0.25,
               int _Nt=1,  double _Qt=RADIAN(10),
               int _Ndx=1, double _Qdx=0.1,
               int _Ndy=1, double _Qdy=0.1,
               double _R=1.0, double _THETA=0.0);
        ~GHOUGH();
        
        /* find one contour */
        CONTOUR *localize(CONTOUR *reference, IMAGE *img) ;
        CONTOUR *localize(CONTOUR *reference, EDGE *edgeMap);
  
  	/* find multiple contours */
        CONTOUR **localize(CONTOUR *reference, IMAGE *img, int numFind) ;
        CONTOUR **localize(CONTOUR *reference, EDGE *edgeMap, int numFind);
};

class GSNAKE : public PYRAMID,
	       public CONTOUR  {

    protected :

	double global_lambda;	/* global regularization parameters */	
	double Eint;		/* Total internal energy of snake */
	double Eext;		/* Total external energy of snake */
        double Esnake;          /* Total snake energy */
	EEXTTYPE EextType;      /* external energy type */
	EDGE *EdgeMap;		/* edge map in current pyramid level */
	IMAGE *GaussImg;	/* gaussImg in current pyramid level */

    protected :


	/* dynamic programming */
	int     mn_dymprog( short level, int search_spacing,
		int nhood, unsigned char blowup = 1, 
		int verbose = 0, int showImg = 1, int img_Xoffset = 0, 
		int img_Yoffset = 0);
	double dymprog(int spacing, LOCATIONS *searchLocs, int classify = 0);
	void move( GSNAKE *old_gssnake,
		   int pt_Xoffset = 0, int pt_Yoffset = 0);


	/* regularization. To compute Epoint based on current regularization
	   policy */
	void regularize( SNAXEL *sxptr,
		double *Emodel, double *Eimage, double *Epoint );

	double EEdge( SNAXEL *now, EDGE *edgeMap );
	double EInten( SNAXEL *now, IMAGE *gaussImg );
	double EMag( SNAXEL *now, EDGE *edgeMap );

	double ESnaxel( SNAXEL *sxptr, int pt_ind, int loc_ind, 
		int spacing, LOCATIONS *searchLocs, int verbose = 0 );

    public :

	GSNAKE(EEXTTYPE etype = _EDGE, double glambda=_LOCAL_MINMAX);
	~GSNAKE(void);
	void reset(void);   
	
	/* generate pyramid */
	genPyramid(short level, short verbose) ;

 	/* compute energy routines */
        double ESnake( short level, int verbose = 0 );

	double ESnaxel( SNAXEL *sxptr,
		BOOLEAN store = _FALSE, int verbose = 0 ); 
		

	double EInternal(SNAXEL *now);
       	double EExternal(SNAXEL *now);

	/* localize gsnake routines */
        int localize(int _Qx=1, int _Qy=1, 
               int _NR=1, double  _QR=0.25, 
               int _Nrxy=1, double _Qrxy=0.1,
               int _Nt=1,  double _Qt=RADIAN(10),
               int _Ndx=1, double _Qdx=0.1,
               int _Ndy=1, double _Qdy=0.1,
               double _R=1.0, double _THETA=0.0);
               
	void fineLocalize( int _qx = 3, int _qy = 3, 
			  int _cg_col = 0, int _cg_row = 0 );

	/* minimization routines */
        int     minimize( 
			int segmentSpacing = 5,
			int numSearchSegment = 5,
			int snaxelSpacing  = 5,
			unsigned char blowup = 1,
			int verbose = 0, 
		        double theLambda = _DEFINED_LAMBDA,
		 	int showImg	= 1,
			int img_Xoffset = 0,
			int img_Yoffset = 0 );
	
	/* marginalization routine */
	double marginalize(int nhoodTangent=5, int nhoodNormal=3) ;

	/* interface */
	GSNAKE *duplicate(GSNAKE *target=NULL);
	void deform( unsigned char blowup=1, short expand=1 );

	void showLine( unsigned char blowup=1,
		   int Xoffset = 0, int Yoffset = 0 );
	void show( unsigned char blowup =1,short expand = 1, 
		   int showImg = 1,
		   int img_Xoffset = 0, int img_Yoffset = 0,
		   int pt_Xoffset = 0, int pt_Yoffset = 0
		  );

	double getEint(void) {return Eint;}
	double getEext(void) {return Eext;}
	double getEsnake(void) { return Esnake;}
	EEXTTYPE getEextType( void ) { return EextType; }
	double getGLambda( void ) { return global_lambda; }
	void putGLambda(double _lambda) { global_lambda = _lambda; }

};

class MODEL : public GSNAKE {

    protected :
	short deformSample;	/* # sample of learn deform */
	short shapeSample;	/* # sample of learn shape */

    protected :
	int init( GSNAKE *sample );
	int initShape( GSNAKE *sample );
	int initDeform( GSNAKE * sample );

    public :
	MODEL(void);
	~MODEL(void) {;}
	int LearnShape( GSNAKE *sample );
	int LearnDeform( GSNAKE *sample );
	GSNAKE *getModel(void) { return this; }
};

class CLASSIFY {

   protected :
   	int numClass ;			/* number of class */
   	EEXTTYPE Eexttype ;		/* type of external energy */
   	CONTOUR **templates ;		/* reference templates */
   	char **labels ;
   	double *Margin_Prob;
   	double *Rigid_Match ;
   	double *Deform_Match ;
   	double *Deform_Prob ;
   
   /* these localization and minimization parameters are made public so
      that modifying them can be easy */
   public :
   	int Qx, Qy ;			/* GHT Image Cell Resolutions */
   	int NR, Nrxy, Nt, Ndx, Ndy ;	/* GHT ranges */
   	double QR, Qrxy, Qt, Qdx, Qdy;  /* GHT Resolutions */
   	double R, THETA ;		/* GHT Constants */
   	int numSearchSegment ;		/* number of search segments */
   	int segmentSpacing ;		/* spacing between segments */
   	int numLevel ;			/* number of pyramid levels */
   	int verbose ;			/* verbose mode */
   	int nhoodTangent, nhoodNormal;	/* neighborhood used in marginaliz-n */
   	
   protected :
   	int init(void) ;
   	
   public :
	CLASSIFY(EEXTTYPE _Eexttype = _EDGE);
	~CLASSIFY(void);
	int read( CONTOUR *contour );
	int read( char *filename );
	int classify(IMAGE *testimg, CLASSTYPE ClassType = _MARGIN_PROB) ;
	int getNumClass( void ) { return numClass ; }
	double getScore( int template_id, CLASSTYPE ClassType = _MARGIN_PROB);
	int selectMax( CLASSTYPE ClassType = _MARGIN_PROB);
	char *getLabel(short class_id) ;
	void dump(char *imgName, FILE *stream = stdout) ;
};



#endif