pyrlib.c File Reference

#include <stdio.h>
#include "rle.h"
#include "pyramid.h"

Include dependency graph for pyrlib.c:

Go to the source code of this file.

Functions
void	extrap_level ()
void	extrap_int_level ()
void	alloc_pyramid ()
void	gauss_level ()
void	band_level ()
void	expand_level ()
void	dump_level_line ()
void	band_to_int_level ()
void	add_int_level ()
int	rle_to_pyramids (FILE *infile, pyramid *gausspyr, pyramid *bandpyr, rle_hdr *in_hdr, int levellimit, float *mask_mult_table)
void	alloc_pyramid (pyramid *pyr)
void	extrap_level (int level, pyramid *pyr)
float *	gauss_mask (int siz)
void	gauss_level (int level, pyramid *pyr, float *mask_mult_table)
void	band_level (int level, pyramid *bandpyr, pyramid *gausspyr, float *mask_mult_table)
void	expand_level (int level, pyramid *gausspyr, rle_pixel **corner, float *mask_mult_table)
void	dump_pyramid (FILE *outfile, int levels, rle_pixel **corners, int xlen, int ylen, int channels, rle_hdr in_hdr)
void	dump_level_line (rle_pixel **scanout, int y, int level, rle_pixel **corners, int xlen, int nchan)
void	rebuild_image (rle_pixel **imgcorner, pyramid *bandpyr, float *mask_mult_table)
void	band_to_int_level (int level, rle_pixel **bandcorners, int **intcorners, int xlen, int ylen, int nchan)
void	extrap_int_level (int level, int **corners, int xlen, int ylen, int nchan)
void	add_int_level (int level, int **intcorners, int xlen, int ylen, int nchan, float *mask_mult_table)

Variables
static char	rcs_ident [] = "$Id: pyrlib.c,v 3.0.1.2 1992/04/30 14:10:36 spencer Exp $"

Function Documentation

void add_int_level

(

)

void add_int_level	(	int	level,
		int **	intcorners,
		int	xlen,
		int	ylen,
		int	nchan,
		float *	mask_mult_table
	)

Definition at line 928 of file pyrlib.c.

{
    int xsize, ysize, x, y, xlinewidth, lilxlinewidth;
    int chan,i,j;
    int *inbase, *outbase;
    int *inrastptr, *outrastptr;
    int *centerpxl, *outpxl, *calcpxl, expandedval;
    float total;
    float *maskmult;

    /* this assumes that the gauss images are extrapolated */

    xsize = xlen >> (level - 1);
    ysize = ylen >> (level - 1);
    /* level is the int level to be expanded */
    inbase = intcorners[level];
    outbase = intcorners[level-1];
    xlinewidth = xsize + MASKSIZE - 1;
    lilxlinewidth = (xsize >> 1) + MASKSIZE - 1;

    for (y = 0; y < ysize; y++)
    {
    inrastptr = &(inbase[MASKBELOW + ((y/2)+MASKBELOW) *
                lilxlinewidth * nchan]);
    outrastptr = &(outbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);

    for (chan = 0; chan < nchan; chan++)
    {
        centerpxl = &(inrastptr[chan * lilxlinewidth]);
        outpxl = &(outrastptr[chan * xlinewidth]);
        for(x=0; x < xsize; x++)
        {
        total = 0.0;
        for (i=0; i < 5; i++)
        {
            if ((y + i - MASKBELOW) % 2 == 0)
            {
            if ((y % 2) == 0)
                calcpxl = centerpxl + ((i - MASKBELOW) / 2)
                * lilxlinewidth * nchan - ( MASKBELOW / 2);
            else
                calcpxl = centerpxl + ((i + 1 - MASKBELOW) / 2)
                * lilxlinewidth * nchan - ( MASKBELOW / 2);
            maskmult = &(mask_mult_table[(i*5) << 8]);

            for (j=0; j < 5; j++)
            {
                if ((x + j - MASKBELOW) % 2 == 0)
                {
                /* since we gots ints, we can't use lookup */
                /* so just multiply by float value (yucko) */
                if ((x % 2) == 0)
                {
                    total += maskmult[ 1 ] * calcpxl[j / 2];
                }
                else
                {
                    total += maskmult[ 1 ] *
                        calcpxl[(j + 1) / 2];
                }
                }
                maskmult += 256;
            }
            }
        }

        total *= 4.0;
        expandedval = (int) total;
        *outpxl += expandedval;
        if ((x % 2) == 1) centerpxl++;
        outpxl++;
        }
    }
    }
}

