---

sadie_short.c

Go to the documentation of this file.

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


/*----------------------------------------------------------------------------*/
/*-General Information--------------------------------------------------------*/
/*                                                                            */
/*   This low-level function allocates memory for a new image, short and      */
/*   initializes its data structure.  It is based on the SADIE function       */
/*   GETMEM.                                                                  */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
void GETMEM_SHORT(
short   nbnd,     /*  I   Number of bands.                                      */
short   nlin,     /*  I   Number of lines.                                      */
short   npix,     /*  I   Number of pixels/line.                                */
IMAGE_SHORT **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_SHORT) + nbnd*sizeof(PIXEL_SHORT **) + nbnd*nlin*sizeof(PIXEL_SHORT *) + nbnd*nlin*npix*sizeof(PIXEL_SHORT);
    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_SHORT *)ptr;
    (*out)->nbnd = nbnd;
    (*out)->nlin = nlin;
    (*out)->npix = npix;
    (*out)->nbit = (short)(sizeof(PIXEL_SHORT)*8);
    for (i=0; i<TLEN; (*out)->text[i++]='\0');
    (*out)->data = (PIXEL_SHORT ***)(ptr + sizeof(IMAGE_SHORT));

    /* initialize pointers */
    for (i=0; i<nbnd; i++) {
        (*out)->data[i] = (PIXEL_SHORT **)(ptr + sizeof(IMAGE_SHORT) + nbnd*sizeof(PIXEL_SHORT **) + i*nlin*sizeof(PIXEL_SHORT *));
        for (j=0; j<nlin; j++) {
            (*out)->data[i][j] = (PIXEL_SHORT *)(ptr + sizeof(IMAGE_SHORT) + nbnd*sizeof(PIXEL_SHORT **) + nbnd*nlin*sizeof(PIXEL_SHORT *) + (j*nbnd+i)*npix*sizeof(PIXEL_SHORT));
        }
    }
    
    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_SHORT(
IMAGE_SHORT **out    /* I/O  Address of the pointer to the image to be released.   */
)
/*----------------------------------------------------------------------------*/
{
    if (NAMES) {
        MESSAGE('I',"");
        MESSAGE('I',"RELIMG_SHORT");
    }

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

    /* release image */
    RELMEM_SHORT(*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_SHORT(
IMAGE_SHORT *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_SHORT pointer */
/*   points to an image that was properly created by SADIE.                   */
/*   It is based on the SADIE routine CHECKIMG.                               */
/*                                                                            */
/*----------------------------------------------------------------------------*/
/*-Interface Information------------------------------------------------------*/
short CHECKIMG_SHORT(
IMAGE_SHORT *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_SHORT(
IMAGE_SHORT *in      /*  I   Pointer to the input image.                           */
)
/*----------------------------------------------------------------------------*/
{   register PIXEL_SHORT *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); */
}

---