src/common/color.c

/* Copyright (c) 1986 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  color.c - routines for color calculations.
 *
 *     10/10/85
 */

#include  <stdio.h>

#include  "color.h"


fwritecolrs(scanline, len, fp)          /* write out a colr scanline */
register COLR  *scanline;
int  len;
register FILE  *fp;
{
        COLR  lastcolr;
        int  rept;
        
        lastcolr[RED] = lastcolr[GRN] = lastcolr[BLU] = 1;
        lastcolr[EXP] = 0;
        rept = 0;
        
        while (len > 0) {
                if (scanline[0][EXP] == lastcolr[EXP] &&
                                scanline[0][RED] == lastcolr[RED] &&
                                scanline[0][GRN] == lastcolr[GRN] &&
                                scanline[0][BLU] == lastcolr[BLU])
                        rept++;
                else {
                        while (rept) {          /* write out count */
                                putc(1, fp);
                                putc(1, fp);
                                putc(1, fp);
                                putc(rept & 255, fp);
                                rept >>= 8;
                        }
                        putc(scanline[0][RED], fp);     /* new color */
                        putc(scanline[0][GRN], fp);
                        putc(scanline[0][BLU], fp);
                        putc(scanline[0][EXP], fp);
                        copycolr(lastcolr, scanline[0]);
                        rept = 0;
                }
                scanline++;
                len--;
        }
        while (rept) {          /* write out count */
                putc(1, fp);
                putc(1, fp);
                putc(1, fp);
                putc(rept & 255, fp);
                rept >>= 8;
        }
        return(ferror(fp) ? -1 : 0);
}


freadcolrs(scanline, len, fp)           /* read in a 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);
}


fwritescan(scanline, len, fp)           /* write out a scanline */
register COLOR  *scanline;
int  len;
register FILE  *fp;
{
        COLR  lastcolr, thiscolr;
        int  rept;
        
        lastcolr[RED] = lastcolr[GRN] = lastcolr[BLU] = 1;
        lastcolr[EXP] = 0;
        rept = 0;
        
        while (len > 0) {
                setcolr(thiscolr, scanline[0][RED],
                                  scanline[0][GRN],
                                  scanline[0][BLU]);
                if (thiscolr[EXP] == lastcolr[EXP] &&
                                thiscolr[RED] == lastcolr[RED] &&
                                thiscolr[GRN] == lastcolr[GRN] &&
                                thiscolr[BLU] == lastcolr[BLU])
                        rept++;
                else {
                        while (rept) {          /* write out count */
                                putc(1, fp);
                                putc(1, fp);
                                putc(1, fp);
                                putc(rept & 255, fp);
                                rept >>= 8;
                        }
                        putc(thiscolr[RED], fp);        /* new color */
                        putc(thiscolr[GRN], fp);
                        putc(thiscolr[BLU], fp);
                        putc(thiscolr[EXP], fp);
                        copycolr(lastcolr, thiscolr);
                        rept = 0;
                }
                scanline++;
                len--;
        }
        while (rept) {          /* write out count */
                putc(1, fp);
                putc(1, fp);
                putc(1, fp);
                putc(rept & 255, fp);
                rept >>= 8;
        }
        return(ferror(fp) ? -1 : 0);
}


freadscan(scanline, len, fp)            /* read in a scanline */
register COLOR  *scanline;
int  len;
register FILE  *fp;
{
        COLR  thiscolr;
        int  rshift;
        register int  i;
        
        rshift = 0;
        
        while (len > 0) {
                thiscolr[RED] = getc(fp);
                thiscolr[GRN] = getc(fp);
                thiscolr[BLU] = getc(fp);
                thiscolr[EXP] = getc(fp);
                if (feof(fp) || ferror(fp))
                        return(-1);
                if (thiscolr[RED] == 1 &&
                                thiscolr[GRN] == 1 &&
                                thiscolr[BLU] == 1) {
                        for (i = thiscolr[EXP] << rshift; i > 0; i--) {
                                copycolor(scanline[0], scanline[-1]);
                                scanline++;
                                len--;
                        }
                        rshift += 8;
                } else {
                        colr_color(scanline[0], thiscolr);
                        scanline++;
                        len--;
                        rshift = 0;
                }
        }
        return(0);
}


