getsun.c

Go to the documentation of this file.

/*
 * getsun - display an rle image on a sun workstation running the
 *          sun window environment.
 *
 * Bug reports, or better yet fixes/enhancements, may be sent to the author.
 * Author:
 *  Philip J. Klimbal
 *  RIACS
 *  MS 230-5
 *  NASA Ames Research Center
 *  Moffett Field, CA 94035
 *  ..!ames!riacs!klimbal
 *  klimbal@riacs.edu
 *
 * Copyright (c) 1987 Research Institute for Advanced Computer Science 
 * All rights reserved. No explicit or implicit warrenty provided.   
 *
 * Based on getX - Put RLE images on X display,
 * by Spencer W. Thomas, University of Utah.
 * Copyright (c) 1986, University of Utah
 *
 *
 * Utah Copyright Header (getX):
 *
 *  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.
 *
 *
 * cc .... -lrle -lsuntool -lsunwindow -lpixrect -lm
 */
static char rcsid[] = "$Header: /l/spencer/src/urt/get/RCS/getsun.c,v 3.0.1.2 1992/04/30 14:05:10 spencer Exp $";
/*
getsun()            Tag the file.
*/

#include <stdio.h>
#include <math.h>
#include <sys/file.h>
#include <suntool/sunview.h>
#include <suntool/canvas.h>
#include "rle.h"

void get_pic(), create_window(), init_color(), map_rgb_to_bw();
void map_scanline(), put_scanline();

/*
 * Basic magic square for dithering
 */
int dm16[16][16];

/* 
 * Color map, gamma correction map, and lookup tables 
 */
rle_pixel ** in_cmap;
int modN[256], divN[256];
int bwflag = 0;         /* if non zero, dither in B&W
                 * Value of 2 means 1-bit system
                 */

/*
 * Number of color map levels, (square and cube), and number of gradations
 * per level.
 */
int levels = 0, levelsq, levelsc;

/* 
 * Global variables
 */
double disp_gam = 2.5;      /* default gammas for display and image */
double img_gam = 1.0;
int iflag = 0;          /* flag to tell if gamma was on command line */

int nscan, nrow;        /* size of window */
int nbyte;          /* size of bitrow for 1-bit displays */

int dbg = 0;            /* set if debug mode */

unsigned char *buffer;      /* data storage pointers */

Frame frame;            /* sun window display frame */
Canvas canvas;          /* display frame canvas */
Pixwin *pw;         /* pixwin canvas */


/*****************************************************************
 * TAG( main )
 * 
 * Usage:
 *  getsun [-D] [-{wW}] [-{iI} gamma] [-g gamma] [-l levels] [file]
 * Inputs:
 *  -D:     Debug mode: print input file as read.
 *  -f:     Don't fork after putting image on screen.
 *  -w:     Black & white: reduce color images to B&W before
 *          display.  Advantage is that smoother shading can
 *          be achieved.
 *  -i gamma:   Specify gamma of image. (default 1.0)
 *  -I gamma:   Specify gamma of display image was computed for.
 *  getsun will also read picture comments from the input file to determine
 *          the image gamma.  These are
 *  image_gamma=    gamma of image (equivalent to -i)
 *  display_gamma=  gamma of display image was computed for.
 *          Command line arguments override values in the file.
 *  -g gamma:   Specify gamma of display. (default 2.5)
 *      -l levels:      Number of color levels.
 *  file:       Input Run Length Encoded file. Uses stdin if not
 *          specified.
 * Outputs:
 *  Puts image on screen.
 * Assumptions:
 *  Input file is in RLE format.
 * Algorithm:
 *  [None]
 */

