rleldmap.c File Reference

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

Include dependency graph for rleldmap.c:

Go to the source code of this file.

Functions
void	get_rle_map ()
void	linmap ()
void	gammap ()
void	filemap ()
void	mfilemap ()
void	applymap ()
void	shiftmap ()
void	main (int argc, char **argv)
rle_map **	allocmap (int nchan, int length, rle_map *cmap)
void	shiftmap (rle_map **map, int nchan, int length, int bits)
void	applymap (rle_map **map, int nchan, int length, int bits, rle_map **submap, int subchan, int sublen, int subbits, rle_map **omap)
void	linmap (double factor, int nchan, int length, int range, rle_map **amap)
void	gammap (double gamma, int nchan, int length, int range, rle_map **amap)
void	filemap (int tflag, char *mapfname, int nchan, int length, rle_map **amap)
void	mfilemap (char **mfnames, int nchan, int length, rle_map **amap)
void	get_rle_map (rle_hdr *the_hdr, char *fname)

Variables
static char	rcsid [] = "$Header: /tmp_mnt/n/itn/hendrix/u/spencer/RCS/rleldmap.c,v 3.0.1.5 1992/02/28 22:12:27 spencer Exp spencer $"

Function Documentation

rle_map** allocmap	(	int	nchan,
		int	length,
		rle_map *	cmap
	)

Definition at line 373 of file rleldmap.c.

{
    rle_map ** map;
    register int i;

    map = (rle_map **)malloc( nchan * sizeof( rle_map * ) );
    RLE_CHECK_ALLOC( "rleldmap", map, "color map" );
    if ( cmap == NULL )
    {
    map[0] = (rle_map *)malloc( nchan * length * sizeof( rle_map ) );
    RLE_CHECK_ALLOC( "rleldmap", map[0], "color map" );
    }
    else
    map[0] = cmap;
    for ( i = 1; i < nchan; i++ )
    map[i] = &map[i-1][length];
    return map;
}

void applymap

(

)

void applymap	(	rle_map **	map,
		int	nchan,
		int	length,
		int	bits,
		rle_map **	submap,
		int	subchan,
		int	sublen,
		int	subbits,
		rle_map **	omap
	)

Definition at line 456 of file rleldmap.c.

{
    register rle_map * s;       /* pointer into submap */
    register rle_map * o;       /* pointer into omap */
    rle_map ** mp, ** sp, ** op;    /* pointer to channel of maps */
    register int subshift;
    int c, i, ochan = ((nchan > subchan) ? nchan : subchan);
    int sub;

    /* Figure out how much to shift subscript */
    for ( i = 1; i < length; i *= 2 )
    ;           /* Round up to power of 2. */
    if ( (1 << subbits) > i )   /* Too many bits in subscript? */
    for ( subshift = 0; (1 << (subbits + subshift)) > i; subshift-- )
        ;
    else            /* not enough bits */
    for ( subshift = 0; (1 << (subbits + subshift)) < i; subshift++ )
        ;

    if ( subshift >= 0 )
    {
    for ( c = ochan, mp = map, sp = submap, op = omap;
          c > 0;
          c--, op++, (nchan > 1 ? mp++ : 0), (subchan > 1 ? sp++ : 0) )
        for ( i = sublen, s = *sp, o = *op; i > 0; i--, s++, o++ )
        if ( (sub = (*s) << subshift) > length )
            *o = 0;
        else
            *o = (*mp)[sub];
    }
    else
    {
    subshift = -subshift;
    for ( c = ochan, mp = map, sp = submap, op = omap;
          c > 0;
          c--, op++, (nchan > 1 ? mp++ : 0), (subchan > 1 ? sp++ : 0) )
        for ( i = sublen, s = *sp, o = *op; i > 0; i--, s++, o++ )
        if ( (sub = (*s) >> subshift) > length )
            *o = 0;
        else
            *o = (*mp)[sub];
    }

    shiftmap( omap, ochan, sublen, bits );
}

void filemap

(

)

void filemap	(	int	tflag,
		char *	mapfname,
		int	nchan,
		int	length,
		rle_map **	amap
	)

Definition at line 606 of file rleldmap.c.