setcolr(clr, r, g, b)           /* assign a short color value */
register COLR  clr;
double  r, g, b;
{
        double  frexp();
        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) * 256.0 / d;

        clr[RED] = r * d;
        clr[GRN] = g * d;
        clr[BLU] = b * d;
        clr[EXP] = e + COLXS;
}


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


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:	1.13
Committed:	Fri Oct 19 11:13:02 1990 UTC (33 years, 6 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.12:	+0 -42 lines
Log Message:	moved normcolrs() to colrops.c
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1986 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* color.c - routines for color calculations.
9			*
10			* 10/10/85
11			*/
12
13			#include <stdio.h>
14
15			#include "color.h"
16
17	greg	1.5
18	greg	1.1	fwritecolrs(scanline, len, fp) /* write out a colr scanline */
19			register COLR *scanline;
20			int len;
21			register FILE *fp;
22			{
23			COLR lastcolr;
24			int rept;
25
26			lastcolr[RED] = lastcolr[GRN] = lastcolr[BLU] = 1;
27			lastcolr[EXP] = 0;
28			rept = 0;
29
30			while (len > 0) {
31			if (scanline[0][EXP] == lastcolr[EXP] &&
32			scanline[0][RED] == lastcolr[RED] &&
33			scanline[0][GRN] == lastcolr[GRN] &&
34			scanline[0][BLU] == lastcolr[BLU])
35			rept++;
36			else {
37			while (rept) { /* write out count */
38			putc(1, fp);
39			putc(1, fp);
40			putc(1, fp);
41			putc(rept & 255, fp);
42			rept >>= 8;
43			}
44			putc(scanline[0][RED], fp); /* new color */
45			putc(scanline[0][GRN], fp);
46			putc(scanline[0][BLU], fp);
47			putc(scanline[0][EXP], fp);
48			copycolr(lastcolr, scanline[0]);
49			rept = 0;
50			}
51			scanline++;
52			len--;
53			}
54			while (rept) { /* write out count */
55			putc(1, fp);
56			putc(1, fp);
57			putc(1, fp);
58			putc(rept & 255, fp);
59			rept >>= 8;
60			}
61			return(ferror(fp) ? -1 : 0);
62			}
63
64
65			freadcolrs(scanline, len, fp) /* read in a colr scanline */
66			register COLR *scanline;
67			int len;
68			register FILE *fp;
69			{
70			int rshift;
71			register int i;
72
73			rshift = 0;
74
75			while (len > 0) {
76			scanline[0][RED] = getc(fp);
77			scanline[0][GRN] = getc(fp);
78			scanline[0][BLU] = getc(fp);
79			scanline[0][EXP] = getc(fp);
80			if (feof(fp) \|\| ferror(fp))
81			return(-1);
82			if (scanline[0][RED] == 1 &&
83			scanline[0][GRN] == 1 &&
84			scanline[0][BLU] == 1) {
85			for (i = scanline[0][EXP] << rshift; i > 0; i--) {
86			copycolr(scanline[0], scanline[-1]);
87			scanline++;
88			len--;
89			}
90			rshift += 8;
91			} else {
92			scanline++;
93			len--;
94			rshift = 0;
95			}
96			}
97			return(0);
98			}
99
100
101			fwritescan(scanline, len, fp) /* write out a scanline */
102			register COLOR *scanline;
103			int len;
104			register FILE *fp;
105			{
106			COLR lastcolr, thiscolr;
107			int rept;
108
109			lastcolr[RED] = lastcolr[GRN] = lastcolr[BLU] = 1;
110			lastcolr[EXP] = 0;
111			rept = 0;
112
113			while (len > 0) {
114			setcolr(thiscolr, scanline[0][RED],
115			scanline[0][GRN],
116			scanline[0][BLU]);
117			if (thiscolr[EXP] == lastcolr[EXP] &&
118			thiscolr[RED] == lastcolr[RED] &&
119			thiscolr[GRN] == lastcolr[GRN] &&
120			thiscolr[BLU] == lastcolr[BLU])
121			rept++;
122			else {
123			while (rept) { /* write out count */
124			putc(1, fp);
125			putc(1, fp);
126			putc(1, fp);
127			putc(rept & 255, fp);
128			rept >>= 8;
129			}
130			putc(thiscolr[RED], fp); /* new color */
131			putc(thiscolr[GRN], fp);
132			putc(thiscolr[BLU], fp);
133			putc(thiscolr[EXP], fp);
134			copycolr(lastcolr, thiscolr);
135			rept = 0;
136			}
137			scanline++;
138			len--;
139			}
140			while (rept) { /* write out count */
141			putc(1, fp);
142			putc(1, fp);
143			putc(1, fp);
144			putc(rept & 255, fp);
145			rept >>= 8;
146			}
147			return(ferror(fp) ? -1 : 0);
148			}
149
150
151			freadscan(scanline, len, fp) /* read in a scanline */
152			register COLOR *scanline;
153			int len;
154			register FILE *fp;
155			{
156			COLR thiscolr;
157			int rshift;
158			register int i;
159
160			rshift = 0;
161
162			while (len > 0) {
163			thiscolr[RED] = getc(fp);
164			thiscolr[GRN] = getc(fp);
165			thiscolr[BLU] = getc(fp);
166			thiscolr[EXP] = getc(fp);
167			if (feof(fp) \|\| ferror(fp))
168			return(-1);
169			if (thiscolr[RED] == 1 &&
170			thiscolr[GRN] == 1 &&
171			thiscolr[BLU] == 1) {
172			for (i = thiscolr[EXP] << rshift; i > 0; i--) {
173			copycolor(scanline[0], scanline[-1]);
174			scanline++;
175			len--;
176			}
177			rshift += 8;
178			} else {
179			colr_color(scanline[0], thiscolr);
180			scanline++;
181			len--;
182			rshift = 0;
183			}
184			}
185			return(0);
186			}
187
188
189			setcolr(clr, r, g, b) /* assign a short color value */
190			register COLR clr;
191			double r, g, b;
192			{
193			double frexp();
194			double d;
195			int e;
196
197			d = r > g ? r : g;
198			if (b > d) d = b;
199
200	greg	1.4	if (d <= 1e-32) {
201	greg	1.1	clr[RED] = clr[GRN] = clr[BLU] = 0;
202			clr[EXP] = 0;
203			return;
204			}
205
206			d = frexp(d, &e) * 256.0 / d;
207
208			clr[RED] = r * d;
209			clr[GRN] = g * d;
210			clr[BLU] = b * d;
211			clr[EXP] = e + COLXS;
212			}
213
214
215			colr_color(col, clr) /* convert short to float color */
216			register COLOR col;
217			register COLR clr;
218			{
219	greg	1.6	double f;
220	greg	1.1
221			if (clr[EXP] == 0)
222			col[RED] = col[GRN] = col[BLU] = 0.0;
223			else {
224	greg	1.2	f = ldexp(1.0, (int)clr[EXP]-(COLXS+8));
225	greg	1.1	col[RED] = (clr[RED] + 0.5)*f;
226			col[GRN] = (clr[GRN] + 0.5)*f;
227			col[BLU] = (clr[BLU] + 0.5)*f;
228			}
229	greg	1.6	}
230
231
232	greg	1.7	bigdiff(c1, c2, md) /* c1 delta c2 > md? */
233			register COLOR c1, c2;
234			double md;
235			{
236			register int i;
237
238			for (i = 0; i < 3; i++)
239			if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) \|\|
240			colval(c2,i)-colval(c1,i) > md*colval(c1,i))
241			return(1);
242			return(0);
243			}