void
main(argc, argv)
int argc;
char **argv;
{
    CONST_DECL char *infname = NULL;
    FILE * infile;
    int gflag = 0;
    int forkflg = 0;

    if ( scanargs( argc, argv,
           "% Ww%- D%- f%- l%-levels!d Ii%-gamma!F g%-gamma!F file%s",
           &bwflag, &dbg, &forkflg,
           &levels, &levels,
           &iflag, &img_gam,
           &gflag, &disp_gam,
           &infname ) == 0 )
    exit( 1 );


    if ( levels != 0 && (levels > 6 || levels < 2)) {
        fprintf(stderr,"Level must be in the range [2,6]; %d is invalid!\n", levels);
        exit( 1 );
    }
    if ( iflag == 1 )       /* -i */
        img_gam = 1.0 / img_gam;

        infile = rle_open_f("getsun", infname, "r");
        if ( infile == stdin )
        infname = "Standard Input";

    if ( !forkflg && fork() != 0 )
        exit(0);
        get_pic( infile, infname);
        if ( infname != NULL)  fclose( infile);

        if ( !forkflg )
    {
        fclose(stdin);      /* Close stdio to release rshd. */
        fclose(stdout);
        fclose(stderr);
    }

    window_main_loop(frame);
    exit(0);
}




/*****************************************************************
 * TAG( get_pic )
 * 
 * Read in an RLE image, compute color map, and display it.
 *
 * Inputs:
 *  infile:  File pointer for input.
 *  infname: Name of input file.
 *
 */
void
get_pic( infile, infname, cmdname )
FILE * infile;
char * infname, * cmdname;
{
    register int    i,
                    y;
    int         ncolors;
    unsigned char  *scan[3];
    rle_hdr hdr;

    /*
     * Read setup info from file. 
     */
    hdr = *rle_hdr_init( (rle_hdr *)NULL );
    rle_names( &hdr, cmdname, infname, 0 );

    hdr.rle_file = infile;
    rle_get_setup_ok(&hdr, NULL, NULL);

    if ( dbg )
    rle_debug( 1 );

    /* We're only interested in R, G, & B */
    RLE_CLR_BIT(hdr, RLE_ALPHA);
    for (i = 3; i < hdr.ncolors; i++)
    RLE_CLR_BIT(hdr, i);
    ncolors = hdr.ncolors > 3 ? 3 : hdr.ncolors;

    /*
     * Compute image size and allocate storage. 
     */
    nrow = (hdr.xmax - hdr.xmin + 1);
    nscan = (hdr.ymax - hdr.ymin + 1);

    /*
     * Get a window of the right size.
     */
    create_window(nrow, nscan, infname);

    if ( bwflag == 2 )
    nbyte = ((nrow + 15) / 16) * 2; /* 1 bit display */
    else
    nbyte = ((nrow + 1) / 2) * 2;

    buffer = (unsigned char *) malloc(nbyte * nscan);
    RLE_CHECK_ALLOC( hdr.cmd, buffer, "image memory" );

    /*
     * Set up for rle_getrow.  Pretend image x origin is 0. 
     */
    for (i = 0; i < 3; i++)
    scan[i] = (unsigned char *) malloc(nrow);
    RLE_CHECK_ALLOC( hdr.cmd, scan[0]&&scan[1]&&scan[2], "input scan memory" );
    hdr.xmax -= hdr.xmin;
    hdr.xmin = 0;

    /* If no image gamma on command line, check comments in file */
    if ( ! iflag )
    {
    char * v;
    if ( (v = rle_getcom( "image_gamma", &hdr )) != NULL )
    {
        img_gam = atof( v );
        /* Protect against bogus information */
        if ( img_gam == 0.0 )
        img_gam = 1.0;
        else
        img_gam = 1.0 / img_gam;
    }
    else if ( (v = rle_getcom( "display_gamma", &hdr )) != NULL )
    {
        img_gam = atof( v );
        /* Protect */
        if ( img_gam == 0.0 )
        img_gam = 1.0;
    }
    }

    /*
     * Set up the color map. 
     */
    /* Input map, at least 3 channels */
    in_cmap = buildmap( &hdr, 3, img_gam, 1.0 );

    init_color();

    /*
     * For each scan line, dither it and display. 
     */
    while ((y = rle_getrow(&hdr, scan)) <= hdr.ymax)
    {
    if ( bwflag && ncolors > 1 )
    {
        map_rgb_to_bw( scan[0], scan[1], scan[ncolors - 1], scan[0],
               in_cmap, nrow );
        /* Note: map_scanline only uses channel 0 for B&W */
    }
    else if ( bwflag )
        for ( i = 0; i < nrow; i++ )
        scan[0][i] = in_cmap[0][scan[0][i]];
    else
        for (i = 2; i >= ncolors; i--)
        bcopy(scan[0], scan[i], nrow);
    map_scanline(scan, nrow, 1, y,
             &buffer[(hdr.ymax - y) * nbyte]);
    put_scanline(&buffer[(hdr.ymax - y) * nbyte], nrow, 0,
             hdr.ymax - y );
    }
    /*
     * Free temp storage 
     */
    for (i = 0; i < 3; i++)
    free(scan[i]);
}




