get4d.c

Go to the documentation of this file.

/* 
 * get4d.c - Put RLE images on the Iris/4D display under the window manager.
 * 
 * Author:  Russell D. Fish (Based on getmex.c .)
 *      Computer Science Dept.
 *      University of Utah
 * Date:    Thu May 26 20:49:11 1988
 * Copyright (c) 1988, University of Utah
 * 
 */
/* modified for Personal Iris with only 8 bit planes (no RGB mode)
 * as well as the other Iris displays.
 * Michael Hart - September 1991
 *    forced limitations - B&W display only, -G option forced
 */

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

#define MAX(i,j)   ( (i) > (j) ? (i) : (j) )
#define MIN(i,j)   ( (i) < (j) ? (i) : (j) )

/* Global variables. */
long window_number;         /* Window number from MAX. */
int x_size, y_size;         /* Size of image. */
int i;                  /* General loop counter */
int dbg = 0;                /* Set if debug mode. */
int forkflg = 0;            /* Set if not to run in background. */
int bwflag = 0;             /* Set for greyscale output. */
int NoBorder = 0;           /* Turn off border */
int gt;         /* Whether we're using GT fast rectangle drawing. */
double disp_gamma = 1.0;        /* Gamma of Iris display. */
double img_gamma = 0.0;         /* Gamma of input image. */
short colmap[128][3];           /* Area to hold the old colormap */
long bitsavail;             /* 0 if not enough for RGB mode */

/* Window preferences. */
int posflag = 0, w_xpos, w_ypos, sizeflag = 0, w_xsize, w_ysize;

unsigned long *rect_image;            /* GT Image data buffer pointer. */
unsigned char *rgb_image;             /* Non-GT Image data buffer pointer. */

rle_hdr     hdr;
rle_pixel **cmap;

/*****************************************************************
 * TAG( main )
 * 
 * Usage:
 *  get4d [-G][-S] [-p xpos ypos] [-f] [-D] [-w] [file]
 * Inputs:
 *  -D: Debug mode: print input file as read.
 *  -f: Don't fork after putting image on screen.
 *  -G: GT mode: single fast rectangle, panning disabled.
 *      (GT mode is the default on GT, GTX, and Personal Iris 4Ds.)
 *  -S: Slow mode: Allows resizing the window, and panning with the
 *      mouse.  (Slow mode is the default on non-GT 4Ds.)
 *  -g disp_gamma:  Gamma of the output display.
 *  -i image_gamma: Gamma the image was calculated for.
 *  -I image_gamma: Gamma of the image pixels (1.0 / (-i gamma)).
 *  -n: No border will be drawn.
 *  -p xpos ypos:   Position of the lower left corner of the window.
 *  -s xsize ysize: Initial size of the window (slow mode only.)
 *
 *  -w: Black & white: reduce color images to B&W before display.
 *      Advantage is that smoother shading can be achieved.
 *
 *  file:   Input Run Length Encoded file.  Uses stdin if not
 *      specified.
 * Outputs:
 *  Puts image in a window on the screen.
 * Assumptions:
 *  Input file is in RLE format.
 */

main(argc, argv)
char **argv;
{
    char *infname = NULL;
    FILE * infile = stdin;
    char vbuff[50];
    char *var;
    int gtflag = 0, slowflag = 0, gflag = 0, iflag = 0;

    hdr = *rle_hdr_init( (rle_hdr *)NULL );
    rle_names( &hdr, cmd_name( argv ), NULL, 0 );

    /* Handle arguments. */
    if ( scanargs( argc, argv,
           "% D%- f%- GS%- g%-disp_gamma!F iI%-image_gamma!F n%- \n\
    p%-xpos!dypos!d s%-xsize!dysize!d w%- file%s",
           &dbg, &forkflg,
           &gtflag,
           &gflag, &disp_gamma,
           &iflag, &img_gamma,
           &NoBorder,
           &posflag, &w_xpos, & w_ypos,
           &sizeflag, &w_xsize, &w_ysize,
           &bwflag,
           &infname ) == 0 )
    exit( 1 );

    if ( gtflag )       /* Mode args override if specified. */
    gt = gtflag - 1;    /* -G->2 means yes GT, -S->1 means no GT. */
    else
    {
#ifndef _IBMR2
    /* See if we`re on a GT.  For this purpose, a Personal Iris is a GT. */
    gversion( vbuff );  /* String like "GL4DGTX-3.1". */
    gt = strncmp( vbuff+4, "GT", 2 ) == 0 ||
         strncmp( vbuff+4, "PI", 2 ) == 0;
#else
    gt = 1;
#endif
    }

    /* Diddle with gammas. */
    if ( iflag == 2 )       /* -i flag. */
    if ( img_gamma != 0.0 ) /* Paranoid. */
        img_gamma = 1.0 / img_gamma;

#ifndef _IBMR2
    /* Look at home for .gamma file. */
    if ( !gflag )
    {
    char *var = getenv( "HOME" );
    char buf[BUFSIZ];
    FILE *gamfile;
    float flt_gam = 0;  /* Just in case of 68000 iris botch. */

    if ( var != NULL && *var != '\0' )
    {
        sprintf( buf, "%s/.gamma", var );
        if ( (gamfile = fopen( buf, "r" )) != NULL )
        {
        fscanf( gamfile, "%f", &flt_gam );
        if ( flt_gam != 0 )
            disp_gamma = 2.4/flt_gam;/* SGI displays have gamma 2.4. */
        fclose( gamfile );
        }
    }
    }
#endif
    /* check machine graphics capability */
    bitsavail = getgdesc(GD_BITS_NORM_SNG_GREEN); /* Can it support RGB mode */
    if(bitsavail==0)
    {
                /* set configuration to force reading in B&W and -G ode disp */
        bwflag = 1;
        gt = 1;
    }
    infile = rle_open_f(hdr.cmd, infname, "r");
    get_pic( infile, infname ); /* Read image and make a window for it. */
    if(bitsavail==0)            /* modify gey levels if necessary */
        convertgreylevels();
    update_pic();       /* Keep drawing the window. */
}

