ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/color.c
(Generate patch)

Comparing ray/src/common/color.c (file contents):
Revision 1.14 by greg, Fri Aug 23 12:33:49 1991 UTC vs.
Revision 2.32 by greg, Thu Dec 7 23:16:58 2023 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1991 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  color.c - routines for color calculations.
6   *
7 < *     10/10/85
7 > *  Externals declared in color.h
8   */
9  
10 < #include  <stdio.h>
10 > #include "copyright.h"
11  
12 + #include  <stdio.h>
13 + #include  <stdlib.h>
14 + #include  <math.h>
15   #include  "color.h"
16  
17 + #ifdef getc_unlocked            /* avoid horrendous overhead of flockfile */
18 + #undef getc
19 + #undef putc
20 + #undef ferror
21 + #define getc    getc_unlocked
22 + #define putc    putc_unlocked
23 + #define ferror  ferror_unlocked
24 + #endif
25 +
26   #define  MINELEN        8       /* minimum scanline length for encoding */
27 + #define  MAXELEN        0x7fff  /* maximum scanline length for encoding */
28   #define  MINRUN         4       /* minimum run length */
29  
30  
31 < char *
32 < tempbuffer(len)                 /* get a temporary buffer */
33 < unsigned  len;
31 > int  CNDX[4] = {0,1,2,3};       /* RGBE indices for SCOLOR, SCOLR */
32 > float  WLPART[4] = {780,588,480,380};   /* RGB wavelength limits+partitions (nm) */
33 >
34 >
35 > int
36 > setspectrsamp(                  /* assign spectral sampling, 1 if good, -1 if bad */
37 >        int cn[4],              /* input cn[3]=nsamps */
38 >        float wlpt[4]           /* input wlpt[0],wlpt[3]=extrema */
39 > )
40   {
41 <        extern char  *malloc(), *realloc();
42 <        static char  *tempbuf = NULL;
27 <        static int  tempbuflen = 0;
41 >        static const float      PKWL[3] = {607, 553, 469};
42 >        int                     i, j;
43  
44 <        if (len > tempbuflen) {
45 <                if (tempbuflen > 0)
46 <                        tempbuf = realloc(tempbuf, len);
44 >        if (cn[3] < 3)
45 >                return(-1);             /* reject this */
46 >
47 >        if (wlpt[0] < wlpt[3]) {
48 >                float   tf = wlpt[0];
49 >                wlpt[0] = wlpt[3]; wlpt[3] = tf;
50 >        }
51 >        if (wlpt[0] - wlpt[3] < 50.f)
52 >                return(-1);             /* also reject */
53 >
54 >        if (cn[3] > MAXCSAMP)
55 >                cn[3] = MAXCSAMP;
56 >
57 >        if ((wlpt[3] >= PKWL[2]) | (wlpt[0] <= PKWL[0])) {
58 >                wlpt[1] = wlpt[0] + 0.333333f*(wlpt[3]-wlpt[0]);
59 >                wlpt[2] = wlpt[0] + 0.666667f*(wlpt[3]-wlpt[0]);
60 >                cn[0] = 0; cn[1] = cn[3]/3; cn[2] = cn[3]*2/3;
61 >                return(0);              /* unhappy but non-fatal return value */
62 >        }
63 >        wlpt[1] = 588.f;                /* tuned for standard green channel */
64 >        wlpt[2] = 480.f;
65 >        if (cn[3] == 3) {               /* nothing to tune? */
66 >                cn[0] = 0; cn[1] = 1; cn[2] = 2;
67 >        } else {                        /* else find nearest color indices */
68 >                double  curwl[3];
69 >                memset(curwl, 0, sizeof(curwl));
70 >                for (i = cn[3]; i--; ) {
71 >                        const float     cwl = (i+.5f)/cn[3]*(wlpt[3]-wlpt[0]) + wlpt[0];
72 >                        for (j = 3; j--; )
73 >                                if (fabs(cwl - PKWL[j]) < fabs(curwl[j] - PKWL[j])) {
74 >                                        curwl[j] = cwl;
75 >                                        cn[j] = i;
76 >                                }
77 >                }
78 >        }
79 >        return(1);                      /* happy return value */
80 > }
81 >
82 >
83 > void
84 > setscolor(                      /* assign spectral color from RGB */
85 >        SCOLOR scol,
86 >        double r,
87 >        double g,
88 >        double b
89 > )
90 > {
91 >        const double    step = (WLPART[3] - WLPART[0])/(double)NCSAMP;
92 >        double          cwl = WLPART[0] + .5*step;
93 >        int             i;
94 >
95 >        for (i = 0; i < NCSAMP; i++) {
96 >                if (cwl >= WLPART[1])
97 >                        scol[i] = r;
98 >                else if (cwl >= WLPART[2])
99 >                        scol[i] = g;
100                  else
101 <                        tempbuf = malloc(len);
102 <                tempbuflen = tempbuf==NULL ? 0 : len;
101 >                        scol[i] = b;
102 >                cwl += step;
103          }
104 + }
105 +
106 +
107 + void
108 + scolor2color(                   /* assign RGB color from spectrum */
109 +        COLOR col,
110 +        SCOLOR scol,            /* uses average over bands */
111 +        int ncs,
112 +        const float wlpt[4]
113 + )
114 + {
115 +        const double    step = (wlpt[3] - wlpt[0])/(double)ncs;
116 +        double          cwl = wlpt[0] + .5*step;
117 +        int             i, j=0, n=0;
118 +
119 +        setcolor(col, 0, 0, 0);
120 +        for (i = 0; i < ncs; i++) {
121 +                if (cwl < wlpt[j+1]) {
122 +                        if (n > 1) col[j] /= (COLORV)n;
123 +                        j++;
124 +                        n = 0;
125 +                }
126 +                col[j] += scol[i];
127 +                n++;
128 +                cwl += step;
129 +        }
130 +        if (n > 1) col[j] /= (COLORV)n;
131 + }
132 +
133 +
134 + void
135 + scolor2colr(                    /* assign RGBE from spectral color */
136 +        COLR clr,
137 +        SCOLOR scol,            /* uses average over bands */
138 +        int ncs,
139 +        const float wlpt[4]
140 + )
141 + {
142 +        COLOR   col;
143 +
144 +        scolor2color(col, scol, ncs, wlpt);
145 +        setcolr(clr, col[RED], col[GRN], col[BLU]);
146 + }
147 +
148 +
149 + void
150 + scolor2scolr(                   /* float spectrum to common exponent */
151 +        SCOLR sclr,
152 +        SCOLOR scol,
153 +        int ncs
154 + )
155 + {
156 +        int     i = ncs;
157 +        COLORV  p = scol[--i];
158 +
159 +        while (i)
160 +                if (scol[--i] > p)
161 +                        p = scol[i];
162 +        if (p <= 1e-32) {
163 +                memset(sclr, 0, ncs+1);
164 +                return;
165 +        }
166 +        p = frexp(p, &i) * 256.0 / p;
167 +        sclr[ncs] = i + COLXS;
168 +        for (i = ncs; i--; )
169 +                sclr[i] = (scol[i] > 0) * (int)(scol[i]*p);
170 + }
171 +
172 +
173 + void
174 + scolr2scolor(                   /* common exponent to float spectrum */
175 +        SCOLOR scol,
176 +        SCOLR sclr,
177 +        int ncs
178 + )
179 + {
180 +        double  f;
181 +        int     i;
182 +
183 +        if (sclr[ncs] == 0) {
184 +                memset(scol, 0, sizeof(COLORV)*ncs);
185 +                return;
186 +        }
187 +        f = ldexp(1.0, (int)sclr[ncs]-(COLXS+8));
188 +
189 +        for (i = ncs; i--; )
190 +                scol[i] = (sclr[i] + 0.5)*f;
191 + }
192 +
193 +
194 + double
195 + scolor_mean(                    /* compute average for spectral color */
196 +        SCOLOR  scol
197 + )
198 + {
199 +        int     i = NCSAMP;
200 +        double  sum = 0;
201 +
202 +        while (i--)
203 +                sum += scol[i];
204 +
205 +        return sum/(double)NCSAMP;
206 + }
207 +
208 +
209 + double
210 + sintens(                        /* find maximum value from spectrum */
211 +        SCOLOR  scol
212 + )
213 + {
214 +        int     i = NCSAMP;
215 +        COLORV  peak = scol[--i];
216 +
217 +        while (i)
218 +                if (scol[--i] > peak)
219 +                        peak = scol[i];
220 +
221 +        return peak;
222 + }
223 +
224 +
225 + void
226 + convertscolor(                  /* spectrum conversion, zero-fill ends */
227 +        SCOLOR dst,             /* destination spectrum */
228 +        int dnc,                /* destination # of spectral samples/intervals */
229 +        double dwl0,            /* starting destination wavelength (longer) */
230 +        double dwl1,            /* ending destination wavelength (shorter) */
231 +        const COLORV src[],     /* source spectrum array */
232 +        int snc,
233 +        double swl0,            /* long/short wavelengths may be reversed */
234 +        double swl1
235 + )
236 + {
237 +        const int       sdir = 1 - 2*(swl0 < swl1);
238 +        const double    sstp = (swl1 - swl0)/(double)snc;
239 +        const double    dstp = (dwl1 - dwl0)/(double)dnc;
240 +        const double    rdstp = 1./dstp;
241 +        int             si, ssi, di;
242 +        double          wl;
243 +
244 +        if ((dnc < 3) | (dwl0 <= dwl1) | (dst == src))
245 +                return;         /* invalid destination */
246 +
247 +        if (dnc == snc && (dwl0-swl0)*(dwl0-swl0) + (dwl1-swl1)*(dwl1-swl1) <= .5) {
248 +                memcpy(dst, src, sizeof(COLORV)*dnc);
249 +                return;         /* same spectral sampling */
250 +        }
251 +        memset(dst, 0, sizeof(COLORV)*dnc);
252 +                                /* set starting positions */
253 +        if ((sdir>0 ? swl0 : swl1) <= dwl0) {
254 +                if (sdir > 0) {
255 +                        wl = swl0;
256 +                        ssi = 0;
257 +                } else {
258 +                        wl = swl1;
259 +                        ssi = snc-1;
260 +                }
261 +                si = 0;
262 +                di = (wl - dwl0)*rdstp;
263 +        } else {
264 +                wl = dwl0;
265 +                if (sdir > 0) {
266 +                        ssi = si = (wl - swl0)/sstp;
267 +                } else {
268 +                        si = (wl - swl1)/sstp;
269 +                        ssi = snc-1 - si;
270 +                }
271 +                di = 0;
272 +        }
273 +        swl0 += (sdir < 0)*sstp;
274 +                                /* step through intervals */
275 +        while ((si < snc) & (di < dnc)) {
276 +                double  intvl;
277 +                if (swl0 + (ssi+sdir)*sstp < dwl0 + (di+1)*dstp) {
278 +                        intvl = dwl0 + (di+1)*dstp - wl;
279 +                        dst[di++] += src[ssi]*intvl*rdstp;
280 +                } else {
281 +                        intvl = swl0 + (ssi+sdir)*sstp - wl;
282 +                        dst[di] += src[ssi]*intvl*rdstp;
283 +                        ssi += sdir;
284 +                        si++;
285 +                }
286 +                wl += intvl;
287 +        }
288 + }
289 +
290 +
291 + void *
292 + tempbuffer(                     /* get a temporary buffer */
293 +        size_t  len
294 + )
295 + {
296 +        static void     *tempbuf = NULL;
297 +        static size_t   tempbuflen = 0;
298 +
299 +        if (!len) {             /* call to free */
300 +                if (tempbuflen) {
301 +                        free(tempbuf);
302 +                        tempbuf = NULL;
303 +                        tempbuflen = 0;
304 +                }
305 +                return(NULL);
306 +        }
307 +        if (len <= tempbuflen)  /* big enough already? */
308 +                return(tempbuf);
309 +                                /* else free & reallocate */
310 +        if (tempbuflen)
311 +                free(tempbuf);
312 +        tempbuf = malloc(len);
313 +        tempbuflen = len*(tempbuf != NULL);
314          return(tempbuf);
315   }
316  
317  
318 < fwritecolrs(scanline, len, fp)          /* write out a colr scanline */
319 < register COLR  *scanline;
320 < int  len;
321 < register FILE  *fp;
318 > int
319 > fwritecolrs(                    /* write out a colr scanline */
320 >        COLR  *scanline,
321 >        int  len,
322 >        FILE  *fp
323 > )
324   {
325 <        register int  i, j, beg, cnt;
325 >        int  i, j, beg, cnt = 1;
326          int  c2;
327          
328 <        if (len < MINELEN)              /* too small to encode */
328 >        if ((len < MINELEN) | (len > MAXELEN))  /* OOBs, write out flat */
329                  return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
330 <        if (len > 32767)                /* too big! */
51 <                return(-1);
52 <        putc(2, fp);                    /* put magic header */
330 >                                        /* put magic header */
331          putc(2, fp);
332 +        putc(2, fp);
333          putc(len>>8, fp);
334 <        putc(len&255, fp);
334 >        putc(len&0xff, fp);
335                                          /* put components seperately */
336          for (i = 0; i < 4; i++) {
337              for (j = 0; j < len; j += cnt) {    /* find next run */
338                  for (beg = j; beg < len; beg += cnt) {
339 <                    for (cnt = 1; cnt < 127 && beg+cnt < len &&
339 >                    for (cnt = 1; (cnt < 127) & (beg+cnt < len) &&
340                              scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
341                          ;
342                      if (cnt >= MINRUN)
343                          break;                  /* long enough */
344                  }
345 <                while (j < beg) {               /* write out non-run(s) */
345 >                if ((beg-j > 1) & (beg-j < MINRUN)) {
346 >                    c2 = j+1;
347 >                    while (scanline[c2++][i] == scanline[j][i])
348 >                        if (c2 == beg) {        /* short run */
349 >                            putc(128+beg-j, fp);
350 >                            putc(scanline[j][i], fp);
351 >                            j = beg;
352 >                            break;
353 >                        }
354 >                }
355 >                while (j < beg) {               /* write out non-run */
356                      if ((c2 = beg-j) > 128) c2 = 128;
357                      putc(c2, fp);
358                      while (c2--)
# Line 79 | Line 368 | register FILE  *fp;
368          return(ferror(fp) ? -1 : 0);
369   }
370  
371 + /*
372 + * An old-format scanline is either a stream of valid RGBE or XYZE real
373 + * pixels or at least one real pixel followed by some number of
374 + * invalid real pixels of the form (1,1,1,n), where n is a count.
375 + * These can themselves be repeated to create a multibyte repeat
376 + * count, with the least significant byte first (little-endian order.)
377 + * Repeat counts are limited by the size of an int; if a repetition
378 + * leads to an overrun, the rest of the the repetition will be
379 + * silently ignored.
380 + */
381 + static int
382 + oldreadcolrs(                   /* read in an old-style colr scanline */
383 +        COLR  *scanline,
384 +        int  len,
385 +        FILE  *fp
386 + )
387 + {
388 +        int  rshift = 0;
389 +        int  i;
390 +        
391 +        while (len > 0) {
392 +                scanline[0][RED] = getc(fp);
393 +                scanline[0][GRN] = getc(fp);
394 +                scanline[0][BLU] = getc(fp);
395 +                scanline[0][EXP] = i = getc(fp);
396 +                if (i == EOF)
397 +                        return(-1);
398 +                if (scanline[0][GRN] == 1 &&
399 +                                (scanline[0][RED] == 1) &
400 +                                (scanline[0][BLU] == 1)) {
401 +                        i = scanline[0][EXP] << rshift;
402 +                        while (i--) {
403 +                                copycolr(scanline[0], scanline[-1]);
404 +                                if (--len <= 0)
405 +                                        return(0);
406 +                                scanline++;
407 +                        }
408 +                        rshift += 8;
409 +                } else {
410 +                        scanline++;
411 +                        len--;
412 +                        rshift = 0;
413 +                }
414 +        }
415 +        return(0);
416 + }
417  
418 < freadcolrs(scanline, len, fp)           /* read in an encoded colr scanline */
419 < register COLR  *scanline;
420 < int  len;
421 < register FILE  *fp;
418 > /*
419 > * There are two scanline formats: old and new.  The old format
420 > * compresses runs of RGBE or XYZE four-byte real pixels; the new
421 > * format breaks the pixels into R, G, B, and E lines (or XYZE lines)
422 > * which are individually run-length encoded.
423 > *
424 > * An old-format scanline always begins with a valid real pixel; at
425 > * least one of the RGB (or XYZ) values will have its high-order bit
426 > * set.  A new-format scanline begins with four bytes which are not a
427 > * valid real pixel: (2, 2, lenhigh, lenlow) where lenhigh is always
428 > * less than 128 and hence never has a high-order bit set.
429 > *
430 > * A new-format scanline is broken into its RGBE or XYZE components.
431 > * Each is output and run-length encoded separately so that a scanline
432 > * is broken into four records.  In turn, each record is organized
433 > * into chunks of up to 128 characters, which begin with a count byte.
434 > * If the count byte is greater than 128, the following data byte is
435 > * repeated (count-128) times.  If not, the count byte is followed by
436 > * that many data bytes.
437 > */
438 > int
439 > freadcolrs(                     /* read in an encoded colr scanline */
440 >        COLR  *scanline,
441 >        int  len,
442 >        FILE  *fp
443 > )
444   {
445 <        register int  i, j;
446 <        int  code;
445 >        int  i, j;
446 >        int  code, val;
447                                          /* determine scanline type */
448 <        if (len < MINELEN)
449 <                return(oldreadcolrs(scanline, len, fp));
448 >        if (len <= 0)
449 >                return(0);
450          if ((i = getc(fp)) == EOF)
451                  return(-1);
452 <        if (i != 2) {
96 <                ungetc(i, fp);
97 <                return(oldreadcolrs(scanline, len, fp));
98 <        }
452 >        scanline[0][RED] = i;
453          scanline[0][GRN] = getc(fp);
454          scanline[0][BLU] = getc(fp);
455          if ((i = getc(fp)) == EOF)
456                  return(-1);
457 <        if (scanline[0][GRN] != 2 || scanline[0][BLU] & 128) {
458 <                scanline[0][RED] = 2;
457 >        if ((scanline[0][RED] != 2) | (scanline[0][GRN] != 2) |
458 >                        (scanline[0][BLU] & 0x80)) {
459                  scanline[0][EXP] = i;
460                  return(oldreadcolrs(scanline+1, len-1, fp));
461          }
# Line 113 | Line 467 | register FILE  *fp;
467                  if ((code = getc(fp)) == EOF)
468                      return(-1);
469                  if (code > 128) {       /* run */
470 <                    scanline[j++][i] = getc(fp);
471 <                    for (code &= 127; --code; j++)
472 <                        scanline[j][i] = scanline[j-1][i];
473 <                } else                  /* non-run */
470 >                    code &= 127;
471 >                    if ((val = getc(fp)) == EOF)
472 >                        return -1;
473 >                    if (j + code > len)
474 >                        return -1;      /* overrun */
475                      while (code--)
476 <                        scanline[j++][i] = getc(fp);
476 >                        scanline[j++][i] = val;
477 >                } else {                /* non-run */
478 >                    if (j + code > len)
479 >                        return -1;      /* overrun */
480 >                    while (code--) {
481 >                        if ((val = getc(fp)) == EOF)
482 >                            return -1;
483 >                        scanline[j++][i] = val;
484 >                    }
485 >                }
486              }
487 <        return(feof(fp) ? -1 : 0);
487 >        return(0);
488   }
489  
490  
491 < oldreadcolrs(scanline, len, fp)         /* read in an old colr scanline */
492 < register COLR  *scanline;
493 < int  len;
130 < register FILE  *fp;
491 > /* read an nc-component common-exponent color scanline */
492 > int
493 > freadscolrs(uby8 *scanline, int nc, int len, FILE *fp)
494   {
495 <        int  rshift;
496 <        register int  i;
497 <        
498 <        rshift = 0;
499 <        
500 <        while (len > 0) {
501 <                scanline[0][RED] = getc(fp);
139 <                scanline[0][GRN] = getc(fp);
140 <                scanline[0][BLU] = getc(fp);
141 <                scanline[0][EXP] = getc(fp);
142 <                if (feof(fp) || ferror(fp))
143 <                        return(-1);
144 <                if (scanline[0][RED] == 1 &&
145 <                                scanline[0][GRN] == 1 &&
146 <                                scanline[0][BLU] == 1) {
147 <                        for (i = scanline[0][EXP] << rshift; i > 0; i--) {
148 <                                copycolr(scanline[0], scanline[-1]);
149 <                                scanline++;
150 <                                len--;
151 <                        }
152 <                        rshift += 8;
153 <                } else {
154 <                        scanline++;
155 <                        len--;
156 <                        rshift = 0;
157 <                }
158 <        }
495 >        if (nc < 3)
496 >                return(-1);
497 >        if (nc == 3)
498 >                return(freadcolrs((COLR *)scanline, len, fp));
499 >
500 >        if (fread(scanline, nc+1, len, fp) != len)
501 >                return(-1);
502          return(0);
503   }
504  
505  
506 < fwritescan(scanline, len, fp)           /* write out a scanline */
507 < register COLOR  *scanline;
508 < int  len;
166 < FILE  *fp;
506 > /* write an common-exponent spectral color scanline */
507 > int
508 > fwritescolrs(uby8 *sscanline, int nc, int len, FILE *fp)
509   {
510 +        if (nc < 3)
511 +                return(-1);
512 +        if (nc == 3)
513 +                return(fwritecolrs((COLR *)sscanline, len, fp));
514 +
515 +        if (fwrite(sscanline, nc+1, len, fp) != len)
516 +                return(-1);
517 +        return(0);
518 + }
519 +
520 +
521 + int
522 + fwritescan(             /* write out an RGB or XYZ scanline */
523 +        COLOR  *scanline,
524 +        int  len,
525 +        FILE  *fp
526 + )
527 + {
528          COLR  *clrscan;
529          int  n;
530 <        register COLR  *sp;
530 >        COLR  *sp;
531                                          /* get scanline buffer */
532          if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
533                  return(-1);
# Line 185 | Line 545 | FILE  *fp;
545   }
546  
547  
548 < freadscan(scanline, len, fp)            /* read in a scanline */
549 < register COLOR  *scanline;
550 < int  len;
551 < FILE  *fp;
548 > int
549 > freadscan(              /* read in an RGB or XYZ scanline */
550 >        COLOR  *scanline,
551 >        int  len,
552 >        FILE  *fp
553 > )
554   {
555 <        register COLR  *clrscan;
555 >        COLR  *clrscan;
556  
557          if ((clrscan = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
558                  return(-1);
# Line 200 | Line 562 | FILE  *fp;
562          colr_color(scanline[0], clrscan[0]);
563          while (--len > 0) {
564                  scanline++; clrscan++;
565 <                if (clrscan[0][RED] == clrscan[-1][RED] &&
566 <                            clrscan[0][GRN] == clrscan[-1][GRN] &&
567 <                            clrscan[0][BLU] == clrscan[-1][BLU] &&
568 <                            clrscan[0][EXP] == clrscan[-1][EXP])
565 >                if (clrscan[0][GRN] == clrscan[-1][GRN] &&
566 >                            (clrscan[0][RED] == clrscan[-1][RED]) &
567 >                            (clrscan[0][BLU] == clrscan[-1][BLU]) &
568 >                            (clrscan[0][EXP] == clrscan[-1][EXP]))
569                          copycolor(scanline[0], scanline[-1]);
570                  else
571                          colr_color(scanline[0], clrscan[0]);
# Line 212 | Line 574 | FILE  *fp;
574   }
575  
576  
577 < setcolr(clr, r, g, b)           /* assign a short color value */
578 < register COLR  clr;
579 < double  r, g, b;
577 > /* read an nc-component color scanline */
578 > int
579 > freadsscan(COLORV *sscanline, int nc, int len, FILE *fp)
580   {
581 <        double  frexp();
581 >        uby8    *tscn = (uby8 *)tempbuffer((nc+1)*len);
582 >        int     i;
583 >
584 >        if (tscn == NULL || freadscolrs(tscn, nc, len, fp) < 0)
585 >                return(-1);
586 >        for (i = len; i-- > 0; ) {
587 >                scolr2scolor(sscanline, tscn, nc);
588 >                sscanline += nc;
589 >                tscn += nc+1;
590 >        }
591 >        return(0);
592 > }
593 >
594 >
595 > /* write an nc-component spectral color scanline */
596 > int
597 > fwritesscan(COLORV *sscanline, int nc, int len, FILE *fp)
598 > {
599 >        uby8    *tscn = (uby8 *)tempbuffer((nc+1)*len);
600 >        int     i;
601 >
602 >        if (tscn == NULL)
603 >                return(-1);
604 >        for (i = 0; i < len; i++) {
605 >                scolor2scolr(tscn+i*(nc+1), sscanline, nc);
606 >                sscanline += nc;
607 >        }
608 >        return(fwritescolrs(tscn, nc, len, fp));
609 > }
610 >
611 >
612 > void
613 > setcolr(                        /* assign a short color value */
614 >        COLR  clr,
615 >        double  r,
616 >        double  g,
617 >        double  b
618 > )
619 > {
620          double  d;
621          int  e;
622          
# Line 231 | Line 631 | double  r, g, b;
631  
632          d = frexp(d, &e) * 256.0 / d;
633  
634 <        clr[RED] = r * d;
635 <        clr[GRN] = g * d;
636 <        clr[BLU] = b * d;
634 >        clr[RED] = (r > 0) * (int)(r*d);
635 >        clr[GRN] = (g > 0) * (int)(g*d);
636 >        clr[BLU] = (b > 0) * (int)(b*d);
637          clr[EXP] = e + COLXS;
638   }
639  
640  
641 < colr_color(col, clr)            /* convert short to float color */
642 < register COLOR  col;
643 < register COLR  clr;
641 > void
642 > colr_color(                     /* convert short to float color */
643 >        COLOR  col,
644 >        COLR  clr
645 > )
646   {
647          double  f;
648          
649 <        if (clr[EXP] == 0)
649 >        if (clr[EXP] == 0) {
650                  col[RED] = col[GRN] = col[BLU] = 0.0;
651 <        else {
250 <                f = ldexp(1.0, (int)clr[EXP]-(COLXS+8));
251 <                col[RED] = (clr[RED] + 0.5)*f;
252 <                col[GRN] = (clr[GRN] + 0.5)*f;
253 <                col[BLU] = (clr[BLU] + 0.5)*f;
651 >                return;
652          }
653 +        f = ldexp(1.0, (int)clr[EXP]-(COLXS+8));
654 +        col[RED] = (clr[RED] + 0.5)*f;
655 +        col[GRN] = (clr[GRN] + 0.5)*f;
656 +        col[BLU] = (clr[BLU] + 0.5)*f;
657   }
658  
659  
660 < bigdiff(c1, c2, md)                     /* c1 delta c2 > md? */
661 < register COLOR  c1, c2;
662 < double  md;
660 > int
661 > bigdiff(                                /* c1 delta c2 > md? */
662 >        COLOR  c1,
663 >        COLOR  c2,
664 >        double  md
665 > )
666   {
667 <        register int  i;
667 >        int  i;
668  
669          for (i = 0; i < 3; i++)
670 <                if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) ||
671 <                        colval(c2,i)-colval(c1,i) > md*colval(c1,i))
670 >                if ((colval(c1,i)-colval(c2,i) > md*colval(c2,i)) |
671 >                                (colval(c2,i)-colval(c1,i) > md*colval(c1,i)))
672 >                        return(1);
673 >        return(0);
674 > }
675 >
676 >
677 > int
678 > sbigsdiff(                              /* sc1 delta sc2 > md? */
679 >        SCOLOR  c1,
680 >        SCOLOR  c2,
681 >        double  md
682 > )
683 > {
684 >        int  i = NCSAMP;
685 >
686 >        while (i--)
687 >                if ((c1[i]-c2[i] > md*c2[i]) | (c2[i]-c1[i] > md*c1[i]))
688                          return(1);
689          return(0);
690   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines