buildmap.c

Go to the documentation of this file.

/*
 * This software is copyrighted as noted below.  It may be freely copied,
 * modified, and redistributed, provided that the copyright notice is 
 * preserved on all copies.
 * 
 * There is no warranty or other guarantee of fitness for this software,
 * it is provided solely "as is".  Bug reports or fixes may be sent
 * to the author, who may or may not act on them as he desires.
 *
 * You may not include this software in a program or other software product
 * without supplying the source, or without informing the end-user that the 
 * source is available for no extra charge.
 *
 * If you modify this software, you should include a notice giving the
 * name of the person performing the modification, the date of modification,
 * and the reason for such modification.
 */
/* 
 * buildmap.c - Build a color map from the RLE file color map.
 * 
 * Author:  Spencer W. Thomas
 *      Computer Science Dept.
 *      University of Utah
 * Date:    Sat Jan 24 1987
 * Copyright (c) 1987, University of Utah
 */

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

/*****************************************************************
 * TAG( buildmap )
 * 
 * Returns a color map that can easily be used to map the pixel values in
 * an RLE file.  Map is built from the color map in the input file.
 * Inputs:
 *  the_hdr:    rle_hdr structure containing color map.
 *  minmap:     Minimum number of channels in output map.
 *  orig_gamma: Adjust color map for this image gamma value
 *          (1.0 means no adjustment).
 *  new_gamma:  Gamma of new display.
 * Outputs:
 *  Returns an array of pointers to arrays of rle_pixels.  The array
 *  of pointers contains max(ncolors, ncmap) elements, each 
 *  array of pixels contains 2^cmaplen elements.  The pixel arrays
 *  should be considered read-only.
 * Assumptions:
 *  [None]
 * Algorithm:
 *  Ensure that there are at least ncolors rows in the map, and
 *  that each has at least 256 elements in it (largest map that can
 *  be addressed by an rle_pixel).
 */
rle_pixel **
buildmap( the_hdr, minmap, orig_gamma, new_gamma )
rle_hdr *the_hdr;
int minmap;
double orig_gamma;
double new_gamma;
{
    rle_pixel ** cmap, * gammap;
    double gamma;
    register int i, j;
    int maplen, cmaplen, nmap;

    if ( the_hdr->ncmap == 0 )  /* make identity map */
    {
    nmap = (minmap < the_hdr->ncolors) ? the_hdr->ncolors : minmap;
    cmap = (rle_pixel **)malloc( nmap * sizeof(rle_pixel *) );
    cmap[0] = (rle_pixel *)malloc( nmap * 256 * sizeof(rle_pixel) );
    for ( j = 1; j < nmap; j++ )
        cmap[j] = cmap[j-1] + 256;
    for ( i = 0; i < 256; i++ )
        for ( j = 0; j < nmap; j++ )
        cmap[j][i] = i;
    maplen = 256;
    }
    else            /* make map from the_hdr */
    {
    /* Map is at least 256 long */
    cmaplen = (1 << the_hdr->cmaplen);
    if ( cmaplen < 256 )
        maplen = 256;
    else
        maplen = cmaplen;

    /* Nmap is max( minmap, the_hdr->ncmap, the_hdr->ncolors ). */
    nmap = minmap;
    if ( nmap < the_hdr->ncmap )
        nmap = the_hdr->ncmap;
    if ( nmap < the_hdr->ncolors )
        nmap = the_hdr->ncolors;

    /* Allocate memory for the map and secondary pointers. */
    cmap = (rle_pixel **)malloc( nmap * sizeof(rle_pixel *) );
    cmap[0] = (rle_pixel *)malloc( nmap * maplen * sizeof(rle_pixel) );
    for ( i = 1; i < nmap; i++ )
        cmap[i] = cmap[0] + i * maplen;

    /* Fill it in. */
    for ( i = 0; i < maplen; i++ )
    {
        for ( j = 0; j < the_hdr->ncmap; j++ )
        if ( i < cmaplen )
            cmap[j][i] = the_hdr->cmap[j*cmaplen + i] >> 8;
        else
            cmap[j][i] = i;
        for ( ; j < nmap; j++ )
        cmap[j][i] = cmap[j-1][i];
    }
    }

    /* Gamma compensate if requested */
    if ( orig_gamma == 0 )
    {
    char *v;
    if ( (v = rle_getcom( "image_gamma", the_hdr )) != NULL )
    {
        orig_gamma = atof( v );
        /* Protect against bogus information */
        if ( orig_gamma == 0.0 )
        orig_gamma = 1.0;
        else
        orig_gamma = 1.0 / orig_gamma;
    }
    else if ( (v = rle_getcom( "display_gamma", the_hdr )) != NULL)
    {
        orig_gamma = atof( v );
        /* Protect */
        if ( orig_gamma == 0.0 )
        orig_gamma = 1.0;
    }
    else
        orig_gamma = 1.0;
    }

    /* Now, compensate for the gamma of the new display, too. */
    if ( new_gamma != 0.0 )
    gamma = orig_gamma / new_gamma;
    else
    gamma = orig_gamma;

    if ( gamma != 1.0 )
    {
    gammap = (rle_pixel *)malloc( 256 * sizeof(rle_pixel) );
    for ( i = 0; i < 256; i++ )
        gammap[i] = (int)(0.5 + 255.0 * pow( i / 255.0, gamma ));
    for ( i = 0; i < nmap; i++ )
        for ( j = 0; j < maplen; j++ )
        cmap[i][j] = gammap[cmap[i][j]];
    free( gammap );
    }

    return cmap;
}