1 |
– |
/* Copyright (c) 1999 Regents of the University of California */ |
2 |
– |
|
1 |
|
#ifndef lint |
2 |
< |
static char SCCSid[] = "$SunId$ SGI"; |
2 |
> |
static const char RCSid[] = "$Id$"; |
3 |
|
#endif |
6 |
– |
|
4 |
|
/* |
5 |
|
* Calibrate a scanned MacBeth Color Checker Chart |
6 |
|
* |
12 |
|
|
13 |
|
#include <stdio.h> |
14 |
|
#include <math.h> |
15 |
< |
#ifdef MSDOS |
16 |
< |
#include <fcntl.h> |
17 |
< |
#endif |
15 |
> |
#include <time.h> |
16 |
> |
|
17 |
> |
#include "platform.h" |
18 |
> |
#include "rtprocess.h" |
19 |
> |
#include "rtio.h" |
20 |
|
#include "color.h" |
21 |
|
#include "resolu.h" |
22 |
|
#include "pmap.h" |
23 |
|
#include "warp3d.h" |
24 |
+ |
#include "mx3.h" |
25 |
|
|
26 |
|
/* MacBeth colors */ |
27 |
|
#define DarkSkin 0 |
101 |
|
#define RG_CORR 04 /* corrected color region */ |
102 |
|
|
103 |
|
#ifndef DISPCOM |
104 |
< |
#define DISPCOM "ximage -op %s" |
104 |
> |
#define DISPCOM "ximage -op \"%s\"" |
105 |
|
#endif |
106 |
|
|
107 |
|
int scanning = 1; /* scanned input (or recorded output)? */ |
125 |
|
FILE *debugfp = NULL; /* debug output picture */ |
126 |
|
char *progname; |
127 |
|
|
128 |
< |
extern char *malloc(); |
128 |
> |
static void init(void); |
129 |
> |
static int chartndx(int x, int y, int *np); |
130 |
> |
static void getpicture(void); |
131 |
> |
static void getcolors(void); |
132 |
> |
static void bresp(COLOR y, COLOR x); |
133 |
> |
static void compute(void); |
134 |
> |
static void putmapping(void); |
135 |
> |
static void compsoln(COLOR cin[], COLOR cout[], int n); |
136 |
> |
static void cwarp(void); |
137 |
> |
static int cvtcolor(COLOR cout, COLOR cin); |
138 |
> |
static int cresp(COLOR cout, COLOR cin); |
139 |
> |
static void xyY2RGB(COLOR rgbout, float xyYin[3]); |
140 |
> |
static void picdebug(void); |
141 |
> |
static void clrdebug(void); |
142 |
> |
static void getpos(char *name, int bnds[2], FILE *fp); |
143 |
> |
static void pickchartpos(char *pfn); |
144 |
|
|
145 |
|
|
146 |
< |
main(argc, argv) |
147 |
< |
int argc; |
148 |
< |
char **argv; |
146 |
> |
int |
147 |
> |
main( |
148 |
> |
int argc, |
149 |
> |
char **argv |
150 |
> |
) |
151 |
|
{ |
152 |
|
int i; |
153 |
|
|
162 |
|
perror(argv[i]); |
163 |
|
exit(1); |
164 |
|
} |
165 |
< |
#ifdef MSDOS |
149 |
< |
setmode(fileno(debugfp), O_BINARY); |
150 |
< |
#endif |
165 |
> |
SET_FILE_BINARY(debugfp); |
166 |
|
newheader("RADIANCE", debugfp); /* start */ |
167 |
|
printargs(argc, argv, debugfp); /* header */ |
168 |
|
break; |
207 |
|
exit(1); |
208 |
|
} |
209 |
|
if (scanning) { /* load input picture header */ |
210 |
< |
#ifdef MSDOS |
196 |
< |
setmode(fileno(stdin), O_BINARY); |
197 |
< |
#endif |
210 |
> |
SET_FILE_BINARY(stdin); |
211 |
|
if (checkheader(stdin, COLRFMT, NULL) < 0 || |
212 |
|
fgetresolu(&xmax, &ymax, stdin) < 0) { |
213 |
|
fprintf(stderr, "%s: bad input picture\n", progname); |
263 |
|
printf("}\n"); |
264 |
|
putmapping(); /* put out color mapping */ |
265 |
|
} |
266 |
< |
if (debugfp != NULL) /* put out debug picture */ |
266 |
> |
if (debugfp != NULL) { /* put out debug picture */ |
267 |
|
if (scanning) |
268 |
|
picdebug(); |
269 |
|
else |
270 |
|
clrdebug(); |
271 |
+ |
} |
272 |
|
exit(0); |
273 |
|
userr: |
274 |
|
fprintf(stderr, |
277 |
|
fprintf(stderr, " or: %s [-d dbg.pic][-i irrad][-m] -c [xyY.dat [output.{cal|cwp}]]\n", |
278 |
|
progname); |
279 |
|
exit(1); |
280 |
+ |
return 1; /* pro forma return */ |
281 |
|
} |
282 |
|
|
283 |
|
|
284 |
< |
init() /* initialize */ |
284 |
> |
static void |
285 |
> |
init(void) /* initialize */ |
286 |
|
{ |
287 |
|
double quad[4][2]; |
288 |
|
register int i; |
308 |
|
} |
309 |
|
|
310 |
|
|
311 |
< |
int |
312 |
< |
chartndx(x, y, np) /* find color number for position */ |
313 |
< |
int x, y; |
314 |
< |
int *np; |
311 |
> |
static int |
312 |
> |
chartndx( /* find color number for position */ |
313 |
> |
int x, |
314 |
> |
int y, |
315 |
> |
int *np |
316 |
> |
) |
317 |
|
{ |
318 |
|
double ipos[3], cpos[3]; |
319 |
|
int ix, iy; |
342 |
|
} |
343 |
|
|
344 |
|
|
345 |
< |
getpicture() /* load in picture colors */ |
345 |
> |
static void |
346 |
> |
getpicture(void) /* load in picture colors */ |
347 |
|
{ |
348 |
|
COLR *scanln; |
349 |
|
COLOR pval; |
381 |
|
scalecolor(inpRGB[i], d); |
382 |
|
inpflags |= 1L<<i; |
383 |
|
} |
384 |
< |
free((char *)scanln); |
384 |
> |
free((void *)scanln); |
385 |
|
} |
386 |
|
|
387 |
|
|
388 |
< |
getcolors() /* get xyY colors from standard input */ |
388 |
> |
static void |
389 |
> |
getcolors(void) /* get xyY colors from standard input */ |
390 |
|
{ |
391 |
|
int gotwhite = 0; |
392 |
|
COLOR whiteclr; |
394 |
|
float xyYin[3]; |
395 |
|
|
396 |
|
while (fgetval(stdin, 'i', &n) == 1) { /* read colors */ |
397 |
< |
if (n < 0 | n > 24 || |
397 |
> |
if ((n < 0) | (n > 24) || |
398 |
|
fgetval(stdin, 'f', &xyYin[0]) != 1 || |
399 |
|
fgetval(stdin, 'f', &xyYin[1]) != 1 || |
400 |
|
fgetval(stdin, 'f', &xyYin[2]) != 1 || |
401 |
< |
xyYin[0] < 0. | xyYin[1] < 0. || |
401 |
> |
(xyYin[0] < 0.) | (xyYin[1] < 0.) || |
402 |
|
xyYin[0] + xyYin[1] > 1.) { |
403 |
|
fprintf(stderr, "%s: bad color input data\n", |
404 |
|
progname); |
434 |
|
} |
435 |
|
|
436 |
|
|
437 |
< |
bresp(y, x) /* piecewise linear interpolation of primaries */ |
438 |
< |
COLOR y, x; |
437 |
> |
static void |
438 |
> |
bresp( /* piecewise linear interpolation of primaries */ |
439 |
> |
COLOR y, |
440 |
> |
COLOR x |
441 |
> |
) |
442 |
|
{ |
443 |
|
register int i, n; |
444 |
|
|
455 |
|
} |
456 |
|
|
457 |
|
|
458 |
< |
compute() /* compute color mapping */ |
458 |
> |
static void |
459 |
> |
compute(void) /* compute color mapping */ |
460 |
|
{ |
461 |
|
COLOR clrin[24], clrout[24]; |
462 |
|
long cflags; |
471 |
|
/* compute piecewise luminance curve */ |
472 |
|
for (i = 0; i < NMBNEU; i++) { |
473 |
|
copycolor(bramp[i][0], inpRGB[mbneu[i]]); |
474 |
+ |
for (n = i ? 3 : 0; n--; ) |
475 |
+ |
if (colval(bramp[i][0],n) <= |
476 |
+ |
colval(bramp[i-1][0],n)+1e-7) { |
477 |
+ |
fprintf(stderr, |
478 |
+ |
"%s: non-increasing neutral patch\n", progname); |
479 |
+ |
exit(1); |
480 |
+ |
} |
481 |
|
copycolor(bramp[i][1], mbRGB[mbneu[i]]); |
482 |
|
} |
483 |
|
/* compute color space gamut */ |
521 |
|
} |
522 |
|
|
523 |
|
|
524 |
< |
putmapping() /* put out color mapping */ |
524 |
> |
static void |
525 |
> |
putmapping(void) /* put out color mapping */ |
526 |
|
{ |
527 |
|
static char cchar[3] = {'r', 'g', 'b'}; |
528 |
|
register int i, j; |
570 |
|
} |
571 |
|
|
572 |
|
|
573 |
< |
compsoln(cin, cout, n) /* solve 3xN system using least-squares */ |
574 |
< |
COLOR cin[], cout[]; |
575 |
< |
int n; |
573 |
> |
static void |
574 |
> |
compsoln( /* solve 3xN system using least-squares */ |
575 |
> |
COLOR cin[], |
576 |
> |
COLOR cout[], |
577 |
> |
int n |
578 |
> |
) |
579 |
|
{ |
580 |
|
extern double mx3d_adjoint(), fabs(); |
581 |
|
double mat[3][3], invmat[3][3]; |
633 |
|
} |
634 |
|
|
635 |
|
|
636 |
< |
cwarp() /* compute color warp map */ |
636 |
> |
static void |
637 |
> |
cwarp(void) /* compute color warp map */ |
638 |
|
{ |
639 |
|
register int i; |
640 |
|
|
650 |
|
} |
651 |
|
|
652 |
|
|
653 |
< |
int |
654 |
< |
cvtcolor(cout, cin) /* convert color according to our mapping */ |
655 |
< |
COLOR cout, cin; |
653 |
> |
static int |
654 |
> |
cvtcolor( /* convert color according to our mapping */ |
655 |
> |
COLOR cout, |
656 |
> |
COLOR cin |
657 |
> |
) |
658 |
|
{ |
659 |
|
COLOR ctmp; |
660 |
|
int clipped; |
673 |
|
} |
674 |
|
|
675 |
|
|
676 |
< |
int |
677 |
< |
cresp(cout, cin) /* transform color according to matrix */ |
678 |
< |
COLOR cout, cin; |
676 |
> |
static int |
677 |
> |
cresp( /* transform color according to matrix */ |
678 |
> |
COLOR cout, |
679 |
> |
COLOR cin |
680 |
> |
) |
681 |
|
{ |
682 |
|
colortrans(cout, solmat, cin); |
683 |
|
return(clipgamut(cout, bright(cout), CGAMUT, colmin, colmax)); |
684 |
|
} |
685 |
|
|
686 |
|
|
687 |
< |
xyY2RGB(rgbout, xyYin) /* convert xyY to RGB */ |
688 |
< |
COLOR rgbout; |
689 |
< |
register float xyYin[3]; |
687 |
> |
static void |
688 |
> |
xyY2RGB( /* convert xyY to RGB */ |
689 |
> |
COLOR rgbout, |
690 |
> |
register float xyYin[3] |
691 |
> |
) |
692 |
|
{ |
693 |
|
COLOR ctmp; |
694 |
|
double d; |
702 |
|
} |
703 |
|
|
704 |
|
|
705 |
< |
picdebug() /* put out debugging picture */ |
705 |
> |
static void |
706 |
> |
picdebug(void) /* put out debugging picture */ |
707 |
|
{ |
708 |
|
static COLOR blkcol = BLKCOLOR; |
709 |
|
COLOR *scan; |
755 |
|
} |
756 |
|
/* clean up */ |
757 |
|
fclose(debugfp); |
758 |
< |
free((char *)scan); |
758 |
> |
free((void *)scan); |
759 |
|
} |
760 |
|
|
761 |
|
|
762 |
< |
clrdebug() /* put out debug picture from color input */ |
762 |
> |
static void |
763 |
> |
clrdebug(void) /* put out debug picture from color input */ |
764 |
|
{ |
765 |
|
static COLR blkclr = BLKCOLR; |
766 |
|
COLR mbclr[24], cvclr[24], orclr[24]; |
826 |
|
} |
827 |
|
/* clean up */ |
828 |
|
fclose(debugfp); |
829 |
< |
free((char *)scan); |
829 |
> |
free((void *)scan); |
830 |
|
} |
831 |
|
|
832 |
|
|
833 |
< |
getpos(name, bnds, fp) /* get boundary position */ |
834 |
< |
char *name; |
835 |
< |
int bnds[2]; |
836 |
< |
FILE *fp; |
833 |
> |
static void |
834 |
> |
getpos( /* get boundary position */ |
835 |
> |
char *name, |
836 |
> |
int bnds[2], |
837 |
> |
FILE *fp |
838 |
> |
) |
839 |
|
{ |
840 |
|
char buf[64]; |
841 |
|
|
849 |
|
} |
850 |
|
|
851 |
|
|
852 |
< |
pickchartpos(pfn) /* display picture and pick chart location */ |
853 |
< |
char *pfn; |
852 |
> |
static void |
853 |
> |
pickchartpos( /* display picture and pick chart location */ |
854 |
> |
char *pfn |
855 |
> |
) |
856 |
|
{ |
857 |
< |
char combuf[512]; |
857 |
> |
char combuf[PATH_MAX]; |
858 |
|
FILE *pfp; |
859 |
|
|
860 |
|
sprintf(combuf, DISPCOM, pfn); |