/* 
 * Read an image from the input file and display it.
 */
get_pic( infile, infname )
FILE * infile;
char * infname;
{
    register int i, y;
    int ncolors;
    unsigned char *scan[3];

    /*
     * Read setup info from file. 
     */
    rle_hdr_init( &hdr );
    rle_names( &hdr, hdr.cmd, infile, 0 );
    hdr.rle_file = infile;
    if ( rle_get_setup( &hdr ) < 0 )
    {
    fprintf(stderr, "%s: Error reading setup information from %s\n",
        hdr.cmd, infname ? infname : "stdin");
    exit(1);
    }

    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;

    /* Do nicer b&w rendering if only one color channel in input. */
    if ( ncolors == 1 && hdr.ncmap <= 1 )
    bwflag = 1;

    /*
     * Compute image size and allocate storage for colormapped image. 
     */
    x_size = (hdr.xmax - hdr.xmin + 1);
    y_size = (hdr.ymax - hdr.ymin + 1);
    if ( gt )
      rect_image = (unsigned long *) malloc(x_size * y_size * sizeof( long ));
    else
      rgb_image = (unsigned char *) malloc(x_size * y_size * 3 * sizeof( char ));

    /*
     * Set up for rle_getrow.  Pretend image x origin is 0. 
     */
    for (i = 0; i < 3; i++)
    scan[i] = (unsigned char *) malloc(x_size);
    hdr.xmax -= hdr.xmin;
    hdr.xmin = 0;

    cmap = buildmap( &hdr, 3, img_gamma, disp_gamma );

    /* For each scan line, pack RGBs into the image memory. */
    while ((y = rle_getrow(&hdr, scan)) <= hdr.ymax)
    {
    switch ( ncolors )
    {
    case 1:
        /* Colormapped image */
        for (i = 0; i < x_size; i++) {
        scan[2][i] = cmap[2][scan[0][i]];
        scan[1][i] = cmap[1][scan[0][i]];
        scan[0][i] = cmap[0][scan[0][i]];
        }
        break;

    case 2:
        /* Weird image. */
        for (i = 0; i < x_size; i++) {
        scan[2][i] = cmap[2][scan[1][i]];
        scan[1][i] = cmap[1][scan[1][i]];
        scan[0][i] = cmap[0][scan[0][i]];
        }
        break;
    case 3:
        /* Normal image. */
        for (i = 0; i < x_size; i++) {
        scan[2][i] = cmap[2][scan[2][i]];
        scan[1][i] = cmap[1][scan[1][i]];
        scan[0][i] = cmap[0][scan[0][i]];
        }
        break;
    }
    if ( bwflag )
    {
        if (ncolors == 1)
        rgb_to_bw (scan[0], scan[1], scan[2], scan[0], x_size );
        else
            rgb_to_bw( scan[0], scan[1], scan[ncolors - 1],
            scan[0], x_size );
        /* Note: pack_scanline only uses channel 0 for B&W */
    }

    if ( gt )
        pack_rect_scanline( scan, x_size,
        &rect_image[(y - hdr.ymin) * x_size] );
    else
        pack_rgb_scanline( scan, x_size,
        &rgb_image[(y - hdr.ymin) * x_size * 3] );
    }

    /*
     * Free temp storage 
     */
    for (i = 0; i < 3; i++)
    free(scan[i]);

    /* Size flag can cut down the window size, except in GT rectangle mode. */
    w_xsize = sizeflag && !gt ? MIN( w_xsize, x_size ) : x_size;
    w_ysize = sizeflag && !gt ? MIN( w_ysize, y_size ) : y_size;

    /* Window should be completely on the screen in GT rectangle mode. */
    if ( posflag && gt )
    {
    w_xpos = MIN( w_xpos, XMAXSCREEN - w_xsize );
    w_ypos = MIN( w_ypos, YMAXSCREEN - w_ysize);
    }

    w_xpos = MAX( 0, w_xpos );  /* Be positive. */
    w_ypos = MAX( 0, w_ypos );

    /* Register our preferences for the window size and location. */
    if ( posflag )
    prefposition( w_xpos, w_xpos + w_xsize - 1,
              w_ypos, w_ypos + w_ysize - 1 );
    else if ( sizeflag || gt )
        /* Have to keep the window full size to use the fast pixel commands. */
          prefsize( w_xsize, w_ysize );
    else
        maxsize( x_size, y_size );

    /*
     * Get a window of the right size (user positions it with the mouse). 
     */
#ifndef _IBMR2
    if ( forkflg ) foreground();    /* Don`t fork. */
#endif
    if ( NoBorder ) noborder();
    window_number = winopen( hdr.cmd );
    if ( infname ) wintitle( infname );

    /* Loosen the constraints once the window is created. */
    if ( !gt )
    maxsize( x_size, y_size );
    winconstraints();

    if(bitsavail==0)
    {       /* only color map available so make a grey scale */
        for(i=0;i<=127;i++)
    {
        getmcolor((i+128),&colmap[i][0],&colmap[i][1],&colmap[i][2]);
        mapcolor((i+128),(i*2),(i*2),(i*2));
    }
    }
    else /* do the normal thing */
        RGBmode();
    gconfig();

    qdevice( ESCKEY );
    qdevice ( WINQUIT );
    qdevice( REDRAW );
    unqdevice( INPUTCHANGE );   /* We don`t pay attention to these. */

    if ( !gt )      /* Disable panning when in gt rectangle mode. */
    {
    qdevice( LEFTMOUSE );   /* Pan the image under mouse control. */
    qdevice( LEFTALTKEY );  /* Reset panning. */
    qdevice( RIGHTALTKEY );
    qdevice( F9KEY );
    }

    /* There was a redraw event sent when the window was created,
     * but we weren`t listening for them yet.
     */
    qenter( REDRAW, window_number );
}