void alloc_pyramid

(

)

void alloc_pyramid

(

pyramid *

pyr

)

Definition at line 223 of file pyrlib.c.

{
    int i, xsize = pyr->xlen[0], ysize = pyr->ylen[0];

    for(i=0; i < pyr->levels; i++)
    {
    pyr->corners[i] = (rle_pixel *) malloc( (xsize + MASKSIZE - 1) *
        (ysize + MASKSIZE - 1) * pyr->nchan );
    RLE_CHECK_ALLOC( "pyrlib", pyr->corners[i], "pyramid" );

    pyr->xlen[i] = xsize;
    pyr->ylen[i] = ysize;
    xsize = xsize >> 1;
    ysize = ysize >> 1;
    }
}

void band_level

(

)

void band_level	(	int	level,
		pyramid *	bandpyr,
		pyramid *	gausspyr,
		float *	mask_mult_table
	)

Definition at line 444 of file pyrlib.c.

{
    int xsize, ysize, x, y, xlinewidth;
    int chan,subtractval,nchan;
    rle_pixel *firstbase, *secondbase, *outbase;
    rle_pixel *firstrastptr, *secondrastptr, *outrastptr;
    rle_pixel *firstpxl, *secondpxl, *outpxl, *signpxl;

    /* this assumes that the gauss images are extrapolated */
    /* the result pyramid will NOT be extrapolated */

    /* second level will be expanded and subtracted from first 
     * to produce out */
    firstbase = gausspyr->corners[level];
    expand_level(level+1, gausspyr, &secondbase, mask_mult_table);
    outbase = bandpyr->corners[level];
    xsize = gausspyr->xlen[level];
    ysize = gausspyr->ylen[level];
    nchan = gausspyr->nchan;
    xlinewidth = xsize + MASKSIZE - 1;

    for (y = 0; y < ysize; y++)
    {
    firstrastptr = &(firstbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);
    secondrastptr = &(secondbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);
    outrastptr = &(outbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * (nchan + 1)]);

    signpxl = &(outrastptr[nchan * xlinewidth]);
    for(x=0; x < xsize; x++)
    {
        /* zero out sign bits for this scanline */
        *signpxl = 0;
        signpxl++;
    }
    for (chan = 0; chan < nchan; chan++)
    {
        firstpxl = &(firstrastptr[chan * xlinewidth]);
        secondpxl = &(secondrastptr[chan * xlinewidth]);
        outpxl = &(outrastptr[chan * xlinewidth]);
        signpxl = &(outrastptr[nchan * xlinewidth]);
        for(x=0; x < xsize; x++)
        {
        subtractval = (int) (*firstpxl) - (int) (*secondpxl);
        if (subtractval >= 0)
            *outpxl = (rle_pixel) subtractval;
        else
        {
            *outpxl = (rle_pixel) -subtractval;
            *signpxl = (1 << chan) | (*signpxl);
        }
        firstpxl++;
        secondpxl++;
        outpxl++;
        signpxl++;
        }
    }
    }
    free( secondbase );
}

void band_to_int_level

(

)

void band_to_int_level	(	int	level,
		rle_pixel **	bandcorners,
		int **	intcorners,
		int	xlen,
		int	ylen,
		int	nchan
	)

Definition at line 813 of file pyrlib.c.

{
    int xsize, ysize, x, y, chan, xlinewidth, sign;
    rle_pixel *firstbase, *firstrastptr, *firstpxl, *signpxl;
    int *outbase, *outrastptr, *outpxl;

    /* copy from band level to int level keeping track of the sign */
    firstbase = bandcorners[level];
    outbase = intcorners[level];
    xsize = xlen >> level;
    ysize = ylen >> level;
    xlinewidth = xsize + MASKSIZE - 1;

    for (y = 0; y < ysize; y++)
    {
    firstrastptr = &(firstbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * (nchan + 1)]);
    outrastptr = &(outbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);

    for (chan = 0; chan < nchan; chan++)
    {
        firstpxl = &(firstrastptr[chan * xlinewidth]);
        outpxl = &(outrastptr[chan * xlinewidth]);
        signpxl = &(firstrastptr[nchan * xlinewidth]);
        for(x=0; x < xsize; x++)
        {
        sign = ((1 << chan) & (*signpxl)) ? -1 : 1;
        *outpxl = (int) (*firstpxl) * sign;
        firstpxl++;
        outpxl++;
        signpxl++;
        }
    }
    }
}