/*****************************************************************
 * TAG( create_window )
 * 
 * Create a sun window and place a pixwin canvas in it.
 *
 * Inputs:
 *  width:  width of window.
 *  height: height of window.
 *  name:   name of image file.
 *
 */
void
create_window( width, height, name)
    int width, height;
    char *name;
{
    char buf[BUFSIZ];

    sprintf(buf,"\"%s\": %d X %d",
        name, height, width);
    frame = window_create(0, FRAME,
        FRAME_SHOW_LABEL, TRUE,
        FRAME_LABEL, buf,
        FRAME_NO_CONFIRM, TRUE,
        0);
    canvas = window_create(frame, CANVAS,
        WIN_HEIGHT, height,
        WIN_WIDTH, width,
        0);
    window_fit(frame);
    if ((pw = canvas_pixwin(canvas)) == NULL) {
        perror("Cannot create pixwin");
        exit( 1 );
    }
    if (pw->pw_pixrect->pr_depth == 1) bwflag=2;
}




/*****************************************************************
 * TAG( map_scanline )
 *
 * Map a scanline to 8 bits through the dither matrix.
 * 
 * Inputs:
 *  rgb:        Pointers to buffers containing the red, green,
 *          and blue color rows.
 *  n:      Length of row.
 *  s:      Skip between pixels in original image.
 *  y:      Y position of row (necessary for dither)
 *  line:       Pointer to output buffer for dithered color data.
 */

#define DMAP(v,x,y) (modN[v]>dm16[x][y] ? divN[v] + 1 : divN[v])
void
map_scanline( rgb, n, s, y, line )
unsigned char *rgb[3], *line;
int n, s, y;
{
    register int i, col, row;

    if ( !bwflag )
    {
    register unsigned char *r, *g, *b;
    for ( row = y % 16, col = 0, i = 0, r = rgb[0], g = rgb[1], b = rgb[2];
          i < n; i++, r+=s, g+=s, b+=s, col = ((col + 1) & 15) )
        line[i] = DMAP(in_cmap[0][*r], col, row) +
                  DMAP(in_cmap[1][*g], col, row) * levels +
                  DMAP(in_cmap[2][*b], col, row) * levelsq;
    }
    else if ( bwflag == 1 ) /* gray scale display */
    {
    register unsigned char *r;

    for ( row = y % 16, col = 0, i = 0, r = rgb[0];
          i < n; i++, r+=s, col = ((col + 1) & 15) )
        line[i] = DMAP(*r, col, row);
    }
    else            /* bitmap display */
    {
    register unsigned short *l = (unsigned short *)line;
    register unsigned char * r;

    for ( row = y % 16, col = 0, i = 0, r = rgb[0], *l = 0;
          i < n; r+=s, col = ((col + 1) & 15) )
    {
        *l |= (*r > dm16[col][row] ? 0 : 1) << (15-(i % 16));
        if ( (++i % 16) == 0 )
        *++l = 0;
    }
    }
}




/*****************************************************************
 * TAG( put_scanline )
 * 
 * Output scanline into pixwin.
 *
 * Inputs:
 *  scan:  pointer to scanline.
 *  width: width of scanline.
 *  x,y:   coordinates of this scanline.
 *
 */
