---

sadie_byte.c

Go to the documentation of this file.

#include        <stdio.h>
#include        <malloc.h>
#include        <tcl.h>
#include        "sadie.h"
#include        "sadie_byte.h"






/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function allocates memory for a new image, byte and      */
/*   initializes its data structure.  It is based on the SADIE function       */
/*   GETMEM.                                                                  */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void GETMEM_BYTE(
short   nbnd,     /*  I   Number of bands.                                      */
short   nlin,     /*  I   Number of lines.                                      */
short   npix,     /*  I   Number of pixels/line.                                */
IMAGE_BYTE **out    /*  O   Address of a pointer to the image being allocated.    */
)
/*----------------------------------------------------------------------------*/
{   register short i, j;
    long total;
    BYTE *ptr=NULL;

    /* allocate space for image data structure, image data and list_byte entry */
    total = sizeof(IMAGE_BYTE) + nbnd*sizeof(PIXEL_BYTE **) + nbnd*nlin*sizeof(PIXEL_BYTE *) + nbnd*nlin*npix*sizeof(PIXEL_BYTE);
    if (total < 0L) {
        MESSAGE('E'," Memory request failed.");
        goto the_end;
    }
    if (!(ptr=(BYTE *)malloc(total*sizeof(BYTE)))) {
        MESSAGE('E'," Memory request failed.");
        goto the_end;
    }

    /* assign (DEFAULT) values */
    *out = (IMAGE_BYTE *)ptr;
    (*out)->nbnd = nbnd;
    (*out)->nlin = nlin;
    (*out)->npix = npix;
    (*out)->nbit = (short)(sizeof(PIXEL_BYTE)*8);
    for (i=0; i<TLEN; (*out)->text[i++]='\0');
    (*out)->data = (PIXEL_BYTE ***)(ptr + sizeof(IMAGE_BYTE));

    /* initialize pointers */
    for (i=0; i<nbnd; i++) {
        (*out)->data[i] = (PIXEL_BYTE **)(ptr + sizeof(IMAGE_BYTE) + nbnd*sizeof(PIXEL_BYTE **) + i*nlin*sizeof(PIXEL_BYTE *));
        for (j=0; j<nlin; j++) {
            (*out)->data[i][j] = (PIXEL_BYTE *)(ptr + sizeof(IMAGE_BYTE) + nbnd*sizeof(PIXEL_BYTE **) + nbnd*nlin*sizeof(PIXEL_BYTE *) + (j*nbnd+i)*npix*sizeof(PIXEL_BYTE));
        }
    }
    
    the_end:
    return;
    /* if (TIMES) TIMING(T_EXIT); */
}

/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This function releases a short image to free memory space.               */
/*   It is based on the SADIE function RELIMG.                                */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void RELIMG_BYTE(
IMAGE_BYTE **out    /* I/O  Address of the pointer to the image to be released.   */
)
/*----------------------------------------------------------------------------*/
{
    if (NAMES) {
        MESSAGE('I',"");
        MESSAGE('I',"RELIMG_BYTE");
    }

    /* check input */
    if (!CHECKIMG_BYTE(*out)) {
        MESSAGE('E'," Can't identify image.");
        goto the_end;
    }

    /* release image */
    RELMEM_BYTE(*out);
    *out = NULL;

    the_end:
    return;
    /* if (TIMES) TIMING(T_EXIT); */
}
 
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function releases a short image and frees its data        */
/*   structure.  It is based on the SADIE function RELMEM.                    */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void RELMEM_BYTE(
IMAGE_BYTE *in      /*  I   Pointer to the image to be released.                  */
)
/*----------------------------------------------------------------------------*/
{   
    /* free allocated space */
    free(in);

    return;
    /* if (TIMES) TIMING(T_EXIT); */
}
 
/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function determines whether or not an IMAGE_BYTE pointer */
/*   points to an image that was properly created by SADIE.                   */
/*   It is based on the SADIE routine CHECKIMG.                               */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
short CHECKIMG_BYTE(
IMAGE_BYTE *in      /*  I   Pointer to the image to be checked.                   */
)
/*----------------------------------------------------------------------------*/
{ 
    return(in!=NULL);
}

/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function finds the maximum and minimum graylevels         */
/*   in a short image.  It is based on the SADIE function RANGE.              */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void RANGE_BYTE(
IMAGE_BYTE *in      /*  I   Pointer to the input image.                           */
)
/*----------------------------------------------------------------------------*/
{   register PIXEL_BYTE *p1, *p2, *p3, *gmin, *gmax;

    /* find minimum and maximum */
    if (((long)in->nbnd*(long)in->nlin*(long)in->npix)%2L == 0) {
        p1 = &in->data[0][0][0];
        p2 = &in->data[0][0][1];
    } else {
        p1 = &in->data[0][0][1];
        p2 = &in->data[0][0][2];
    }
    p3 = &(in->data[in->nbnd-1][in->nlin-1][in->npix-1]);
    for (gmin=gmax=(&in->data[0][0][0]); p1<p3; p1+=2,p2+=2) {
        if (*p1 < *p2) {
            if (*p1 < *gmin) gmin = p1;
            if (*p2 > *gmax) gmax = p2;
        } else {
            if (*p2 < *gmin) gmin = p2;
            if (*p1 > *gmax) gmax = p1;
        }
    }
    in->gmin = *gmin;
    in->gmax = *gmax;

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

---