void dump_level_line

(

)

void dump_level_line	(	rle_pixel **	scanout,
		int	y,
		int	level,
		rle_pixel **	corners,
		int	xlen,
		int	nchan
	)

Definition at line 678 of file pyrlib.c.

{
    int xsize, x, chan, xlinewidth;
    rle_pixel * outpxl, * outrastptr, *outbase, *scanoutptr;

    xsize = xlen >> level;
    xlinewidth = xsize + MASKSIZE - 1;
    outbase = corners[level];
    outrastptr = &(outbase[MASKBELOW + (y + MASKBELOW) * xlinewidth * nchan]);

    /* for each channel in the level
     * copy the pixel into scanout
     */
    for ( chan=0; chan < nchan; chan++)
    {
    outpxl = &(outrastptr[chan * xlinewidth]);
    scanoutptr = scanout[chan + nchan * level];
    for (x=0; x < xsize; x++)
    {
        *scanoutptr = *outpxl;
        scanoutptr++;
        outpxl++;
    }
    }
}

void dump_pyramid	(	FILE *	outfile,
		int	levels,
		rle_pixel **	corners,
		int	xlen,
		int	ylen,
		int	channels,
		rle_hdr	in_hdr
	)

Definition at line 609 of file pyrlib.c.

{
    rle_hdr out_hdr;
    int chan, level, x, y, activelevels, adjust_alpha = 0;
    rle_pixel **scanout;
    rle_pixel **outrows;

/*    fprintf(stderr,"Dumping %d level pyramid with %d channels per level\n",
        levels, channels);
*/
    if ((levels == 1) && (in_hdr.alpha))
    adjust_alpha = 1;   /* for dumping a normal image */
    (void)rle_hdr_cp( &in_hdr, &out_hdr );
    out_hdr.alpha = adjust_alpha;
    out_hdr.ncolors = channels * levels - adjust_alpha;
    out_hdr.rle_file = outfile;

    for ( chan=0; chan < channels*levels - adjust_alpha; chan++)
    {
    RLE_SET_BIT( out_hdr, chan );
    }
    if ( rle_row_alloc( &out_hdr, &scanout ) < 0 )
    RLE_CHECK_ALLOC( in_hdr.cmd, 0, 0 );
    outrows = (rle_pixel **) malloc( channels * levels * sizeof(rle_pixel *) );
    RLE_CHECK_ALLOC( in_hdr.cmd, outrows, 0 );

    if (adjust_alpha) scanout--;
    for ( chan=0; chan < channels*levels; chan++)
    {
    outrows[chan] = scanout[chan];
    /* fill the scanline with black */
    for (x = 0; x < xlen; x++)
        scanout[chan][x] = 0;
    }

    rle_put_setup( &out_hdr );

    activelevels = levels;
    for (y = 0; y < ylen; y++)
    {
    /* for each active level, dump the data into the right part
     * of the scanline.
     */
    for (level = 0; level < activelevels; level++)
    {
        dump_level_line(scanout,y,level,corners,xlen,channels);
    }
    rle_putrow( &(outrows[adjust_alpha]), xlen, &out_hdr );

    /* check if top level becomes inactive, dump black
     * to the scanline for next time.
     */
    if (y == (ylen >> (activelevels -1)))
    {
        for (chan = 0; chan < channels; chan++)
        for (x = 0; x < (xlen >> (activelevels -1)); x++)
            scanout[chan + channels * (activelevels-1)][x] = 0;
        activelevels--;
    }
    }
    rle_puteof( &out_hdr );
}

void expand_level

(

)

void expand_level	(	int	level,
		pyramid *	gausspyr,
		rle_pixel **	corner,
		float *	mask_mult_table
	)

Definition at line 518 of file pyrlib.c.

