/*
 * 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.
 */
/* 
 * rlegrid.c - Generate grids and checkerboards for test images
 * 
 * Author:	James Painter
 * 		Computer Science
 * 		University of Utah
 * Date:	Tue November 20, 1990 
 * Copyright (c) 1990, University of Utah
 */
#ifndef lint
char rcsid[] = "$Header: /l/spencer/src/urt/tools/RCS/rlegrid.c,v 3.0.1.1 1992/04/30 14:12:01 spencer Exp $";
#endif
/*
rlegrid()			Tag the file.
*/

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

/*****************************************************************
 * TAG( main )
 * 
 * Generate simple grids
 *
 * Usage:
 * 	rlegrid [-o outfile] [-s xsize ysize] [-w width] [-f fb_color] 
 *              [-b bg_color][-c]
 *
 * Outputs:
 * 	-o outfile:	The output RLE file.  Default stdout.
 * 			"-" means stdout.
 * Assumptions:
 *	[None]
 * Algorithm:
 */
void
main( argc, argv )
int argc;
char **argv;
{
    char       *outfname = NULL;
    int 	oflag = 0, sflag=0, wflag=0, fflag=0, bflag=0, cflag=0;
    int         xsize=512, ysize=512, width=16, fg_color=255, bg_color=0;
    int		x,y,i;
    FILE       *outfile;
    rle_hdr out_hdr;
    rle_op **scanraw[2];	/* space for two raw scanline buffers */
    rle_op *p, *q;
    int    *nrawp[2];
    unsigned char fg, bg;

    out_hdr = *rle_hdr_init( NULL );

    if ( scanargs( argc, argv, 
 "% o%-outfile!s s%-xsize!dysize!d w%-width!d f%-fg_color!d b%-bg_color!d c%-",
		   &oflag, &outfname, 
		   &sflag, &xsize, &ysize,
		   &wflag, &width,
		   &fflag, &fg_color,
		   &bflag, &bg_color,
		  &cflag )
	     == 0 )
       exit( 1 );

    fg = fg_color;
    bg = bg_color;

    outfile = rle_open_f( cmd_name( argv ), outfname, "w" );
    
    /* Set up the output header.
     */
    (void)rle_hdr_init( &out_hdr );
    rle_names( &out_hdr, cmd_name( argv ), outfname, 0 );
    out_hdr.rle_file = outfile;
    out_hdr.xmax = xsize -1;
    out_hdr.ymax = ysize -1;
    out_hdr.ncolors = 1;
    out_hdr.alpha = 0;


    /* Add to the history comment. */
    rle_addhist( argv, (rle_hdr *)0, &out_hdr );

    /* Write the output image header. */
    rle_put_setup( &out_hdr );


    /* Allocate memory into which the image scanlines can be read.
     */
    if ( rle_raw_alloc( &out_hdr, scanraw+0, nrawp+0 ) < 0  ||
	 rle_raw_alloc( &out_hdr, scanraw+1, nrawp+1 ) < 0 )
	RLE_CHECK_ALLOC( cmd_name( argv ), 0, "image memory" );

    /* Fill the scan lines */
    if (cflag)
      {
	/* checkerboard option */
	p = scanraw[0][0];
	q = scanraw[1][0];
	*nrawp[0] = *nrawp[1] = 0;
	for(x=0; x<xsize;x+=2*width)
	  {
	    p->opcode = RRunDataOp;
	    p->xloc = x;
	    p->length = width;
	    *q = *p;	
	    p->u.run_val = fg_color;
	    q->u.run_val = bg_color;
	    (*nrawp[0])++; (*nrawp[1])++;
	    
	    p++; q++;
	    p->opcode = RRunDataOp;
	    p->xloc = x+width;
	    p->length = (x+width < xsize) ? width : (xsize-x);
	    *q = *p;
	    p->u.run_val = bg_color;
	    q->u.run_val = fg_color;
	    (*nrawp[0])++; (*nrawp[1])++;
	    p++; q++;
	  }
      }
    else
      {  /* default: grid */

	p = scanraw[0][0];
	p->opcode = RRunDataOp;
	p->xloc = 0;
	p->length = xsize;
	p->u.run_val = fg_color;
	*nrawp[0] = 1;

	/* grided scanline */
	p = scanraw[1][0];
	*nrawp[1] = 0;
	for(x=0; x<xsize;x+=width)
	  {
	    p->opcode = RByteDataOp;
	    p->xloc = x;
	    p->length = 1;
	    p->u.pixels = (rle_pixel *) &fg;
	    (*nrawp[1])++;
	    
	    p++;
	    p->opcode = RRunDataOp;
	    p->xloc = x+1;
	    p->length = (x+width < xsize) ? width-1 : (xsize-x);
	    p->u.run_val = bg_color;
	    (*nrawp[1])++;
	    p++;
	  }
      }

    /* write the output file */
    for ( y = 0; y < ysize; y++ )
      {
	i = (cflag) ? ((y/width) %2) : ((y %width) != 0);
	rle_putraw( scanraw[i], nrawp[i], &out_hdr );
      }

    /* Free memory. */
    rle_raw_free( &out_hdr, scanraw[0], nrawp[0] );
    rle_raw_free( &out_hdr, scanraw[1], nrawp[1] );

    /* Write an end-of-image code. */
    rle_puteof( &out_hdr );

    exit( 0 );
}