imgmem.c

大师写的二代小波经典之作

/*
 *  -*- Mode ANSI C -*-
 *  $Id: imgmem.c,v 1.6 1996/09/17 16:10:50 fernande Exp $
 *  $Source: /sgi.acct/sweldens/cvs/liftpack/Util/imgmem.c,v $
 *  Author: Gabriel Fernandez, Senthil Periaswamy
 *
 *  Image Allocation routines.
 */
/* do not edit anyhting above this line */

/* FLWT header files */
#include <imgmem.h>
#include <flwterr.h>
#include <memchk.h>


/********************************************************************************
**  The high level routines are:                                               **
**                                                                             **
**    Image IMG_InitMem ( long width, long height, int colorPlanes, int bpp ); **
**    void  IMG_FreeMem ( Image *img );                                        **
**                                                                             **
**  The lower level routines are:                                              **
**                                                                             **
**    Volume MEM_Init3DC( int depth, long width, long height );                **
**    Volume MEM_Init3D( int depth, long width, long height );                 **
**    Matrix MEM_Init2D( long width, long height );                            **
**    Vector MEM_Init1D( long width );                                         **
**    void   MEM_Free2D( Matrix buff );                                        **
**    void   MEM_Free1D( Vector  buff );                                       **
**                                                                             **
**  and the lowest level routine are malloc and free.                          **
**                                                                             **
*********************************************************************************/

/* code */

/*
 * IMG_InitMem function: allocates memory for an image, guaranteeing
 *                       continuity in the bands.
 */
boolean
IMG_InitMem ( Image *img, const long width, const long height,
                          const int colorPlanes, const int bpp )
{
    int i;

    if ( colorPlanes > MAX_COLOR_PLANES || colorPlanes <= 0 ) {
        Error ("IMG_InitMem", INVALID_VALUE_INT, ABORT, "color planes", 	
               1, MAX_COLOR_PLANES);
    }

    if ( width == 0 || height == 0 ) {
        Error ("IMG_Initmem", INVALID_RELATIONAL_INT, ABORT,
               "Dimensions", ">", 0);
        /* NOTREACHED */
    }

    /* Everything should be fine now */
    img->width       = (int)width;
    img->height      = (int)height;
    img->colorPlanes = colorPlanes;
    img->bpp         = bpp;

    for ( i=0; i<colorPlanes ; i++ ) {
        img->band[i] = MEM_Init2D ( width, height );
        if (!img->band[i]) {
            Error ("IMG_InitMem", MEMORY_MATRIX, RETURN);
            return FALSE;
        }
    }

    return TRUE;
}


/*
 * IMG_FreeMem function: given the image allocated in IMG_InitMem, the
 *                       function deallocates the occupied memory.
 */
void
IMG_FreeMem ( Image img )
{
    int i;

    /* Free each band */
    for ( i=0 ; i<img.colorPlanes ; i++ ) {
        if ( img.band[i] ) {
            MEM_Free2D ( (Matrix)img.band[i] );
            img.band[i] = (Matrix)NULL;
        }
        if ( img.comment ) {
            free ( (char *)img.comment );
            img.comment = NULL;
        }
        if ( img.levels ) {
            free ( (int *)img.levels );
            img.levels = NULL;
        }
    }
}


/*
 * MEM_Init3DC function: initialize memory for a contiguous 3D volume.
 */
Volume
MEM_Init3DC ( int depth, long width, long height )
{
    Volume buff;
    Vector ptrData;
    long y, z;

    /* Allocate the whole 3D image */
    ptrData = MEM_Init1D( (long)(depth*width*height) );
    if ( ptrData == NULL ) {
        return NULL;
    }

    /* Allocate memory for the array of double pointers */
    buff = (Volume)malloc( (size_t)(depth*sizeof(Matrix)) );
    if ( buff == NULL ) {
        return NULL;
    }

    /* Assign pointers of the matrices */
    for( z=0 ; z<depth ; z++ ) {
        buff[z] = (Matrix)malloc( (size_t)(height*sizeof(Vector)) );
        if ( buff[z] == NULL ) {
            return NULL;
        }
        for( y=0 ; y<height ; y++, ptrData += width ) {
            buff[z][y] = ptrData;
        }
    }

    return buff;
}