{
    int xsize, ysize, x, y, xlinewidth, lilxlinewidth;
    int chan,i,j,nchan;
    rle_pixel *inbase, *outbase;
    rle_pixel *inrastptr, *outrastptr;
    rle_pixel *centerpxl, *outpxl, *calcpxl, expandedval;
    float total;
    float *maskmult;

    /* this assumes that the gauss images are extrapolated */

    xsize = gausspyr->xlen[level - 1];
    ysize = gausspyr->ylen[level - 1];
    nchan = gausspyr->nchan;
    /* level is the gauss level to be expanded */
    outbase = (rle_pixel *) malloc( (xsize + MASKSIZE - 1) *
        (ysize + MASKSIZE - 1) * nchan );
    RLE_CHECK_ALLOC( "pyrlib", outbase, "expand level" );

    inbase = gausspyr->corners[level];
    *corner = outbase;
    xlinewidth = xsize + MASKSIZE - 1;
    lilxlinewidth = (xsize >> 1) + MASKSIZE - 1;

    for (y = 0; y < ysize; y++)
    {
    inrastptr = &(inbase[MASKBELOW + ((y/2)+MASKBELOW) *
                lilxlinewidth * nchan]);
    outrastptr = &(outbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);

    for (chan = 0; chan < nchan; chan++)
    {
        centerpxl = &(inrastptr[chan * lilxlinewidth]);
        outpxl = &(outrastptr[chan * xlinewidth]);
        for(x=0; x < xsize; x++)
        {
        total = 0.0;
        for (i=0; i < 5; i++)
        {
            if ((y + i - MASKBELOW) % 2 == 0)
            {
            if ((y % 2) == 0)
                calcpxl = centerpxl + ((i - MASKBELOW) / 2)
                * lilxlinewidth * nchan - ( MASKBELOW / 2);
            else
                calcpxl = centerpxl + ((i + 1 - MASKBELOW) / 2)
                * lilxlinewidth * nchan - ( MASKBELOW / 2);
            maskmult = &(mask_mult_table[(i*5) << 8]);

            for (j=0; j < 5; j++)
            {
                if ((x + j - MASKBELOW) % 2 == 0)
                {
                /* look up multiply in maskmult table */
                if ((x % 2) == 0)
                    total += maskmult[ calcpxl[j / 2] ];
                else
                    total += maskmult[ calcpxl[(j + 1) / 2] ];
                }
                maskmult += 256;
            }
            }
        }

        /* bound result to 0 to 255 */
        total *= 4.0;
        expandedval = (total < 0.0) ? 0 :
                ((total > 255.0) ? 255 : (rle_pixel) total );
        *outpxl = (rle_pixel) expandedval;
        if ((x % 2) == 1) centerpxl++;
        outpxl++;
        }
    }
    }
}

void extrap_int_level

(

)

void extrap_int_level	(	int	level,
		int **	corners,
		int	xlen,
		int	ylen,
		int	nchan
	)

Definition at line 855 of file pyrlib.c.

{
    int chan, x, y, i, newvalue, xsize, ysize;
    int xlinewidth;
    int *rastptr, *rasterbase;
    int *bot_edge_pxl, *bot_data_pxl, *bot_extrap_pxl;
    int *top_edge_pxl, *top_data_pxl, *top_extrap_pxl;
    int *left_edge_pxl, *left_data_pxl, *left_extrap_pxl;
    int *right_edge_pxl, *right_data_pxl, *right_extrap_pxl;

    rasterbase = corners[level];
    xsize = xlen >> level;
    ysize = ylen >> level;
    xlinewidth = xsize + MASKSIZE - 1;
    rastptr = &(rasterbase[MASKBELOW + MASKBELOW * xlinewidth * nchan]);

    for (chan = 0; chan < nchan; chan++)
    {
    bot_edge_pxl = &(rastptr[chan * xlinewidth]);
    top_edge_pxl = &(rastptr[(ysize-1) * nchan * xlinewidth
                    + chan * xlinewidth]);
    for(x=0; x < xsize; x++)
    {
        for (i=1; i <= MASKBELOW; i++)
        {
        bot_data_pxl = bot_edge_pxl + i * xlinewidth * nchan;
        bot_extrap_pxl = bot_edge_pxl - i * xlinewidth * nchan;
        newvalue = 2 * (*bot_edge_pxl) - (*bot_data_pxl);
        *bot_extrap_pxl = newvalue;
        }
        for (i=1; i <= MASKABOVE; i++)
        {
        top_data_pxl = top_edge_pxl - i * xlinewidth * nchan;
        top_extrap_pxl = top_edge_pxl + i * xlinewidth * nchan;
        newvalue = 2 * (*top_edge_pxl) - (*top_data_pxl);
        *top_extrap_pxl = newvalue;
        }
        bot_edge_pxl++;
        top_edge_pxl++;
    }
    }

    left_edge_pxl = &(rastptr[(-MASKBELOW) * nchan * xlinewidth]);
    right_edge_pxl = &(rastptr[(-MASKBELOW) * nchan * xlinewidth
                    + xlinewidth - MASKSIZE]);
    for (chan = 0; chan < nchan; chan++)
    {
    for(y=0; y < ysize + MASKSIZE - 1; y++)
    {
        for (i=1; i <= MASKBELOW; i++)
        {
        left_data_pxl = left_edge_pxl + i;
        left_extrap_pxl = left_edge_pxl - i;
        newvalue = 2 * (*left_edge_pxl) - (*left_data_pxl);
        *left_extrap_pxl = newvalue;
        }
        for (i=1; i <= MASKABOVE; i++)
        {
        right_data_pxl = right_edge_pxl - i;
        right_extrap_pxl = right_edge_pxl + i;
        newvalue = 2 * (*right_edge_pxl) - (*right_data_pxl);
        *right_extrap_pxl = newvalue;
        }
        left_edge_pxl += xlinewidth;
        right_edge_pxl += xlinewidth;
    }
    }
}

