get4d.c File Reference

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

Include dependency graph for get4d.c:

Go to the source code of this file.

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

Functions
	main (argc, char **argv)
	get_pic (FILE *infile, char *infname)
	update_pic ()
	pack_rect_scanline (rgb, int n, long *line)
	pack_rgb_scanline (rgb, int n, unsigned char *lines)
	convertgreylevels (void)

Variables
long	window_number
int	x_size
int	y_size
int	i
int	dbg = 0
int	forkflg = 0
int	bwflag = 0
int	NoBorder = 0
int	gt
double	disp_gamma = 1.0
double	img_gamma = 0.0
short	colmap [128][3]
long	bitsavail
int	posflag = 0
int	w_xpos
int	w_ypos
int	sizeflag = 0
int	w_xsize
int	w_ysize
unsigned long *	rect_image
unsigned char *	rgb_image
rle_hdr	hdr
rle_pixel **	cmap

Macro Definition Documentation

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

Definition at line 23 of file get4d.c.

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

Definition at line 24 of file get4d.c.

Function Documentation

convertgreylevels

(

void

)

Definition at line 566 of file get4d.c.

References i, rect_image, x_size, and y_size.

{
    for(i=0;i<(x_size*y_size);i++)
        (*(rect_image+i)) = (((*(rect_image+i))&255)>>1)|128;
}

get_pic	(	FILE *	infile,
		char *	infname
	)

Definition at line 165 of file get4d.c.

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

main	(	argc	,
		char **	argv
	)

Definition at line 79 of file get4d.c.

{
    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. */
}

pack_rect_scanline	(	rgb	,
		int	n,
		long *	line
	)

Definition at line 507 of file get4d.c.

{
    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_rgb_scanline	(	rgb	,
		int	n,
		unsigned char *	lines
	)

Definition at line 542 of file get4d.c.

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

update_pic

(

)

Definition at line 347 of file get4d.c.

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

Variable Documentation

long bitsavail

Definition at line 38 of file get4d.c.

int bwflag = 0

Definition at line 32 of file get4d.c.

rle_pixel** cmap

Definition at line 47 of file get4d.c.

short colmap[128][3]

Definition at line 37 of file get4d.c.

int dbg = 0

Definition at line 30 of file get4d.c.

double disp_gamma = 1.0

Definition at line 35 of file get4d.c.

int forkflg = 0

Definition at line 31 of file get4d.c.

int gt

Definition at line 34 of file get4d.c.

rle_hdr hdr

Definition at line 46 of file get4d.c.

int i

Definition at line 29 of file get4d.c.

Referenced by convertgreylevels().

double img_gamma = 0.0

Definition at line 36 of file get4d.c.

int NoBorder = 0

Definition at line 33 of file get4d.c.

int posflag = 0

Definition at line 41 of file get4d.c.

unsigned long* rect_image

Definition at line 43 of file get4d.c.

Referenced by convertgreylevels().

unsigned char* rgb_image

Definition at line 44 of file get4d.c.

int sizeflag = 0

Definition at line 41 of file get4d.c.

int w_xpos

Definition at line 41 of file get4d.c.

int w_xsize

Definition at line 41 of file get4d.c.

int w_ypos

Definition at line 41 of file get4d.c.

int w_ysize

Definition at line 41 of file get4d.c.

long window_number

Definition at line 27 of file get4d.c.

int x_size

Definition at line 28 of file get4d.c.

int y_size

Definition at line 28 of file get4d.c.