void
put_scanline( scan, width, x, y )
    unsigned char *scan;
    int width, x, y;
{
    Pixrect *pix;

    if ((pix = mem_point(width,1,pw->pw_pixrect->pr_depth,scan)) == NULL) {
        perror("Unable to allocate pixrect");
        exit( 1 );
    }

    pw_write(pw, x, y, width, 1, PIX_SRC, pix, 0, 0);
    free(pix);
}




/*****************************************************************
 * TAG( map_rgb_to_bw )
 * 
 * Convert RGB to black and white through NTSC transform, but map
 * RGB through a color map first.
 * Inputs:
 *  red_row, green_row, blue_row:   Given RGB pixel data.
 *  map:        Array[3] of pointers to pixel arrays,
 *          representing color map.
 *  rowlen:     Number of pixels in the rows.
 * Outputs:
 *  bw_row:     Output B&W data.  May coincide with one of the
 *          inputs.
 * Algorithm:
 *  BW = .35*map[0][R] + .55*map[1][G] + .10*map[2][B]
 */
void
map_rgb_to_bw( red_row, green_row, blue_row, bw_row, map, rowlen )
rle_pixel *red_row;
rle_pixel *green_row;
rle_pixel *blue_row;
rle_pixel *bw_row;
rle_pixel **map;
int rowlen;
{
    register int x, bw;

    for (x=0; x<rowlen; x++)
    {
    /* 68000 won't store float > 127 into byte? */
    /* HP compiler blows it */
    bw = .35*map[0][red_row[x]] + .55*map[1][green_row[x]] +
        .10*map[2][blue_row[x]];
    bw_row[x] = bw;
    }
}




/*****************************************************************
 * TAG( init_color )
 * 
 * Build color map and load it into the pixwin.
 *
 */
void
init_color()
{
    register int i;
    int rgbmap[256][3], bwmap[256];
    unsigned char colormap[3][256];
    char buf[12];

    if ( !bwflag )
    {
    /* 
     * Figure out how many color map entries we can get
     */
    if ( levels == 0 )
        levels = 5;     /* default starting point */

    levelsq = levels * levels;
    levelsc = levelsq * levels;

    dithermap( levels, disp_gam, rgbmap, divN, modN, dm16 );

    /* 
    * Copy the color map entries into something that sunwindows
        * can work with.
    */
    for(i = 0; i < levelsc; i++) {
        colormap[0][i] = (u_char)rgbmap[i][0]&0xff;
        colormap[1][i] = (u_char)rgbmap[i][1]&0xff;
        colormap[2][i] = (u_char)rgbmap[i][2]&0xff;
    }
    sprintf(buf,"getsun.c%1d",levels);
    pw_setcmsname(pw, buf);
    pw_putcolormap(pw, 0, 4<<levels,colormap[0],colormap[1],colormap[2]);
    return;
    }

    /* Get a B&W color map (gray scale) */
    if ( bwflag == 1 )
    {
    if ( levels == 0 )
        levels = 5;
    levelsq = levels * levels;
    levelsc = levelsq * levels;
    bwdithermap( levels, disp_gam, bwmap, divN, modN, dm16 );

    /* 
    * Copy the color map entries into something that sunwindows
        * can work with.
    */
        for ( i = 0; i < levelsc; i++ )
        {
        colormap[0][i] = (u_char)bwmap[i]&0xff;
        colormap[1][i] = (u_char)bwmap[i]&0xff;
        colormap[2][i] = (u_char)bwmap[i]&0xff;
        }
    sprintf(buf,"getsun.g%1d",levels);
    pw_setcmsname(pw, buf);
    pw_putcolormap(pw, 0,4<<levels, colormap[0],colormap[1],colormap[2]);
    return;
    }

    /* If b&w 1-bit display, just use two colors */
    if ( bwflag == 2 )
    {
    /* All we care about, really, is the magic square */
    make_square( 255.0, divN, modN, dm16 );
    levels = levelsc = 2;
    return;
    }
}