void extrap_level

(

)

void extrap_level	(	int	level,
		pyramid *	pyr
	)

Definition at line 252 of file pyrlib.c.

{
    int chan, x, y, i, newvalue, xsize, ysize;
    int xlinewidth, nchan;
    rle_pixel *rastptr, *rasterbase;
    rle_pixel *bot_edge_pxl, *bot_data_pxl, *bot_extrap_pxl;
    rle_pixel *top_edge_pxl, *top_data_pxl, *top_extrap_pxl;
    rle_pixel *left_edge_pxl, *left_data_pxl, *left_extrap_pxl;
    rle_pixel *right_edge_pxl, *right_data_pxl, *right_extrap_pxl;

    rasterbase = pyr->corners[level];
    xsize = pyr->xlen[level];
    ysize = pyr->ylen[level];
    nchan = pyr->nchan;
    xlinewidth = xsize + MASKSIZE - 1;
    rastptr = &(rasterbase[MASKBELOW + MASKBELOW * xlinewidth * nchan]);

    for (chan = 0; chan < nchan; chan++)
    {
    bot_edge_pxl = &(rastptr[chan * xlinewidth]);
    top_edge_pxl = &(rastptr[(ysize-1) * nchan * xlinewidth
                    + chan * xlinewidth]);
    for(x=0; x < xsize; x++)
    {
        for (i=1; i <= MASKBELOW; i++)
        {
        bot_data_pxl = bot_edge_pxl + i * xlinewidth * nchan;
        bot_extrap_pxl = bot_edge_pxl - i * xlinewidth * nchan;
        newvalue = 2 * (*bot_edge_pxl) - (*bot_data_pxl);
        *bot_extrap_pxl = (newvalue < 0) ? 0 :
            ((newvalue > 255) ? 255 : newvalue);
        }
        for (i=1; i <= MASKABOVE; i++)
        {
        top_data_pxl = top_edge_pxl - i * xlinewidth * nchan;
        top_extrap_pxl = top_edge_pxl + i * xlinewidth * nchan;
        newvalue = 2 * (*top_edge_pxl) - (*top_data_pxl);
        *top_extrap_pxl = (newvalue < 0) ? 0 :
            ((newvalue > 255) ? 255 : newvalue);
        }
        bot_edge_pxl++;
        top_edge_pxl++;
    }
    }

    left_edge_pxl = &(rastptr[(-MASKBELOW) * nchan * xlinewidth]);
    right_edge_pxl = &(rastptr[(-MASKBELOW) * nchan * xlinewidth
                    + xlinewidth - MASKSIZE]);
    for (chan = 0; chan < nchan; chan++)
    {
    for(y=0; y < ysize + MASKSIZE - 1; y++)
    {
        for (i=1; i <= MASKBELOW; i++)
        {
        left_data_pxl = left_edge_pxl + i;
        left_extrap_pxl = left_edge_pxl - i;
        newvalue = 2 * (*left_edge_pxl) - (*left_data_pxl);
        *left_extrap_pxl = (newvalue < 0) ? 0 :
            ((newvalue > 255) ? 255 : newvalue);
        }
        for (i=1; i <= MASKABOVE; i++)
        {
        right_data_pxl = right_edge_pxl - i;
        right_extrap_pxl = right_edge_pxl + i;
        newvalue = 2 * (*right_edge_pxl) - (*right_data_pxl);
        *right_extrap_pxl = (newvalue < 0) ? 0 :
            ((newvalue > 255) ? 255 : newvalue);
        }
        left_edge_pxl += xlinewidth;
        right_edge_pxl += xlinewidth;
    }
    }
}

void gauss_level

(

)

