---

findbestfocus.c

Go to the documentation of this file.

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


/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function takes an array of input images and determines which one    */
/*   has the best focus.  See W. S. Conner's thesis for algorithm             */
/*   description.                                                             */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void FINDBESTFOCUS (
IMAGE **in,     /*  I   Pointer to an array[nimg] containing pointers         */
                /*      to the input images.                                  */
int nimg,       /*  I   Number of input images.                               */
int* bestfocus  /*      Pointer to the best focused image's number            */
/*----------------------------------------------------------------------------*/
) { register int i, j, k;
    char   msg[SLEN];
    int nlin, npix;
    IMAGE *periodogram=NULL;
    PIXEL **radialavg=NULL;
    PIXEL dcvalue;
    PIXEL avgvalue;
    PIXEL maxvalue;
    PIXEL value;
    int count_array[11];
    int delta_x, delta_y, radius;

    int progmeter;
    double progress;
    double localpercent;
    double localprogress;
    int count, total, increment;
    int cancel=0;

    progmeter = ProgMeter_Create("Find Best Focus");
    progress = 0.0;


    /* check input */
    for (i=0; i<nimg; i++) {
        if (!CHECKIMG(in[i])) {
            MESSAGE('E'," Can't identify input image(s).");
            goto the_end;
        }
    }
    /* for (nlin=in[0]->nlin,i=1; i<nimg; i++) { */
    for (nlin=256,i=0; i<nimg; i++) {
        if (nlin != in[i]->nlin) {
            //printf("%d: %d vs. %d\n",i,nlin,in[i]->nlin);
            MESSAGE('E'," Number of lines must be identical in all images.");
            goto the_end;
        }
    }
    /* for (npix=in[0]->npix,i=1; i<nimg; i++) { */
    for (npix=256,i=0; i<nimg; i++) {
        if (npix != in[i]->npix) {
            MESSAGE('E'," Number of pixels must be identical in all images.");
            goto the_end;
        }
    }
    for (i=0; i<nimg; i++) {
        if (in[i]->nbnd != 1) {
            MESSAGE('E'," All images must be single band.");
            goto the_end;
        }
    }
    
    

    radialavg = (PIXEL**) malloc(nimg*sizeof(PIXEL  * ));
    if (radialavg == (PIXEL **) NULL){
        
        printf("No memory for radialavg\n");
        goto the_end;
    
    } else {

        for  (i = 0; i < nimg; i++){
            radialavg[i] = (PIXEL  *) calloc(11, sizeof(PIXEL));
            if (radialavg[i] == (PIXEL *) NULL){
                printf ("No memory for element %d\n",radialavg[i]);
                goto the_end;
            }
        }
        
    }
    
    
    if (progmeter) {
        localpercent = 0.9;
        localprogress = 0.0;
        count = 0;
        total = nimg*(22+(49*49));
        increment = rint((double)total/25.0);
    }
    for (i=0; i<nimg; i++) {
    
        for (j=0; j<11; j++) {
            if (progmeter) {
                count++;
                if ((count%increment) == 0) {
                    localprogress = ((double)count/(double)total)*100.0;
                    cancel = ProgMeter_Update(progmeter,(localprogress*localpercent)+progress);
                    if (cancel != 0) goto the_end;
                }
            }

            count_array[j] = 0;
        }
    
        PERIODOGRAM(in[i],&periodogram);
        
        
        
        /* Only look at the 14/256 to 24/256 cycles/pixel frequency range */
        for (j=40; j<89; j++) {
            delta_y = (double)(j-64);
            for (k=40; k<89; k++) {

                if (progmeter) {
                    count++;
                    if ((count%increment) == 0) {
                        localprogress = ((double)count/(double)total)*100.0;
                        cancel = ProgMeter_Update(progmeter,(localprogress*localpercent)+progress);
                        if (cancel != 0) goto the_end;
                    }
                }

                delta_x = (double)(k-64);

                radius = (int) rnd(sqrt((delta_x)*(delta_x) + (delta_y)*(delta_y)));

                if ((radius <= 24) &&(radius >= 14)) {
                    //printf("%d: %d -- %f -- %f -- (%d,%d)\n",i,radius-14,radialavg[i][radius - 14],periodogram->data[0][j][k],j,k);
                    radialavg[i][radius - 14] += periodogram->data[0][j][k];
                    count_array[radius - 14] += 1;
                }
            }
        }
        
        dcvalue = periodogram->data[0][64][64];

        for (j=0; j<11; j++) {
            if (progmeter) {
                count++;
                if ((count%increment) == 0) {
                    localprogress = ((double)count/(double)total)*100.0;
                    cancel = ProgMeter_Update(progmeter,(localprogress*localpercent)+progress);
                    if (cancel != 0) goto the_end;
                }
            }

            radialavg[i][j] /= (PIXEL) count_array[j];
            radialavg[i][j] /= dcvalue;
        }
        
    }
    if (progmeter) {
        progress += localpercent * 100.0;
    }
    
    printf("Done creating periodograms...\n");
    
    /* Normalize the frequencies to one another */
    for (j=0; j<11; j++) {
        avgvalue = (PIXEL)0.0;
        
        for (i=0; i<nimg; i++) {
            avgvalue += radialavg[i][j];
        }

        avgvalue /= (PIXEL)nimg;

        for (i=0; i<nimg; i++) {
            radialavg[i][j] /= avgvalue;
        }
    }
    
    printf("Done normalizing frequencies...\n");

    /* Find the best focused image */
    *bestfocus = 0;
    maxvalue = (PIXEL) -99999.0;
    for (i=0; i<nimg; i++) {
        value = (PIXEL)0.0;
    
        for (j=0; j<11; j++) {
            value += radialavg[i][j];
        }
        
        if (value > maxvalue) {
            *bestfocus = i;
            maxvalue = value;
        }
        
        printf("image %d: %f\n",i,value);
    }

    if (progmeter) {
        progress = 100.0;
        cancel = ProgMeter_Update(progmeter,progress);
        if (cancel != 0) goto the_end;
    }
    printf("Image %d has the best focus.\n",*bestfocus);

    the_end:
    if(radialavg) {
        /* Free Bresh Array */
        for (i=0; i < nimg; i++){
            if(radialavg[i]) {
                free(radialavg[i]);
                radialavg[i] = NULL;
            }
        }

        free(radialavg);
        radialavg = NULL;
    }
    
    if (periodogram) {
        RELMEM(periodogram);
    }

    if (progmeter) {
        ProgMeter_Destroy(progmeter);
    }


}

---