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.5 2000/06/17 20:12:15 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   fprintf(stdout, "usage: %s sdfname outfile [OPTIONS]\n", fileBasename(program));
  87   fprintf(stdout, "Convert IF file to an image file\n");
  88   fprintf(stdout, "\n");
  89   fprintf(stdout, "     sdfname    Name of input SDF file\n");
  90   fprintf(stdout, "     outfile    Name of output file\n");
  91   fprintf(stdout, "     --format   Output format\n");
  92   fprintf(stdout, "         pgm    PGM (portable graymap) format (default)\n");
  93   fprintf(stdout, "         pgmasc PGM (portable graymap) ASCII format\n");
  94 #ifdef HAVE_PNG
  95   fprintf(stdout, "         png    PNG (8-bit) format\n");
  96   fprintf(stdout, "         png16  PNG (16-bit) format\n");
  97 #endif
  98 #ifdef HAVE_GIF
  99   fprintf(stdout, "         gif    GIF format\n");
 100 #endif
 101   fprintf(stdout, "         disp   Display on screen\n");
 102   fprintf(stdout, "     --center   Center of window\n");
 103   fprintf(stdout, "         mode   Mode is center of window (default)\n");
 104   fprintf(stdout, "         mean   Mean is center of window\n");
 105   fprintf(stdout, "     --auto     Set auto window\n");
 106   fprintf(stdout, "         full   Use full window (default)\n");
 107   fprintf(stdout, "         std0.1 Use 0.1 standard deviation about center\n");
 108   fprintf(stdout, "         std0.5 Use 0.5 standard deviation about center\n");
 109   fprintf(stdout, "         std1   Use one standard deviation about center\n");
 110   fprintf(stdout, "         std2   Use two standard deviations about center\n");
 111   fprintf(stdout, "         std3   Use three standard deviations about center\n");
 112   fprintf(stdout, "     --scale    Scaling factor for output size\n");
 113   fprintf(stdout, "     --min      Set minimum intensity\n");
 114   fprintf(stdout, "     --max      Set maximum intensity\n");
 115   fprintf(stdout, "     --stats    Print image statistics\n");
 116   fprintf(stdout, "     --labels   Print image labels\n");
 117   fprintf(stdout, "     --debug    Set debug mode\n");
 118   fprintf(stdout, "     --verbose  Set verbose mode\n");
 119   fprintf(stdout, "     --version  Print version\n");
 120   fprintf(stdout, "     --help     Print this help message\n");
 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               fprintf(stderr, "Error setting --min to %s\n", 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               fprintf(stderr, "Error setting --max to %s\n", 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               fprintf(stderr,"Error setting --scale to %s\n", 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               fprintf(stderr, "Invalid auto mode %s\n", 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               fprintf(stderr, "Invalid center mode %s\n", 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               fprintf(stderr, "Invalid format mode %s\n", 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           fprintf(stdout, "Version %s\n", VERSION);
 255 #else
 256           fprintf(stderr, "Unknown version number");
 257 #endif
 258           exit(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     fprintf(stderr, "File %s does not exist\n", 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         fprintf(stderr, "Internal Error: Invalid auto mode %d\n", opt_auto);
 381         return (1);
 382       }
 383     }
 384     if (opt_stats) {
 385       fprintf(stdout,"nx=%d\n", nx);
 386       fprintf(stdout,"ny=%d\n", ny);
 387       fprintf(stdout,"min=%f\n", minfound);
 388       fprintf(stdout,"max=%f\n", maxfound);
 389       fprintf(stdout,"mean=%f\n", mean);
 390       fprintf(stdout,"mode=%f\n", mode);
 391       fprintf(stdout,"stddev=%f\n", stddev);
 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         fprintf(stderr, "Internal Error: Invalid center mode %d\n", 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     fprintf(stdout,"min_disp=%f\n", densmin);
 413     fprintf(stdout,"max_disp=%f\n", densmax);
 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       fprintf(stderr, "Internal Error: Invalid format mode %d\n", 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 = new unsigned char [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   delete rowp;
 478
 479   fclose(fp);
 480 }
 481
 482 void
 483 sdf2d_to_pgmasc (ImageFile& im, char *outfile, int nxcell, int nycell, double densmin, double densmax)
 484 {
 485   FILE *fp;
 486   int nx = im.nx();
 487   int ny = im.ny();
 488   ImageFileArray v = im.getArray();
 489
 490   unsigned char* rowp = new unsigned char [nx * nxcell];
 491   if (rowp == NULL)
 492     return;
 493
 494   if ((fp = fopen (outfile, "wb")) == NULL)
 495      return;
 496
 497   fprintf(fp, "P2\n");
 498   fprintf(fp, "%d %d\n", nx, ny);
 499   fprintf(fp, "255\n");
 500
 501   for (int irow = ny - 1; irow >= 0; irow--) {
 502     for (int icol = 0; icol < nx; icol++) {
 503       int pos = icol * nxcell;
 504       double dens = (v[icol][irow] - densmin) / (densmax - densmin);
 505       dens = clamp (dens, 0., 1.);
 506       for (int p = pos; p < pos + nxcell; p++) {
 507         rowp[p] = static_cast<unsigned int> (dens * 255.);
 508       }
 509     }
 510     for (int ir = 0; ir < nycell; ir++) {
 511       for (int ic = 0; ic < nx * nxcell; ic++)
 512         fprintf(fp, "%d ", rowp[ic]);
 513       fprintf(fp, "\n");
 514     }
 515   }
 516   delete rowp;
 517
 518   fclose(fp);
 519 }
 520
 521
 522 #ifdef HAVE_PNG
 523 void
 524 sdf2d_to_png (ImageFile& im, char *outfile, int bitdepth, int nxcell, int nycell, double densmin, double densmax)
 525 {
 526   FILE *fp;
 527   png_structp png_ptr;
 528   png_infop info_ptr;
 529   double max_out_level = (1 << bitdepth) - 1;
 530   int nx = im.nx();
 531   int ny = im.ny();
 532   ImageFileArray v = im.getArray();
 533
 534   unsigned char* rowp = new unsigned char [nx * nxcell * (bitdepth / 8)];
 535
 536   if ((fp = fopen (outfile, "wb")) == NULL)
 537      return;
 538
 539   png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 540   if (! png_ptr)
 541     return;
 542
 543   info_ptr = png_create_info_struct(png_ptr);
 544   if (! info_ptr) {
 545     png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
 546     fclose(fp);
 547     return;
 548   }
 549
 550   if (setjmp(png_ptr->jmpbuf)) {
 551     png_destroy_write_struct(&png_ptr, &info_ptr);
 552     fclose(fp);
 553     return;
 554   }
 555
 556   png_init_io(png_ptr, fp);
 557
 558   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);
 559
 560   png_write_info(png_ptr, info_ptr);
 561   for (int irow = ny - 1; irow >= 0; irow--) {
 562     png_bytep row_pointer = rowp;
 563
 564     for (int icol = 0; icol < nx; icol++) {
 565       int pos = icol * nxcell;
 566       double dens = (v[icol][irow] - densmin) / (densmax - densmin);
 567       dens = clamp (dens, 0., 1.);
 568       unsigned int outval = static_cast<unsigned int> (dens * max_out_level);
 569
 570       for (int p = pos; p < pos + nxcell; p++) {
 571         if (bitdepth == 8)
 572           rowp[p] = outval;
 573         else {
 574           int rowpos = p * 2;
 575           rowp[rowpos] = (outval >> 8) & 0xFF;
 576           rowp[rowpos+1] = (outval & 0xFF);
 577         }
 578       }
 579     }
 580     for (int ir = 0; ir < nycell; ir++)
 581       png_write_rows (png_ptr, &row_pointer, 1);
 582   }
 583   delete rowp;
 584
 585   png_write_end(png_ptr, info_ptr);
 586   png_destroy_write_struct(&png_ptr, &info_ptr);
 587
 588   fclose(fp);
 589 }
 590 #endif
 591
 592 #ifdef HAVE_GD
 593 #include "gd.h"
 594 #define N_GRAYSCALE 256
 595 #endif
 596
 597 void
 598 sdf2d_to_gif (ImageFile& im, char *outfile, int nxcell, int nycell, double densmin, double densmax)
 599 {
 600 #ifdef HAVE_GD
 601   gdImagePtr gif;
 602   FILE *out;
 603   int gs_indices[N_GRAYSCALE];
 604   int nx = im.nx();
 605   int ny = im.ny();
 606   ImageFileArray v = im.getArray();
 607
 608   usnigned char* rowp = new unsigned char [nx * nxcell];
 609   if (rowp == NULL)
 610     return;
 611
 612   gif = gdImageCreate(nx * nxcell, ny * nycell);
 613   for (int i = 0; i < N_GRAYSCALE; i++)
 614     gs_indices[i] = gdImageColorAllocate(gif, i, i, i);
 615
 616   int lastrow = ny * nycell - 1;
 617   for (int irow = 0; irow < ny; irow++) {
 618     int rpos = irow * nycell;
 619     for (int ir = rpos; ir < rpos + nycell; ir++) {
 620       for (int icol = 0; icol < nx; icol++) {
 621         int cpos = icol * nxcell;
 622         double dens = (v[icol][irow] - densmin) / (densmax - densmin);
 623         dens = clamp(dens, 0., 1.);
 624         for (int ic = cpos; ic < cpos + nxcell; ic++) {
 625           rowp[ic] = (unsigned int) (dens * (double) (N_GRAYSCALE - 1));
 626           gdImageSetPixel(gif, ic, lastrow - ir, gs_indices[rowp[ic]]);
 627         }
 628       }
 629     }
 630   }
 631   delete rowp;
 632
 633   if ((out = fopen(outfile,"w")) == NULL) {
 634     fprintf(stderr,"Error opening output file %s for writing\n", outfile);
 635     exit(1);
 636   }
 637   gdImageGif(gif,out);
 638   fclose(out);
 639   gdImageDestroy(gif);
 640 #else
 641   fprintf(stderr, "This version does not support GIF");
 642 #endif
 643 }
 644
 645 #ifndef NO_MAIN
 646 int
 647 main (int argc, char *const argv[])
 648 {
 649   return (if2img_main(argc, argv));
 650 }
 651 #endif