{
    FILE * mapfile;
    register int c, i;
    int ent;

    mapfile = rle_open_f( "rleldmap", mapfname, "r" );

    if ( tflag == 1 )       /* channel-major order */
    for ( c = 0; c < nchan; c++ )
        for ( i = 0; i < length; i++ )
        switch ( fscanf( mapfile, "%d", &ent ) )
        {
        case EOF:   /* EOF */
            fprintf( stderr,
        "rleldmap: Premature end of file reading map %s at channel %d, entry %d\n",
               mapfname, c, i );
            exit(-1);
            /* NOTREACHED */
        case 1:     /* Got it */
            amap[c][i] = ent;
            break;
        case 0:     /* no conversion? */
            fprintf( stderr,
                "rleldmap: Bad data in map %s at channel %d, entry %d\n",
               mapfname, c, i );
            exit(-1);
            /* NOTREACHED */
        default:    /* error */
            fprintf( stderr,
                 "rleldmap: Error reading map %s at channel %d, entry %d\n",
                 mapfname, c, i );
            exit(-1);
            /* NOTREACHED */
        }
    else            /* Entry-major order */
    for ( i = 0; i < length; i++ )
        for ( c = 0; c < nchan; c++ )
        switch ( fscanf( mapfile, "%d", &ent ) )
        {
        case EOF:   /* EOF */
            fprintf( stderr, 
        "rleldmap: Premature end of file reading map %s at entry %d, channel %d\n",
               mapfname, i, c );
            exit(-1);
            /* NOTREACHED */
        case 1:     /* Got it */
            amap[c][i] = ent;
            break;
        case 0:     /* no conversion? */
            fprintf( stderr,
                "rleldmap: Bad data in map %s at entry %d, channel %d\n",
                 mapfname, i, c );
            exit(-1);
            /* NOTREACHED */
        default:    /* error */
            fprintf( stderr,
                "rleldmap: Error reading map %s at entry %d, channel %d: ",
              mapfname, i, c );
            perror("");
            exit(-1);
            /* NOTREACHED */
        }
    if ( mapfile != stdin )
    fclose( mapfile );
}

void gammap

(

)

void gammap	(	double	gamma,
		int	nchan,
		int	length,
		int	range,
		rle_map **	amap
	)

Definition at line 569 of file rleldmap.c.

{
    register int i;
    double l = length - 1;

    gamma = 1.0 / gamma;
    for ( i = 0; i < length; i++ )
    amap[0][i] = (rle_map)(0.5 + range * pow( (double)i / l,
                             gamma ));

    for ( i = 1; i < nchan; i++ )
    bcopy( (char *)amap[0], (char *)amap[i],
           length * sizeof(rle_map) );
}

void get_rle_map

(

)

void get_rle_map	(	rle_hdr *	the_hdr,
		char *	fname
	)

Definition at line 751 of file rleldmap.c.

{
    FILE * infile;

    infile = rle_open_f( "rleldmap", fname, "r" );

    the_hdr->rle_file = infile;
    if ( rle_get_setup( the_hdr ) < 0 )
    {
    fprintf( stderr,
         "rleldmap: Can't read setup information from %s\n", fname );
    exit(-1);
    }

    if ( the_hdr->ncmap == 0 )
    {
    fprintf( stderr, "rleldmap: No color map in %s\n", fname );
    exit(-1);
    }

    if ( infile != stdin )
    fclose( infile );
}

void linmap

(

)

void linmap	(	double	factor,
		int	nchan,
		int	length,
		int	range,
		rle_map **	amap
	)

Definition at line 524 of file rleldmap.c.

{
    register int i;
    double l = length - 1, m;

    for ( i = 0; i < length; i++ )
    {
    m = range * ((double)i / l) * factor;
    if ( factor < 0 )
    {
        m = range + m;
        if ( m < 0 )
        m = 0;
    }
    else
        if ( m > range )
        m = range;
    amap[0][i] = (rle_map)(0.5 + m);
    }

    for ( i = 1; i < nchan; i++ )
    bcopy( (char *)amap[0], (char *)amap[i],
           length * sizeof(rle_map) );
}

void main	(	int	argc,
		char **	argv
	)

Definition at line 139 of file rleldmap.c.

