rletocgm.c File Reference

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

Include dependency graph for rletocgm.c:

Go to the source code of this file.

Functions
static void	open_output (char *outfname)
static void	close_output ()
static void	begin_direct_page (rle_hdr *in_hdr)
static void	handle_color_table (rle_hdr *in_hdr, rle_pixel **cmap)
static void	begin_indexed_page (rle_hdr *in_hdr)
static void	end_page ()
static void	center_image (rle_hdr *in_hdr, float *px, float *py, float *qx, float *qy, float *rx, float *ry)
static void	process_indexed_page (rle_hdr *in_hdr)
static void	process_direct_page (rle_hdr *in_hdr)
	main (int argc, char **argv)

Variables
static char	rcs_id [] = "$Header: /l/spencer/src/urt/cnv/RCS/rletocgm.c,v 3.0.1.1 1992/04/30 13:59:08 spencer Exp $"
static int	verboseflag = 0

Function Documentation

static void begin_direct_page ( rle_hdr *  in_hdr )

static

Definition at line 95 of file rletocgm.c.

{
  int ierr= 0, one= 1;
  float red, green, blue;

  if (in_hdr->background) {
    red= ((float)in_hdr->bg_color[0])/255.0;
    green= ((float)in_hdr->bg_color[1])/255.0;
    blue= ((float)in_hdr->bg_color[2])/255.0;
  }
  else {
    red= 0.0;
    green= 0.0;
    blue= 0.0;
  }

  wrbegp(&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing begin page!\n");
    exit(2);
  }
  wrtcsm(&one,&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing color selection mode!\n");
    exit(2);
  }  
  wrbgdc(&red, &green, &blue, &ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing background color!\n");
    exit(2);
  }  
  wrbgpb(&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing begin picture body!\n");
    exit(2);
  }  
}

static void begin_indexed_page ( rle_hdr *  in_hdr )

static

Definition at line 195 of file rletocgm.c.

{
  int ierr= 0;
  rle_pixel **cmap;
  float red, green, blue;

  /* Load the color table, and write background color information */
  cmap= buildmap( in_hdr, 3, 0.0, 1.0 );
  if (in_hdr->background) {
    red= (float)cmap[0][in_hdr->bg_color[0]]/255.0;
    green= (float)cmap[1][in_hdr->bg_color[0]]/255.0;
    blue= (float)cmap[2][in_hdr->bg_color[0]]/255.0;
  }
  else {
    red= 0.0;
    green= 0.0;
    blue= 0.0;
  }

  /* Preliminary CGM stuff */
  wrbegp(&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing begin page!\n");
    exit(2);
  }  
  wrbgdc(&red, &green, &blue, &ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing background color!\n");
    exit(2);
  }  
  wrbgpb(&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing begin picture body!\n");
    exit(2);
  }  

  /* Produce a color table */
  handle_color_table(in_hdr, cmap);

  /* Clean up */
  free( (char *)cmap[0] );
}

static void center_image ( rle_hdr *  in_hdr, float *  px, float *  py, float *  qx, float *  qy, float *  rx, float *  ry  )

static

Definition at line 252 of file rletocgm.c.

{
  float xrange, yrange;

  xrange= (float)(in_hdr->xmax - in_hdr->xmin + 1);
  yrange= (float)(in_hdr->ymax - in_hdr->ymin + 1);
  if (xrange>=yrange) {
    *px= 0.0;
    *qx= 1.0;
    *rx= *qx;
    *py= 0.5 * (1.0 - yrange/xrange);
    *qy= 1.0 - *py;
    *ry= *py;
  }
  else {
    *py= 0.0;
    *qy= 1.0;
    *ry= *py;
    *px= 0.5 * (1.0 - xrange/yrange);
    *qx= 1.0 - *px;
    *rx= *qy;
  }
}

static void close_output ( )

static

Definition at line 83 of file rletocgm.c.

{
  int ierr= 0;

  wrtend(&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error closing output!\n");
    exit(2);
  }  
}

static void end_page ( )

static

Definition at line 240 of file rletocgm.c.

{
  int ierr= 0;

  wrendp(&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error ending output page!\n");
    exit(2);
  }    
}

static void handle_color_table ( rle_hdr *  in_hdr, rle_pixel **  cmap  )

static

Definition at line 135 of file rletocgm.c.

