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

Comparing ray/src/px/pcond2.c (file contents):
Revision 3.8 by greg, Wed Feb 5 16:08:18 1997 UTC vs.
Revision 3.19 by greg, Wed Sep 11 18:56:11 2024 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1997 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   * Input and output conditioning routines for pcond.
6 + *  Added white-balance adjustment 10/01 (GW).
7   */
8  
9   #include "pcond.h"
# Line 33 | Line 31 | static WARP3D  *cwarp;                 /* color warping structure */
31   static COLOR    *scanbuf;               /* scanline processing buffer */
32   static int      nread;                  /* number of scanlines processed */
33  
34 + static void sfscan(COLOR *sl, int len, double sf);
35 + static void matscan(COLOR *sl, int len, COLORMAT mat);
36 + static void mbscan(COLOR *sl, int len, struct mbc *mb);
37 + static void cwscan(COLOR *sl, int len, WARP3D *wp);
38 + static void getmbcalfile(char *fn, struct mbc *mb);
39  
40 +
41   double
42 < rgblum(clr, scotopic)           /* compute (scotopic) luminance of RGB color */
43 < COLOR   clr;
44 < int     scotopic;
42 > rgblum(         /* compute (scotopic) luminance of RGB color */
43 >        COLOR   clr,
44 >        int     scotopic
45 > )
46   {
47          if (scotopic)           /* approximate */
48                  return( WHTSEFFICACY * (colval(clr,RED)*.062 +
# Line 49 | Line 54 | int    scotopic;
54  
55  
56   double
57 < cielum(xyz, scotopic)           /* compute (scotopic) luminance of CIE color */
58 < COLOR   xyz;
59 < int     scotopic;
57 > cielum(         /* compute (scotopic) luminance of CIE color */
58 >        COLOR   xyz,
59 >        int     scotopic
60 > )
61   {
62          if (scotopic)           /* approximate */
63                  return(colval(xyz,CIEY) *
# Line 62 | Line 68 | int    scotopic;
68  
69  
70   COLOR *
71 < nextscan()                              /* read and condition next scanline */
71 > nextscan(void)                          /* read and condition next scanline */
72   {
73          if (nread >= numscans(&inpres)) {
74                  if (cwarpfile != NULL)
75                          free3dw(cwarp);
76 <                free((char *)scanbuf);
76 >                free((void *)scanbuf);
77                  return(scanbuf = NULL);
78          }
79          if (what2do&DO_ACUITY)
80                  acuscan(scanbuf, nread);
81 <        else if (freadscan(scanbuf, scanlen(&inpres), infp) < 0) {
81 >        else if (fread2scan(scanbuf, scanlen(&inpres), infp,
82 >                                NCSAMP, WLPART) < 0) {
83                  fprintf(stderr, "%s: %s: scanline read error\n",
84                                  progname, infn);
85                  exit(1);
# Line 89 | Line 96 | nextscan()                             /* read and condition next scanline */
96                  mbscan(scanbuf, scanlen(&inpres), &mbcond);
97          else if (cwarpfile != NULL)             /* device color space warp */
98                  cwscan(scanbuf, scanlen(&inpres), cwarp);
99 <        else if (lumf == cielum | inprims != outprims)
99 >        else if ((lumf == cielum) | (inprims != outprims))
100                  matscan(scanbuf, scanlen(&inpres), mbcond.cmat);
101          nread++;
102          return(scanbuf);
# Line 97 | Line 104 | nextscan()                             /* read and condition next scanline */
104  
105  
106   COLOR *
107 < firstscan()                             /* return first processed scanline */
107 > firstscan(void)                         /* return first processed scanline */
108   {
109          if (mbcalfile != NULL)          /* load macbethcal file */
110                  getmbcalfile(mbcalfile, &mbcond);
# Line 106 | Line 113 | firstscan()                            /* return first processed scanline */
113                          syserror(cwarpfile);
114          } else
115                  if (lumf == rgblum)
116 <                        comprgb2rgbmat(mbcond.cmat, inprims, outprims);
116 >                        comprgb2rgbWBmat(mbcond.cmat, inprims, outprims);
117                  else
118 <                        compxyz2rgbmat(mbcond.cmat, outprims);
118 >                        compxyz2rgbWBmat(mbcond.cmat, outprims);
119          if (what2do&DO_ACUITY)
120                  initacuity();
121          scanbuf = (COLOR *)malloc(scanlen(&inpres)*sizeof(COLOR));
# Line 119 | Line 126 | firstscan()                            /* return first processed scanline */
126   }
127  
128  
129 < sfscan(sl, len, sf)                     /* apply scalefactor to scanline */
130 < register COLOR  *sl;
131 < int     len;
132 < double  sf;
129 > static void
130 > sfscan(                 /* apply scalefactor to scanline */
131 >        COLOR   *sl,
132 >        int     len,
133 >        double  sf
134 > )
135   {
136          while (len--) {
137                  scalecolor(sl[0], sf);
# Line 131 | Line 140 | double sf;
140   }
141  
142  
143 < matscan(sl, len, mat)                   /* apply color matrix to scaline */
144 < register COLOR  *sl;
145 < int     len;
146 < COLORMAT        mat;
143 > static double
144 > greypoint(                      /* compute gamut mapping grey target */
145 >        COLOR col
146 > )
147   {
148 +        COLOR   gryc;
149 +        int     i;
150 +                                /* improves saturated color rendering */
151 +        copycolor(gryc, col);
152 +        for (i = 3; i--; )
153 +                if (gryc[i] > 1)
154 +                        gryc[i] = 1;
155 +                else if (gryc[i] < 0)
156 +                        gryc[i] = 0;
157 +        return(bright(gryc));
158 + }
159 +
160 +
161 + static void
162 + matscan(                        /* apply color matrix to scaline */
163 +        COLOR   *sl,
164 +        int     len,
165 +        COLORMAT        mat
166 + )
167 + {
168          while (len--) {
169                  colortrans(sl[0], mat, sl[0]);
170 <                clipgamut(sl[0], bright(sl[0]), CGAMUT, cblack, cwhite);
170 >                clipgamut(sl[0], greypoint(sl[0]), CGAMUT, cblack, cwhite);
171                  sl++;
172          }
173   }
174  
175  
176 < mbscan(sl, len, mb)                     /* apply macbethcal adj. to scaline */
177 < COLOR   *sl;
178 < int     len;
179 < register struct mbc     *mb;
176 > static void
177 > mbscan(                 /* apply macbethcal adj. to scaline */
178 >        COLOR   *sl,
179 >        int     len,
180 >        struct mbc      *mb
181 > )
182   {
183          double  d;
184 <        register int    i, j;
184 >        int     i, j;
185  
186          while (len--) {
187                  colortrans(sl[0], mb->cmat, sl[0]);
188 <                clipgamut(sl[0], bright(sl[0]), CGAMUT, mb->cmin, mb->cmax);
188 >                clipgamut(sl[0], greypoint(sl[0]), CGAMUT, mb->cmin, mb->cmax);
189                  for (i = 0; i < 3; i++) {
190                          d = colval(sl[0],i);
191                          for (j = 0; j < 4 && mb->xa[i][j+1] <= d; j++)
# Line 168 | Line 199 | register struct mbc    *mb;
199   }
200  
201  
202 < cwscan(sl, len, wp)                     /* apply color space warp to scaline */
203 < COLOR   *sl;
204 < int     len;
205 < WARP3D  *wp;
202 > static void
203 > cwscan(                 /* apply color space warp to scaline */
204 >        COLOR   *sl,
205 >        int     len,
206 >        WARP3D  *wp
207 > )
208   {
209          int     rval;
210  
# Line 184 | Line 217 | WARP3D *wp;
217                                          progname, cwarpfile);
218                          exit(1);
219                  }
220 <                clipgamut(sl[0], bright(sl[0]), CGAMUT, cblack, cwhite);
220 >                clipgamut(sl[0], greypoint(sl[0]), CGAMUT, cblack, cwhite);
221                  sl++;
222          }
223   }
224  
225  
226 < getmbcalfile(fn, mb)                    /* load macbethcal file */
227 < char    *fn;
228 < register struct mbc     *mb;
226 > static void
227 > getmbcalfile(                   /* load macbethcal file */
228 >        char    *fn,
229 >        struct mbc      *mb
230 > )
231   {
197 –        extern char     *fgets();
232          char    buf[128];
233          FILE    *fp;
234          int     inpflags = 0;
235 <        register int    i;
235 >        int     i;
236  
237          if ((fp = fopen(fn, "r")) == NULL)
238                  syserror(fn);
# Line 253 | Line 287 | register struct mbc    *mb;
287                          inpflags |= 040;
288                  else if (!(inpflags & 0100) &&
289                                  sscanf(buf,
290 <                                "r = %f*r1 + %f*g1 + %f*b1",
290 >                                "ro = %f*rn + %f*gn + %f*bn",
291                                  &mb->cmat[0][0], &mb->cmat[0][1],
292                                  &mb->cmat[0][2]) == 3)
293                          inpflags |= 0100;
294                  else if (!(inpflags & 0200) &&
295                                  sscanf(buf,
296 <                                "g = %f*r1 + %f*g1 + %f*b1",
296 >                                "go = %f*rn + %f*gn + %f*bn",
297                                  &mb->cmat[1][0], &mb->cmat[1][1],
298                                  &mb->cmat[1][2]) == 3)
299                          inpflags |= 0200;
300                  else if (!(inpflags & 0400) &&
301                                  sscanf(buf,
302 <                                "b = %f*r1 + %f*g1 + %f*b1",
302 >                                "bo = %f*rn + %f*gn + %f*bn",
303                                  &mb->cmat[2][0], &mb->cmat[2][1],
304                                  &mb->cmat[2][2]) == 3)
305                          inpflags |= 0400;

Diff Legend

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