/*
 * MEM_Free3DC function: frees a contiguos 3D volume.
 */
void
MEM_Free3DC ( Volume buff )
{
    if ( buff == NULL )
        return;

    MEM_Free1D ( buff[0][0] );
    free ( (Matrix)buff[0] );
    free ( (Volume)buff );
}


/*
 * MEM_Init3D function: initialize memory for an array of matrices.
 */
Matrix *
MEM_Init3D ( int depth, long width, long height )
{
    Matrix *buff;
    long i;

    /* Allocate memory for a row of pointers */
    buff = (Matrix *)malloc( (size_t)(depth*sizeof(Matrix)) );
    if ( !buff )
        return NULL;

    /* Allocate each matrix with Init2D */
    for ( i=0 ; i<(long)depth ; i++ ) {
	buff[i] = MEM_Init2D( (long)width, (long)height );
	if ( !buff[i] )
	    return NULL;
    }

    return buff;
}


/*
 * MEM_Free3D function: frees an array of matrices.
 */
void
MEM_Free3D ( Matrix *buff, int depth )
{
    int i;

    if ( buff == NULL )
        return;

    for ( i=0 ; i<depth ; i++ ) {
        MEM_Free2D ( buff[i] );
    }

    free ( (Matrix *)buff );
}


/*
 * MEM_Init2D function: initialize memory for a 2D vector.
 */
Matrix
MEM_Init2D ( long width, long height )
{
    Matrix buff;
    long i, length = width*height;

    /* First allocate a row of pointers */
    buff = (Matrix)malloc( (size_t)(height*sizeof(Vector)) );
    if ( buff == NULL ) {
        return NULL;
    }

    /* Allocate entire 2D vector */
    buff[0] = MEM_Init1D ( length );
    if ( buff[0] == NULL ) {
        return NULL;
    }

    /* Set the row-pointers to point correctly into the 2D vector */
    for ( i=1 ; i<height ; ++i ) {
        buff[i] = buff[i-1] + width;
    }

    return buff;
}


/*
 * MEM_Free2D function: frees a 2D vector.
 */
void
MEM_Free2D ( Matrix buff )
{
    if ( buff == NULL )
        return;

    MEM_Free1D ( buff[0] );
    free ( (Matrix)buff );
}


/*
 * MEM_InitVecs function: initialize memory for an array of vectors.
 */
Vector *
MEM_InitVecs ( int depth, long width )
{
    Vector *buff;
    long i;

    /* Allocate memory for a row of pointers */
    buff = (Vector *)malloc( (size_t)(depth*sizeof(Vector)) );
    if ( !buff )
        return NULL;

    /* Allocate each vector with MEM_Init1D */
    for ( i=0 ; i<(long)depth ; i++ ) {
        buff[i] = MEM_Init1D( (long)width );
	    if ( !buff[i] )
	        return NULL;
    }

    return buff;
}


/*
 * MEM_FreeVecs function: frees an array of vectors.
 */
void
MEM_FreeVecs ( Vector *buff, int depth )
{
    int i;

    if ( buff == NULL )
        return;

    for ( i=0 ; i<depth ; i++ ) {
        MEM_Free1D( buff[i] );
    }

    free ( (Vector *)buff );
}


/*
 * MEM_Init1D function: initializes a 1D vector.
 */
Vector
MEM_Init1D ( long n )
{
    return (Vector)malloc( (size_t)(n*sizeof(Flt)) );
}


/*
 * MEM_Free1D function: frees a 1D vector.
 */
void
MEM_Free1D ( Vector buff )
{
    free ( (Vector)buff );
}