void gauss_level	(	int	level,
		pyramid *	pyr,
		float *	mask_mult_table
	)

Definition at line 373 of file pyrlib.c.

{
    int xsize, ysize, x, y, xlinewidth, lilxlinewidth;
    int chan,i,j,nchan;
    rle_pixel *inbase, *outbase, *inrastptr, *outrastptr;
    rle_pixel *centerpxl, *outpxl, *calcpxl;
    float total;
    float *maskmult;

    /* this assumes that the level-1 image is extrapolated */

    inbase = pyr->corners[level-1];
    outbase = pyr->corners[level];
    xsize = pyr->xlen[level - 1];
    ysize = pyr->ylen[level - 1];
    nchan = pyr->nchan;
    xlinewidth = xsize + MASKSIZE - 1;
    lilxlinewidth = (xsize >> 1) + MASKSIZE - 1;

    for (y = 0; y < ysize; y+=2)
    {
    inrastptr = &(inbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);
    outrastptr = &(outbase[MASKBELOW + ((y/2)+MASKBELOW) *
                lilxlinewidth * nchan]);

    for (chan = 0; chan < nchan; chan++)
    {
        centerpxl = &(inrastptr[chan * xlinewidth]);
        outpxl = &(outrastptr[chan * lilxlinewidth]);
        for(x=0; x < xsize; x+=2)
        {
        total = 0.0;
        for (i=0; i < 5; i++)
        {
            calcpxl = centerpxl + (i - MASKBELOW)
                * xlinewidth * nchan - MASKBELOW;
            maskmult = &(mask_mult_table[(i*5) << 8]);

            for (j=0; j < 5; j++)
            {
            /* look up multiply in maskmult table */
            total += maskmult[ calcpxl[j] ];
            maskmult += 256;
            }
        }

        /* bound result to 0 to 255 */
        *outpxl = (total < 0.0) ? 0 :
                ((total > 255.0) ? 255 : (rle_pixel) total );
        centerpxl++; centerpxl++;
        outpxl++;
        }
    }
    }
}

float* gauss_mask

(

int

siz

)

Definition at line 333 of file pyrlib.c.

{
    int i,j;
    float w[5];
    float *mptr;

    w[0] = 0.05;
    w[1] = 0.25;
    w[2] = 0.4;
    w[3] = 0.25;
    w[4] = 0.05;

    mptr = (float *) malloc( sizeof(float) * siz * siz );
    RLE_CHECK_ALLOC( "pyrlib", mptr, "mask" );

    if (siz != 5)
    {
    fprintf(stderr,"mask size not 5\n");
    exit(-1);
    }

    for(i=0; i< 5; i++)
    {
    for(j=0;j<5;j++)
    {
        mptr[j+i*siz] = w[j]*w[i];
    }
    }
    return mptr;
}

void rebuild_image	(	rle_pixel **	imgcorner,
		pyramid *	bandpyr,
		float *	mask_mult_table
	)

Definition at line 709 of file pyrlib.c.

