smush.c

Go to the documentation of this file.

/* 
 * smush.c - Blur an image.  A level 1 smush is just a convolution with
 * a gaussian mask (or given mask).  Higher levels will be more blurry.
 * 
 * Author:  Rod Bogart
 *      Computer Science Dept.
 *      University of Utah
 * Date:    Wed Oct 15 1986
 * Copyright (c) 1986, University of Utah
 * 
 */
#ifndef lint
static char rcs_ident[] = "$Header: /software/dmsv/sun4/sunos/SWT-BACKUP/spencer/src/urt/tools/tools/RCS/smush.c,v 3.0.1.1 1992/01/23 20:56:39 spencer Exp $";
#endif

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

char *progname;

void
main(argc, argv)
int  argc;
char *argv[];
{
    char * infname = NULL, * outfname = NULL, * maskfname = NULL;
    FILE * outfile = stdout;
    int oflag = 0, mflag = 0, no_norm = 0;
    int xlinewidth, xlen, ylen, x, y;
    int i, j, k, chan, nchan, level, levels = 1;
    int maskskip, origmasksize;
    int maxmaskskip, maxmasksize, maxmaskbelow;
    int masksize, maskbelow, maskabove; /*number of maskels below and above */
                    /* the center maskel. */
    float *maskmult;
    float *mask_mult_table;
    rle_hdr     in_hdr, out_hdr;
    float total, *mask, *gauss_mask(), *read_mask();
    int newvalue;
    rle_pixel *rastptr, *rasterbase, *centerpxl, *calcpxl;
    rle_pixel *outrastptr, *outrasterbase, *outpxl, *tempbase;
    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;
    rle_pixel **scanout;
    rle_pixel **rows;
    int rle_cnt, rle_err;

    progname = cmd_name( argv );
    in_hdr = *rle_hdr_init( NULL );
    out_hdr = *rle_hdr_init( NULL );

    if ( scanargs( argc, argv,
           "% m%-maskfile!s n%- o%-outfile!s level%d infile%s",
           &mflag, &maskfname, &no_norm,
           &oflag, &outfname, &levels, &infname ) == 0 )
    exit( 1 );

    if (mflag)
    {
    mask = read_mask(&origmasksize, maskfname, no_norm);
    }
    else
    {
    origmasksize = 5;
    mask = gauss_mask(origmasksize);
    }

    in_hdr.rle_file = rle_open_f(progname, infname, "r");
    rle_names( &in_hdr, progname, infname, 0 );
    rle_names( &out_hdr, in_hdr.cmd, outfname, 0 );

    for ( rle_cnt = 0;
      (rle_err = rle_get_setup( &in_hdr )) == RLE_SUCCESS;
      rle_cnt++ )
    {
    if ( in_hdr.alpha )
        RLE_SET_BIT( in_hdr, RLE_ALPHA );
    (void)rle_hdr_cp( &in_hdr, &out_hdr );
    if ( rle_cnt == 0 )
        outfile = rle_open_f( progname, outfname, "w" );
    out_hdr.rle_file = outfile;

    rle_addhist( argv, &in_hdr, &out_hdr );

    /* initialize mask_mult_table */
    mask_mult_table = (float *) malloc(sizeof(float) * origmasksize *
                       origmasksize * 256);
    RLE_CHECK_ALLOC( progname, mask_mult_table, 0 );
    for (i=0; i < origmasksize; i++)
    {
        maskmult = &(mask_mult_table[(i*origmasksize) << 8]);
        for (j=0; j < origmasksize; j++)
        {
        for (k=0;k < 256; k++)
            maskmult[ k ] = (float) k * mask[i*origmasksize+j];
        maskmult += 256;
        }
    }

    if (levels < 1)
    {
        fprintf(stderr, "Level must be greater than 0.\n");
        exit(-1);
    }

    /* initial size of array has a border large enough for the biggest mask */
    maxmaskskip = 1 << (levels - 1);
    maxmasksize = (origmasksize - 1) * maxmaskskip + 1;
    maxmaskbelow = (maxmasksize-1) / 2;
    in_hdr.xmax -= in_hdr.xmin;
    in_hdr.xmin = 0;
    xlen = in_hdr.xmax - in_hdr.xmin + 1;
    ylen = in_hdr.ymax - in_hdr.ymin + 1;
    xlinewidth = xlen + maxmasksize - 1;

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

    /* Note:
     * When you read in a row of pixels with rle_getrow, it places blank
     * pixels between 0 and xmin of your buffer.  However, when you
     * use rle_putrow to write them out, the buffer must be pointing at
     * where the data actually starts (i.e., at [xmin] of the getrow
     * buffer.  */

    /* WARNING: Heavy-duty pointer munging ahead */

    rows = (rle_pixel **) malloc( nchan * sizeof( rle_pixel * ) );
    RLE_CHECK_ALLOC( progname, rows, 0 );

    rasterbase = (unsigned char *)malloc(
        xlinewidth * (ylen + maxmasksize - 1) * nchan );
    outrasterbase = (unsigned char *)malloc(
        xlinewidth * (ylen + maxmasksize - 1) * nchan );

    RLE_CHECK_ALLOC( progname, rasterbase && outrasterbase, "raster" );
    rastptr = &(rasterbase[maxmaskbelow * xlinewidth * nchan + maxmaskbelow]);

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

    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] );
    }

    for(level = 1; level <= levels; level++)
    {
        /* actual mask is always size by size of data with extra zeros */
        maskskip = 1 << (level - 1);
        masksize = (origmasksize - 1) * maskskip + 1;
        maskbelow = (masksize-1) / 2;
        maskabove = masksize / 2;

        /****************************************************
         * Extrapolate boundary pixels
         ****************************************************/
        if ((maskbelow > 0) && (maskabove > 0))
        {
        rastptr = &(rasterbase[maxmaskbelow +
                       maxmaskbelow * xlinewidth * nchan]);

        for (chan = 0; chan < nchan; chan++)
        {
            bot_edge_pxl = &(rastptr[chan * xlinewidth]);
            top_edge_pxl = &(rastptr[(ylen-1) * nchan * xlinewidth
                         + chan * xlinewidth]);
            for(x=0; x < xlen; 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 < ylen + 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;
            }
        }
        }

        for (y = 0; y < ylen; y++)
        {
        rastptr = &(rasterbase[maxmaskbelow + (y+maxmaskbelow) *
                       xlinewidth * nchan]);
        outrastptr = &(outrasterbase[maxmaskbelow + (y+maxmaskbelow) *
                         xlinewidth * nchan]);

        for (chan = 0; chan < nchan; chan++)
        {
            centerpxl = &(rastptr[chan * xlinewidth]);
            outpxl = &(outrastptr[chan * xlinewidth]);
            for(x=0; x < xlen; x++)
            {
            total = 0.0;
            for (i=0; i < origmasksize; i++)
            {
                calcpxl = centerpxl + (i * maskskip - maskbelow)
                * xlinewidth * nchan - maskbelow;
                maskmult = &(mask_mult_table[(i*origmasksize) << 8]);

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

            /* bound result to 0 to 255 */
            *outpxl = (total < 0.0) ? 0 :
            ((total > 255.0) ? 255 : (unsigned char) total );
            centerpxl++;
            outpxl++;
            }
        }
        }
        /* swap inbase and out base pointers for next pass */
        tempbase = rasterbase;
        rasterbase = outrasterbase;
        outrasterbase = tempbase;
    }

    /****************************************************
     * Set up output scanline
     ****************************************************/
    if ( rle_row_alloc( &out_hdr, &scanout ) < 0 )
        RLE_CHECK_ALLOC( progname, 0, 0 );
    if (out_hdr.alpha)
        scanout--;      /* Use zero based (vs. -1 based) addressing */
    for ( chan=0; chan < nchan; chan++)
    {
        rows[chan] = scanout[chan];
    }

    rle_put_setup( &out_hdr );
    for (y = 0; y < ylen; y++)
    {
        rastptr = &(rasterbase[maxmaskbelow + (y+maxmaskbelow) *
                   xlinewidth * nchan]);

        for (chan = 0; chan < nchan; chan++)
        {
        outpxl = &(rastptr[chan * xlinewidth]);
        for(x=0; x < xlen; x++)
        {
            scanout[chan][x] = *outpxl;
            outpxl++;
        }
        }
        rle_putrow( &rows[out_hdr.alpha], xlen, &out_hdr );
    }

    rle_puteof( &out_hdr );

    free( mask_mult_table );
    free( rows );
    free( rasterbase );
    free( outrasterbase );
    if ( out_hdr.alpha )
        scanout++;      /* Reverse above action. */
    rle_row_free( &out_hdr, scanout );
    }

    /* Check for an error.  EOF or EMPTY is ok if at least one image
     * has been read.  Otherwise, print an error message.
     */
    if ( rle_cnt == 0 || (rle_err != RLE_EOF && rle_err != RLE_EMPTY) )
    rle_get_error( rle_err, cmd_name( argv ), infname );

    exit( 0 );
}

float *
gauss_mask(siz)
int siz;
{
    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( progname, mptr, 0 );

    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;
}

float *
read_mask(size, fname, no_norm)
int * size;
char * fname;
int no_norm;
{
    FILE * maskfile;
    int i,j,masksize;
    float *mptr, total;

    maskfile = rle_open_f( progname, fname, "r" );

    fscanf(maskfile, "%d", &masksize);

    mptr = (float *) malloc( sizeof(float) * masksize * masksize);
    RLE_CHECK_ALLOC( progname, mptr, 0 );

    total = 0.0;
    for (i=0; i< masksize; i++)
    for (j=0; j< masksize; j++)
    {
        fscanf(maskfile, "%f", &(mptr[j+i*masksize]));
        total += mptr[j+i*masksize];
    }

    if (!no_norm)
    {
    if (total <= 0.0)
    {
        fprintf(stderr,"%s: Input mask total not valid\n", progname);
        exit(1);
    }
    /* normalize the mask */
    for (i=0; i< masksize; i++)
        for (j=0; j< masksize; j++)
        {
        mptr[j+i*masksize] /= total;
        }
    }

    *size = masksize;

    if ( maskfile != stdin )
    fclose( maskfile );

    return mptr;
}