/* 
 * Track events & redraw image when necessary.
 */
update_pic()
{
    short data;
    long event;
    long window_x_size, window_y_size, window_x_origin, window_y_origin;
    int x_min, x_max, y_min, y_max, x_start, y_start, x_end, y_end, x_len;
    long x_origin, y_origin, new_x_center, new_y_center;
    int x_center, y_center, saved_x_center, saved_y_center;

    register int y;
    register unsigned char *y_ptr;

    /* Looking at the center, at first. */
    x_center = saved_x_center = x_size / 2;
    y_center = saved_y_center = y_size / 2;

    /* Redraw the window when necessary. */
    while ( TRUE )
    {
        event = qread( &data );
# ifdef DEBUG
    printf( "event %d, data %d\n", event, data );
#endif
    switch ( event )
    {
        case ESCKEY:
            case WINQUIT:
                if(bitsavail==0) /* restore colormap */
                    for(i=0;i<=127;i++)
                        mapcolor((i+128),colmap[i][0],colmap[i][1],colmap[i][2]);
        gexit();
        exit(0);
        break;
        case REDRAW:
        winset( window_number );
        reshapeviewport();

        if ( gt )
        {
            /* On a GT, just blast out the whole rectangle.  If the
             * origin is off the screen to the left, it kills the
             * window server.  Could duplicate the slow output logic
             * below, but avoid the complication for now...
             */
            getorigin( &x_origin, &y_origin );
            if ( x_origin < 0 )
            {
            RGBcolor( 128, 128, 128 );  /* Punt. */
            clear();
            }
            else
            lrectwrite( 0, 0, x_size-1, y_size-1, rect_image );
        }
        else
        {
            /* Do panning in a resizable window.  (Slow mode.) */
            RGBcolor( 128, 128, 128 );
            clear();

            /* Lower left corner of screen, in image coordinates.
             * (Keep the center of the image in the center of the
             * window.)
             */
            getsize( &window_x_size, &window_y_size );
            x_min = x_center - window_x_size/2;
            x_max = x_min + (window_x_size-1);
            y_min = y_center - window_y_size/2;
            y_max = y_min + (window_y_size-1);

            /* Coordinate bounds have half a pixel added all around. */
            ortho2( x_min - .5, x_max + .5, y_min - .5, y_max + .5 );

            /* Draw just the part of the image in the window. */
            x_start = MAX( x_min, 0 );
            y_start = MAX( y_min, 0 );
            x_end = MIN( x_max, x_size-1 );
            y_end = MIN( y_max, y_size-1 );
            x_len = x_end - x_start + 1;

            /* Dump the scanlines.  Check once in a while for another
             * redraw event queued up, and quit early if one is seen.
             */
            y_ptr = rgb_image + y_start*x_size*3 + x_start;
            for ( y = y_start;
              y <= y_end && (y%16 != 0 || qtest() != REDRAW);
              y++, y_ptr += x_size * 3 )
            {
            cmov2i( x_start, y );
            writeRGB( x_len,
                  y_ptr, y_ptr + x_size, y_ptr + x_size * 2 );
            }
        }
        break;

        /* Alt key - Reset viewing to look at the center of the image.
         * Shift-Alt - Restores a saved view center.
         * Control-alt - Saves the current view center for Shift-Setup.
         * F9 is the same as the Alt keys.
         */
        case LEFTALTKEY:
        case RIGHTALTKEY:
        case F9KEY:
        if ( data == 1 )    /* Ignore button up events. */
        {
            if ( getbutton(RIGHTSHIFTKEY) || getbutton(LEFTSHIFTKEY) )
            {
            x_center = saved_x_center;  /* Restore. */
            y_center = saved_y_center;
            qenter( REDRAW, window_number );
            }
            else if ( getbutton(CTRLKEY) )
            {
            saved_x_center = x_center;  /* Save. */
            saved_y_center = y_center;
            }
            else
            {
            x_center = x_size / 2;      /* Reset. */
            y_center = y_size / 2;
            qenter( REDRAW, window_number );
            }

        }
        break;

        /* Pan a point picked with the left mouse button to the center
         * of attention.  Beep if cursor is not on the image.
         */
        case LEFTMOUSE:
        if ( data == 1 )    /* Ignore button up events. */
        {
            getorigin( &x_origin, &y_origin );
            new_x_center = getvaluator( MOUSEX ) - x_origin + x_min;
            new_y_center = getvaluator( MOUSEY ) - y_origin + y_min;
            if ( new_x_center >= x_start &&
             new_x_center <= x_end &&
             new_y_center >= y_start &&
             new_y_center <= y_end )
            {
            x_center = new_x_center;
            y_center = new_y_center;
            qenter( REDRAW, window_number );
            }
            else
            ringbell();
        }
        break;
    }
    }
}