{
    int i, xsize, ysize, level, nchan, xlen, ylen;
    int x, y, chan, xlinewidth,levels;
    int ** intcorners;
    int *intbase, *intrastptr, *intpxl;
    rle_pixel *outbase, *outrastptr, *outpxl;

    /* band pyramid is probably not extrapolated
     * allocate int_pyramid without sign channel
     * copy band pyramid to int pyramid (do correct thing with sign)
     * for each level (highest to lowest+1)
     *   extrapolate level
     *   expand level and add result directly to next level
     *   free temp expanded level
     * allocate rle_pixel image of level 1 size
     * copy from int level 1 to image
     * free int pyramid
     */

    /*************************************************************
    * Allocate int pyramid
    *************************************************************/
    levels = bandpyr->levels;
    nchan = bandpyr->nchan - 1;
    xlen = bandpyr->xlen[0];  ylen = bandpyr->ylen[0];
    intcorners = (int **) malloc( levels * sizeof( int *) );
    RLE_CHECK_ALLOC( "pyrhalf", intcorners, "pyramid" );

    xsize = xlen;    ysize = ylen;
    for(i=0; i < levels; i++)
    {
    intcorners[i] = (int *) malloc( (xsize + MASKSIZE - 1)
        * (ysize + MASKSIZE - 1) * nchan * sizeof(int) );
    RLE_CHECK_ALLOC( "pyrhalf", intcorners[i], "pyramid" );
    xsize = xsize >> 1;
    ysize = ysize >> 1;
    }
    /*************************************************************
    * Copy band pyramid to int (with sign correct)
    *************************************************************/
    for(level = levels - 1; level >= 0; level--)
    {
    band_to_int_level(level,bandpyr->corners,intcorners,
        xlen,ylen,nchan);
    }
    /*************************************************************
    * For each level in the int pyramid (highest to lowest+1)
    *************************************************************/
    for(level = levels - 1; level >= 1; level--)
    {
    /* extrapolate level */
    extrap_int_level(level,intcorners,xlen,ylen,nchan);
    /* expand level and add result directly to next level */
    add_int_level(level,intcorners,xlen,ylen,
        nchan,mask_mult_table);
    }
    /*************************************************************
    * Allocate single image buffer
    *************************************************************/
    *imgcorner = (rle_pixel *) malloc( (xlen + MASKSIZE - 1) *
        (ylen + MASKSIZE - 1) * nchan );
    RLE_CHECK_ALLOC( "pyrhalf", imgcorner, "pyramid" );

    /*************************************************************
    * Copy lowest level of int pyramid to image buffer (clamp 0 - 255)
    *************************************************************/
    intbase = intcorners[0];
    outbase = *imgcorner;
    xsize = xlen;
    ysize = ylen;
    xlinewidth = xsize + MASKSIZE - 1;

    for (y = 0; y < ysize; y++)
    {
    intrastptr = &(intbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);
    outrastptr = &(outbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);

    for (chan = 0; chan < nchan; chan++)
    {
        intpxl = &(intrastptr[chan * xlinewidth]);
        outpxl = &(outrastptr[chan * xlinewidth]);
        for(x=0; x < xsize; x++)
        {
        *outpxl = (rle_pixel) ((*intpxl) > 255) ? 255 :
            (((*intpxl) < 0) ? 0 : (*intpxl));
        intpxl++;
        outpxl++;
        }
    }
    }
    /*************************************************************
     * Free levels of int pyramid 
     *************************************************************/
    for(i=0; i < levels; i++)
    free(intcorners[i]);
}

int rle_to_pyramids	(	FILE *	infile,
		pyramid *	gausspyr,
		pyramid *	bandpyr,
		rle_hdr *	in_hdr,
		int	levellimit,
		float *	mask_mult_table
	)

Definition at line 24 of file pyrlib.c.