{
    int apply = 0, nflag = 0, nchan = 3, length = 256, range, lbits,
    sflag = 0, bits = 8, lflag = 0, gflag = 0,
    tflag = 0, mflag = 0, rflag = 0, oflag = 0, nmfiles = 0;
    int ichan, ilength, ilbits; /* Input map parameters */
    int ochan, olength, olbits; /* output map parameters */
    double factor = 1.0, gamma = 1.0;
    char * mapfname = NULL, ** mfnames = NULL, * rlefname = NULL,
    * outputfname = NULL, * inputfname = NULL;
    char map_comment[30];
    FILE *outfile = stdout;
    rle_map ** imap = NULL, ** omap, ** amap, ** allocmap();
    rle_hdr     in_hdr, out_hdr, rle_f_hdr;
    int rle_cnt, rle_err;

    in_hdr = *rle_hdr_init( NULL );
    out_hdr = *rle_hdr_init( NULL );
    rle_f_hdr = *rle_hdr_init( NULL );

    if ( scanargs( argc, argv,
    "% ab%- n%-nchan!dlength!d s%-bits!d l%-factor%F g%-gamma!F \n\
\ttf%-file!s m%-files!*s r%-rlefile!s o%-outputfile!s inputfile%s",
           &apply, &nflag, &nchan, &length, &sflag, &bits,
           &lflag, &factor, &gflag, &gamma,
           &tflag, &mapfname, &mflag, &nmfiles, &mfnames,
           &rflag, &rlefname, &oflag, &outputfname,
           &inputfname ) == 0 )
    exit( 1 );      /* bad arguments */

    /* Check for exclusive flag use */
    if ( (lflag != 0) + (gflag != 0) + (tflag != 0) + (mflag != 0) +
     (rflag != 0) != 1 )
    {
    fprintf(stderr,
        "%s: Must specify exactly one of -l -g -t -f -m -r\n",
         cmd_name( argv ) );
    exit(-1);
    }

    /* Compute color map parameters */
    if ( rflag )        /* from RLE file? */
    {
    if ( lflag )
        fprintf(stderr, 
        "%s: Nchan, length and bits ignored, values from rle file used\n",
            cmd_name( argv ));
    rle_names( &rle_f_hdr, cmd_name( argv ), rlefname, 0 );
    get_rle_map( &rle_f_hdr, rlefname );
    lbits = rle_f_hdr.cmaplen;
    length = 1 << lbits;
    nchan = rle_f_hdr.ncmap;
    bits = 16;
    /* Just use the rle map */
    amap = allocmap( length, nchan, rle_f_hdr.cmap );
    }
    else
    {
    for ( lbits = 0; length > 1<<lbits; lbits++ )
        ;           /* Get log2 of length */
    if ( length != 1 << lbits )
    {
        fprintf( stderr,
            "%s: Length (%d) rounded up to power of 2 (%d)\n",
             cmd_name( argv ), length, 1 << lbits );
        length = 1 << lbits;    /* round length to power of 2 */
    }
    /* Allocate space for the applied map */
    amap = allocmap( nchan, length, NULL );
    }
    range = (1 << bits) - 1;

    /* Compute the requested map */
    if ( lflag )
    linmap( factor, nchan, length, range, amap );
    if ( gflag )
    gammap( gamma, nchan, length, range, amap );
    if ( tflag )
    filemap( tflag, mapfname, nchan, length, amap );
    if ( mflag )
    mfilemap( mfnames, nchan, length, amap );

    /* Open input file and verify header */
    in_hdr.rle_file = rle_open_f(cmd_name( argv ), inputfname, "r");
    rle_names( &in_hdr, cmd_name( argv ), inputfname, 0 );
    rle_names( &out_hdr, in_hdr.cmd, outputfname, 0 );

    for ( rle_cnt = 0;
      (rle_err = rle_get_setup( &in_hdr )) == RLE_SUCCESS ||
      rle_err == RLE_EMPTY;
      rle_cnt++ )
    {
    if ( rle_err == RLE_EMPTY )
    {
        if ( rle_cnt == 0 )
        apply = 0;  /* can't apply to non-existant map */
        else
        break;
        /* Build in_hdr for non-existant image (all zeros works fine) */
        bzero( &in_hdr, sizeof in_hdr );
    }

    /* If apply flag was given, check for compatibility of color maps */
    if ( in_hdr.ncmap == 0 )
        apply = 0;      /* Can't apply to non-existent map */
    if ( apply )
    {
        char *c;

        ilbits = in_hdr.cmaplen;
        ilength = (1 << ilbits);
        if ( (c = rle_getcom( "color_map_length", &in_hdr )) &&
         atoi(c) > 0 && atoi(c) < ilength )
        ilength = atoi(c);
        ichan = in_hdr.ncmap;
        if ( ! ( nchan == 1 || ichan == 1 ||
             nchan == ichan ) )
        {
        fprintf( stderr,
 "%s: Nchan (%d) and input color map (%d channels) are not compatible\n",
             cmd_name( argv ), nchan, ichan );
        exit(-1);
        }
        ochan = (nchan > ichan) ? nchan : ichan;

        if ( apply == 1 )   /* "before", omap[i] = imap[amap[i]] */
        {
        olength = length;
        olbits = lbits;
        }
        else        /* "after", omap[i] = amap[imap[i]] */
        {
        olength = ilength;
        olbits = ilbits;
        }
    
        /* Get convenient access to the input map */
        imap = allocmap( in_hdr.ncmap, 1 << in_hdr.cmaplen,
                 in_hdr.cmap );

        /* Allocate an output map */
        omap = allocmap( ochan, olength, NULL );

        /* And do the application */
        if ( apply == 1 )
        applymap( imap, in_hdr.ncmap, 1 << in_hdr.cmaplen, 16,
              amap, nchan, length, bits,
              omap );
        else
        applymap( amap, nchan, length, bits,
              imap, in_hdr.ncmap, ilength, 16,
              omap );
    }
    else
    {
        /* "Copy" the applied map, and left justify it */
        omap = allocmap( nchan, length, NULL );
        bcopy( amap[0], omap[0], nchan * length * sizeof(rle_map) );
        olength = length;
        olbits = lbits;
        ochan = nchan;
        shiftmap( omap, ochan, olength, bits );
    }

    /* Now, open the output */
    /* start by copying input parameters */
    (void)rle_hdr_cp( &in_hdr, &out_hdr );
    out_hdr.ncmap = ochan;
    out_hdr.cmaplen = olbits;
    out_hdr.cmap = omap[0];
    if ( olength != 1 << olbits )
    {
        sprintf( map_comment, "color_map_length=%d", olength );
        rle_putcom( map_comment, &out_hdr );
    }
    else
        rle_delcom( "color_map_length", &out_hdr );
    if ( rle_cnt == 0 )
        outfile = rle_open_f(cmd_name( argv ), outputfname, "w");
    out_hdr.rle_file = outfile;

    rle_addhist( argv, &in_hdr, &out_hdr );

    rle_put_setup( &out_hdr );

    /* Copy the rest of the input to the output */
    if ( rle_err != RLE_EMPTY )
        rle_cp( &in_hdr, &out_hdr );

    /* Free temp storage. */
    free( omap[0] );
    free( omap );
    out_hdr.cmap = 0;   /* Don't try to free it again? */
    if ( apply )
    {
        free( imap );
    }
    if ( rle_err == RLE_EMPTY )
    {
        rle_err = RLE_SUCCESS;
        break;
    }
    }

    /* 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 ), inputfname );

    exit( 0 );
}

void mfilemap

(

)

void mfilemap	(	char **	mfnames,
		int	nchan,
		int	length,
		rle_map **	amap
	)

Definition at line 693 of file rleldmap.c.

{
    FILE * mapfile;
    register int c, i;
    int ent;

    for ( c = 0; c < nchan; c++, mfnames++ )
    {
    mapfile = rle_open_f( "rleldmap", *mfnames, "r" );

    for ( i = 0; i < length; i++ )
        switch ( fscanf( mapfile, "%d", &ent ) )
        {
        case EOF:       /* EOF */
        fprintf( stderr,
            "rleldmap: Premature end of file reading map %s at channel %d, entry %d\n",
            *mfnames, c, i );
        exit(-1);
        /* NOTREACHED */
        case 1:     /* Got it */
        amap[c][i] = ent;
        break;
        case 0:     /* no conversion? */
        fprintf( stderr,
            "rleldmap: Bad data in map %s at channel %d, entry %d\n",
             *mfnames, c, i );
        exit(-1);
        /* NOTREACHED */
        default:        /* error */
        fprintf( stderr,
             "rleldmap: Error reading map %s at channel %d, entry %d: ",
             *mfnames, c, i );
        perror("");
        exit(-1);
        /* NOTREACHED */
        }
    if ( mapfile != stdin )
        fclose( mapfile );
    }
}

void shiftmap

(

)

void shiftmap	(	rle_map **	map,
		int	nchan,
		int	length,
		int	bits
	)

Definition at line 413 of file rleldmap.c.

{
    register rle_map * e;
    register int i;
    
    bits = 16 - bits;
    if ( bits == 0 )
    return;         /* no work! */

    for ( i = nchan * length, e = map[0]; i > 0; i--, e++ )
    *e <<= bits;
}

Variable Documentation

char rcsid[] = "$Header: /tmp_mnt/n/itn/hendrix/u/spencer/RCS/rleldmap.c,v 3.0.1.5 1992/02/28 22:12:27 spencer Exp spencer $"

static

Definition at line 28 of file rleldmap.c.