{
  int tablesize, i, zero= 0, ierr= 0;
  float *rarray, *garray, *barray;
  char *comstring;

  /* Calculate table size, then reset it if there is a comment to that
   * effect in the RLE file.
   */
  if (in_hdr->cmaplen) 
    tablesize= 2<<(in_hdr->cmaplen-1);
  else tablesize= 2;
  comstring= rle_getcom( "color_map_length", in_hdr );
  if (!comstring)   comstring= rle_getcom( "colormap_length", in_hdr );
  if (comstring) sscanf( comstring, "%d", &tablesize );

  if ( !(rarray= (float *)malloc( tablesize*sizeof(float) )) ) {
    fprintf(stderr,
        "rletocgm: unable to allocate %d floats for color table reds!\n",
        tablesize);
    exit(2);
  }
  if ( !(garray= (float *)malloc( tablesize*sizeof(float) )) ) {
    fprintf(stderr,
        "rletocgm: unable to allocate %d floats for color table greens!\n",
        tablesize);
    exit(2);
  }
  if ( !(barray= (float *)malloc( tablesize*sizeof(float) )) ) {
    fprintf(stderr,
        "rletocgm: unable to allocate %d floats for color table blues!\n",
        tablesize);
    exit(2);
  }

  /* Transcribe the color map into the float arrays */
  for (i=0; i<tablesize; i++) {
    rarray[i]= (float)cmap[0][i]/255.0;
    garray[i]= (float)cmap[1][i]/255.0;
    barray[i]= (float)cmap[2][i]/255.0;
  }

  /* Actually write the map */
  wrctbl(rarray, garray, barray, &zero, &tablesize, &ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing color map!\n");
    exit(2);
  }      

  /* Clean up */
  free( (char *)rarray );
  free( (char *)garray );
  free( (char *)barray );
}

main	(	int	argc,
		char **	argv
	)

Definition at line 452 of file rletocgm.c.

{
  char       *infname = NULL,
  *outfname = NULL;
  int rle_cnt, rle_err;
  int   oflag = 0, debugflag= 0;
  FILE       *outfile;
  rle_hdr in_hdr;   /* Headers for input file. */
  
  in_hdr = *rle_init_hdr( (rle_hdr *)NULL );
  if ( scanargs( argc, argv, "% o%-outfile!s d%- v%- infile%s",
        &oflag, &outfname, &debugflag, &verboseflag, &infname ) == 0 )
    exit( 1 );
  
  /* Turn on debugging if requested. */
  if (debugflag) {
    int ierr= 0;
    rle_debug(1);
    tgldbg(&ierr);
    if (ierr) fprintf(stderr,"rletocgm: couldn't set debugging!\n");
  }

  /* Open the input file.
   * The output file won't be opened until the first image header
   * has been read.  This avoids unnecessarily wiping out a
   * pre-existing file if the input is garbage.
   */
  rle_names( &in_hdr, cmd_name( argv ), infname, 0 );
  in_hdr.rle_file = rle_open_f( in_hdr.cmd, infname, "r" );
  
  /* Read images from the input file until the end of file is
   * encountered or an error occurs.
   */
  rle_cnt = 0;
  while ( (rle_err = rle_get_setup( &in_hdr )) == RLE_SUCCESS )
    {
      
      /* Open the CGM output file */
      if (rle_cnt==0) open_output(oflag ? outfname : "-");
      
      /* Count the input images. */
      rle_cnt++;
      
      /* Be verbose if requested */
      if (verboseflag) fprintf(stderr,"image %d: ",rle_cnt);

      /* Based on the number of colors in the header, select either indexed
       * or direct color processing for the images in the file.
       */
      switch (in_hdr.ncolors) {
      case 1: process_indexed_page(&in_hdr); break;
      case 3: process_direct_page(&in_hdr); break;
      default: fprintf(stderr,
               "rletocgm: %d is an invalid number of color planes!\n",
               in_hdr.ncolors);
      }
    }
  
  /* Close the CGM output file */
  close_output();
  
  /* Check for an error.  EOF or EMPTY is ok if at least one image
   * has been read.  Otherwise, print an error message.
   */
  if ( rle_cnt == 0 || (rle_err != RLE_EOF && rle_err != RLE_EMPTY) )
    rle_get_error( rle_err, in_hdr.cmd, infname );
  
  exit( 0 );
}

static void open_output ( char *  outfname )

static

Definition at line 65 of file rletocgm.c.

{
  int ierr= 0, i256= 256;
  
  wrcopn(outfname,&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error opening file <%s> for output!\n",outfname);
    exit(2);
  }
  wrmxci(&i256,&ierr);
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing to file!\n");
    exit(2);
  }
}

static void process_direct_page ( rle_hdr *  in_hdr )

static

Definition at line 346 of file rletocgm.c.

