Initial commit

1 files changed, 277 insertions, 0 deletions

diff --git a/vendor/x11iraf/util/ras2text.c b/vendor/x11iraf/util/ras2text.c
new file mode 100644
index 00000000..7e490a82
--- /dev/null
+++ b/vendor/x11iraf/util/ras2text.c
@@ -0,0 +1,277 @@
+#include <stdio.h>
+#include <rasterfile.h>
+
+/*
+ * RAS2TEXT -- This is a small standalone utility program to convert a color
+ * Sun rasterfile to a printable ASCII form suitable for inclusion as an image
+ * in a GUI.  The dimensions of the raster are output, along with the RGB 
+ * colortable and the hex-encoded and optionally run length encoded pixels.
+ *
+ * Usage:	ras2text [-hex1 | -hex2] [-rle] fname
+ *
+ * The decoded Sun raster is written as text to the standard output.
+ */
+
+#define	HEX1	1
+#define	HEX2	2
+
+struct color {
+    unsigned char red, green, blue;
+};
+
+main (argc, argv)
+int argc;
+char **argv;
+{
+	register unsigned char *op;
+	register unsigned char *ip;
+	register int i, j, v;
+	struct rasterfile r;
+	struct color colors[256];
+	unsigned char red[256], green[256], blue[256];
+	unsigned char hex1[256], hex2[256*2];
+	unsigned char *data, *obuf, *cbuf;
+	int encoding, compress, debug;
+	int fd, npix, nelem, maxval, n;
+	char *fname;
+
+	fname = NULL;
+	encoding = HEX2;
+	compress = 0;
+	debug = 0;
+
+	/* Process argument list. */
+	for (i=1;  i < argc;  i++)
+	    if (argv[i][0] == '-') {
+		if (strcmp (argv[i], "-hex1") == 0)
+		    encoding = HEX1;
+		else if (strcmp (argv[i], "-hex2") == 0)
+		    encoding = HEX2;
+		else if (strcmp (argv[i], "-rle") == 0)
+		    compress++;
+		else if (strcmp (argv[i], "-d") == 0)
+		    debug++;
+		else
+		    fprintf (stderr, "unknown switch %s\n", argv[i]);
+	    } else
+		fname = argv[i];
+
+	/* Open file. */
+	if ((fd = open (fname, 0)) < 0) {
+	    fprintf (stderr, "cannot open %s\n", fname);
+	    exit (1);
+	}
+
+	/* Read file header. */
+	if (read(fd,&r,sizeof(r)) != sizeof(r) || r.ras_magic != RAS_MAGIC) {
+	    fprintf (stderr, "not a Sun rasterfile: %s\n", fname);
+	    exit (2);
+	}
+
+	/* Print header. */
+	printf ("width %d height %d depth %d\n",
+	    r.ras_width, r.ras_height, r.ras_depth);
+	
+	if (debug) {
+	    fprintf (stderr, "width=%d height=%d depth=%d length=%d type=%d\n",
+		r.ras_width, r.ras_height, r.ras_depth, r.ras_length,
+		r.ras_type);
+	    fprintf (stderr, "maptype=%d, maplength=%d\n",
+		r.ras_maptype, r.ras_maplength);
+	}
+
+	if (r.ras_type != RT_STANDARD) {
+	    fprintf (stderr, "rasterfile not in standard format\n");
+	    exit (3);
+	}
+
+	/* Read the colormap. */
+	if (n = r.ras_maplength / 3) {
+	    if (read (fd, red,   n) != n ||
+		read (fd, green, n) != n ||
+		read (fd, blue,  n) != n)  {
+
+		fprintf (stderr, "cannot read colormap\n");
+		exit (4);
+	    }
+	}
+
+	/* Read the pixels. */
+	if ((data = (unsigned char *) malloc (npix=r.ras_length)) == NULL) {
+	    fprintf (stderr, "out of memory\n");
+	    exit (5);
+	}
+	if ((npix = read(fd,data,npix)) != r.ras_length) {
+	    fprintf (stderr, "data read error\n");
+	    exit (6);
+	}
+
+	/* If bitmap convert to byte pixel array. */
+	if (r.ras_depth == 1) {
+	    unsigned char *bits = data;
+	    npix = r.ras_width * r.ras_height;
+	    if ((data = (unsigned char *) malloc (npix)) == NULL) {
+		fprintf (stderr, "out of memory\n");
+		exit (5);
+	    }
+	    for (i=0, op=data;  i < npix;  i++)
+		*op++ = !((bits[i/8] & (1 << (7 - (i % 8)))) != 0);
+
+	    free (bits);
+	}
+
+	if ((obuf = (unsigned char *) malloc (npix*2)) == NULL) {
+	    fprintf (stderr, "out of memory\n");
+	    exit (5);
+	}
+
+	/* Find largest pixel value. */
+	for (i=0, maxval=v=0;  i < npix;  i++)
+	    if (data[i] > v)
+		v = data[i];
+	maxval = v;
+	if (debug)
+	    fprintf (stderr, "max pixel value = %d\n", maxval);
+
+	/* Print the colormap. */
+	n = r.ras_maplength / 3;
+	for (i=0;  i < n;  i++) {
+	    colors[i].red = red[i];
+	    colors[i].green = green[i];
+	    colors[i].blue = blue[i];
+	}
+
+	if (n >= maxval)
+	    n = maxval + 1;
+
+	printf ("colormap (length %d) = {\n    ", nelem = n);
+	for (i=0, n=1;  i < nelem;  i++, n++) {
+	    printf ("{%3d %3d %3d}  ",
+		colors[i].red, colors[i].green, colors[i].blue);
+	    if (n && n > 4) {
+		printf ("\n    ");
+		n = 0;
+	    }
+	}
+	if (n)
+	    printf ("\n");
+	printf ("}\n");
+
+	if (r.ras_length <= 0) {
+	    fprintf (stderr, "no data\n");
+	    exit (7);
+	}
+
+	/* Print the pixels.
+	 */
+
+	/* Generate binary to hex1 (64 element) lookup table. */
+	for (n=0, op=hex1;  n < 256;  n++) {
+	    i = (n % 64);
+	    if (i < 10)
+		*op++ = i + '0';
+	    else if (i < 36)
+		*op++ = (i - 10) + 'A';
+	    else if (i < 62)
+		*op++ = (i - 36) + 'a';
+	    else if (i == 62)
+		*op++ = '$';
+	    else
+		*op++ = '_';
+	}
+
+	/* Generate binary to hex2 (256 element) lookup table. */
+	for (n=0, op=hex2;  n < 256;  n++) {
+	    i = ((n >> 4) & 017);
+	    *op++ = (i < 10) ? i + '0' : (i-10) + 'A';
+	    i = (n & 017);
+	    *op++ = (i < 10) ? i + '0' : (i-10) + 'A';
+	}
+
+	/* Hex encode the data. */
+	if (encoding == HEX1) {
+	    /* Hex1 encoding uses only one character per pixel but the
+	     * pixel range is restricted to 0 to 63.
+	     */
+	    for (j=0, ip=data, op=obuf;  j < r.ras_height;  j++) {
+		for (i=0;  i < r.ras_width;  i++)
+		    *op++ = hex1[*ip++];
+		if (r.ras_width % 2)
+		    ip++;
+	    }
+	} else if (encoding == HEX2) {
+	    /* Hex2 encoding uses 2 characters per pixel and supports
+	     * pixel values in the range 0 to 255.
+	     */
+	    for (j=0, ip=data, op=obuf;  j < r.ras_height;  j++) {
+		for (i=0;  i < r.ras_width;  i++) {
+		    v = *ip++ * 2;
+		    *op++ = hex2[v];
+		    *op++ = hex2[v+1];
+		}
+		if (r.ras_width % 2)
+		    ip++;
+	    }
+	}
+	*op = '\0';
+
+	/* Run length compress the data.  The compressed data stream
+	 * contains a mixture of literal data codes and repeat codes.
+	 * A "@" followed by a hex1-encoded number N causes the most
+	 * recent pixel value to be repeated N+1 times, where N < 64.
+	 * A "%" followed by a hex2-encoded number N causes the most
+	 * recent pixel value to be repeated N+1 times, where N < 256.
+	 */
+	if (compress) {
+	    npix = r.ras_length;
+	    if ((cbuf = (unsigned char *) malloc (npix*3)) == NULL) {
+		fprintf (stderr, "out of memory\n");
+		exit (8);
+	    }
+
+	    ip = obuf;
+	    op = cbuf;
+	    *op++ = v = *ip++;
+	    while (*ip) {
+		for (n=0;  n < 256 && *ip == v;  ip++, n++)
+		    ;
+		if (n == 0) {
+		    *op++ = v = *ip++;
+		} else if (n < 3) {
+		    while (--n >= 0)
+			*op++ = v;
+		} else if (n <= 64) {
+		    *op++ = '@';
+		    *op++ = hex1[n-1];
+		} else if (n <= 256) {
+		    *op++ = '%';
+		    *op++ = hex2[(n-1)*2];
+		    *op++ = hex2[(n-1)*2+1];
+		}
+	    }
+	    *op = '\0';
+
+	    free (obuf);
+	    obuf = cbuf;
+	}
+
+	/* Output the encoded pixel data.
+	 */
+	printf ("pixels (%s%s) = {\n    ",
+	    (encoding == HEX1) ? "hex1" : "hex2", compress ? " rle" : "");
+	for (ip=obuf, n=1;  *ip;  ip++, n++) {
+	    putchar (*ip);
+	    if (n && n > 72) {
+		printf ("\n    ");
+		n = 0;
+	    }
+	}
+	if (n)
+	    printf ("\n");
+	printf ("}\n");
+
+	free (data);
+	free (obuf);
+	close (fd);
+	exit (0);
+}