Image.cc

00001 /*
00002 File: Image.cc
00003 
00004 Function: See header file
00005 
00006 Author(s): Andrew Willmott
00007 
00008 Copyright: (c) 1997-2000, Andrew Willmott
00009 */
00010 
00011 #include "gcl/Image.h"
00012 #include "gcl/GCLConfig.h"
00013 #include "gcl/VecUtil.h"
00014 
00015 #include <iostream.h>
00016 #include <stdio.h>
00017 #include <ctype.h>
00018 
00019 
00020 // --- Image class ------------------------------------------------------------
00021 
00022 
00023 
00024 Int Image::sJPEGQuality = 90;
00025 
00026  Void Image::Clear(const Colour &c)
00027 // should almost always be overridden
00028 {
00029 Int x, y;
00030 
00031 for (y = 0; y < height; y++)
00032 for (x = 0; x < width; x++)
00033 SetPixel(x, y, c);
00034 }
00035 
00036  Void Image::CopyFrom(Int x, Int y, Image &img)
00037 {
00038 Int test = img.Width();
00039 Int copyWidth = Min(img.Width(), width - x);
00040 Int copyHeight = Min(img.Height(), height - y);
00041 Colour *buffer = new Colour[copyWidth];
00042 Int i;
00043 
00044 for (i = 0; i < copyHeight; i++)
00045 {
00046 img.GetSpan(i, x, copyWidth, buffer);
00047 SetSpan(y++, 0, copyWidth, buffer);
00048 } 
00049 
00050 delete[] buffer;
00051 }
00052 
00053  Void Image::GammaCorrect(ClrReal gamma)
00054 {
00055 ClrReal invGamma = 1.0 / gamma;
00056 Colour c;
00057 Int x, y;
00058 
00059 for (y = 0; y < Height(); y++)
00060 for (x = 0; x < Width(); x++)
00061 {
00062 c = GetPixel(x, y);
00063 
00064 c[0] = pow(c[0], invGamma);
00065 c[1] = pow(c[1], invGamma);
00066 c[2] = pow(c[2], invGamma);
00067 
00068 SetPixel(x, y, c);
00069 }
00070 }
00071 
00072  Void Image::Scale(ClrReal scale)
00073 {
00074 Colour *buffer = new Colour[width];
00075 Int i, j;
00076 Colour result;
00077 
00078 for (i = 0; i < height; i++)
00079 {
00080 GetSpan(i, 0, width, buffer);
00081 for (j = 0; j < width; j++)
00082 buffer[j] *= scale;
00083 SetSpan(i, 0, width, buffer);
00084 } 
00085 }
00086 
00087  ClrReal Image::MaxComponent()
00088 {
00089 Int x, y;
00090 ClrReal maxCmpt = 0.0;
00091 Colour c;
00092 
00093 for (y = 0; y < height; y++)
00094 for (x = 0; x < width; x++)
00095 {
00096 c = GetPixel(x, y);
00097 maxCmpt = Max(maxCmpt, MaxCmpt(c));
00098 }
00099 
00100 return(maxCmpt);
00101 }
00102 
00103  Colour Image::AverageColour()
00104 {
00105 Colour *buffer = new Colour[width];
00106 Int i, j;
00107 Colour result = cBlack;
00108 
00109 for (i = 0; i < height; i++)
00110 {
00111 Colour bsum = cBlack;
00112 
00113 GetSpan(i, 0, width, buffer);
00114 for (j = 0; j < width; j++)
00115 bsum += buffer[j];
00116 bsum /= width;
00117 result += bsum;
00118 }
00119 
00120 delete[] buffer;
00121 result /= height;
00122 
00123 return(result);
00124 }
00125 
00126  Void Image::FindComponentBounds(Colour &min, Colour &max)
00127 {
00128 Int x, y;
00129 Colour c;
00130 
00131 for (y = 0; y < height; y++)
00132 for (x = 0; x < width; x++)
00133 {
00134 c = GetPixel(x, y);
00135 FindMinCmpts(min, c, min);
00136 FindMaxCmpts(max, c, max);
00137 }
00138 }
00139 
00140  Void Image::Transform(const ClrTrans &trans)
00141 {
00142 Colour *buffer = new Colour[width];
00143 Int i, j;
00144 
00145 for (i = 0; i < height; i++)
00146 {
00147 GetSpan(i, 0, width, buffer);
00148 for (j = 0; j < width; j++)
00149 {
00150 buffer[j] = xform(trans, buffer[j]);
00151 ClipColour(buffer[j]);
00152 }
00153 SetSpan(i, 0, width, buffer);
00154 } 
00155 
00156 delete[] buffer;
00157 }
00158 
00159  Void Image::Over(Int x, Int y, Image &img)
00160 {
00161 Int test = img.Width();
00162 Int copyWidth = Min(img.Width(), width - x);
00163 Int copyHeight = Min(img.Height(), height - y);
00164 Colour *buffer = new Colour[copyWidth];
00165 Int i;
00166 
00167 // XXX UNFINISHED: want to do composite operation: d = d * (1 - s.alpha) + s
00168 
00169 for (i = 0; i < copyHeight; i++)
00170 {
00171 img.GetSpan(i, x, copyWidth, buffer);
00172 SetSpan(y++, 0, copyWidth, buffer);
00173 } 
00174 
00175 delete[] buffer;
00176 }
00177 
00178  Void Image::DownSample(Image &out)
00180 {
00181 Int i, j;
00182 static ColourList span1, span2, outSpan;
00183 
00184 out.SetSize(Width() / 2, Height() / 2); 
00185 span1.SetSize(Width());
00186 span2.SetSize(Width());
00187 outSpan.SetSize(out.Width());
00188 
00189 for (i = 0; i < out.Height(); i++)
00190 {
00191 GetSpan(2 * i, 0, Width(), span1.Ref());
00192 GetSpan(2 * i + 1, 0, Width(), span2.Ref());
00193 
00194 for (j = 0; j < out.Width(); j++)
00195 {
00196 outSpan[j] = span1[2 * j] + span1[2 * j + 1];
00197 outSpan[j] += span2[2 * j] + span2[2 * j + 1];
00198 outSpan[j] /= 4.0;
00199 }
00200 
00201 out.SetSpan(i, 0, out.Width(), outSpan.Ref());
00202 }
00203 }
00204 
00205 
00206 // These should almost always be overridden with more efficient routines
00207 
00208  Void Image::SetRealPixel(Int x, Int y, ClrReal r, ImgChannel channel)
00209 {
00210 if (channel == chMono)
00211 SetPixel(x, y, cWhite * r);
00212 else if (channel <= chBlue)
00213 {
00214 Colour c = GetPixel(x, y);
00215 
00216 c[channel - chRed] = r; 
00217 SetPixel(x, y, c);
00218 }
00219 }
00220 
00221  ClrReal Image::GetRealPixel(Int x, Int y, ImgChannel channel) const
00222 {
00223 if (channel <= chBlue)
00224 {
00225 Colour c = GetPixel(x, y);
00226 
00227 if (channel == chMono)
00228 return(dot(cWhite, c) * (1.0 / 3.0));
00229 else
00230 return(c[channel - chRed]);
00231 }
00232 else
00233 return(0.0);
00234 }
00235 
00236  Void Image::SetRealSpan(Int row, Int start, Int length, 
00237 const ClrReal *src, ImgChannel channel)
00238 {
00239 Int i;
00240 
00241 for (i = 0; i < length; i++)
00242 SetRealPixel(start + i, row, src[i], channel);
00243 }
00244 
00245  Void Image::GetRealSpan(Int row, Int start, Int length, 
00246 ClrReal *dst, ImgChannel channel) const
00247 {
00248 Int i;
00249 
00250 for (i = 0; i < length; i++)
00251 dst[i] = GetRealPixel(start + i, row, channel);
00252 }
00253 
00254  Void Image::SetRGBASpan(Int row, Int start, Int length, const RGBAPixel *src) 
00255 {
00256 Int i;
00257 Colour *buffer = new Colour[length];
00258 
00259 for (i = 0; i < length; i++)
00260 buffer[i] = RGBAToColour(src[i]);
00261 
00262 SetSpan(row, start, length, buffer);
00263 
00264 delete[] buffer;
00265 }
00266 
00267  Void Image::GetRGBASpan(Int row, Int start, Int length, RGBAPixel *dst) const
00268 {
00269 Int i;
00270 Colour *buffer = new Colour[length];
00271 
00272 GetSpan(row, start, length, buffer);
00273 
00274 for (i = 0; i < length; i++)
00275 dst[i] = ColourToRGBA(buffer[i]);
00276 
00277 delete[] buffer;
00278 }
00279 
00280  Void Image::SetByteSpan(Int row, Int start, Int length, 
00281 const Byte *src, ImgChannel channel)
00282 {
00283 Int i;
00284 Colour *buffer = new Colour[length];
00285 
00286 for (i = 0; i < length; i++)
00287 buffer[i] = ByteToColour(src[i]);
00288 
00289 SetSpan(row, start, length, buffer);
00290 
00291 delete[] buffer;
00292 }
00293 
00294  Void Image::GetByteSpan(Int row, Int start, Int length, 
00295 Byte *dst, ImgChannel channel) const
00296 {
00297 Int i;
00298 Colour *buffer = new Colour[length];
00299 
00300 GetSpan(row, start, length, buffer);
00301 
00302 for (i = 0; i < length; i++)
00303 dst[i] = ColourToByte(buffer[i]);
00304 
00305 delete[] buffer;
00306 }
00307 
00308 
00309 // --- File methods -----------------------------------------------------------
00310 
00311  Char *tImageFormats[] = 
00312 {
00313 "ppm", "PPM image format",
00314 #ifdef GCL_TIFF
00315 "tif", "Adobe TIFF format",
00316 #endif
00317 #ifdef GCL_JPEG
00318 "jpg", "JPEG format",
00319 #endif
00320 #ifdef GCL_GIF
00321 "gif", "GIF format (read only)",
00322 #endif
00323 0
00324 };
00325 
00326  Void Image::PrintSupportedFormats(ostream &s)
00327 {
00328 Char **p = tImageFormats;
00329 
00330 s << "Supported image file extensions: " << endl;
00331 
00332 while (*p)
00333 {
00334 s << String().Printf("%-5s %s\n", *p, *(p + 1));
00335 p += 2;
00336 }
00337 }
00338 
00339  Int Image::Save(FileName &filename)
00340 {
00341 if (filename.GetExtension() == "ppm")
00342 return(SavePPM(filename.GetPath()));
00343 #ifdef GCL_TIFF
00344 else if (filename.GetExtension() == "tiff" || filename.GetExtension() == "tif")
00345 return(SaveTIFF(filename.GetPath()));
00346 #endif
00347 #ifdef GCL_JPEG
00348 else if (filename.GetExtension() == "jpg")
00349 return(SaveJPEG(filename.GetPath()));
00350 #endif
00351 else
00352 {
00353 #ifdef GCL_TIFF
00354 if (filename.GetExtension() != "")
00355 cerr << "Unknown image file extension:"
00356 << " saving in TIFF format" << endl;
00357 filename.SetExtension("tif");
00358 return(SaveTIFF(filename.GetPath()));
00359 #else
00360 if (filename.GetExtension() != "")
00361 cerr << "Unknown image file extension:"
00362 << " saving in PPM format" << endl;
00363 filename.SetExtension("ppm");
00364 return(SavePPM(filename.GetPath()));
00365 #endif 
00366 }
00367 }
00368 
00369  static StrConst kImageExtensions[] =
00370 {
00371 "ppm",
00372 "pgm",
00373 #ifdef GCL_TIFF
00374 "tif",
00375 "tiff",
00376 #endif
00377 #ifdef GCL_JPEG
00378 "jpg",
00379 #endif
00380 #ifdef GCL_GIF
00381 "gif",
00382 #endif
00383 0
00384 };
00385 
00386  Int Image::Load(FileName &filename)
00387 {
00388 Int result = filename.FindFileExtension(kImageExtensions);
00389 
00390 if (result == kBadExtension)
00391 cerr << "error: unknown image extension '" << filename.GetExtension()
00392 << "'" << endl;
00393 else if (result == kFileNotFound)
00394 cerr << "error: can't find image file " << filename.GetPath() << endl;
00395 
00396 if (result < 0)
00397 return(result);
00398 
00399 filename.DecompressSetup();
00400 if (result < 2)
00401 return(LoadPPM(filename.GetPath()));
00402 #ifdef GCL_TIFF
00403 else if (filename.GetExtension() == "tiff" || filename.GetExtension() == "tif")
00404 return(LoadTIFF(filename.GetPath()));
00405 #endif
00406 #ifdef GCL_JPEG
00407 else if (filename.GetExtension() == "jpg")
00408 return(LoadJPEG(filename.GetPath()));
00409 #endif
00410 #ifdef GCL_GIF
00411 else if (filename.GetExtension() == "gif")
00412 return(LoadGIF(filename.GetPath()));
00413 #endif
00414 filename.DecompressCleanup();
00415 
00416 _Error("Unhandled extension");
00417 
00418 return(-1);
00419 }
00420 
00421 
00422 // --- PPM read/write ---------------------------------------------------------
00423 
00424 
00425  Int Image::SavePPM(const Char *filename)
00426 {
00427 int i, j;
00428 FILE *ppm;
00429 RGBAPixel *p, *buffer = new RGBAPixel[width];
00430 
00431 if (!buffer)
00432 return(-1);
00433 ppm = fopen(filename, "w");
00434 if (!ppm)
00435 return(-1);
00436 
00437 fprintf(ppm, "P6\n%u %u\n255\n", width, height);
00438 
00439 for (j = height - 1; j >= 0; j--)
00440 {
00441 GetRGBASpan(j, 0, width, buffer);
00442 p = buffer;
00443 for (i = 0; i < width; i++, p++)
00444 {
00445 fputc(p->ch[rgba_R], ppm);
00446 fputc(p->ch[rgba_G], ppm);
00447 fputc(p->ch[rgba_B], ppm);
00448 }
00449 }
00450 
00451 delete[] buffer;
00452 return(fclose(ppm));
00453 }
00454 
00455  static Int ppmReadInt(FILE *ppm)
00456 {
00457 Int result, c;
00458 
00459 // chomp space & comments
00460 c = fgetc(ppm);
00461 
00462 while(isspace(c) || c == '#')
00463 {
00464 if (c == '#')
00465 do 
00466 c = fgetc(ppm);
00467 while (c != '\n' && c != '\r' && c != EOF);
00468 
00469 c = fgetc(ppm);
00470 }
00471 
00472 ungetc(c, ppm);
00473 fscanf(ppm, "%d", &result);
00474 
00475 return(result); 
00476 }
00477 
00478  Int Image::LoadPPM(const Char *filename)
00479 {
00480 Int i, j;
00481 Int x, y, level;
00482 Char p1, p2;
00483 Bool isMono;
00484 FILE *ppm;
00485 RGBAPixel *p, *buffer;
00486 Byte *mp, *mBuffer;
00487 
00488 ppm = fopen(filename, "r");
00489 if (!ppm)
00490 return(-1);
00491 
00492 p1 = fgetc(ppm);
00493 p2 = fgetc(ppm);
00494 
00495 if (p1 != 'P' || p2 <= '1' || p2 > '6')
00496 {
00497 _Warning("(LoadPPM) not a PPM file");
00498 return(-1);
00499 }
00500 
00501 if (p2 < '2' || p2 == '4' || p2 > '6')
00502 {
00503 _Warning("(LoadPPM) Only handles PGM and PPM files");
00504 return(-1);
00505 }
00506 
00507 isMono = (p2 == '2' || p2 == '5');
00508 
00509 x = ppmReadInt(ppm);
00510 y = ppmReadInt(ppm);
00511 level = ppmReadInt(ppm);
00512 
00513 if (level != 255)
00514 _Warning("(LoadPPM) Ignoring scaling factor.");
00515 
00516 SetSize(x, y);
00517 
00518 if (fgetc(ppm) != '\n')
00519 {
00520 _Warning("(LoadPPM) Corrupt PPM file");
00521 return(-1);
00522 }
00523 
00524 if (isMono)
00525 mBuffer = new Byte[width];
00526 else
00527 buffer = new RGBAPixel[width];
00528 
00529 for (j = height - 1; j >= 0; j--)
00530 {
00531 if (p2 == '2')
00532 for (i = 0, mp = mBuffer; i < width; i++, mp++)
00533 {
00534 Int b;
00535 
00536 fscanf(ppm, "%d", &b);
00537 *mp = b;
00538 }
00539 else if (p2 == '3')
00540 for (i = 0, p = buffer; i < width; i++, p++)
00541 {
00542 Int b;
00543 fscanf(ppm, "%d", &b);
00544 p->ch[rgba_R] = b;
00545 fscanf(ppm, "%d", &b);
00546 p->ch[rgba_G] = b;
00547 fscanf(ppm, "%d", &b);
00548 p->ch[rgba_B] = b;
00549 p->ch[rgba_A] = 255;
00550 }
00551 else if (p2 == '5')
00552 fread(mBuffer, 1, width, ppm);
00553 else if (p2 == '6')
00554 for (i = 0, p = buffer; i < width; i++, p++)
00555 {
00556 // UUU #ifdef endianess here sometime
00557 p->ch[rgba_R] = fgetc(ppm);
00558 p->ch[rgba_G] = fgetc(ppm);
00559 p->ch[rgba_B] = fgetc(ppm);
00560 p->ch[rgba_A] = 255;
00561 }
00562 
00563 if (isMono)
00564 SetByteSpan(j, 0, width, mBuffer);
00565 else
00566 SetRGBASpan(j, 0, width, buffer);
00567 }
00568 
00569 if (isMono)
00570 delete[] mBuffer;
00571 else
00572 delete[] buffer;
00573 
00574 return(fclose(ppm));
00575 }
00576 
00577 
00578 // --- TIFF read/write --------------------------------------------------------
00579 
00580 
00581 #ifdef GCL_TIFF
00582 
00583 #include "tiffio.h"
00584 
00585  Int Image::SaveTIFF(const Char *filename)
00586 {
00587 TIFF *tif;
00588 UInt32 samples_per_pixel = 3;
00589 UInt32 w = Width();
00590 UInt32 h = Height();
00591 UInt32 scanline_size = samples_per_pixel * w;
00592 UInt32 i, k;
00593 Int y;
00594 Char *scanline_buf;
00595 RGBAPixel *rgba_buf;
00596 
00597 tif = TIFFOpen(filename, "w");
00598 if (!tif)
00599 return(-1);
00600 
00601 TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, w);
00602 TIFFSetField(tif, TIFFTAG_IMAGELENGTH, h);
00603 
00604 /* These are the charateristics of our Pic data */
00605 TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_LEFTTOP);
00606 TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samples_per_pixel);
00607 TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
00608 TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
00609 TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
00610 #ifdef GCL_PATENTS_SUCK
00611 // use PKZIP compression to escape the pitiful unisys nonsense.
00612 // currently, RH 6.2's tiff libs print a pissy little message
00613 // LZW and don't use it, but they haven't enabled support
00614 // for deflate compression. I suppose that would have just
00615 // been too bright of them. If you want compressed images,
00616 // you'll have to rebuild with either LZW reenabled, or deflate
00617 // enabled.
00618 TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE); 
00619 #else
00620 TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
00621 #endif
00622 
00623 if( TIFFScanlineSize(tif) != scanline_size )
00624 {
00625 fprintf(stderr,
00626 "TIFF: Mismatch with library's expected scanline size!\n");
00627 return(-1);
00628 }
00629 
00630 TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(tif, 0));
00631 
00632 scanline_buf = new Char[scanline_size];
00633 rgba_buf = new RGBAPixel[scanline_size];
00634 
00635 if (!scanline_buf)
00636 {
00637 fprintf(stderr, "TIFF: Can't allocate scanline buffer!\n");
00638 return(-1);
00639 }
00640 
00641 for (y = h - 1; y >= 0; y--)
00642 {
00643 GetRGBASpan(y, 0, w, rgba_buf);
00644 k = 0;
00645 for (i = 0; i < w; i++)
00646 {
00647 scanline_buf[k++] = rgba_buf[i].ch[rgba_R];
00648 scanline_buf[k++] = rgba_buf[i].ch[rgba_G];
00649 scanline_buf[k++] = rgba_buf[i].ch[rgba_B];
00650 }
00651 
00652 TIFFWriteScanline(tif, scanline_buf, h - y - 1, 0);
00653 /* note that TIFFWriteScanline modifies the buffer you pass it */
00654 }
00655 
00656 delete[] scanline_buf;
00657 delete[] rgba_buf;
00658 TIFFClose(tif);
00659 
00660 return(0);
00661 }
00662 
00663  Int Image::LoadTIFF(const Char *filename)
00664 {
00665 TIFF *tif;
00666 TIFFRGBAImage img;
00667 Int result = -1;
00668 Char emsg[1024];
00669 
00670 tif = TIFFOpen(filename, "r");
00671 if (!tif)
00672 {
00673 _Warning("(LoadTIFF) Couldn't find file.");
00674 return(-1);
00675 }
00676 
00677 if (TIFFRGBAImageBegin(&img, tif, 0, emsg)) 
00678 {
00679 SetSize(img.width, img.height);
00680 
00681 #ifdef GCL_BIG_END
00682 // TIFF unpacks data in AGBR format, which is endian dependent.
00683 // If we're on big-end machines, it matches with our format,
00684 // and we can write the data straight in, otherwise we have to
00685 // convert.
00686 if (Tag() == imgRGBATag)
00687 TIFFRGBAImageGet(&img, ((RGBAImage*) this)->Data(), 
00688 img.width, img.height); 
00689 else
00690 {
00691 #endif
00692 Int npixels = img.width * img.height;
00693 UInt32 *raster = 
00694 (UInt32*) _TIFFmalloc(npixels * sizeof (UInt32));
00695 
00696 // should use TIFF put methods here, but they're too poorly
00697 // documented to waste time on just at the mo'
00698 if (raster) 
00699 {
00700 if (TIFFRGBAImageGet(&img, (uint32*) raster, img.width, img.height)) 
00701 {
00702 Int i, j;
00703 RGBAPixel *rgbaBuf = new RGBAPixel[img.width];
00704 
00705 if (rgbaBuf)
00706 for (i = 0; i < img.height; i++)
00707 {
00708 for (j = 0; j < img.width; j++)
00709 {
00710 UInt32 pixel = raster[i * img.width + j];
00711 
00712 rgbaBuf[j].ch[rgba_R] = TIFFGetR(pixel);
00713 rgbaBuf[j].ch[rgba_G] = TIFFGetG(pixel);
00714 rgbaBuf[j].ch[rgba_B] = TIFFGetB(pixel);
00715 rgbaBuf[j].ch[rgba_A] = TIFFGetA(pixel);
00716 }
00717 SetRGBASpan(i, 0, img.width, rgbaBuf);
00718 }
00719 
00720 delete[] rgbaBuf;
00721 }
00722 else
00723 {
00724 _Warning("(LoadTIFF) TIFFRGBAImageGet failed");
00725 return(-1);
00726 }
00727 _TIFFfree(raster);
00728 }
00729 else
00730 {
00731 _Warning("(LoadTIFF) couldn't allocate raster data");
00732 return(-1);
00733 }
00734 
00735 #ifdef GCL_BIG_END
00736 }
00737 #endif
00738 
00739 TIFFRGBAImageEnd(&img);
00740 result = 0;
00741 } 
00742 else
00743 TIFFError("(LoadTIFF)", emsg);
00744 
00745 
00746 TIFFClose(tif);
00747 
00748 return(result);
00749 }
00750 
00751 #ifdef UNFINISHED
00752 
00753 // code for ward's clever scaling scheme
00754 
00755 To a standard TIFF writer, one needs to add the following code fragment 
00756 to the initialization routine to set up for sending XYZ data:
00757 
00758 Int Image::SaveTIFF_LogLUV(const Char *filename, Float stonits)
00759 {
00760 TIFF *tif;
00761 UInt32 samples_per_pixel = 3;
00762 UInt32 w = Width();
00763 UInt32 h = Height();
00764 UInt32 scanline_size = samples_per_pixel * w;
00765 UInt32 y, i, k;
00766 Char *scanline_buf;
00767 RGBAPixel *rgba_buf;
00768 
00769 tif = TIFFOpen(filename, "w");
00770 if (!tif)
00771 return(-1);
00772 
00773 TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, w);
00774 TIFFSetField(tif, TIFFTAG_IMAGELENGTH, h);
00775 
00776 /* These are the charateristics of our Pic data */
00777 TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_LEFTTOP);
00778 TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, samples_per_pixel);
00779 TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
00780 // TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
00781 // TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
00782 // TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_LZW);
00783 // TIFFSetField(tif, TIFFTAG_PREDICTOR, 2);
00784 
00785 // set up for LUV output...
00786 TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_SGILOG);
00787 TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_LOGLUV);
00788 TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
00789 TIFFSetField(tif, TIFFTAG_SGILOGDATAFMT, SGILOGDATAFMT_FLOAT);
00790 TIFFSetField(tif, TIFFTAG_STONITS, stonits);
00791 
00792 if( TIFFScanlineSize(tif) != scanline_size )
00793 {
00794 _Warning("TIFF: Mismatch with library's expected scanline size!\n");
00795 return(-1);
00796 }
00797 
00798 TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, TIFFDefaultStripSize(tif, 0));
00799 
00800 scanline_buf = new Char[scanline_size];
00801 rgba_buf = new RGBAPixel[scanline_size];
00802 
00803 if (!scanline_buf)
00804 {
00805 Warning("TIFF: Can't allocate scanline buffer!\n");
00806 return(-1);
00807 }
00808 
00809 for(y = h - 1; y >= 0; y--)
00810 {
00811 GetRGBASpan(y, 0, w, rgba_buf);
00812 k = 0;
00813 for (i = 0; i < w; i++)
00814 {
00815 scanline_buf[k++] = rgba_buf[i].ch[rgba_R];
00816 scanline_buf[k++] = rgba_buf[i].ch[rgba_G];
00817 scanline_buf[k++] = rgba_buf[i].ch[rgba_B];
00818 }
00819 
00820 TIFFWriteScanline(tif, scanline_buf, y, 0);
00821 /* note that TIFFWriteScanline modifies the buffer you pass it */
00822 }
00823 delete[] scanline_buf;
00824 delete[] rgba_buf;
00825 TIFFClose(tif);
00826 return(0);
00827 }
00828 
00829 #endif
00830 #endif
00831 
00832 
00833 // --- GIF read/write --------------------------------------------------------
00834 
00835 #ifdef GCL_GIF
00836 
00837 // Bog off, UNISYS
00838 
00839 extern "C"
00840 {
00841 #include "gif_lib.h"
00842 }
00843 
00844 // why on earth isn't this handled by DGifSlurp? 
00845  // and why does that code assume char is unsigned? 
00846  static Int tInterlacedOffset[] = { 0, 4, 2, 1 };
00847 static Int tInterlacedJump[] = { 8, 8, 4, 2 };
00848  
00849 Int Image::SaveGIF(const Char *filename)
00850 {
00851 return(-1);
00852 }
00853  
00854 Int Image::LoadGIF(const Char *filename)
00855 {
00856 GifFileType *gifFile;
00857 SavedImage *theGIFImg;
00858 ColorMapObject *clrMap;
00859 RGBAPixel *buffer;
00860 Int i, j, result = -1;
00861 Int pass, destRow, destStep;
00862 
00863 gifFile = DGifOpenFileName(filename); 
00864 if (gifFile)
00865 {
00866 if (DGifSlurp(gifFile) == GIF_OK)
00867 {
00868 buffer = new RGBAPixel[gifFile->SWidth];
00869 
00870 theGIFImg = gifFile->SavedImages; // first image
00871 
00872 SetSize(theGIFImg->ImageDesc.Width, theGIFImg->ImageDesc.Height);
00873 
00874 if (theGIFImg->ImageDesc.ColorMap)
00875 clrMap = theGIFImg->ImageDesc.ColorMap;
00876 else if (gifFile->SColorMap)
00877 clrMap = gifFile->SColorMap;
00878 else
00879 {
00880 _Warning("GIF file contains no colormap!");
00881 return(-1);
00882 }
00883 
00884 if (theGIFImg->ImageDesc.Interlace)
00885 {
00886 destRow = tInterlacedOffset[0];
00887 destStep = tInterlacedJump[0];
00888 pass = 0;
00889 }
00890 else
00891 {
00892 destRow = 0;
00893 destStep = 1;
00894 }
00895 
00896 for (i = 0; i < theGIFImg->ImageDesc.Height; i++)
00897 {
00898 Byte *sp = (Byte*) theGIFImg->RasterBits + i * theGIFImg->ImageDesc.Width;
00899 
00900 for (j = 0; j < theGIFImg->ImageDesc.Width; j++)
00901 {
00902 Byte idx = *sp++;
00903 
00904 buffer[j].ch[rgba_R] = clrMap->Colors[idx].Red;
00905 buffer[j].ch[rgba_G] = clrMap->Colors[idx].Green;
00906 buffer[j].ch[rgba_B] = clrMap->Colors[idx].Blue;
00907 buffer[j].ch[rgba_A] = 255;
00908 }
00909 
00910 SetRGBASpan(height - 1 - destRow, 0, theGIFImg->ImageDesc.Width, buffer);
00911 destRow += destStep;
00912 if (destRow >= height && theGIFImg->ImageDesc.Interlace)
00913 {
00914 pass++;
00915 Assert(pass < 4, "Too many passes in GIF file");
00916 destRow = tInterlacedOffset[pass];
00917 destStep = tInterlacedJump[pass];
00918 }
00919 }
00920 
00921 delete[] buffer;
00922 result = 0;
00923 }
00924 else
00925 PrintGifError();
00926 
00927 if (DGifCloseFile(gifFile) != GIF_OK)
00928 PrintGifError();
00929 }
00930 else
00931 PrintGifError();
00932 
00933 return(result);
00934 }
00935 
00936 #endif
00937 
00938 
00939 // --- JPEG read/write --------------------------------------------------------
00940 
00941 #ifdef GCL_JPEG
00942 
00943 extern "C"
00944 {
00945 #include "jpeglib.h"
00946  }
00947 
00948 Int Image::SaveJPEG(const Char *filename)
00949 {
00950 FILE *outfile;
00951 JSAMPROW rowPtr[1];
00952 struct jpeg_compress_struct compressObj;
00953 struct jpeg_error_mgr jerr;
00954 JSAMPLE *scanlineBuf, *p;
00955 Int i, j;
00956 
00957 compressObj.err = jpeg_std_error(&jerr);
00958 jpeg_create_compress(&compressObj);
00959 
00960 // Set up file for output... 
00961 
00962 if ((outfile = fopen(filename, "wb")) == NULL)
00963 {
00964 _Warning("(Image::SaveJPEG) can't open for writing: " + StrConst(filename));
00965 return(-1);
00966 }
00967 
00968 jpeg_stdio_dest(&compressObj, outfile);
00969 
00970 compressObj.image_width = width;
00971 compressObj.image_height = height;
00972 compressObj.input_components = 3;
00973 compressObj.in_color_space = JCS_RGB;
00974 
00975 jpeg_set_defaults(&compressObj);
00976 jpeg_set_quality(&compressObj, sJPEGQuality, TRUE);
00977 
00978 // Set up scanlines 
00979 
00980 scanlineBuf = new JSAMPLE[width * 3];
00981 if (!scanlineBuf)
00982 return(-1);
00983 rowPtr[0] = scanlineBuf;
00984 
00985 // Compress & save
00986 
00987 jpeg_start_compress(&compressObj, TRUE);
00988 
00989 for (i = height - 1; i >= 0; i--)
00990 {
00991 Colour c;
00992 
00993 p = scanlineBuf;
00994 for (j = 0; j < width; j++)
00995 {
00996 c = GetPixel(j, i);
00997 *p++ = Byte(c[0] * 255.0);
00998 *p++ = Byte(c[1] * 255.0);
00999 *p++ = Byte(c[2] * 255.0);
01000 }
01001 
01002 jpeg_write_scanlines(&compressObj, rowPtr, 1);
01003 }
01004 
01005 jpeg_finish_compress(&compressObj);
01006 fclose(outfile);
01007 delete[] scanlineBuf;
01008  }
01009 
01010 Int Image::LoadJPEG(const Char *filename)
01011 {
01012 struct jpeg_decompress_struct cinfo;
01013 struct jpeg_error_mgr jerr;
01014 JSAMPROW buffer;
01015 FILE *file;
01016 RGBAPixel *rgba_buf;
01017 Int i, j, k, err = -1;
01018 
01019 cinfo.err = jpeg_std_error(&jerr);
01020 jpeg_create_decompress(&cinfo);
01021 
01022 file = fopen(filename, "rb");
01023 if (!file) 
01024 {
01025 fprintf(stderr, "JPEG: could not open file \"%s\"\n", filename);
01026 return(err);
01027 }
01028 
01029 jpeg_stdio_src(&cinfo, file);
01030 jpeg_read_header(&cinfo, TRUE);
01031 
01032 // decompress options
01033 cinfo.out_color_space = JCS_RGB;
01034 cinfo.quantize_colors = FALSE;
01035 cinfo.do_fancy_upsampling = FALSE;
01036 cinfo.do_block_smoothing = FALSE;
01037 
01038 jpeg_start_decompress(&cinfo);
01039 
01040 SetSize(cinfo.output_width, cinfo.output_height);
01041 
01042 // JSAMPLE better be a byte.
01043 Assert(sizeof(JSAMPLE) == 1, "JSAMPLE is not a byte");
01044 Assert(cinfo.output_components == 3, "JCS_RGB request failed");
01045 buffer = (JSAMPROW) new Byte[cinfo.output_width * cinfo.output_components];
01046 rgba_buf = new RGBAPixel[cinfo.output_width];
01047 
01048 if (!buffer || !rgba_buf) 
01049 {
01050 delete[] buffer; delete[] rgba_buf;
01051 fprintf(stderr, "JPEG: out of memory\n");
01052 goto bye;
01053 }
01054 
01055 k = cinfo.output_height;
01056 
01057 while (cinfo.output_scanline < cinfo.output_height) 
01058 {
01059 jpeg_read_scanlines(&cinfo, &buffer, 1);
01060 
01061 for (i = 0, j = 0; i < cinfo.output_width; i++) 
01062 {
01063 rgba_buf[i].ch[rgba_R] = buffer[j++];
01064 rgba_buf[i].ch[rgba_G] = buffer[j++];
01065 rgba_buf[i].ch[rgba_B] = buffer[j++]; 
01066 rgba_buf[i].ch[rgba_A] = 255; 
01067 }
01068 SetRGBASpan(--k, 0, cinfo.output_width, rgba_buf);
01069 }
01070 
01071 jpeg_finish_decompress(&cinfo);
01072 err = 0;
01073 delete[] buffer; 
01074 delete[] rgba_buf;
01075 
01076 bye:
01077 jpeg_destroy_decompress(&cinfo);
01078 
01079 fclose(file);
01080 return(err);
01081 }
01082 
01083 #endif
01084 
01085 
01086  // --- RGBAImage methods ------------------------------------------------------
01087 
01088 Void RGBAImage::SetSize(Int width, Int height)
01089 {
01090 delete[] data;
01091 data = new RGBAPixel[width * height];
01092 SELF.width = width;
01093 SELF.height = height;
01094  }
01095 
01096 Void RGBAImage::Clear(const Colour &c)
01097 {
01098 RGBAPixel *p = data, bc = ColourToRGBA(c);
01099 Int i;
01100 
01101 for (i = 0; i < width * height; i++, p++)
01102 *p = bc;
01103  }
01104 
01105 Void RGBAImage::SetPixel(Int x, Int y, const Colour &c)
01106 {
01107 Assert(x >= 0 && y >= 0 && x < width && y < height,
01108 "illegal pixel access.");
01109 data[x + y * width] = ColourToRGBA(c);
01110  }
01111 
01112 Colour RGBAImage::GetPixel(Int x, Int y) const
01113 {
01114 Assert(x >= 0 && y >= 0 && x < width && y < height,
01115 "illegal pixel access.");
01116 return(RGBAToColour(data[x + y * width]));
01117  }
01118 
01119 Void RGBAImage::SetSpan(Int row, Int start, Int length, const Colour *src)
01120 {
01121 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01122 "(RGBAImage::SetSpan) illegal span access.");
01123 Int i;
01124 RGBAPixel *p = data + row * width + start;
01125 const Colour *cp = src;
01126 
01127 for (i = 0; i < length; i++, p++, cp++)
01128 *p = ColourToRGBA(*cp);
01129  }
01130 
01131 Void RGBAImage::GetSpan(Int row, Int start, Int length, Colour *dst) const
01132 {
01133 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01134 "(RGBAImage::GetSpan) illegal span access.");
01135 Int i;
01136 RGBAPixel *p = data + row * width + start;
01137 Colour *cp = dst;
01138 
01139 for (i = 0; i < length; i++, p++, cp++)
01140 *cp = RGBAToColour(*p);
01141  }
01142 
01143 Void RGBAImage::SetRGBASpan(Int row, Int start, Int length, 
01144 const RGBAPixel *src) 
01145 {
01146 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01147 "(RGBAImage::SetRGBASpan) illegal span access.");
01148 
01149 memcpy(data + row * width + start, src, length * sizeof(RGBAPixel));
01150  }
01151 
01152 Void RGBAImage::GetRGBASpan(Int row, Int start, Int length,
01153 RGBAPixel *dst) const
01154 {
01155 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01156 "(RGBAImage::GetRGBASpan) illegal span access.");
01157 
01158 memcpy(dst, data + row * width + start, length * sizeof(RGBAPixel));
01159 }
01160 
01161 
01162  // --- ByteImage methods ------------------------------------------------------
01163 
01164 Void ByteImage::SetSize(Int width, Int height)
01165 {
01166 delete[] data;
01167 data = new Byte[width * height];
01168 SELF.width = width;
01169 SELF.height = height;
01170  }
01171 
01172 Void ByteImage::Clear(const Colour &c)
01173 {
01174 Byte *p = data, bc = ColourToByte(c);
01175 Int i;
01176 
01177 for (i = 0; i < width * height; i++, p++)
01178 *p = bc;
01179  }
01180 
01181 Void ByteImage::SetPixel(Int x, Int y, const Colour &c)
01182 {
01183 Assert(x >= 0 && y >= 0 && x < width && y < height,
01184 "illegal pixel access.");
01185 data[x + y * width] = ColourToByte(c);
01186  }
01187 
01188 Colour ByteImage::GetPixel(Int x, Int y) const
01189 {
01190 Assert(x >= 0 && y >= 0 && x < width && y < height, 
01191 "illegal pixel access.");
01192 return(ByteToColour(data[x + y * width]));
01193  }
01194 
01195 Void ByteImage::SetRealPixel(Int x, Int y, ClrReal r, ImgChannel ch)
01196 {
01197 Assert(x >= 0 && y >= 0 && x < width && y < height, 
01198 "illegal pixel access.");
01199 if (ch <= chBlue)
01200 data[x + y * width] = (Byte) (r * 255.0);
01201 }
01202  
01203 
01204 ClrReal ByteImage::GetRealPixel(Int x, Int y, ImgChannel ch) const
01205 {
01206 Assert(x >= 0 && y >= 0 && x < width && y < height, 
01207 "illegal pixel access.");
01208 
01209 if (ch <= chBlue)
01210 return(data[x + y * width] / 255.0);
01211 else
01212 return(0.0);
01213  }
01214 
01215 Void ByteImage::SetSpan(Int row, Int start, Int length, const Colour *src)
01216 {
01217 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01218 "(ByteImage::SetSpan) illegal span access.");
01219 Int i;
01220 Byte *p = data + row * width + start;
01221 const Colour *cp = src;
01222 
01223 for (i = 0; i < length; i++, p++, cp++)
01224 *p = ColourToByte(*cp);
01225  }
01226 
01227 Void ByteImage::GetSpan(Int row, Int start, Int length, Colour *dst) const
01228 {
01229 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01230 "(ByteImage::GetSpan) illegal span access.");
01231 Int i;
01232 Byte *p = data + row * width + start;
01233 Colour *cp = dst;
01234 
01235 for (i = 0; i < length; i++, p++, cp++)
01236 *cp = ByteToColour(*p);
01237  }
01238 
01239 Void ByteImage::SetByteSpan(Int row, Int start, Int length, 
01240 const Byte *src, ImgChannel channel) 
01241 {
01242 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01243 "(ByteImage::SetByteSpan) illegal span access.");
01244 
01245 memcpy(data + row * width + start, src, length);
01246  }
01247 
01248 Void ByteImage::GetByteSpan(Int row, Int start, Int length,
01249 Byte *dst, ImgChannel channel) const
01250 {
01251 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01252 "(ByteImage::GetByteSpan) illegal span access.");
01253 
01254 memcpy(dst, data + row * width + start, length);
01255 }
01256 
01257 
01258  // --- RGBEImage methods ------------------------------------------------------
01259 
01260 Void RGBEImage::SetSize(Int width, Int height)
01261 {
01262 delete[] data;
01263 data = new RGBEPixel[width * height];
01264 SELF.width = width;
01265 SELF.height = height;
01266  }
01267 
01268 Void RGBEImage::Clear(const Colour &c)
01269 {
01270 RGBEPixel *p = data, bc = ColourToRGBE(c);
01271 Int i;
01272 
01273 for (i = 0; i < width * height; i++, p++)
01274 *p = bc;
01275  }
01276 
01277 Void RGBEImage::SetPixel(Int x, Int y, const Colour &c)
01278 {
01279 Assert(x >= 0 && y >= 0 && x < width && y < height,
01280 "illegal pixel access.");
01281 data[x + y * width] = ColourToRGBE(c);
01282  }
01283 
01284 Colour RGBEImage::GetPixel(Int x, Int y) const
01285 {
01286 Assert(x >= 0 && y >= 0 && x < width && y < height,
01287 "illegal pixel access.");
01288 return(RGBEToColour(data[x + y * width]));
01289  }
01290 
01291 Void RGBEImage::SetSpan(Int row, Int start, Int length, const Colour *src)
01292 {
01293 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01294 "(RGBEImage::SetSpan) illegal span access.");
01295 Int i;
01296 RGBEPixel *p = data + row * width + start;
01297 const Colour *cp = src;
01298 
01299 for (i = 0; i < length; i++, p++, cp++)
01300 *p = ColourToRGBE(*cp);
01301  }
01302 
01303 Void RGBEImage::GetSpan(Int row, Int start, Int length, Colour *dst) const
01304 {
01305 Assert(row >= 0 && row < height && start >= 0 && start + length <= width,
01306 "(RGBEImage::GetSpan) illegal span access.");
01307 Int i;
01308 RGBEPixel *p = data + row * width + start;
01309 Colour *cp = dst;
01310 
01311 for (i = 0; i < length; i++, p++, cp++)
01312 *cp = RGBEToColour(*p);
01313  }
01314 
01315  const Int kRGBE_Excess = 128;
01316 
01317 Colour RGBEToColour(RGBEPixel rgbe)
01318 {
01319 Colour result;
01320 Double f;
01321 
01322 if (rgbe.ch[3] == 0)
01323 return(cBlack);
01324 
01325 f = ldexp(1.0, (Int) rgbe.ch[3] - (kRGBE_Excess + 8));
01326 
01327 result[0] = f * (rgbe.ch[0] + 0.5);
01328 result[1] = f * (rgbe.ch[1] + 0.5);
01329 result[2] = f * (rgbe.ch[2] + 0.5);
01330 
01331 return(result); 
01332  }
01333 
01334 RGBEPixel ColourToRGBE(const Colour &c)
01335 {
01336 RGBEPixel result;
01337 Int e;
01338 Double d;
01339 
01340 d = MaxCmpt(c);
01341 if (d <= 1e-32)
01342 {
01343 *((UInt32*) result.ch) = 0;
01344 }
01345 else
01346 {
01347 d = frexp(d, &e) * 256.0 / d;
01348 
01349 result.ch[0] = (Byte) (c[0] * d);
01350 result.ch[1] = (Byte) (c[1] * d);
01351 result.ch[2] = (Byte) (c[2] * d);
01352 result.ch[3] = e + kRGBE_Excess;
01353 }
01354 
01355 return(result); 
01356  }
01357 
01358 RGBEPixel RGBEMult(RGBEPixel rgbe, Double s)
01359 {
01360 Colour temp;
01361 Double d, f;
01362 Int e;
01363 RGBEPixel result;
01364 
01365 *((UInt32*) result.ch) = 0;
01366 
01367 if (rgbe.ch[3] == 0)
01368 return(result);
01369 
01370 f = ldexp(1.0, (Int) rgbe.ch[3] - (kRGBE_Excess + 8));
01371 
01372 temp[0] = f * (rgbe.ch[0] + 0.5);
01373 temp[1] = f * (rgbe.ch[1] + 0.5);
01374 temp[2] = f * (rgbe.ch[2] + 0.5);
01375 
01376 d = MaxCmpt(temp);
01377 if (d <= 1e-32)
01378 return(result);
01379 else
01380 {
01381 d = frexp(d, &e) * 256.0 / d;
01382 
01383 result.ch[0] = (Byte) (temp[0] * d);
01384 result.ch[1] = (Byte) (temp[1] * d);
01385 result.ch[2] = (Byte) (temp[2] * d);
01386 result.ch[3] = e + kRGBE_Excess;
01387 }
01388 
01389 return(result); 
01390 }
01391 
01392 
01393 // --- ChannelImage methods ---------------------------------------------------
01394 
01395 #ifdef UNFINISHED
01396 
01397 ChannelImage::ChannelImage() : tag(imgChannelTag) {}
01398 {
01399 }
01400 #endif
01401  
01402 
01403 Int RGBEImage::SavePIC(const Char *filename)
01404 {
01405 Int i, j;
01406 FILE *pic;
01407 RGBEPixel *p, *buffer = new RGBEPixel[width];
01408 
01409 if (!buffer)
01410 return(-1);
01411 pic = fopen(filename, "w");
01412 if (!pic)
01413 return(-1);
01414 
01415 fprintf(pic, "#?RADIANCE\n");
01416 fprintf(pic, "gcl_out\n");
01417 fprintf(pic, "FORMAT=32-bit_rle_rgbe\n");
01418 fprintf(pic, "\n");
01419 fprintf(pic, "-Y %d +X %d\n", width, height);
01420 
01421 for (j = height - 1; j >= 0; j--)
01422 {
01423 p = data + j * width;
01424 // convert to radiance
01425 for (i = 0; i < width; i++)
01426 buffer[i] = RGBEMult(p[i], 1.0 / 179.0);
01427 fwrite(buffer, sizeof(RGBEPixel), width, pic);
01428 }
01429 
01430 delete[] buffer;
01431 
01432 return(fclose(pic));
01433  }
01434 
01435 Int RGBEImage::LoadPIC(const Char *filename)
01436 {
01437 Int i, j;
01438 Int x, y, level;
01439 FILE *pic;
01440 RGBEPixel *p, *buffer;
01441 
01442 pic = fopen(filename, "r");
01443 if (!pic)
01444 return(-1);
01445 
01446 if (fscanf(pic, 
01447 "#?RADIANCE\n"
01448 "gcl_out\n"
01449 "FORMAT=32-bit_rle_rgbe\n\n"
01450 "-Y %d +X %d\n", &x, &y) != 2)
01451 {
01452 _Warning("Couldn't read pic file: bad format/not gcl_out\n");
01453 fclose(pic);
01454 return(-1);
01455 }
01456 
01457 SetSize(x, y);
01458 
01459 for (j = height - 1; j >= 0; j--)
01460 {
01461 p = data + j * width;
01462 fread(p, sizeof(RGBEPixel), width, pic);
01463 }
01464 
01465 return(fclose(pic));
01466 }