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.1 by greg, Thu Oct 3 16:52:49 1996 UTC vs.
Revision 3.13 by greg, Mon Nov 8 15:50:59 2004 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1996 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"
10 + #include "warp3d.h"
11  
12  
13   RGBPRIMP        inprims = stdprims;     /* input primaries */
# Line 19 | Line 18 | double (*lumf)() = rgblum;             /* input luminance functio
18   double  inpexp = 1.0;                   /* input exposure value */
19  
20   char    *mbcalfile = NULL;              /* macbethcal mapping file */
21 + char    *cwarpfile = NULL;              /* color space warping file */
22  
23 < static struct mbc       mbcond;         /* macbethcal conditioning struct */
23 > static struct mbc {
24 >        COLORMAT        cmat;
25 >        float   xa[3][6], ya[3][6];
26 >        COLOR   cmin, cmax;
27 > }       mbcond;                         /* macbethcal conditioning struct */
28  
29 + static WARP3D   *cwarp;                 /* color warping structure */
30 +
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 < double
41 < rgblum(clr, scotopic)           /* compute (scotopic) luminance of RGB color */
42 < COLOR   clr;
43 < int     scotopic;
40 >
41 > extern double
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 40 | Line 53 | int    scotopic;
53   }
54  
55  
56 < double
57 < cielum(xyz, scotopic)           /* compute (scotopic) luminance of CIE color */
58 < COLOR   xyz;
59 < int     scotopic;
56 > extern double
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 53 | Line 67 | int    scotopic;
67   }
68  
69  
70 < COLOR *
71 < nextscan()                              /* read and condition next scanline */
70 > extern COLOR *
71 > nextscan(void)                          /* read and condition next scanline */
72   {
73          if (nread >= numscans(&inpres)) {
74 < #ifdef DEBUG
75 <                fputs("done\n", stderr);
76 < #endif
77 <                return(NULL);
74 >                if (cwarpfile != NULL)
75 >                        free3dw(cwarp);
76 >                free((void *)scanbuf);
77 >                return(scanbuf = NULL);
78          }
79 <        if (freadscan(scanbuf, scanlen(&inpres), infp) < 0) {
79 >        if (what2do&DO_ACUITY)
80 >                acuscan(scanbuf, nread);
81 >        else if (freadscan(scanbuf, scanlen(&inpres), infp) < 0) {
82                  fprintf(stderr, "%s: %s: scanline read error\n",
83                                  progname, infn);
84                  exit(1);
85          }
70 –        nread++;
86          if (what2do&DO_VEIL)                    /* add veiling */
87 <                addveil(scanbuf, nread-1);
87 >                addveil(scanbuf, nread);
88          if (what2do&DO_COLOR)                   /* scotopic color loss */
89                  scotscan(scanbuf, scanlen(&inpres));
90          if (what2do&DO_LINEAR)                  /* map luminances */
# Line 78 | Line 93 | nextscan()                             /* read and condition next scanline */
93                  mapscan(scanbuf, scanlen(&inpres));
94          if (mbcalfile != NULL)                  /* device color correction */
95                  mbscan(scanbuf, scanlen(&inpres), &mbcond);
96 <        else if (lumf == cielum | inprims != outprims)
96 >        else if (cwarpfile != NULL)             /* device color space warp */
97 >                cwscan(scanbuf, scanlen(&inpres), cwarp);
98 >        else if ((lumf == cielum) | (inprims != outprims))
99                  matscan(scanbuf, scanlen(&inpres), mbcond.cmat);
100 +        nread++;
101          return(scanbuf);
102   }
103  
104  
105 < COLOR *
106 < firstscan()                             /* return first processed scanline */
105 > extern COLOR *
106 > firstscan(void)                         /* return first processed scanline */
107   {
108          if (mbcalfile != NULL)          /* load macbethcal file */
109                  getmbcalfile(mbcalfile, &mbcond);
110 <        else
110 >        else if (cwarpfile != NULL) {
111 >                if ((cwarp = load3dw(cwarpfile, NULL)) == NULL)
112 >                        syserror(cwarpfile);
113 >        } else
114                  if (lumf == rgblum)
115 <                        comprgb2rgbmat(mbcond.cmat, inprims, outprims);
115 >                        comprgb2rgbWBmat(mbcond.cmat, inprims, outprims);
116                  else
117 <                        compxyz2rgbmat(mbcond.cmat, outprims);
117 >                        compxyz2rgbWBmat(mbcond.cmat, outprims);
118 >        if (what2do&DO_ACUITY && !initacuity()) {
119 >                fprintf(stderr, "%s: warning - cannot initialize acuity pass\n",
120 >                                progname);
121 >                what2do &= ~DO_ACUITY;
122 >        }
123          scanbuf = (COLOR *)malloc(scanlen(&inpres)*sizeof(COLOR));
124          if (scanbuf == NULL)
125                  syserror("malloc");
126          nread = 0;
101 – #ifdef DEBUG
102 –        fprintf(stderr, "%s: processing image...", progname);
103 – #endif
127          return(nextscan());
128   }
129  
130  
131 < sfscan(sl, len, sf)                     /* apply scalefactor to scanline */
132 < register COLOR  *sl;
133 < int     len;
134 < double  sf;
131 > static void
132 > sfscan(                 /* apply scalefactor to scanline */
133 >        register COLOR  *sl,
134 >        int     len,
135 >        double  sf
136 > )
137   {
138          while (len--) {
139                  scalecolor(sl[0], sf);
# Line 117 | Line 142 | double sf;
142   }
143  
144  
145 < matscan(sl, len, mat)                   /* apply color matrix to scaline */
146 < register COLOR  *sl;
147 < int     len;
148 < COLORMAT        mat;
145 > static void
146 > matscan(                        /* apply color matrix to scaline */
147 >        register COLOR  *sl,
148 >        int     len,
149 >        COLORMAT        mat
150 > )
151   {
152          while (len--) {
153                  colortrans(sl[0], mat, sl[0]);
154 +                clipgamut(sl[0], bright(sl[0]), CGAMUT, cblack, cwhite);
155                  sl++;
156          }
157   }
158  
159  
160 < mbscan(sl, len, mb)                     /* apply macbethcal adj. to scaline */
161 < COLOR   *sl;
162 < int     len;
163 < register struct mbc     *mb;
160 > static void
161 > mbscan(                 /* apply macbethcal adj. to scaline */
162 >        COLOR   *sl,
163 >        int     len,
164 >        register struct mbc     *mb
165 > )
166   {
167          double  d;
168          register int    i, j;
169  
170          while (len--) {
171 +                colortrans(sl[0], mb->cmat, sl[0]);
172 +                clipgamut(sl[0], bright(sl[0]), CGAMUT, mb->cmin, mb->cmax);
173                  for (i = 0; i < 3; i++) {
174                          d = colval(sl[0],i);
175                          for (j = 0; j < 4 && mb->xa[i][j+1] <= d; j++)
# Line 146 | Line 178 | register struct mbc    *mb;
178                                          (d - mb->xa[i][j])*mb->ya[i][j+1] ) /
179                                          (mb->xa[i][j+1] - mb->xa[i][j]);
180                  }
149 –                colortrans(sl[0], mb->cmat, sl[0]);
181                  sl++;
182          }
183   }
184  
185  
186 < getmbcalfile(fn, mb)                    /* load macbethcal file */
187 < char    *fn;
188 < register struct mbc     *mb;
186 > static void
187 > cwscan(                 /* apply color space warp to scaline */
188 >        COLOR   *sl,
189 >        int     len,
190 >        WARP3D  *wp
191 > )
192   {
193 <        extern char     *fgets();
193 >        int     rval;
194 >
195 >        while (len--) {
196 >                rval = warp3d(sl[0], sl[0], wp);
197 >                if (rval & W3ERROR)
198 >                        syserror("warp3d");
199 >                if (rval & W3BADMAP) {
200 >                        fprintf(stderr, "%s: %s: bad color space map\n",
201 >                                        progname, cwarpfile);
202 >                        exit(1);
203 >                }
204 >                clipgamut(sl[0], bright(sl[0]), CGAMUT, cblack, cwhite);
205 >                sl++;
206 >        }
207 > }
208 >
209 >
210 > static void
211 > getmbcalfile(                   /* load macbethcal file */
212 >        char    *fn,
213 >        register struct mbc     *mb
214 > )
215 > {
216          char    buf[128];
217          FILE    *fp;
218          int     inpflags = 0;
219 +        register int    i;
220  
221          if ((fp = fopen(fn, "r")) == NULL)
222                  syserror(fn);
# Line 238 | Line 295 | register struct mbc    *mb;
295                  exit(1);
296          }
297          fclose(fp);
298 +                                        /* compute gamut */
299 +        for (i = 0; i < 3; i++) {
300 +                colval(mb->cmin,i) = mb->xa[i][0] -
301 +                                mb->ya[i][0] *
302 +                                (mb->xa[i][1]-mb->xa[i][0]) /
303 +                                (mb->ya[i][1]-mb->ya[i][0]);
304 +                colval(mb->cmax,i) = mb->xa[i][4] +
305 +                                (1.-mb->ya[i][4]) *
306 +                                (mb->xa[i][5] - mb->xa[i][4]) /
307 +                                (mb->ya[i][5] - mb->ya[i][4]);
308 +        }
309   }

Diff Legend

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