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

Comparing ray/src/common/tmaptiff.c (file contents):
Revision 3.2 by greg, Tue Feb 25 02:47:22 2003 UTC vs.
Revision 3.3 by greg, Mon Jul 14 04:56:54 2003 UTC

# Line 14 | Line 14 | static const char      RCSid[] = "$Id$";
14   #include "tmprivat.h"
15   #include "tmaptiff.h"
16  
17 +                                        /* input cases we handle */
18 + #define TC_LOGLUV32     1
19 + #define TC_LOGLUV24     2
20 + #define TC_LOGL16       3
21 + #define TC_GRYFLOAT     4
22 + #define TC_RGBFLOAT     5
23 + #define TC_GRYSHORT     6
24 + #define TC_RGBSHORT     7
25  
26 + /* figure out what kind of TIFF we have and if we can tone-map it */
27 + static int
28 + getTIFFtype(TIFF *tif)
29 + {
30 +        uint16  comp, phot, pconf;
31 +        uint16  samp_fmt, bits_samp;
32 +        
33 +        TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &pconf);
34 +        if (pconf != PLANARCONFIG_CONTIG)
35 +                return(0);
36 +        TIFFGetFieldDefaulted(tif, TIFFTAG_PHOTOMETRIC, &phot);
37 +        TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &comp);
38 +        TIFFGetFieldDefaulted(tif, TIFFTAG_SAMPLEFORMAT, &samp_fmt);
39 +        TIFFGetFieldDefaulted(tif, TIFFTAG_BITSPERSAMPLE, &bits_samp);
40 +        switch (phot) {
41 +        case PHOTOMETRIC_LOGLUV:
42 +                if (comp == COMPRESSION_SGILOG)
43 +                        return(TC_LOGLUV32);
44 +                if (comp == COMPRESSION_SGILOG24)
45 +                        return(TC_LOGLUV24);
46 +                return(0);
47 +        case PHOTOMETRIC_LOGL:
48 +                if (comp == COMPRESSION_SGILOG)
49 +                        return(TC_LOGL16);
50 +                return(0);
51 +        case PHOTOMETRIC_MINISBLACK:
52 +                if (samp_fmt == SAMPLEFORMAT_UINT) {
53 +                        if (bits_samp == 16)
54 +                                return(TC_GRYSHORT);
55 +                        return(0);
56 +                }
57 +                if (samp_fmt == SAMPLEFORMAT_IEEEFP) {
58 +                        if (bits_samp == 8*sizeof(float))
59 +                                return(TC_GRYFLOAT);
60 +                        return(0);
61 +                }
62 +                return(0);
63 +        case PHOTOMETRIC_RGB:
64 +                if (samp_fmt == SAMPLEFORMAT_UINT) {
65 +                        if (bits_samp == 16)
66 +                                return(TC_RGBSHORT);
67 +                        return(0);
68 +                }
69 +                if (samp_fmt == SAMPLEFORMAT_IEEEFP) {
70 +                        if (bits_samp == 8*sizeof(float))
71 +                                return(TC_RGBFLOAT);
72 +                        return(0);
73 +                }
74 +                return(0);
75 +        }
76 +        return(0);
77 + }
78 +
79 + /* load and convert TIFF */
80   int
81 < tmLoadTIFF(lpp, cpp, xp, yp, fname, tp) /* load and convert TIFF */
20 < TMbright        **lpp;
21 < BYTE    **cpp;
22 < int     *xp, *yp;
23 < char    *fname;
24 < TIFF    *tp;
81 > tmLoadTIFF(TMbright **lpp, BYTE **cpp, int *xp, int *yp, char *fname, TIFF *tp)
82   {
83          char    *funcName = fname==NULL ? "tmLoadTIFF" : fname;
84 +        RGBPRIMP        inppri = tmTop->monpri;
85 +        RGBPRIMS        myprims;
86 +        float   *fa;
87          TIFF    *tif;
88          int     err;
89 <        union {uint16 *w; uint32 *l; MEM_PTR p;} sl;
30 <        uint16  comp, phot, pconf;
89 >        union {uint16 *w; uint32 *l; float *f; MEM_PTR p;} sl;
90          uint32  width, height;
91 +        int     tcase;
92          double  stonits;
93          int     y;
94                                          /* check arguments */
# Line 43 | Line 103 | TIFF   *tp;
103          err = TM_E_BADFILE;
104          if ((tif = tp) == NULL && (tif = TIFFOpen(fname, "r")) == NULL)
105                  returnErr(TM_E_BADFILE);
106 <        TIFFGetFieldDefaulted(tif, TIFFTAG_PHOTOMETRIC, &phot);
107 <        TIFFGetFieldDefaulted(tif, TIFFTAG_COMPRESSION, &comp);
106 >        tcase = getTIFFtype(tif);
107 >        if (!tcase)
108 >                goto done;
109          if (!TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width) ||
110                          !TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height))
111                  goto done;
112          *xp = width; *yp = height;
113 <        TIFFGetFieldDefaulted(tif, TIFFTAG_PLANARCONFIG, &pconf);
114 <        if (pconf != PLANARCONFIG_CONTIG)
115 <                goto done;
113 >        if (TIFFGetField(tif, TIFFTAG_PRIMARYCHROMATICITIES, &fa)) {
114 >                myprims[RED][CIEX] = fa[0];
115 >                myprims[RED][CIEY] = fa[1];
116 >                myprims[GRN][CIEX] = fa[2];
117 >                myprims[GRN][CIEY] = fa[3];
118 >                myprims[BLU][CIEX] = fa[4];
119 >                myprims[BLU][CIEY] = fa[5];
120 >                myprims[WHT][CIEX] = 1./3.;
121 >                myprims[WHT][CIEY] = 1./3.;
122 >                if (TIFFGetField(tif, TIFFTAG_WHITEPOINT, &fa)) {
123 >                        myprims[WHT][CIEX] = fa[0];
124 >                        myprims[WHT][CIEY] = fa[1];
125 >                }
126 >                inppri = myprims;
127 >        }
128          if (!TIFFGetField(tif, TIFFTAG_STONITS, &stonits))
129                  stonits = 1.;
130 <        if (phot == PHOTOMETRIC_LOGLUV) {
131 <                if (comp != COMPRESSION_SGILOG && comp != COMPRESSION_SGILOG24)
132 <                        goto done;
130 >        switch (tcase) {                /* set up conversion */
131 >        case TC_LOGLUV32:
132 >        case TC_LOGLUV24:
133                  TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_RAW);
134                  sl.l = (uint32 *)malloc(width*sizeof(uint32));
135 <                if (cpp != TM_NOCHROMP) {
136 <                        *cpp = (BYTE *)malloc(width*height*3*sizeof(BYTE));
137 <                        if (*cpp == NULL) {
65 <                                err = TM_E_NOMEM;
66 <                                goto done;
67 <                        }
68 <                }
69 <        } else if (phot == PHOTOMETRIC_LOGL) {
70 <                if (comp != COMPRESSION_SGILOG)
71 <                        goto done;
135 >                tmSetSpace(TM_XYZPRIM, stonits);
136 >                break;
137 >        case TC_LOGL16:
138                  TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_16BIT);
139                  sl.w = (uint16 *)malloc(width*sizeof(uint16));
140 <        } else
140 >                tmSetSpace(tmTop->monpri, stonits);
141 >                break;
142 >        case TC_RGBFLOAT:
143 >                sl.f = (float *)malloc(width*3*sizeof(float));
144 >                tmSetSpace(inppri, stonits);
145 >                break;
146 >        case TC_GRYFLOAT:
147 >                sl.f = (float *)malloc(width*sizeof(float));
148 >                tmSetSpace(tmTop->monpri, stonits);
149 >                break;
150 >        case TC_RGBSHORT:
151 >                sl.w = (uint16 *)malloc(width*3*sizeof(uint16));
152 >                tmSetSpace(inppri, stonits);
153 >                break;
154 >        case TC_GRYSHORT:
155 >                sl.w = (uint16 *)malloc(width*sizeof(uint16));
156 >                tmSetSpace(tmTop->monpri, stonits);
157 >                break;
158 >        default:
159 >                err = TM_E_CODERR1;
160                  goto done;
161 +        }
162          *lpp = (TMbright *)malloc(width*height*sizeof(TMbright));
163          if (sl.p == NULL | *lpp == NULL) {
164                  err = TM_E_NOMEM;
165                  goto done;
166          }
167 <                                        /* set input color space */
168 <        tmSetSpace(TM_XYZPRIM, stonits);
167 >        switch (tcase) {                /* allocate color if needed */
168 >        case TC_LOGLUV32:
169 >        case TC_LOGLUV24:
170 >        case TC_RGBFLOAT:
171 >        case TC_RGBSHORT:
172 >                if (cpp == TM_NOCHROMP)
173 >                        break;
174 >                *cpp = (BYTE *)malloc(width*height*3*sizeof(BYTE));
175 >                if (*cpp == NULL) {
176 >                        err = TM_E_NOMEM;
177 >                        goto done;
178 >                }
179 >                break;
180 >        }
181                                          /* read and convert each scanline */
182          for (y = 0; y < height; y++) {
183                  if (TIFFReadScanline(tif, sl.p, y, 0) < 0) {
184                          err = TM_E_BADFILE;
185                          break;
186                  }
187 <                if (phot == PHOTOMETRIC_LOGL)
188 <                        err = tmCvL16(*lpp + y*width, sl.w, width);
189 <                else if (comp == COMPRESSION_SGILOG24)
92 <                        err = tmCvLuv24(*lpp + y*width,
187 >                switch (tcase) {
188 >                case TC_LOGLUV32:
189 >                        err = tmCvLuv32(*lpp + y*width,
190                                  cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
191                                          sl.l, width);
192 <                else
193 <                        err = tmCvLuv32(*lpp + y*width,
192 >                        break;
193 >                case TC_LOGLUV24:
194 >                        err = tmCvLuv24(*lpp + y*width,
195                                  cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
196                                          sl.l, width);
197 +                        break;
198 +                case TC_LOGL16:
199 +                        err = tmCvL16(*lpp + y*width, sl.w, width);
200 +                        break;
201 +                case TC_RGBFLOAT:
202 +                        err = tmCvColors(*lpp + y*width,
203 +                                cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
204 +                                        (COLOR *)sl.f, width);
205 +                        break;
206 +                case TC_GRYFLOAT:
207 +                        err = tmCvGrays(*lpp + y*width, sl.f, width);
208 +                        break;
209 +                case TC_RGBSHORT:
210 +                        err = tmCvRGB48(*lpp + y*width,
211 +                                cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp+y*3*width,
212 +                                        (uint16 (*)[3])sl.w, width, DEFGAM);
213 +                        break;
214 +                case TC_GRYSHORT:
215 +                        err = tmCvGray16(*lpp + y*width, sl.w, width, DEFGAM);
216 +                        break;
217 +                default:
218 +                        err = TM_E_CODERR1;
219 +                        break;
220 +                }
221                  if (err != TM_E_OK)
222                          break;
223          }
# Line 127 | Line 249 | done:                                  /* clean up */
249   * As in tmMapPicture(), grey values are also returned if flags&TM_F_BW.
250   */
251   int
252 < tmMapTIFF(psp, xp, yp, flags, monpri, gamval, Lddyn, Ldmax, fname, tp)
253 < BYTE    **psp;
132 < int     *xp, *yp;
133 < int     flags;
134 < RGBPRIMP        monpri;
135 < double  gamval, Lddyn, Ldmax;
136 < char    *fname;
137 < TIFF    *tp;
252 > tmMapTIFF(BYTE **psp, int *xp, int *yp, int flags, RGBPRIMP monpri,
253 >        double gamval, double Lddyn, double Ldmax, char *fname, TIFF *tp)
254   {
255          char    *funcName = fname==NULL ? "tmMapTIFF" : fname;
256          TMbright        *lp;

Diff Legend

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