/*
 * Pack a scanline into a vector of RGB longs.
 * 
 * Inputs:
 *  rgb:        Pointers to buffers containing the red, green,
 *          and blue color rows.
 *  n:      Length of row.
 *  line:       Pointer to output buffer for packed color data.
 */
pack_rect_scanline( rgb, n, line )
unsigned char *rgb[3];
int n;
long *line;
{
    register int i;
    register long *dest = line;

    if ( !bwflag )          /* Color display. */
    {
    register unsigned char *r, *g, *b;

    for ( i = 0, r = rgb[0], g = rgb[1], b = rgb[2];
          i < n; i++, r++, g++, b++ )
        /* Combine 3 8-bit colors into a long. */
        *dest++ = *r + (*g<<8) + (*b<<16);
    }
    else                /* Gray scale display. */
    {
    register unsigned char *bw;

    for ( i = 0, bw = rgb[0]; i < n; i++, bw++ )
        *dest++ = *bw + (*bw<<8) + (*bw<<16);
    }
}

/*
 * Pack a scanline into an RGB trio of vectors of bytes.
 * 
 * Inputs:
 *  rgb:        Pointers to buffers containing the red, green,
 *          and blue color rows.
 *  n:      Length of row.
 *  line:       Pointer to output buffer for packed color data.
 */
pack_rgb_scanline( rgb, n, lines )
unsigned char *rgb[3];
int n;
unsigned char *lines;
{
    int chnl;
    register int i;
    register unsigned char *src, *dest;

    for ( chnl = 0, dest = lines; chnl < 3; chnl++ )
    {
    src = rgb[ bwflag ? 0 : chnl ]; /* Use just channel 0 for greyscale. */
    for ( i = 0; i < n; i++ )
        *dest++ = *src++;
    }
}

/*
 * This routine is called only if the color map is required.  It converts
 * the 8 bit grey scale levels to 7 bit grey scale levels starting at 128
 * and going through to 255.  We can't use the full 256 grey levels to 
 * display the image because the windows and text of other applications
 * can't be seen if they are remapped to a grey scale.
 */
convertgreylevels(void)
{
    for(i=0;i<(x_size*y_size);i++)
        (*(rect_image+i)) = (((*(rect_image+i))&255)>>1)|128;
}