{
  int x, y;
  rle_pixel **rows;             /* Will be used for scanline storage. */
  static float *rarray= (float *)0; /* red CGM image */
  static float *garray= (float *)0; /* green CGM image */
  static float *barray= (float *)0; /* blue CGM image */
  float *rptr, *gptr, *bptr;
  static int nx, ny;            /* dimensions of image */
  float px, py, qx, qy, rx, ry; /* CGM array boundaries */
  int ierr= 0;
  
  /* Be verbose if requested */
  if (verboseflag) fprintf(stderr,"Found direct color (3 channel) page\n");
  
  /* Begin an output page */
  begin_direct_page(in_hdr);
  
  /* Calculate array boundaries */
  center_image(in_hdr, &px, &py, &qx, &qy, &rx, &ry);
  
  /* Allocate the CGM image array, if it's not already there */
  if (!rarray || 
      !(nx == in_hdr->xmax - in_hdr->xmin + 1) ||
      !(ny == in_hdr->ymax - in_hdr->ymin + 1)) {
    if (rarray) free( (char *)rarray );
    if (garray) free( (char *)garray );
    if (barray) free( (char *)barray );
    nx= in_hdr->xmax - in_hdr->xmin + 1;
    ny= in_hdr->ymax - in_hdr->ymin + 1;
    if ( !(rarray= (float *)malloc( nx*ny*sizeof(float) )) ) {
      fprintf(stderr,"rletocgm: cannot allocate %d floats for red!\n",nx*ny);
      exit(2);
    }
    if ( !(garray= (float *)malloc( nx*ny*sizeof(float) )) ) {
      fprintf(stderr,"rletocgm: cannot allocate %d floats for green!\n",nx*ny);
      exit(2);
    }
    if ( !(barray= (float *)malloc( nx*ny*sizeof(float) )) ) {
      fprintf(stderr,"rletocgm: cannot allocate %d floats for blue!\n",nx*ny);
      exit(2);
    }
  }

  /* Allocate memory into which the image scanlines can be read. */
  if ( rle_row_alloc( in_hdr, &rows ) < 0 ) {
    fprintf( stderr, "rletocgm: Unable to allocate image memory.\n" );
    exit( RLE_NO_SPACE );
  }
  
  /* Read the input image and copy it to the output file. */
  rptr= rarray;
  gptr= garray;
  bptr= barray;
  for ( y = in_hdr->ymin; y <= in_hdr->ymax; y++ )
    {
      /* Read a scanline. */
      rle_getrow( in_hdr, rows );
      
      for (x=0; x<nx; x++) {
    *rptr++= (float)rows[0][x]/255.0;
    *gptr++= (float)rows[1][x]/255.0;
    *bptr++= (float)rows[2][x]/255.0;
      }
    }
  
  /* Write the CGM cell array */
  wcladc( rarray, garray, barray, 
     &nx, &ny, &px, &py, &qx, &qy, &rx, &ry, &ierr );
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing direct color cell array!\n");
    exit(2);
  }      

  /* Protect from bad input. */
  while ( rle_getskip( in_hdr ) != 32768 );
  
  /* Free memory. */
  rle_row_free( in_hdr, rows );
  
  /* End the page */
  end_page();
}

static void process_indexed_page ( rle_hdr *  in_hdr )

static

Definition at line 279 of file rletocgm.c.

{
  int x, y;
  rle_pixel **rows;             /* Will be used for scanline storage. */
  static int *iarray= (int *)0; /* Stores the CGM integer image */
  int *iptr;
  static int nx, ny;            /* dimensions of iarray */
  float px, py, qx, qy, rx, ry; /* CGM array boundaries */
  int ierr= 0;

  /* Be verbose if requested */
  if (verboseflag) fprintf(stderr,"Found indexed color (1 channel) page\n");

  /* Begin an output page, including the color table */
  begin_indexed_page(in_hdr);
  
  /* Calculate array boundaries */
  center_image(in_hdr, &px, &py, &qx, &qy, &rx, &ry);

  /* Allocate the CGM image array, if it's not already there */
  if (!iarray || 
      !(nx == in_hdr->xmax - in_hdr->xmin + 1) ||
      !(ny == in_hdr->ymax - in_hdr->ymin + 1)) {
    if (iarray) free( (char *)iarray );
    nx= in_hdr->xmax - in_hdr->xmin + 1;
    ny= in_hdr->ymax - in_hdr->ymin + 1;
    if ( !(iarray= (int *)malloc( nx*ny*sizeof(int) )) ) {
      fprintf(stderr,"rletocgm: cannot allocate %d ints!\n",nx*ny);
      exit(2);
    }
  }

  /* Allocate memory into which the image scanlines can be read. */
  if ( rle_row_alloc( in_hdr, &rows ) < 0 ) {
    fprintf( stderr, "rletocgm: Unable to allocate image memory.\n" );
    exit( RLE_NO_SPACE );
  }
  
  /* Read the input image and copy it to the output file. */
  iptr= iarray;
  for ( y = in_hdr->ymin; y <= in_hdr->ymax; y++ )
    {
      /* Read a scanline. */
      rle_getrow( in_hdr, rows );
      
      for (x=0; x<nx; x++) *iptr++= rows[0][x];
    }
  
  /* Write the CGM cell array */
  wrtcla( iarray, &nx, &ny, &px, &py, &qx, &qy, &rx, &ry, &ierr );
  if (ierr) {
    fprintf(stderr,"rletocgm: Error writing indexed cell array!\n");
    exit(2);
  }      

  /* Protect from bad input. */
  while ( rle_getskip( in_hdr ) != 32768 );
  
  /* Free memory. */
  rle_row_free( in_hdr, rows );
  
  /* End the page */
  end_page();
}

Variable Documentation

char rcs_id[] = "$Header: /l/spencer/src/urt/cnv/RCS/rletocgm.c,v 3.0.1.1 1992/04/30 13:59:08 spencer Exp $"

static

Definition at line 31 of file rletocgm.c.

int verboseflag = 0

static

Definition at line 63 of file rletocgm.c.