{
    rle_pixel *rastptr, *rasterbase;
    rle_pixel *firstbase, *outbase;
    int xlen, ylen, nchan;
    int xsize, ysize, levels, xlinewidth;
    int i, chan, x, y, minlen;
    rle_pixel *firstrastptr, *outrastptr;
    rle_pixel *firstpxl, *outpxl, *signpxl;
    rle_pixel **rows;
    int rle_err;

    in_hdr->rle_file = infile;

    if ( (rle_err = rle_get_setup( in_hdr )) < 0 )
    {
    return rle_err;
    }
    if ( in_hdr->alpha )
    RLE_SET_BIT( *in_hdr, RLE_ALPHA );

    in_hdr->xmax -= in_hdr->xmin;
    in_hdr->xmin = 0;
    xlen = in_hdr->xmax + 1;
    ylen = in_hdr->ymax - in_hdr->ymin + 1;
    xlinewidth = xlen + MASKSIZE - 1;

    /* assumes that alpha is 1 or 0 */
    nchan = in_hdr->ncolors + in_hdr->alpha;

    if (nchan > 8)
    {
    fprintf(stderr,"pyrlib: %d is too many input channels, 8 max\n",nchan);
    exit(-2);
    }
    /*************************************************************
     * Figure out how many levels
     * Note that the smallest level will be between 8 and 4 pixels
     * in its minimum direction.
     *************************************************************/

    minlen = (xlen < ylen) ? xlen : ylen;
    levels = levellimit;
    if (!levellimit)
    for(levels = 1; minlen > 8; minlen = minlen >> 1, levels++);
    else if ((minlen >> (levels - 1)) <= 4)
    {
    fprintf(stderr,
        "pyrlib: %d is too many levels to make a pyramid\n",levels);
    exit(-2);
    }

    if (levels < 2)
    {
    fprintf(stderr,
        "pyrlib: %d is too few levels to make a pyramid\n",levels);
    exit(-2);
    }

    gausspyr->levels = levels;
    gausspyr->nchan = nchan;
    gausspyr->xlen = (int *) malloc( levels * sizeof( int ) );
    gausspyr->ylen = (int *) malloc( levels * sizeof( int ) );
    gausspyr->corners = (rle_pixel **) malloc( levels * sizeof( rle_pixel *) );

    RLE_CHECK_ALLOC( in_hdr->cmd,
             gausspyr->corners && gausspyr->xlen && gausspyr->ylen,
             "gaussian pyramid" );

    gausspyr->xlen[0] = xlen;
    gausspyr->ylen[0] = ylen;

/*    fprintf(stderr,"Allocating gaussian pyramid structure\n"); */
    alloc_pyramid(gausspyr);

    if ( bandpyr )          /* zero means do gauss only */
    {
    bandpyr->levels = levels;
    bandpyr->nchan = nchan + 1; /* plus for sign chan */
    bandpyr->xlen = (int *) malloc( levels * sizeof( int ) );
    bandpyr->ylen = (int *) malloc( levels * sizeof( int ) );
    bandpyr->corners = (rle_pixel **) malloc(levels * sizeof(rle_pixel *));

    RLE_CHECK_ALLOC( in_hdr->cmd, 
             bandpyr->corners && bandpyr->xlen && bandpyr->ylen,
             "band pyramid" );

    bandpyr->xlen[0] = xlen;
    bandpyr->ylen[0] = ylen;

/*  fprintf(stderr,"Allocating band pyramid structure\n"); */
    alloc_pyramid(bandpyr);
    }

    rows = (rle_pixel **) malloc( nchan * sizeof( rle_pixel * ) );
    RLE_CHECK_ALLOC( in_hdr->cmd, rows, 0 );

    rasterbase = gausspyr->corners[0];
    rastptr = &(rasterbase[MASKBELOW * xlinewidth * nchan + MASKBELOW]);

    /****************************************************
     * Read in all of the pixels
     ****************************************************/

/*    fprintf(stderr,"Reading input image\n"); */
    for (i = in_hdr->ymin; i <= in_hdr->ymax; i++)
    {
        for (chan=0; chan < nchan; chan++)
        {
            rows[chan] = rastptr;
        /* Increment pointer by xlinewidth */
        rastptr = &(rastptr[xlinewidth]);
    }
    /* assumes 1 or 0 for alpha */
    rle_getrow( in_hdr, &rows[in_hdr->alpha] );
    }

    /****************************************************
     * Build each gauss level
     ****************************************************/
    for(i=1; i < levels; i++)
    {
/*  fprintf(stderr,"Building gauss level %d\n", i); */
    /* extrapolate the level we have */
    extrap_level(i-1, gausspyr);

    /* make gauss image in this level */
    gauss_level(i, gausspyr, mask_mult_table);
    }

    /* extrapolate the highest level */
    extrap_level(levels-1, gausspyr);

    /****************************************************
     * Build each band level from the gauss levels
     ****************************************************/
    if (bandpyr)
    {
    for(i=levels - 2; i >= 0; i--)
    {
/*      fprintf(stderr,"Building band level %d\n", i); */

        /* make band image from gauss images */
        band_level(i, bandpyr, gausspyr, mask_mult_table);
    }

    /****************************************************
    * The highest band is just the highest gauss (remnant)
    ****************************************************/
    firstbase = gausspyr->corners[levels - 1];
    outbase = bandpyr->corners[levels - 1];
    xsize = xlen >> (levels - 1);
    ysize = ylen >> (levels - 1);
    xlinewidth = xsize + MASKSIZE - 1;

    for (y = 0; y < ysize; y++)
    {
        firstrastptr = &(firstbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * nchan]);
        outrastptr = &(outbase[MASKBELOW + (y+MASKBELOW) *
                xlinewidth * (nchan + 1)]);

        signpxl = &(outrastptr[nchan * xlinewidth]);
        for(x=0; x < xsize; x++)
        {
        /* zero out sign bits for each scanline */
        *signpxl = 0;
        signpxl++;
        }
        for (chan = 0; chan < nchan; chan++)
        {
        firstpxl = &(firstrastptr[chan * xlinewidth]);
        outpxl = &(outrastptr[chan * xlinewidth]);
        for(x=0; x < xsize; x++)
        {
            *outpxl = *firstpxl;
            firstpxl++;
            outpxl++;
        }
        }
    }
    }
    return RLE_SUCCESS;
}

Variable Documentation

char rcs_ident[] = "$Id: pyrlib.c,v 3.0.1.2 1992/04/30 14:10:36 spencer Exp $"

static

Definition at line 12 of file pyrlib.c.