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.7 by greg, Fri Oct 20 15:26:11 1995 UTC vs.
Revision 2.10 by greg, Wed Nov 1 09:04:16 1995 UTC

# Line 77 | Line 77 | COLOR  mbRGB[24];              /* MacBeth RGB values */
77   #define NMBNEU          6       /* Number of MacBeth neutral colors */
78   short   mbneu[NMBNEU] = {Black,Neutral35,Neutral5,Neutral65,Neutral8,White};
79  
80 < #define NMBMOD          16      /* Number of MacBeth unsaturated colors */
81 < short   mbmod[NMBMOD] = {
82 <                DarkSkin,LightSkin,BlueSky,Foliage,BlueFlower,BluishGreen,
83 <                PurplishBlue,ModerateRed,YellowGreen,OrangeYellow,
84 <                Black,Neutral35,Neutral5,Neutral65,Neutral8,White
85 <        };
80 > #define  NEUFLGS        (1L<<White|1L<<Neutral8|1L<<Neutral65| \
81 >                                1L<<Neutral5|1L<<Neutral35|1L<<Black)
82  
83 < #define NMBSAT          8       /* Number of MacBeth saturated colors */
84 < short   mbsat[NMBSAT] = {
85 <                Red,Green,Blue,Magenta,Yellow,Cyan,
90 <                Orange,Purple
91 <        };
83 > #define  SATFLGS        (1L<<Red|1L<<Green|1L<<Blue|1L<<Magenta|1L<<Yellow| \
84 >                        1L<<Cyan|1L<<Orange|1L<<Purple|1L<<PurplishBlue| \
85 >                        1L<<YellowGreen|1<<OrangeYellow|1L<<BlueFlower)
86  
87 < #define  REQFLGS        (1L<<White|1L<<Neutral8|1L<<Neutral65| \
88 <                                1L<<Neutral5|1L<<Neutral35|1L<<Black)
87 > #define  UNSFLGS        (1L<<DarkSkin|1L<<LightSkin|1L<<BlueSky|1L<<Foliage| \
88 >                        1L<<BluishGreen|1L<<ModerateRed)
89  
90 < #define  CENTCVG        0.3     /* measured coverage of square sample */
91 < #define  FULLCVG        0.9     /* coverage of entire square */
90 > #define  REQFLGS        NEUFLGS                 /* need these colors */
91 > #define  MODFLGS        (NEUFLGS|UNSFLGS)       /* should be in gamut */
92  
93 + #define  RG_BORD        0       /* patch border */
94 + #define  RG_CENT        01      /* central region of patch */
95 + #define  RG_ORIG        02      /* original color region */
96 + #define  RG_CORR        04      /* corrected color region */
97 +
98   int     xmax, ymax;             /* input image dimensions */
99   int     bounds[4][2];           /* image coordinates of chart corners */
100   double  imgxfm[3][3];           /* coordinate transformation matrix */
101  
102   COLOR   inpRGB[24];             /* measured or scanned input colors */
103   long    inpflags = 0;           /* flags of which colors were input */
104 + long    gmtflags = 0;           /* flags of out-of-gamut colors */
105  
106   COLOR   bramp[NMBNEU][2];       /* brightness ramp (per primary) */
107   double  solmat[3][3];           /* color mapping matrix */
# Line 190 | Line 190 | char   **argv;
190                  getcolors();
191          compute();                      /* compute color mapping */
192                                          /* print comment */
193 <        printf("{ Color correction file computed by:\n\t");
193 >        printf("{\n\tColor correction file computed by:\n\t\t");
194          printargs(argc, argv, stdout);
195 +        printf("\n\tUsage: pcomb -f %s uncorrected.pic > corrected.pic\n",
196 +                        i+1 < argc ? argv[i+1] : "{this_file}");
197          printf("}\n");
198          putmapping();                   /* put out color mapping */
199          if (debugfp != NULL)            /* put out debug picture */
# Line 235 | Line 237 | init()                         /* initialize */
237  
238  
239   int
240 < chartndx(x, y, cvg)                     /* find color number for position */
240 > chartndx(x, y, np)                      /* find color number for position */
241   int     x, y;
242 < double  cvg;
242 > int     *np;
243   {
244          double  ipos[3], cpos[3];
245          int     ix, iy;
246          double  fx, fy;
245 –        double  cmin, cmax;
247  
248          ipos[0] = x;
249          ipos[1] = y;
# Line 251 | Line 252 | double cvg;
252          cpos[0] /= cpos[2];
253          cpos[1] /= cpos[2];
254          if (cpos[0] < 0. || cpos[0] >= 6. || cpos[1] < 0. || cpos[1] >= 4.)
255 <                return(-1);
255 >                return(RG_BORD);
256          ix = cpos[0];
257          iy = cpos[1];
258          fx = cpos[0] - ix;
259          fy = cpos[1] - iy;
260 <        cmin = .5*(1.-cvg);
261 <        cmax = 1. - cmin;
262 <        if (fx < cmin || fx >= cmax || fy < cmin || fy >= cmax)
263 <                return(-1);
264 <        return(iy*6 + ix);
260 >        *np = iy*6 + ix;
261 >        if (fx >= 0.35 && fx < 0.65 && fy >= 0.35 && fy < 0.65)
262 >                return(RG_CENT);
263 >        if (fx < 0.05 || fx >= 0.95 || fy < 0.05 || fy >= 0.95)
264 >                return(RG_BORD);
265 >        if (fx >= 0.5)                  /* right side is corrected */
266 >                return(RG_CORR);
267 >        return(RG_ORIG);                /* left side is original */
268   }
269  
270  
# Line 270 | Line 274 | getpicture()                           /* load in picture colors */
274          COLOR   pval;
275          int     ccount[24];
276          double  d;
277 <        int     y;
278 <        register int    x, i;
277 >        int     y, i;
278 >        register int    x;
279  
280          scanln = (COLR *)malloc(xmax*sizeof(COLR));
281          if (scanln == NULL) {
# Line 288 | Line 292 | getpicture()                           /* load in picture colors */
292                                          progname);
293                          exit(1);
294                  }
295 <                for (x = 0; x < xmax; x++) {
296 <                        i = chartndx(x, y, CENTCVG);
293 <                        if (i >= 0) {
295 >                for (x = 0; x < xmax; x++)
296 >                        if (chartndx(x, y, &i) == RG_CENT) {
297                                  colr_color(pval, scanln[x]);
298                                  addcolor(inpRGB[i], pval);
299                                  ccount[i]++;
300                          }
298 –                }
301          }
302          for (i = 0; i < 24; i++) {              /* compute averages */
303                  if (ccount[i] == 0)
# Line 359 | Line 361 | getcolors()                    /* get xyY colors from standard input */
361   bresp(y, x)             /* piecewise linear interpolation of primaries */
362   COLOR   y, x;
363   {
362 –        double  cv[3];
364          register int    i, n;
365  
366          for (i = 0; i < 3; i++) {
367                  for (n = 0; n < NMBNEU-2; n++)
368                          if (colval(x,i) < colval(bramp[n+1][0],i))
369                                  break;
370 <                cv[i] = ((colval(bramp[n+1][0],i) - colval(x,i)) *
370 >                colval(y,i) = ((colval(bramp[n+1][0],i) - colval(x,i)) *
371                                                  colval(bramp[n][1],i) +
372                                  (colval(x,i) - colval(bramp[n][0],i)) *
373                                                  colval(bramp[n+1][1],i)) /
374                          (colval(bramp[n+1][0],i) - colval(bramp[n][0],i));
374 –                if (cv[i] < 0.) cv[i] = 0.;
375          }
376 –        setcolor(y, cv[0], cv[1], cv[2]);
376   }
377  
378  
379   compute()                       /* compute color mapping */
380   {
381 <        COLOR   clrin[NMBMOD], clrout[NMBMOD];
382 <        register int    i, n;
381 >        COLOR   clrin[24], clrout[24];
382 >        long    cflags;
383 >        COLOR   ctmp;
384 >        register int    i, j, n;
385                                          /* did we get what we need? */
386          if ((inpflags & REQFLGS) != REQFLGS) {
387                  fprintf(stderr, "%s: missing required input colors\n",
# Line 392 | Line 393 | compute()                      /* compute color mapping */
393                  copycolor(bramp[i][0], inpRGB[mbneu[i]]);
394                  copycolor(bramp[i][1], mbRGB[mbneu[i]]);
395          }
396 <                                        /* compute color matrix */
397 <        for (n = 0, i = 0; i < NMBMOD; i++)
398 <                if (inpflags & 1L<<mbmod[i]) {
399 <                        bresp(clrin[n], inpRGB[mbmod[i]]);
400 <                        copycolor(clrout[n], mbRGB[mbmod[i]]);
401 <                        n++;
402 <                }
403 <        compsoln(clrin, clrout, n);
396 >                                        /* compute color mapping */
397 >        do {
398 >                cflags = inpflags & ~gmtflags;
399 >                n = 0;                          /* compute transform matrix */
400 >                for (i = 0; i < 24; i++)
401 >                        if (cflags & 1L<<i) {
402 >                                bresp(clrin[n], inpRGB[i]);
403 >                                copycolor(clrout[n], mbRGB[i]);
404 >                                n++;
405 >                        }
406 >                compsoln(clrin, clrout, n);
407 >                                                /* check out-of-gamut colors */
408 >                for (i = 0; i < 24; i++)
409 >                        if (cflags & 1L<<i) {
410 >                                cresp(ctmp, mbRGB[i]);
411 >                                for (j = 0; j < 3; j++)
412 >                                        if (colval(ctmp,j) <= 0. ||
413 >                                                colval(ctmp,j) >= 1.) {
414 >                                                gmtflags |= 1L<<i;
415 >                                                break;
416 >                                        }
417 >                        }
418 >        } while (cflags & gmtflags);
419 >        if (gmtflags & MODFLGS)
420 >                fprintf(stderr,
421 >                "%s: warning - some moderate colors are out of gamut\n",
422 >                                progname);
423   }
424  
425  
# Line 451 | Line 471 | int    n;
471          double  colv[3], rowv[3];
472          register int    i, j, k;
473  
474 <        if (n < 3 | n > NMBMOD) {
475 <                fprintf(stderr, "%s: bad number of colors to match\n", progname);
474 >        if (n < 3) {
475 >                fprintf(stderr, "%s: too few colors to match!\n", progname);
476                  exit(1);
477          }
478          if (n == 3)
# Line 504 | Line 524 | int    n;
524   cvtcolor(cout, cin)             /* convert color according to our mapping */
525   COLOR   cout, cin;
526   {
527 +        COLOR   ctmp;
528 +
529 +        bresp(ctmp, cin);
530 +        cresp(cout, ctmp);
531 +        if (colval(cout,RED) < 0.)
532 +                colval(cout,RED) = 0.;
533 +        if (colval(cout,GRN) < 0.)
534 +                colval(cout,GRN) = 0.;
535 +        if (colval(cout,BLU) < 0.)
536 +                colval(cout,BLU) = 0.;
537 + }
538 +
539 +
540 + cresp(cout, cin)                /* transform color according to matrix */
541 + COLOR   cout, cin;
542 + {
543          double  r, g, b;
544  
545 <        bresp(cout, cin);
546 <        r = colval(cout,0)*solmat[0][0] + colval(cout,1)*solmat[0][1]
547 <                        + colval(cout,2)*solmat[0][2];
548 <        if (r < 0) r = 0;
549 <        g = colval(cout,0)*solmat[1][0] + colval(cout,1)*solmat[1][1]
550 <                        + colval(cout,2)*solmat[1][2];
515 <        if (g < 0) g = 0;
516 <        b = colval(cout,0)*solmat[2][0] + colval(cout,1)*solmat[2][1]
517 <                        + colval(cout,2)*solmat[2][2];
518 <        if (b < 0) b = 0;
545 >        r = colval(cin,0)*solmat[0][0] + colval(cin,1)*solmat[0][1]
546 >                        + colval(cin,2)*solmat[0][2];
547 >        g = colval(cin,0)*solmat[1][0] + colval(cin,1)*solmat[1][1]
548 >                        + colval(cin,2)*solmat[1][2];
549 >        b = colval(cin,0)*solmat[2][0] + colval(cin,1)*solmat[2][1]
550 >                        + colval(cin,2)*solmat[2][2];
551          setcolor(cout, r, g, b);
552   }
553  
# Line 537 | Line 569 | register float xyYin[3];
569  
570   picdebug()                      /* put out debugging picture */
571   {
572 +        static COLOR    blkcol = BLKCOLOR;
573          COLOR   *scan;
574 <        int     y;
575 <        register int    x, i;
574 >        int     y, i;
575 >        register int    x, rg;
576  
577          if (fseek(stdin, 0L, 0) == EOF) {
578                  fprintf(stderr, "%s: cannot seek on input picture\n", progname);
# Line 565 | Line 598 | picdebug()                     /* put out debugging picture */
598                          exit(1);
599                  }
600                  for (x = 0; x < xmax; x++) {
601 <                        i = chartndx(x, y, CENTCVG);
602 <                        if (i < 0)
601 >                        rg = chartndx(x, y, &i);
602 >                        if (rg == RG_CENT) {
603 >                                if (!(1L<<i & gmtflags) || (x+y)&07)
604 >                                        copycolor(scan[x], mbRGB[i]);
605 >                                else
606 >                                        copycolor(scan[x], blkcol);
607 >                        } else if (rg == RG_CORR)
608                                  cvtcolor(scan[x], scan[x]);
609 <                        else
610 <                                copycolor(scan[x], mbRGB[i]);
609 >                        else if (rg != RG_ORIG)
610 >                                copycolor(scan[x], blkcol);
611                  }
612                  if (fwritescan(scan, xmax, debugfp) < 0) {
613                          fprintf(stderr, "%s: error writing debugging picture\n",
# Line 586 | Line 624 | picdebug()                     /* put out debugging picture */
624   clrdebug()                      /* put out debug picture from color input */
625   {
626          static COLR     blkclr = BLKCOLR;
627 <        COLR    mbclr[24], cvclr[24];
627 >        COLR    mbclr[24], cvclr[24], orclr[24];
628          COLR    *scan;
629          COLOR   ctmp;
630 <        int     y;
631 <        register int    i, x;
630 >        int     y, i;
631 >        register int    x, rg;
632                                                  /* convert colors */
633          for (i = 0; i < 24; i++) {
634                  setcolr(mbclr[i], colval(mbRGB[i],RED),
635                                  colval(mbRGB[i],GRN), colval(mbRGB[i],BLU));
636                  if (inpflags & 1L<<i) {
637 +                        setcolr(orclr[i], colval(inpRGB[i],RED),
638 +                                        colval(inpRGB[i],GRN),
639 +                                        colval(inpRGB[i],BLU));
640                          cvtcolor(ctmp, inpRGB[i]);
641                          setcolr(cvclr[i], colval(ctmp,RED),
642                                          colval(ctmp,GRN), colval(ctmp,BLU));
# Line 613 | Line 654 | clrdebug()                     /* put out debug picture from color input
654          fprtresolu(xmax, ymax, debugfp);
655                                                  /* write debug picture */
656          for (y = ymax-1; y >= 0; y--) {
657 <                for (x = 0; x < xmax; x++)
658 <                        if ((i = chartndx(x, y, CENTCVG)) >= 0)
659 <                                copycolr(scan[x], mbclr[i]);
660 <                        else if ((i = chartndx(x, y, FULLCVG)) >= 0 &&
661 <                                        inpflags & 1L<<i)
662 <                                copycolr(scan[x], cvclr[i]);
663 <                        else
657 >                for (x = 0; x < xmax; x++) {
658 >                        rg = chartndx(x, y, &i);
659 >                        if (rg == RG_CENT) {
660 >                                if (!(1L<<i & gmtflags) || (x+y)&07)
661 >                                        copycolr(scan[x], mbclr[i]);
662 >                                else
663 >                                        copycolr(scan[x], blkclr);
664 >                        } else if (rg == RG_BORD || !(1L<<i & inpflags))
665                                  copycolr(scan[x], blkclr);
666 +                        else if (rg == RG_ORIG)
667 +                                copycolr(scan[x], orclr[i]);
668 +                        else /* rg == RG_CORR */
669 +                                copycolr(scan[x], cvclr[i]);
670 +                }
671                  if (fwritecolrs(scan, xmax, debugfp) < 0) {
672                          fprintf(stderr, "%s: error writing debugging picture\n",
673                                          progname);

Diff Legend

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