---

maxgraddir.c

Go to the documentation of this file.

#include "sadie.h"
#include "proto.h"

/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This procedure takes as input a gradient magnitude and a gradient        */
/*   direction image.  Gradient directions are quantized into eight discrete  */
/*   directions, and the average gradient magnitude of each sector is         */
/*   computed on a pixel-by-pixel basis.  The sector with the highest         */
/*   gradient magnitude generally corresponds to the orientation of tree      */
/*   rings in the image.  See W. S. Conner's thesis for more information on   */
/*   determining the average orientation of tree rings within a region of     */
/*   interest.                                                                */
/*                                                                            */
/*          337.5 -  22.5 degrees   --      Sector 1                          */
/*          22.5  -  67.5 degrees   --      Sector 2                          */
/*          67.5  - 112.5 degrees   --      Sector 3                          */
/*          112.5 - 157.5 degrees   --      Sector 4                          */
/*          157.5 - 202.5 degrees   --      Sector 5                          */
/*          202.5 - 247.5 degrees   --      Sector 6                          */
/*          247.5 - 292.5 degrees   --      Sector 7                          */
/*          292.5 - 337.5 degrees   --      Sector 8                          */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void MAXGRADDIR (
IMAGE  *mag,    /*  I   Pointer to the input gradient magnitude image.        */
IMAGE  *dir    /*  I   Pointer to the input gradient direction image.         */
/*----------------------------------------------------------------------------*/
) { register short i, j, k;
    char msg[SLEN];
    double theta;
    int sectornum;
    int count[8];
    PIXEL value[8];

    /* if (TIMES) TIMING(T_SECTOR); */
    if (NAMES) {
        MESSAGE('I',"");
        MESSAGE('I',"MAXGRADDIR");
        MESSAGE('I',"");
        sprintf(msg," Input mag:                       %s",mag->text);
        MESSAGE('I',msg);
        sprintf(msg," Input dir:                       %s",dir->text);
        MESSAGE('I',msg);
        MESSAGE('I'," ...............");
    }

    /* check input */
    if (!CHECKIMG(mag)) {
        MESSAGE('E'," Can't identify image.");
        goto the_end;
    }
    if (!CHECKIMG(dir)) {
        MESSAGE('E'," Can't identify image.");
        goto the_end;
    }
    if (dir->nbnd != mag->nbnd  ||  dir->nlin != mag->nlin  ||  dir->npix != mag->npix) {
        MESSAGE('E'," Input images must be the same size.");
        goto the_end;
    }
    
    /* Find the min and max values in the dir image */
    RANGE(dir);
    
    /* Verify that this is a gradient direction image */
    if (dir->gmin < -2.0*PI  ||  2.0*PI < dir->gmax) {
        MESSAGE('E'," This is not a gradient direction image!");
        MESSAGE('E'," Direction must be between -360 and +360 degrees.");
        goto the_end;
    }

    for (i=0; i<8; i++) {
        count[i]  = 0;
        value[i]  = (PIXEL)0.0;
    }

    for (i=0; i<dir->nbnd; i++) {
        for (j=0; j<dir->nlin; j++) {
            for (k=0; k<dir->npix; k++) {
                theta = (double)(dir->data[i][j][k]);
                
                /* Convert to positive angle */
                if (theta < 0.0) {
                    theta = (2.0*PI) + theta;
                }
                
                if ((theta < (PI / 8.0))  &&  (0 <= theta)) {
                    sectornum = 0;
                } else if ((theta <= (2*PI))  &&  (((15.0*PI)/8.0) <= theta)) {
                    sectornum = 0;
                } else if ((theta < ((3.0*PI)/8.0))  &&  ((PI/8.0) <= theta)) {
                    sectornum = 1;
                } else if ((theta < ((5.0*PI)/8.0))  &&  (((3.0*PI)/8.0) <= theta)) {
                    sectornum = 2;
                } else if ((theta < ((7.0*PI)/8.0))  &&  (((5.0*PI)/8.0) <= theta)) {
                    sectornum = 3;
                } else if ((theta < ((9.0*PI)/8.0))  &&  (((7.0*PI)/8.0) <= theta)) {
                    sectornum = 4;
                } else if ((theta < ((11.0*PI)/8.0))  &&  (((9.0*PI)/8.0) <= theta)) {
                    sectornum = 5;
                } else if ((theta < ((13.0*PI)/8.0))  &&  (((11.0*PI)/8.0) <= theta)) {
                    sectornum = 6;
                } else {  /* if (theta < ((15.0*PI)/8.0)  &&  ((13.0*PI)/8.0) <= theta) */
                    sectornum = 7;
                }
            
                count[sectornum] += 1;
                value[sectornum] += mag->data[i][j][k];
            }
        }
    }

    for (i=0; i<8; i++) {
        if (count[i] <= 0) {
            printf("Direction %d %5.4f\n",i+1,0.0);
        } else {
            printf("Direction %d %5.4f\n",i+1,value[i]/(PIXEL)count[i]);
        }
    }

        
    the_end:
    /* if (TIMES) TIMING(T_EXIT); */
}

---