src/if2img.cpp

   1 /*****************************************************************************
   2 ** FILE IDENTIFICATION
   3 **
   4 **   Name:          if2img.cpp
   5 **   Purpose:       Convert an image file to a viewable image
   6 **   Programmer:    Kevin Rosenberg
   7 **   Date Started:  April 2000
   8 **
   9 **  This is part of the CTSim program
  10 **  Copyright (C) 1983-2000 Kevin Rosenberg
  11 **
  12 **  $Id: if2img.cpp,v 1.8 2000/06/22 10:17:28 kevin Exp $
  13 **
  14 **  This program is free software; you can redistribute it and/or modify
  15 **  it under the terms of the GNU General Public License (version 2) as
  16 **  published by the Free Software Foundation.
  17 **
  18 **  This program is distributed in the hope that it will be useful,
  19 **  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 **  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 **  GNU General Public License for more details.
  22 **
  23 **  You should have received a copy of the GNU General Public License
  24 **  along with this program; if not, write to the Free Software
  25 **  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26 ******************************************************************************/
  27
  28 /* FILE
  29  *   if2img.c           Convert an SDF file to a viewable format image
  30  */
  31
  32 #include "ct.h"
  33
  34 #if HAVE_PNG
  35 void sdf2d_to_png (ImageFile& im, char *outfile, int bitdepth, int nxcell, int nycell, double densmin, double densmax);
  36 #endif
  37 #if HAVE_GIF
  38 void sdf2d_to_gif (ImageFile& im, char *outfile, int nxcell, int nycell, double densmin, double densmax);
  39 #endif
  40 void sdf2d_to_pgm (ImageFile& im, char *outfile, int nxcell, int nycell, double densmin, double densmax);
  41 void sdf2d_to_pgmasc (ImageFile& im, char *outfile, int nxcell, int nycell, double densmin, double densmax);
  42
  43 enum { O_SCALE, O_MIN, O_MAX, O_AUTO, O_CENTER, O_STATS, O_FORMAT, O_LABELS,
  44        O_HELP, O_VERBOSE, O_VERSION, O_DEBUG };
  45
  46 static struct option my_options[] =
  47 {
  48   {"scale", 1, 0, O_SCALE},
  49   {"min", 1, 0, O_MIN},
  50   {"max", 1, 0, O_MAX},
  51   {"auto", 1, 0, O_AUTO},
  52   {"center", 1, 0, O_CENTER},
  53   {"format", 1, 0, O_FORMAT},
  54   {"labels", 0, 0, O_LABELS},
  55   {"stats", 0, 0, O_STATS},
  56   {"verbose", 0, 0, O_VERBOSE},
  57   {"debug", 0, 0, O_DEBUG},
  58   {"help", 0, 0, O_HELP},
  59   {"version", 0, 0, O_VERSION},
  60   {0, 0, 0, 0}
  61 };
  62
  63 enum { O_AUTO_FULL, O_AUTO_STD0_1, O_AUTO_STD0_5, O_AUTO_STD1, O_AUTO_STD2, O_AUTO_STD3 };
  64 #define O_AUTO_FULL_STR  "full"
  65 #define O_AUTO_STD0_1_STR  "std0.1"
  66 #define O_AUTO_STD0_5_STR  "std0.5"
  67 #define O_AUTO_STD1_STR  "std1"
  68 #define O_AUTO_STD2_STR  "std2"
  69 #define O_AUTO_STD3_STR  "std3"
  70
  71 enum { O_CENTER_MEAN, O_CENTER_MODE };
  72 #define O_CENTER_MEAN_STR  "mean"
  73 #define O_CENTER_MODE_STR  "mode"
  74
  75 enum { O_FORMAT_GIF, O_FORMAT_PNG, O_FORMAT_PNG16, O_FORMAT_PGM, O_FORMAT_PGMASC, O_FORMAT_DISP };
  76 #define O_FORMAT_GIF_STR   "gif"
  77 #define O_FORMAT_PNG_STR   "png"
  78 #define O_FORMAT_PNG16_STR   "png16"
  79 #define O_FORMAT_PGM_STR   "pgm"
  80 #define O_FORMAT_PGMASC_STR "pgmasc"
  81 #define O_FORMAT_DISP_STR    "disp"
  82
  83 void
  84 if2img_usage (const char *program)
  85 {
  86   cout << "usage: " << fileBasename(program) << " ifname outfile [OPTIONS]" << endl;
  87   cout << "Convert IF file to an image file" << endl;
  88   cout << endl;
  89   cout << "     sdfname    Name of input SDF file" << endl;
  90   cout << "     outfile    Name of output file" << endl;
  91   cout << "     --format   Output format" << endl;
  92   cout << "         pgm    PGM (portable graymap) format (default)" << endl;
  93   cout << "         pgmasc PGM (portable graymap) ASCII format" << endl;
  94 #ifdef HAVE_PNG
  95   cout << "         png    PNG (8-bit) format" << endl;
  96   cout << "         png16  PNG (16-bit) format" << endl;
  97 #endif
  98 #ifdef HAVE_GIF
  99   cout << "         gif    GIF format" << endl;
 100 #endif
 101   cout << "         disp   Display on screen" << endl;
 102   cout << "     --center   Center of window" << endl;
 103   cout << "         mode   Mode is center of window (default)" << endl;
 104   cout << "         mean   Mean is center of window" << endl;
 105   cout << "     --auto     Set auto window" << endl;
 106   cout << "         full   Use full window (default)" << endl;
 107   cout << "         std0.1 Use 0.1 standard deviation about center" << endl;
 108   cout << "         std0.5 Use 0.5 standard deviation about center" << endl;
 109   cout << "         std1   Use one standard deviation about center" << endl;
 110   cout << "         std2   Use two standard deviations about center" << endl;
 111   cout << "         std3   Use three standard deviations about center" << endl;
 112   cout << "     --scale    Scaling factor for output size" << endl;
 113   cout << "     --min      Set minimum intensity" << endl;
 114   cout << "     --max      Set maximum intensity" << endl;
 115   cout << "     --stats    Print image statistics" << endl;
 116   cout << "     --labels   Print image labels" << endl;
 117   cout << "     --debug    Set debug mode" << endl;
 118   cout << "     --verbose  Set verbose mode" << endl;
 119   cout << "     --version  Print version" << endl;
 120   cout << "     --help     Print this help message" << endl;
 121 }
 122
 123
 124 int
 125 if2img_main (int argc, char *const argv[])
 126 {
 127   ImageFile* pim = NULL;
 128
 129   double densmin = HUGE_VAL, densmax = -HUGE_VAL;
 130   char *in_file, *out_file;
 131   int opt_verbose = 0;
 132   int opt_scale = 1;
 133   int opt_auto = O_AUTO_FULL;
 134   int opt_set_max = 0;
 135   int opt_set_min = 0;
 136   int opt_stats = 0;
 137   int opt_debug = 0;
 138   int opt_center = O_CENTER_MODE;
 139   int opt_format = O_FORMAT_PGM;
 140   int opt_labels = 0;
 141
 142   while (1)
 143     {
 144       int c = getopt_long (argc, argv, "", my_options, NULL);
 145       char *endptr = NULL;
 146       char *endstr;
 147
 148       if (c == -1)
 149         break;
 150
 151       switch (c)
 152         {
 153         case O_MIN:
 154           opt_set_min = 1;
 155           densmin = strtod(optarg, &endptr);
 156           endstr = optarg + strlen(optarg);
 157           if (endptr != endstr)
 158             {
 159               sys_error (ERR_SEVERE, "Error setting --min to %s", optarg);
 160               if2img_usage(argv[0]);
 161               return (1);
 162             }
 163           break;
 164         case O_MAX:
 165           opt_set_max = 1;
 166           densmax = strtod(optarg, &endptr);
 167           endstr = optarg + strlen(optarg);
 168           if (endptr != endstr)
 169             {
 170               sys_error (ERR_SEVERE, "Error setting --max to %s", optarg);
 171               if2img_usage(argv[0]);
 172               return (1);
 173             }
 174           break;
 175         case O_SCALE:
 176           opt_scale = strtol(optarg, &endptr, 10);
 177           endstr = optarg + strlen(optarg);
 178           if (endptr != endstr)
 179             {
 180               sys_error (ERR_SEVERE, "Error setting --scale to %s", optarg);
 181               if2img_usage(argv[0]);
 182               return (1);
 183             }
 184           break;
 185         case O_AUTO:
 186           if (strcmp(optarg, O_AUTO_FULL_STR) == 0)
 187             opt_auto = O_AUTO_FULL;
 188           else if (strcmp(optarg, O_AUTO_STD1_STR) == 0)
 189             opt_auto = O_AUTO_STD1;
 190           else if (strcmp(optarg, O_AUTO_STD0_5_STR) == 0)
 191             opt_auto = O_AUTO_STD0_5;
 192           else if (strcmp(optarg, O_AUTO_STD0_1_STR) == 0)
 193             opt_auto = O_AUTO_STD0_1;
 194           else if (strcmp(optarg, O_AUTO_STD2_STR) == 0)
 195             opt_auto = O_AUTO_STD2;
 196           else if (strcmp(optarg, O_AUTO_STD3_STR) == 0)
 197             opt_auto = O_AUTO_STD3;
 198           else
 199             {
 200               sys_error (ERR_SEVERE, "Invalid auto mode %s", optarg);
 201               if2img_usage(argv[0]);
 202               return (1);
 203             }
 204                 break;
 205         case O_CENTER:
 206           if (strcmp(optarg, O_CENTER_MEAN_STR) == 0)
 207             opt_center = O_CENTER_MEAN;
 208           else if (strcmp(optarg, O_CENTER_MODE_STR) == 0)
 209             opt_center = O_CENTER_MODE;
 210           else
 211             {
 212               sys_error (ERR_SEVERE, "Invalid center mode %s", optarg);
 213               if2img_usage(argv[0]);
 214               return (1);
 215             }
 216           break;
 217         case O_FORMAT:
 218           if (strcmp(optarg, O_FORMAT_PGM_STR) == 0)
 219             opt_format = O_FORMAT_PGM;
 220           else if (strcmp(optarg, O_FORMAT_PGMASC_STR) == 0)
 221             opt_format = O_FORMAT_PGMASC;
 222 #if HAVE_PNG
 223           else if (strcmp(optarg, O_FORMAT_PNG_STR) == 0)
 224             opt_format = O_FORMAT_PNG;
 225           else if (strcmp(optarg, O_FORMAT_PNG16_STR) == 0)
 226             opt_format = O_FORMAT_PNG16;
 227 #endif
 228 #if HAVE_GIF
 229           else if (strcmp(optarg, O_FORMAT_GIF_STR) == 0)
 230             opt_format = O_FORMAT_GIF;
 231 #endif
 232           else if (strcmp(optarg, O_FORMAT_DISP_STR) == 0)
 233             opt_format = O_FORMAT_DISP;
 234           else {
 235               sys_error (ERR_SEVERE, "Invalid format mode %s", optarg);
 236               if2img_usage(argv[0]);
 237               return (1);
 238             }
 239           break;
 240         case O_LABELS:
 241           opt_labels = 1;
 242           break;
 243         case O_VERBOSE:
 244           opt_verbose = 1;
 245           break;
 246         case O_DEBUG:
 247           opt_debug = 1;
 248           break;
 249         case O_STATS:
 250           opt_stats = 1;
 251           break;
 252         case O_VERSION:
 253 #ifdef VERSION
 254           cout << "Version " << VERSION;
 255 #else
 256           cout << "Unknown version number" << endl;
 257 #endif
 258           return (0);
 259         case O_HELP:
 260         case '?':
 261           if2img_usage(argv[0]);
 262           return (0);
 263         default:
 264           if2img_usage(argv[0]);
 265           return (1);
 266         }
 267     }
 268
 269   if ((opt_format == O_FORMAT_DISP && optind + 1 != argc)
 270       || (opt_format != O_FORMAT_DISP && optind + 2 != argc))
 271     {
 272         if2img_usage(argv[0]);
 273         return (1);
 274     }
 275
 276   in_file = argv[optind];
 277
 278   if (opt_format != O_FORMAT_DISP)
 279       out_file = argv[optind+1];
 280   else out_file = NULL;
 281
 282   pim = new ImageFile (in_file);
 283   ImageFile& im = *pim;
 284   if (! im.fileRead()) {
 285     sys_error (ERR_FATAL, "File %s does not exist", in_file);
 286     return (1);
 287   }
 288
 289   if (opt_labels) {
 290     int nlabels = im.getNumLabels();
 291
 292     for (int i = 0; i < nlabels; i++) {
 293       Array2dFileLabel label;
 294       im.labelRead (label, i);
 295
 296       if (label.getLabelType() == Array2dFileLabel::L_HISTORY) {
 297         cout << "History: " << label.getLabelString() << endl;
 298         cout << "  calc time = " << label.getCalcTime() << " secs" << endl;
 299         cout << "  Timestamp = " << label.getDateString() << endl;
 300       } else if (label.getLabelType() == Array2dFileLabel::L_USER) {
 301         cout << "Note: " <<  label.getLabelString() << endl;
 302         cout << "  Timestamp = %s" << label.getDateString() << endl;
 303       }
 304     }
 305   }
 306
 307   if (opt_stats || (! (opt_set_max && opt_set_min))) {
 308     double minfound = HUGE_VAL, maxfound = -HUGE_VAL;
 309     double mode = 0, mean = 0, stddev = 0, window = 0;
 310     double spread;
 311     int hist[256];
 312     int ibin, nbin = 256;
 313     int max_bin, max_binindex;
 314     double maxbin;
 315     int nx = im.nx();
 316     int ny = im.ny();
 317     ImageFileArray v = im.getArray();
 318
 319     maxbin = nbin - 1;
 320     for (int ix = 0; ix < nx; ix++) {
 321       for (int iy = 0; iy < ny; iy++) {
 322         if (v[ix][iy] > maxfound)
 323           maxfound = v[ix][iy];
 324         if (v[ix][iy] < minfound)
 325           minfound = v[ix][iy];
 326         mean += v[ix][iy];
 327       }
 328     }
 329     spread = maxfound - minfound;
 330     if (spread == 0)
 331       mode = minfound;
 332     else {
 333       for (ibin = 0; ibin < nbin; ibin++)
 334         hist[ibin] = 0;
 335       for (int ix = 0; ix < nx; ix++) {
 336         for (int iy = 0; iy < ny; iy++) {
 337           int b = (int) ((((v[ix][iy] - minfound) / spread) * (double) maxbin) + 0.5);
 338           hist[b]++;
 339         }
 340       }
 341       max_binindex = 0;
 342       max_bin = -1;
 343       for (ibin = 0; ibin < nbin; ibin++) {
 344         if (hist[ibin] > max_bin) {
 345           max_bin = hist[ibin];
 346           max_binindex = ibin;
 347         }
 348       }
 349       mode = (((double) max_binindex) * spread / ((double) maxbin)) + minfound;
 350     }
 351
 352     if (opt_auto == O_AUTO_FULL) {
 353         if (! opt_set_max)
 354           densmax = maxfound;
 355         if (! opt_set_min)
 356           densmin = minfound;
 357     }
 358     if (opt_stats || opt_auto != O_AUTO_FULL) {
 359       mean /= nx * ny;
 360       for (int ix = 0; ix < nx; ix++) {
 361         for (int iy = 0; iy < ny; iy++) {
 362             double diff = (v[ix][iy] - mean);
 363             stddev += diff * diff;
 364         }
 365       }
 366       stddev = sqrt(stddev / (nx * ny));
 367       if (opt_auto == O_AUTO_FULL)
 368         ;
 369       else if (opt_auto == O_AUTO_STD1)
 370             window = stddev;
 371       else if (opt_auto == O_AUTO_STD0_1)
 372         window = stddev * 0.1;
 373       else if (opt_auto == O_AUTO_STD0_5)
 374         window = stddev * 0.5;
 375           else if (opt_auto == O_AUTO_STD2)
 376             window = stddev * 2;
 377       else if (opt_auto == O_AUTO_STD3)
 378         window = stddev * 3;
 379       else {
 380         sys_error (ERR_SEVERE, "Internal Error: Invalid auto mode %d", opt_auto);
 381         return (1);
 382       }
 383     }
 384     if (opt_stats) {
 385       cout <<"nx: " << nx << endl;
 386       cout <<"ny: " << ny << endl;
 387       cout <<"min: " << minfound << endl;
 388       cout <<"max: " << maxfound << endl;
 389       cout <<"mean: " << mean << endl;
 390       cout <<"mode: " << mode << endl;
 391       cout <<"stddev: " << stddev << endl;
 392     }
 393     if (opt_auto != O_AUTO_FULL) {
 394       double center;
 395
 396       if (opt_center == O_CENTER_MODE)
 397         center = mode;
 398       else if (opt_center == O_CENTER_MEAN)
 399         center = mean;
 400       else {
 401         sys_error (ERR_SEVERE, "Internal Error: Invalid center mode %d", opt_center);
 402         return (1);
 403       }
 404       if (! opt_set_max)
 405         densmax = center + window;
 406       if (! opt_set_min)
 407         densmin = center - window;
 408       }
 409   }
 410
 411   if (opt_stats) {
 412     cout << "min display: " << densmin << endl;
 413     cout << "max display: " << densmax << endl;
 414   }
 415
 416   if (opt_format == O_FORMAT_PGM)
 417     sdf2d_to_pgm (im, out_file, opt_scale, opt_scale, densmin, densmax);
 418   else if (opt_format == O_FORMAT_PGMASC)
 419     sdf2d_to_pgmasc (im, out_file, opt_scale, opt_scale, densmin, densmax);
 420 #if HAVE_PNG
 421   else if (opt_format == O_FORMAT_PNG)
 422     sdf2d_to_png (im, out_file, 8, opt_scale, opt_scale, densmin, densmax);
 423   else if (opt_format == O_FORMAT_PNG16)
 424     sdf2d_to_png (im, out_file, 16, opt_scale, opt_scale, densmin, densmax);
 425 #endif
 426 #if HAVE_GIF
 427   else if (opt_format == O_FORMAT_GIF)
 428     sdf2d_to_gif (im, out_file, opt_scale, opt_scale, densmin, densmax);
 429 #endif
 430   else if (opt_format == O_FORMAT_DISP) {
 431 #if HAVE_SGP
 432     // image_display_scale (im, opt_scale, densmin, densmax);
 433     //  cio_kb_getc();
 434       sgp2_close(sgp2_get_active_win());
 435 #endif
 436   }
 437   else
 438     {
 439       sys_error (ERR_SEVERE, "Internal Error: Invalid format mode %d", opt_format);
 440       return (1);
 441     }
 442   return (0);
 443 }
 444
 445
 446 void
 447 sdf2d_to_pgm (ImageFile& im, char *outfile, int nxcell, int nycell, double densmin, double densmax)
 448 {
 449   FILE *fp;
 450   int nx = im.nx();
 451   int ny = im.ny();
 452   ImageFileArray v = im.getArray();
 453
 454   unsigned char rowp [nx * nxcell];
 455
 456   if ((fp = fopen (outfile, "wb")) == NULL)
 457      return;
 458
 459   fprintf(fp, "P5\n");
 460   fprintf(fp, "%d %d\n", nx, ny);
 461   fprintf(fp, "255\n");
 462
 463   for (int irow = ny - 1; irow >= 0; irow--) {
 464     for (int icol = 0; icol < nx; icol++) {
 465       int pos = icol * nxcell;
 466       double dens = (v[icol][irow] - densmin) / (densmax - densmin);
 467       dens = clamp (dens, 0., 1.);
 468       for (int p = pos; p < pos + nxcell; p++) {
 469         rowp[p] = static_cast<unsigned int> (dens * 255.);
 470       }
 471     }
 472     for (int ir = 0; ir < nycell; ir++) {
 473       for (int ic = 0; ic < nx * nxcell; ic++)
 474         fprintf(fp, "%c ", rowp[ic]);
 475     }
 476   }
 477
 478   fclose(fp);
 479 }
 480
 481 void
 482 sdf2d_to_pgmasc (ImageFile& im, char *outfile, int nxcell, int nycell, double densmin, double densmax)
 483 {
 484   FILE *fp;
 485   int nx = im.nx();
 486   int ny = im.ny();
 487   ImageFileArray v = im.getArray();
 488
 489   unsigned char rowp [nx * nxcell];
 490   if (rowp == NULL)
 491     return;
 492
 493   if ((fp = fopen (outfile, "wb")) == NULL)
 494      return;
 495
 496   fprintf(fp, "P2\n");
 497   fprintf(fp, "%d %d\n", nx, ny);
 498   fprintf(fp, "255\n");
 499
 500   for (int irow = ny - 1; irow >= 0; irow--) {
 501     for (int icol = 0; icol < nx; icol++) {
 502       int pos = icol * nxcell;
 503       double dens = (v[icol][irow] - densmin) / (densmax - densmin);
 504       dens = clamp (dens, 0., 1.);
 505       for (int p = pos; p < pos + nxcell; p++) {
 506         rowp[p] = static_cast<unsigned int> (dens * 255.);
 507       }
 508     }
 509     for (int ir = 0; ir < nycell; ir++) {
 510       for (int ic = 0; ic < nx * nxcell; ic++)
 511         fprintf(fp, "%d ", rowp[ic]);
 512       fprintf(fp, "\n");
 513     }
 514   }
 515
 516   fclose(fp);
 517 }
 518
 519
 520 #ifdef HAVE_PNG
 521 void
 522 sdf2d_to_png (ImageFile& im, char *outfile, int bitdepth, int nxcell, int nycell, double densmin, double densmax)
 523 {
 524   FILE *fp;
 525   png_structp png_ptr;
 526   png_infop info_ptr;
 527   double max_out_level = (1 << bitdepth) - 1;
 528   int nx = im.nx();
 529   int ny = im.ny();
 530   ImageFileArray v = im.getArray();
 531
 532   unsigned char rowp [nx * nxcell * (bitdepth / 8)];
 533
 534   if ((fp = fopen (outfile, "wb")) == NULL)
 535      return;
 536
 537   png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 538   if (! png_ptr)
 539     return;
 540
 541   info_ptr = png_create_info_struct(png_ptr);
 542   if (! info_ptr) {
 543     png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
 544     fclose(fp);
 545     return;
 546   }
 547
 548   if (setjmp(png_ptr->jmpbuf)) {
 549     png_destroy_write_struct(&png_ptr, &info_ptr);
 550     fclose(fp);
 551     return;
 552   }
 553
 554   png_init_io(png_ptr, fp);
 555
 556   png_set_IHDR(png_ptr, info_ptr, nx * nxcell, ny * nycell, bitdepth, PNG_COLOR_TYPE_GRAY, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_DEFAULT);
 557
 558   png_write_info(png_ptr, info_ptr);
 559   for (int irow = ny - 1; irow >= 0; irow--) {
 560     png_bytep row_pointer = rowp;
 561
 562     for (int icol = 0; icol < nx; icol++) {
 563       int pos = icol * nxcell;
 564       double dens = (v[icol][irow] - densmin) / (densmax - densmin);
 565       dens = clamp (dens, 0., 1.);
 566       unsigned int outval = static_cast<unsigned int> (dens * max_out_level);
 567
 568       for (int p = pos; p < pos + nxcell; p++) {
 569         if (bitdepth == 8)
 570           rowp[p] = outval;
 571         else {
 572           int rowpos = p * 2;
 573           rowp[rowpos] = (outval >> 8) & 0xFF;
 574           rowp[rowpos+1] = (outval & 0xFF);
 575         }
 576       }
 577     }
 578     for (int ir = 0; ir < nycell; ir++)
 579       png_write_rows (png_ptr, &row_pointer, 1);
 580   }
 581
 582   png_write_end(png_ptr, info_ptr);
 583   png_destroy_write_struct(&png_ptr, &info_ptr);
 584
 585   fclose(fp);
 586 }
 587 #endif
 588
 589 #ifdef HAVE_GD
 590 #include "gd.h"
 591 #define N_GRAYSCALE 256
 592 #endif
 593
 594 void
 595 sdf2d_to_gif (ImageFile& im, char *outfile, int nxcell, int nycell, double densmin, double densmax)
 596 {
 597 #ifdef HAVE_GD
 598   gdImagePtr gif;
 599   FILE *out;
 600   int gs_indices[N_GRAYSCALE];
 601   int nx = im.nx();
 602   int ny = im.ny();
 603   ImageFileArray v = im.getArray();
 604
 605   unsigned char rowp [nx * nxcell];
 606   if (rowp == NULL)
 607     return;
 608
 609   gif = gdImageCreate(nx * nxcell, ny * nycell);
 610   for (int i = 0; i < N_GRAYSCALE; i++)
 611     gs_indices[i] = gdImageColorAllocate(gif, i, i, i);
 612
 613   int lastrow = ny * nycell - 1;
 614   for (int irow = 0; irow < ny; irow++) {
 615     int rpos = irow * nycell;
 616     for (int ir = rpos; ir < rpos + nycell; ir++) {
 617       for (int icol = 0; icol < nx; icol++) {
 618         int cpos = icol * nxcell;
 619         double dens = (v[icol][irow] - densmin) / (densmax - densmin);
 620         dens = clamp(dens, 0., 1.);
 621         for (int ic = cpos; ic < cpos + nxcell; ic++) {
 622           rowp[ic] = (unsigned int) (dens * (double) (N_GRAYSCALE - 1));
 623           gdImageSetPixel(gif, ic, lastrow - ir, gs_indices[rowp[ic]]);
 624         }
 625       }
 626     }
 627   }
 628
 629   if ((out = fopen(outfile,"w")) == NULL) {
 630     sys_error(ERR_FATAL, "Error opening output file %s for writing", outfile);
 631     return (1);
 632   }
 633   gdImageGif(gif,out);
 634   fclose(out);
 635   gdImageDestroy(gif);
 636 #else
 637   cout << "This version does not support GIF" << endl;
 638 #endif
 639 }
 640
 641 #ifndef NO_MAIN
 642 int
 643 main (int argc, char *const argv[])
 644 {
 645   int retval = 1;
 646
 647   try {
 648     retval = if2img_main(argc, argv);
 649   } catch (exception e) {
 650     cerr << "Exception: " << e.what() << endl;
 651   } catch (...) {
 652     cerr << "Unknown exception" << endl;
 653   }
 654
 655   return (retval);
 656 }
 657 #endif