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

Comparing ray/src/px/macbethcal.c (file contents):
Revision 2.6 by greg, Tue Oct 17 11:05:17 1995 UTC vs.
Revision 2.7 by greg, Fri Oct 20 15:26:11 1995 UTC

# Line 90 | Line 90 | short  mbsat[NMBSAT] = {
90                  Orange,Purple
91          };
92  
93 + #define  REQFLGS        (1L<<White|1L<<Neutral8|1L<<Neutral65| \
94 +                                1L<<Neutral5|1L<<Neutral35|1L<<Black)
95 +
96 + #define  CENTCVG        0.3     /* measured coverage of square sample */
97 + #define  FULLCVG        0.9     /* coverage of entire square */
98 +
99   int     xmax, ymax;             /* input image dimensions */
100   int     bounds[4][2];           /* image coordinates of chart corners */
101   double  imgxfm[3][3];           /* coordinate transformation matrix */
102  
103 < COLOR   picRGB[24];             /* picture colors */
103 > COLOR   inpRGB[24];             /* measured or scanned input colors */
104 > long    inpflags = 0;           /* flags of which colors were input */
105  
106   COLOR   bramp[NMBNEU][2];       /* brightness ramp (per primary) */
107   double  solmat[3][3];           /* color mapping matrix */
# Line 109 | Line 116 | main(argc, argv)
116   int     argc;
117   char    **argv;
118   {
119 +        int     inpispic = 1;
120          int     i;
121  
122          progname = argv[0];
123 <        if (argc > 2 && !strcmp(argv[1], "-d")) {       /* debug output */
124 <                if ((debugfp = fopen(argv[2], "w")) == NULL) {
125 <                        perror(argv[2]);
126 <                        exit(1);
127 <                }
123 >        for (i = 1; i < argc && argv[i][0] == '-'; i++)
124 >                switch (argv[i][1]) {
125 >                case 'd':                               /* debug output */
126 >                        i++;
127 >                        if (badarg(argc-i, argv+i, "s"))
128 >                                goto userr;
129 >                        if ((debugfp = fopen(argv[i], "w")) == NULL) {
130 >                                perror(argv[i]);
131 >                                exit(1);
132 >                        }
133   #ifdef MSDOS
134 <                setmode(fileno(debugfp), O_BINARY);
134 >                        setmode(fileno(debugfp), O_BINARY);
135   #endif
136 <                newheader("RADIANCE", debugfp);
137 <                printargs(argc, argv, debugfp);
138 <                argv += 2;
139 <                argc -= 2;
140 <        }
141 <        if (argc != 3 && argc != 11)
142 <                goto userr;
143 <        if (strcmp(argv[1], "-") && freopen(argv[1], "r", stdin) == NULL) {
136 >                        newheader("RADIANCE", debugfp);         /* start */
137 >                        printargs(argc, argv, debugfp);         /* header */
138 >                        break;
139 >                case 'p':                               /* picture position */
140 >                        if (badarg(argc-i-1, argv+i+1, "iiiiiiii"))
141 >                                goto userr;
142 >                        bounds[0][0] = atoi(argv[++i]);
143 >                        bounds[0][1] = atoi(argv[++i]);
144 >                        bounds[1][0] = atoi(argv[++i]);
145 >                        bounds[1][1] = atoi(argv[++i]);
146 >                        bounds[2][0] = atoi(argv[++i]);
147 >                        bounds[2][1] = atoi(argv[++i]);
148 >                        bounds[3][0] = atoi(argv[++i]);
149 >                        bounds[3][1] = atoi(argv[++i]);
150 >                        inpispic = 2;
151 >                        break;
152 >                case 'c':                               /* color input */
153 >                        inpispic = 0;
154 >                        break;
155 >                default:
156 >                        goto userr;
157 >                }
158 >                                                        /* open files */
159 >        if (i < argc && freopen(argv[i], "r", stdin) == NULL) {
160                  perror(argv[1]);
161                  exit(1);
162          }
163 <        if (strcmp(argv[2], "-") && freopen(argv[2], "w", stdout) == NULL) {
163 >        if (i+1 < argc && freopen(argv[i+1], "w", stdout) == NULL) {
164                  perror(argv[2]);
165                  exit(1);
166          }
167 +        if (inpispic) {                 /* load input picture header */
168   #ifdef MSDOS
169 <        setmode(fileno(stdin), O_BINARY);
169 >                setmode(fileno(stdin), O_BINARY);
170   #endif
171 <        if (checkheader(stdin, COLRFMT, NULL) < 0 ||
172 <                        fgetresolu(&xmax, &ymax, stdin) < 0) {
173 <                fprintf(stderr, "%s: bad input picture\n", progname);
174 <                exit(1);
145 <        }
146 <                                        /* get chart boundaries */
147 <        if (argc == 11) {
148 <                for (i = 0; i < 4; i++) {
149 <                        if (!isint(argv[2*i+3]) | !isint(argv[2*i+4]))
150 <                                goto userr;
151 <                        bounds[i][0] = atoi(argv[2*i+3]);
152 <                        bounds[i][1] = atoi(argv[2*i+4]);
171 >                if (checkheader(stdin, COLRFMT, NULL) < 0 ||
172 >                                fgetresolu(&xmax, &ymax, stdin) < 0) {
173 >                        fprintf(stderr, "%s: bad input picture\n", progname);
174 >                        exit(1);
175                  }
176 <        } else {
176 >        } else {                        /* else set default xmax and ymax */
177 >                xmax = 512;
178 >                ymax = 2*512/3;
179 >        }
180 >        if (inpispic != 2) {            /* use default boundaries */
181                  bounds[0][0] = bounds[2][0] = .029*xmax + .5;
182                  bounds[0][1] = bounds[1][1] = .956*ymax + .5;
183                  bounds[1][0] = bounds[3][0] = .971*xmax + .5;
184                  bounds[2][1] = bounds[3][1] = .056*ymax + .5;
185          }
186          init();                         /* initialize */
187 <        getcolors();                    /* get picture colors */
187 >        if (inpispic)                   /* get picture colors */
188 >                getpicture();
189 >        else
190 >                getcolors();
191          compute();                      /* compute color mapping */
192                                          /* print comment */
193 <        printf("{ Color correction file computed by %s }\n", progname);
194 <        printf("{ from scanned MacBetch color chart %s }\n", argv[1]);
193 >        printf("{ Color correction file computed by:\n\t");
194 >        printargs(argc, argv, stdout);
195 >        printf("}\n");
196          putmapping();                   /* put out color mapping */
197 <        putdebug();                     /* put out debug picture */
197 >        if (debugfp != NULL)            /* put out debug picture */
198 >                if (inpispic)
199 >                        picdebug();
200 >                else
201 >                        clrdebug();
202          exit(0);
203   userr:
204 <        fprintf(stderr, "Usage: %s [-d dbg.pic] input.pic output.cal [xul yul xur yur xll yll xlr ylr]\n",
204 >        fprintf(stderr,
205 > "Usage: %s [-d dbg.pic][-p xul yul xur yur xll yll xlr ylr] input.pic [output.cal]\n",
206                          progname);
207 +        fprintf(stderr, "   or: %s [-d dbg.pic] -c [xyY.dat [output.cal]]\n",
208 +                        progname);
209          exit(1);
210   }
211  
# Line 176 | Line 213 | userr:
213   init()                          /* initialize */
214   {
215          double  quad[4][2];
216 +        register int    i;
217                                          /* make coordinate transformation */
218          quad[0][0] = bounds[0][0];
219          quad[0][1] = bounds[0][1];
# Line 190 | Line 228 | init()                         /* initialize */
228                  fprintf(stderr, "%s: bad chart boundaries\n", progname);
229                  exit(1);
230          }
231 +                                        /* map MacBeth colors to RGB space */
232 +        for (i = 0; i < 24; i++)
233 +                xyY2RGB(mbRGB[i], mbxyY[i]);
234   }
235  
236  
237   int
238 < chartndx(x, y)                          /* find color number for position */
238 > chartndx(x, y, cvg)                     /* find color number for position */
239   int     x, y;
240 + double  cvg;
241   {
242          double  ipos[3], cpos[3];
243          int     ix, iy;
244          double  fx, fy;
245 +        double  cmin, cmax;
246  
247          ipos[0] = x;
248          ipos[1] = y;
# Line 213 | Line 256 | int    x, y;
256          iy = cpos[1];
257          fx = cpos[0] - ix;
258          fy = cpos[1] - iy;
259 <        if (fx < .35 || fx >= .65 || fy < .35 || fy >= .65)
259 >        cmin = .5*(1.-cvg);
260 >        cmax = 1. - cmin;
261 >        if (fx < cmin || fx >= cmax || fy < cmin || fy >= cmax)
262                  return(-1);
263          return(iy*6 + ix);
264   }
265  
266  
267 < getcolors()                             /* load in picture colors */
267 > getpicture()                            /* load in picture colors */
268   {
269          COLR    *scanln;
270          COLOR   pval;
# Line 234 | Line 279 | getcolors()                            /* load in picture colors */
279                  exit(1);
280          }
281          for (i = 0; i < 24; i++) {
282 <                setcolor(picRGB[i], 0., 0., 0.);
282 >                setcolor(inpRGB[i], 0., 0., 0.);
283                  ccount[i] = 0;
284          }
285          for (y = ymax-1; y >= 0; y--) {
# Line 244 | Line 289 | getcolors()                            /* load in picture colors */
289                          exit(1);
290                  }
291                  for (x = 0; x < xmax; x++) {
292 <                        i = chartndx(x, y);
292 >                        i = chartndx(x, y, CENTCVG);
293                          if (i >= 0) {
294                                  colr_color(pval, scanln[x]);
295 <                                addcolor(picRGB[i], pval);
295 >                                addcolor(inpRGB[i], pval);
296                                  ccount[i]++;
297                          }
298                  }
299          }
300 <        for (i = 0; i < 24; i++) {
301 <                if (ccount[i] == 0) {
302 <                        fprintf(stderr, "%s: bad chart boundaries\n",
300 >        for (i = 0; i < 24; i++) {              /* compute averages */
301 >                if (ccount[i] == 0)
302 >                        continue;
303 >                d = 1./ccount[i];
304 >                scalecolor(inpRGB[i], d);
305 >                inpflags |= 1L<<i;
306 >        }
307 >        free((char *)scanln);
308 > }
309 >
310 >
311 > getcolors()                     /* get xyY colors from standard input */
312 > {
313 >        int     gotwhite = 0;
314 >        COLOR   whiteclr;
315 >        int     n;
316 >        float   xyYin[3];
317 >
318 >        while (fgetval(stdin, 'i', &n) == 1) {          /* read colors */
319 >                if (n < 0 | n > 24 ||
320 >                                fgetval(stdin, 'f', &xyYin[0]) != 1 ||
321 >                                fgetval(stdin, 'f', &xyYin[1]) != 1 ||
322 >                                fgetval(stdin, 'f', &xyYin[2]) != 1 ||
323 >                                xyYin[0] < 0. | xyYin[0] > 1. |
324 >                                xyYin[1] < 0. | xyYin[1] > 1.) {
325 >                        fprintf(stderr, "%s: bad color input data\n",
326                                          progname);
327                          exit(1);
328                  }
329 <                d = 1.0/ccount[i];
330 <                scalecolor(picRGB[i], d);
329 >                if (n == 0) {                           /* calibration white */
330 >                        xyY2RGB(whiteclr, xyYin);
331 >                        gotwhite++;
332 >                } else {                                /* standard color */
333 >                        n--;
334 >                        xyY2RGB(inpRGB[n], xyYin);
335 >                        inpflags |= 1L<<n;
336 >                }
337          }
338 <        free((char *)scanln);
338 >                                        /* normalize colors */
339 >        if (!gotwhite) {
340 >                if (!(inpflags & 1L<<White)) {
341 >                        fprintf(stderr, "%s: missing input for White\n",
342 >                                        progname);
343 >                        exit(1);
344 >                }
345 >                setcolor(whiteclr,
346 >                        colval(inpRGB[White],RED)/colval(mbRGB[White],RED),
347 >                        colval(inpRGB[White],GRN)/colval(mbRGB[White],GRN),
348 >                        colval(inpRGB[White],BLU)/colval(mbRGB[White],BLU));
349 >        }
350 >        for (n = 0; n < 24; n++)
351 >                if (inpflags & 1L<<n)
352 >                        setcolor(inpRGB[n],
353 >                                colval(inpRGB[n],RED)/colval(whiteclr,RED),
354 >                                colval(inpRGB[n],GRN)/colval(whiteclr,GRN),
355 >                                colval(inpRGB[n],BLU)/colval(whiteclr,BLU));
356   }
357  
358  
# Line 289 | Line 380 | COLOR  y, x;
380   compute()                       /* compute color mapping */
381   {
382          COLOR   clrin[NMBMOD], clrout[NMBMOD];
383 <        COLOR   ctmp;
384 <        double  d;
385 <        register int    i;
386 <                                        /* map MacBeth colors to RGB space */
387 <        for (i = 0; i < 24; i++) {
388 <                d = mbxyY[i][2] / mbxyY[i][1];
298 <                ctmp[0] = mbxyY[i][0] * d;
299 <                ctmp[1] = mbxyY[i][2];
300 <                ctmp[2] = (1. - mbxyY[i][0] - mbxyY[i][1]) * d;
301 <                cie_rgb(mbRGB[i], ctmp);
383 >        register int    i, n;
384 >                                        /* did we get what we need? */
385 >        if ((inpflags & REQFLGS) != REQFLGS) {
386 >                fprintf(stderr, "%s: missing required input colors\n",
387 >                                progname);
388 >                exit(1);
389          }
390                                          /* compute piecewise luminance curve */
391          for (i = 0; i < NMBNEU; i++) {
392 <                copycolor(bramp[i][0], picRGB[mbneu[i]]);
392 >                copycolor(bramp[i][0], inpRGB[mbneu[i]]);
393                  copycolor(bramp[i][1], mbRGB[mbneu[i]]);
394          }
395                                          /* compute color matrix */
396 <        for (i = 0; i < NMBMOD; i++) {
397 <                bresp(clrin[i], picRGB[mbmod[i]]);
398 <                copycolor(clrout[i], mbRGB[mbmod[i]]);
399 <        }
400 <        compsoln(clrin, clrout, NMBMOD);
396 >        for (n = 0, i = 0; i < NMBMOD; i++)
397 >                if (inpflags & 1L<<mbmod[i]) {
398 >                        bresp(clrin[n], inpRGB[mbmod[i]]);
399 >                        copycolor(clrout[n], mbRGB[mbmod[i]]);
400 >                        n++;
401 >                }
402 >        compsoln(clrin, clrout, n);
403   }
404  
405  
# Line 363 | Line 452 | int    n;
452          register int    i, j, k;
453  
454          if (n < 3 | n > NMBMOD) {
455 <                fprintf(stderr, "%s: inconsistent code!\n", progname);
455 >                fprintf(stderr, "%s: bad number of colors to match\n", progname);
456                  exit(1);
457          }
458          if (n == 3)
# Line 431 | Line 520 | COLOR  cout, cin;
520   }
521  
522  
523 < putdebug()                      /* put out debugging picture */
523 > xyY2RGB(rgbout, xyYin)          /* convert xyY to RGB */
524 > COLOR   rgbout;
525 > register float  xyYin[3];
526   {
527 +        COLOR   ctmp;
528 +        double  d;
529 +
530 +        d = xyYin[2] / xyYin[1];
531 +        ctmp[0] = xyYin[0] * d;
532 +        ctmp[1] = xyYin[2];
533 +        ctmp[2] = (1. - xyYin[0] - xyYin[1]) * d;
534 +        cie_rgb(rgbout, ctmp);
535 + }
536 +
537 +
538 + picdebug()                      /* put out debugging picture */
539 + {
540          COLOR   *scan;
541          int     y;
542          register int    x, i;
543  
440 –        if (debugfp == NULL)
441 –                return;
544          if (fseek(stdin, 0L, 0) == EOF) {
545                  fprintf(stderr, "%s: cannot seek on input picture\n", progname);
546                  exit(1);
# Line 455 | Line 557 | putdebug()                     /* put out debugging picture */
557          fputformat(COLRFMT, debugfp);
558          putc('\n', debugfp);
559          fprtresolu(xmax, ymax, debugfp);
560 +                                                /* write debug picture */
561          for (y = ymax-1; y >= 0; y--) {
562                  if (freadscan(scan, xmax, stdin) < 0) {
563                          fprintf(stderr, "%s: error rereading input picture\n",
# Line 462 | Line 565 | putdebug()                     /* put out debugging picture */
565                          exit(1);
566                  }
567                  for (x = 0; x < xmax; x++) {
568 <                        i = chartndx(x, y);
568 >                        i = chartndx(x, y, CENTCVG);
569                          if (i < 0)
570                                  cvtcolor(scan[x], scan[x]);
571                          else
# Line 474 | Line 577 | putdebug()                     /* put out debugging picture */
577                          exit(1);
578                  }
579          }
580 +                                                /* clean up */
581 +        fclose(debugfp);
582 +        free((char *)scan);
583 + }
584 +
585 +
586 + clrdebug()                      /* put out debug picture from color input */
587 + {
588 +        static COLR     blkclr = BLKCOLR;
589 +        COLR    mbclr[24], cvclr[24];
590 +        COLR    *scan;
591 +        COLOR   ctmp;
592 +        int     y;
593 +        register int    i, x;
594 +                                                /* convert colors */
595 +        for (i = 0; i < 24; i++) {
596 +                setcolr(mbclr[i], colval(mbRGB[i],RED),
597 +                                colval(mbRGB[i],GRN), colval(mbRGB[i],BLU));
598 +                if (inpflags & 1L<<i) {
599 +                        cvtcolor(ctmp, inpRGB[i]);
600 +                        setcolr(cvclr[i], colval(ctmp,RED),
601 +                                        colval(ctmp,GRN), colval(ctmp,BLU));
602 +                }
603 +        }
604 +                                                /* allocate scanline */
605 +        scan = (COLR *)malloc(xmax*sizeof(COLR));
606 +        if (scan == NULL) {
607 +                perror(progname);
608 +                exit(1);
609 +        }
610 +                                                /* finish debug header */
611 +        fputformat(COLRFMT, debugfp);
612 +        putc('\n', debugfp);
613 +        fprtresolu(xmax, ymax, debugfp);
614 +                                                /* write debug picture */
615 +        for (y = ymax-1; y >= 0; y--) {
616 +                for (x = 0; x < xmax; x++)
617 +                        if ((i = chartndx(x, y, CENTCVG)) >= 0)
618 +                                copycolr(scan[x], mbclr[i]);
619 +                        else if ((i = chartndx(x, y, FULLCVG)) >= 0 &&
620 +                                        inpflags & 1L<<i)
621 +                                copycolr(scan[x], cvclr[i]);
622 +                        else
623 +                                copycolr(scan[x], blkclr);
624 +                if (fwritecolrs(scan, xmax, debugfp) < 0) {
625 +                        fprintf(stderr, "%s: error writing debugging picture\n",
626 +                                        progname);
627 +                        exit(1);
628 +                }
629 +        }
630 +                                                /* clean up */
631 +        fclose(debugfp);
632          free((char *)scan);
633   }

Diff Legend

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