src/common/color.c

#ifndef lint
static const char       RCSid[] = "$Id$";
#endif
/*
 *  color.c - routines for color calculations.
 *
 *  Externals declared in color.h
 */

#include "copyright.h"

#include  <stdio.h>

#include  <stdlib.h>

#include  <math.h>

#include  "color.h"

#define  MINELEN        8       /* minimum scanline length for encoding */
#define  MAXELEN        0x7fff  /* maximum scanline length for encoding */
#define  MINRUN         4       /* minimum run length */


char *
tempbuffer(len)                 /* get a temporary buffer */
unsigned int  len;
{
        static char  *tempbuf = NULL;
        static unsigned  tempbuflen = 0;

        if (len > tempbuflen) {
                if (tempbuflen > 0)
                        tempbuf = (char *)realloc(tempbuf, len);
                else
                        tempbuf = (char *)malloc(len);
                tempbuflen = tempbuf==NULL ? 0 : len;
        }
        return(tempbuf);
}


int
fwritecolrs(scanline, len, fp)          /* write out a colr scanline */
register COLR  *scanline;
int  len;
register FILE  *fp;
{
        register int  i, j, beg, cnt = 1;
        int  c2;
        
        if (len < MINELEN | len > MAXELEN)      /* OOBs, write out flat */
                return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
                                        /* put magic header */
        putc(2, fp);
        putc(2, fp);
        putc(len>>8, fp);
        putc(len&255, fp);
                                        /* put components seperately */
        for (i = 0; i < 4; i++) {
            for (j = 0; j < len; j += cnt) {    /* find next run */
                for (beg = j; beg < len; beg += cnt) {
                    for (cnt = 1; cnt < 127 && beg+cnt < len &&
                            scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
                        ;
                    if (cnt >= MINRUN)
                        break;                  /* long enough */
                }
                if (beg-j > 1 && beg-j < MINRUN) {
                    c2 = j+1;
                    while (scanline[c2++][i] == scanline[j][i])
                        if (c2 == beg) {        /* short run */
                            putc(128+beg-j, fp);
                            putc(scanline[j][i], fp);
                            j = beg;
                            break;
                        }
                }
                while (j < beg) {               /* write out non-run */
                    if ((c2 = beg-j) > 128) c2 = 128;
                    putc(c2, fp);
                    while (c2--)
                        putc(scanline[j++][i], fp);
                }
                if (cnt >= MINRUN) {            /* write out run */
                    putc(128+cnt, fp);
                    putc(scanline[beg][i], fp);
                } else
                    cnt = 0;
            }
        }
        return(ferror(fp) ? -1 : 0);
}


static int
oldreadcolrs(scanline, len, fp)         /* read in an old colr scanline */
register COLR  *scanline;
int  len;
register FILE  *fp;
{
        int  rshift;
        register int  i;
        
        rshift = 0;
        
        while (len > 0) {
                scanline[0][RED] = getc(fp);
                scanline[0][GRN] = getc(fp);
                scanline[0][BLU] = getc(fp);
                scanline[0][EXP] = getc(fp);
                if (feof(fp) || ferror(fp))
                        return(-1);
                if (scanline[0][RED] == 1 &&
                                scanline[0][GRN] == 1 &&
                                scanline[0][BLU] == 1) {
                        for (i = scanline[0][EXP] << rshift; i > 0; i--) {
                                copycolr(scanline[0], scanline[-1]);
                                scanline++;
                                len--;
                        }
                        rshift += 8;
                } else {
                        scanline++;
                        len--;
                        rshift = 0;
                }
        }
        return(0);
}


int
freadcolrs(scanline, len, fp)           /* read in an encoded colr scanline */
register COLR  *scanline;
int  len;
register FILE  *fp;
{
        register int  i, j;
        int  code, val;
                                        /* determine scanline type */
        if (len < MINELEN | len > MAXELEN)
                return(oldreadcolrs(scanline, len, fp));
        if ((i = getc(fp)) == EOF)
                return(-1);
        if (i != 2) {
                ungetc(i, fp);
                return(oldreadcolrs(scanline, len, fp));
        }
        scanline[0][GRN] = getc(fp);
        scanline[0][BLU] = getc(fp);
        if ((i = getc(fp)) == EOF)
                return(-1);
        if (scanline[0][GRN] != 2 || scanline[0][BLU] & 128) {
                scanline[0][RED] = 2;
                scanline[0][EXP] = i;
                return(oldreadcolrs(scanline+1, len-1, fp));
        }
        if ((scanline[0][BLU]<<8 | i) != len)
                return(-1);             /* length mismatch! */
                                        /* read each component */
        for (i = 0; i < 4; i++)
            for (j = 0; j < len; ) {
                if ((code = getc(fp)) == EOF)
                    return(-1);
                if (code > 128) {       /* run */
                    code &= 127;
                    if ((val = getc(fp)) == EOF)
                        return -1;
                    while (code--)
                        scanline[j++][i] = val;
                } else                  /* non-run */
                    while (code--) {
                        if ((val = getc(fp)) == EOF)
                            return -1;
                        scanline[j++][i] = val;
                    }
            }
        return(0);
}


int
fwritescan(scanline, len, fp)           /* write out a scanline */
register COLOR  *scanline;
int  len;
FILE  *fp;
{
        COLR  *clrscan;
        int  n;
        register COLR  *sp;
                                        /* get scanline buffer */
        if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
                return(-1);
        clrscan = sp;
                                        /* convert scanline */
        n = len;
        while (n-- > 0) {
                setcolr(sp[0], scanline[0][RED],
                                  scanline[0][GRN],
                                  scanline[0][BLU]);
                scanline++;
                sp++;
        }
        return(fwritecolrs(clrscan, len, fp));
}


int
freadscan(scanline, len, fp)            /* read in a scanline */
register COLOR  *scanline;
int  len;
FILE  *fp;
{
        register COLR  *clrscan;

        if ((clrscan = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
                return(-1);
        if (freadcolrs(clrscan, len, fp) < 0)
                return(-1);
                                        /* convert scanline */
        colr_color(scanline[0], clrscan[0]);
        while (--len > 0) {
                scanline++; clrscan++;
                if (clrscan[0][RED] == clrscan[-1][RED] &&
                            clrscan[0][GRN] == clrscan[-1][GRN] &&
                            clrscan[0][BLU] == clrscan[-1][BLU] &&
                            clrscan[0][EXP] == clrscan[-1][EXP])
                        copycolor(scanline[0], scanline[-1]);
                else
                        colr_color(scanline[0], clrscan[0]);
        }
        return(0);
}


void
setcolr(clr, r, g, b)           /* assign a short color value */
register COLR  clr;
double  r, g, b;
{
        double  d;
        int  e;
        
        d = r > g ? r : g;
        if (b > d) d = b;

        if (d <= 1e-32) {
                clr[RED] = clr[GRN] = clr[BLU] = 0;
                clr[EXP] = 0;
                return;
        }

        d = frexp(d, &e) * 255.9999 / d;

        if (r > 0.0)
                clr[RED] = r * d;
        else
                clr[RED] = 0;
        if (g > 0.0)
                clr[GRN] = g * d;
        else
                clr[GRN] = 0;
        if (b > 0.0)
                clr[BLU] = b * d;
        else
                clr[BLU] = 0;

        clr[EXP] = e + COLXS;
}


void
colr_color(col, clr)            /* convert short to float color */
register COLOR  col;
register COLR  clr;
{
        double  f;
        
        if (clr[EXP] == 0)
                col[RED] = col[GRN] = col[BLU] = 0.0;
        else {
                f = ldexp(1.0, (int)clr[EXP]-(COLXS+8));
                col[RED] = (clr[RED] + 0.5)*f;
                col[GRN] = (clr[GRN] + 0.5)*f;
                col[BLU] = (clr[BLU] + 0.5)*f;
        }
}


int
bigdiff(c1, c2, md)                     /* c1 delta c2 > md? */
register COLOR  c1, c2;
double  md;
{
        register int  i;

        for (i = 0; i < 3; i++)
                if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) ||
                        colval(c2,i)-colval(c1,i) > md*colval(c1,i))
                        return(1);
        return(0);
}
Revision:	2.11
Committed:	Mon Apr 7 15:43:08 2003 UTC (21 years ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.10:	+13 -3 lines
Log Message:	Updated man pages and fixed ages old bug in conversion of negative colors
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.9	static const char RCSid[] = "$Id$";
3	greg	1.1	#endif
4			/*
5			* color.c - routines for color calculations.
6			*
7	greg	2.9	* Externals declared in color.h
8			*/
9
10	greg	2.10	#include "copyright.h"
11	greg	1.1
12			#include <stdio.h>
13
14	greg	2.9	#include <stdlib.h>
15
16	greg	2.7	#include <math.h>
17
18	greg	1.1	#include "color.h"
19
20	greg	1.14	#define MINELEN 8 /* minimum scanline length for encoding */
21	greg	2.6	#define MAXELEN 0x7fff /* maximum scanline length for encoding */
22	greg	1.14	#define MINRUN 4 /* minimum run length */
23
24	greg	2.4
25	greg	1.14	char *
26			tempbuffer(len) /* get a temporary buffer */
27	greg	2.9	unsigned int len;
28	greg	1.14	{
29			static char *tempbuf = NULL;
30	greg	2.5	static unsigned tempbuflen = 0;
31	greg	1.14
32			if (len > tempbuflen) {
33			if (tempbuflen > 0)
34	greg	2.9	tempbuf = (char *)realloc(tempbuf, len);
35	greg	1.14	else
36	greg	2.9	tempbuf = (char *)malloc(len);
37	greg	1.14	tempbuflen = tempbuf==NULL ? 0 : len;
38			}
39			return(tempbuf);
40			}
41
42
43	greg	2.9	int
44	greg	1.1	fwritecolrs(scanline, len, fp) /* write out a colr scanline */
45			register COLR *scanline;
46	greg	2.9	int len;
47	greg	1.1	register FILE *fp;
48			{
49	greg	2.9	register int i, j, beg, cnt = 1;
50	greg	1.14	int c2;
51	greg	1.1
52	greg	2.5	if (len < MINELEN \| len > MAXELEN) /* OOBs, write out flat */
53	greg	1.14	return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
54	greg	2.2	/* put magic header */
55			putc(2, fp);
56	greg	1.14	putc(2, fp);
57			putc(len>>8, fp);
58			putc(len&255, fp);
59			/* put components seperately */
60			for (i = 0; i < 4; i++) {
61			for (j = 0; j < len; j += cnt) { /* find next run */
62			for (beg = j; beg < len; beg += cnt) {
63			for (cnt = 1; cnt < 127 && beg+cnt < len &&
64			scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
65			;
66			if (cnt >= MINRUN)
67			break; /* long enough */
68	greg	1.1	}
69	greg	1.15	if (beg-j > 1 && beg-j < MINRUN) {
70			c2 = j+1;
71			while (scanline[c2++][i] == scanline[j][i])
72			if (c2 == beg) { /* short run */
73			putc(128+beg-j, fp);
74			putc(scanline[j][i], fp);
75			j = beg;
76			break;
77			}
78			}
79			while (j < beg) { /* write out non-run */
80	greg	1.14	if ((c2 = beg-j) > 128) c2 = 128;
81			putc(c2, fp);
82			while (c2--)
83			putc(scanline[j++][i], fp);
84			}
85			if (cnt >= MINRUN) { /* write out run */
86			putc(128+cnt, fp);
87			putc(scanline[beg][i], fp);
88			} else
89			cnt = 0;
90			}
91	greg	1.1	}
92			return(ferror(fp) ? -1 : 0);
93			}
94
95
96	greg	2.9	static int
97			oldreadcolrs(scanline, len, fp) /* read in an old colr scanline */
98			register COLR *scanline;
99			int len;
100			register FILE *fp;
101			{
102			int rshift;
103			register int i;
104
105			rshift = 0;
106
107			while (len > 0) {
108			scanline[0][RED] = getc(fp);
109			scanline[0][GRN] = getc(fp);
110			scanline[0][BLU] = getc(fp);
111			scanline[0][EXP] = getc(fp);
112			if (feof(fp) \|\| ferror(fp))
113			return(-1);
114			if (scanline[0][RED] == 1 &&
115			scanline[0][GRN] == 1 &&
116			scanline[0][BLU] == 1) {
117			for (i = scanline[0][EXP] << rshift; i > 0; i--) {
118			copycolr(scanline[0], scanline[-1]);
119			scanline++;
120			len--;
121			}
122			rshift += 8;
123			} else {
124			scanline++;
125			len--;
126			rshift = 0;
127			}
128			}
129			return(0);
130			}
131
132
133			int
134	greg	1.14	freadcolrs(scanline, len, fp) /* read in an encoded colr scanline */
135	greg	1.1	register COLR *scanline;
136			int len;
137			register FILE *fp;
138			{
139	greg	1.14	register int i, j;
140	greg	2.6	int code, val;
141	greg	1.14	/* determine scanline type */
142	greg	2.5	if (len < MINELEN \| len > MAXELEN)
143	greg	1.14	return(oldreadcolrs(scanline, len, fp));
144			if ((i = getc(fp)) == EOF)
145			return(-1);
146			if (i != 2) {
147			ungetc(i, fp);
148			return(oldreadcolrs(scanline, len, fp));
149			}
150			scanline[0][GRN] = getc(fp);
151			scanline[0][BLU] = getc(fp);
152			if ((i = getc(fp)) == EOF)
153			return(-1);
154			if (scanline[0][GRN] != 2 \|\| scanline[0][BLU] & 128) {
155			scanline[0][RED] = 2;
156			scanline[0][EXP] = i;
157			return(oldreadcolrs(scanline+1, len-1, fp));
158			}
159			if ((scanline[0][BLU]<<8 \| i) != len)
160			return(-1); /* length mismatch! */
161			/* read each component */
162			for (i = 0; i < 4; i++)
163			for (j = 0; j < len; ) {
164			if ((code = getc(fp)) == EOF)
165			return(-1);
166			if (code > 128) { /* run */
167	greg	2.6	code &= 127;
168	greg	2.9	if ((val = getc(fp)) == EOF)
169			return -1;
170	greg	2.6	while (code--)
171			scanline[j++][i] = val;
172	greg	1.14	} else /* non-run */
173	greg	2.9	while (code--) {
174			if ((val = getc(fp)) == EOF)
175			return -1;
176			scanline[j++][i] = val;
177			}
178	greg	1.14	}
179	greg	1.1	return(0);
180			}
181
182
183	greg	2.9	int
184	greg	1.1	fwritescan(scanline, len, fp) /* write out a scanline */
185			register COLOR *scanline;
186			int len;
187	greg	1.14	FILE *fp;
188	greg	1.1	{
189	greg	1.14	COLR *clrscan;
190			int n;
191			register COLR *sp;
192			/* get scanline buffer */
193			if ((sp = (COLR )tempbuffer(lensizeof(COLR))) == NULL)
194			return(-1);
195			clrscan = sp;
196			/* convert scanline */
197			n = len;
198			while (n-- > 0) {
199			setcolr(sp[0], scanline[0][RED],
200	greg	1.1	scanline[0][GRN],
201			scanline[0][BLU]);
202			scanline++;
203	greg	1.14	sp++;
204	greg	1.1	}
205	greg	1.14	return(fwritecolrs(clrscan, len, fp));
206	greg	1.1	}
207
208
209	greg	2.9	int
210	greg	1.1	freadscan(scanline, len, fp) /* read in a scanline */
211			register COLOR *scanline;
212			int len;
213	greg	1.14	FILE *fp;
214	greg	1.1	{
215	greg	1.14	register COLR *clrscan;
216
217			if ((clrscan = (COLR )tempbuffer(lensizeof(COLR))) == NULL)
218			return(-1);
219			if (freadcolrs(clrscan, len, fp) < 0)
220			return(-1);
221			/* convert scanline */
222			colr_color(scanline[0], clrscan[0]);
223			while (--len > 0) {
224			scanline++; clrscan++;
225			if (clrscan[0][RED] == clrscan[-1][RED] &&
226			clrscan[0][GRN] == clrscan[-1][GRN] &&
227			clrscan[0][BLU] == clrscan[-1][BLU] &&
228			clrscan[0][EXP] == clrscan[-1][EXP])
229			copycolor(scanline[0], scanline[-1]);
230			else
231			colr_color(scanline[0], clrscan[0]);
232	greg	1.1	}
233			return(0);
234			}
235
236
237	greg	2.9	void
238	greg	1.1	setcolr(clr, r, g, b) /* assign a short color value */
239			register COLR clr;
240			double r, g, b;
241			{
242			double d;
243			int e;
244
245			d = r > g ? r : g;
246			if (b > d) d = b;
247
248	greg	1.4	if (d <= 1e-32) {
249	greg	1.1	clr[RED] = clr[GRN] = clr[BLU] = 0;
250			clr[EXP] = 0;
251			return;
252			}
253
254	greg	2.8	d = frexp(d, &e) * 255.9999 / d;
255	greg	1.1
256	greg	2.11	if (r > 0.0)
257			clr[RED] = r * d;
258			else
259			clr[RED] = 0;
260			if (g > 0.0)
261			clr[GRN] = g * d;
262			else
263			clr[GRN] = 0;
264			if (b > 0.0)
265			clr[BLU] = b * d;
266			else
267			clr[BLU] = 0;
268
269	greg	1.1	clr[EXP] = e + COLXS;
270			}
271
272
273	greg	2.9	void
274	greg	1.1	colr_color(col, clr) /* convert short to float color */
275			register COLOR col;
276			register COLR clr;
277			{
278	greg	1.6	double f;
279	greg	1.1
280			if (clr[EXP] == 0)
281			col[RED] = col[GRN] = col[BLU] = 0.0;
282			else {
283	greg	1.2	f = ldexp(1.0, (int)clr[EXP]-(COLXS+8));
284	greg	1.1	col[RED] = (clr[RED] + 0.5)*f;
285			col[GRN] = (clr[GRN] + 0.5)*f;
286			col[BLU] = (clr[BLU] + 0.5)*f;
287			}
288	greg	1.6	}
289
290
291	greg	2.9	int
292	greg	1.7	bigdiff(c1, c2, md) /* c1 delta c2 > md? */
293			register COLOR c1, c2;
294			double md;
295			{
296			register int i;
297
298			for (i = 0; i < 3; i++)
299			if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) \|\|
300			colval(c2,i)-colval(c1,i) > md*colval(c1,i))
301			return(1);
302			return(0);
303			}