d2/image_rw.h

   1 // Copyright 2002 David Hilvert <dhilvert@auricle.dyndns.org>,
   2 //                              <dhilvert@ugcs.caltech.edu>
   3
   4 /*  This file is part of the Anti-Lamenessing Engine.
   5
   6     The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with the Anti-Lamenessing Engine; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 /*
  22  * image_rw.h: Read and write images.
  23  */
  24
  25
  26 #ifndef __image_rw_h__
  27 #define __image_rw_h__
  28
  29 #include "image.h"
  30 #include "image_ale_real.h"
  31 #include "image_bayer_ale_real.h"
  32 #include "image_accel.h"
  33 #include "ppm.h"
  34 #include "exposure/exposure.h"
  35 #include "exposure/exposure_default.h"
  36
  37 class image_rw {
  38
  39         /*
  40          * Private data members
  41          */
  42
  43         /*
  44          * PPM type
  45          *
  46          * 0 = No type selected
  47          * 1 = PPM Raw
  48          * 2 = PPM Plain
  49          */
  50         static int ppm_type;
  51
  52         /*
  53          * Bit depth
  54          */
  55         static unsigned int num_bits;
  56         static unsigned int mcv;
  57
  58         /*
  59          * Nearest-neighbor defined value radius.
  60          */
  61         static double nn_defined_radius;
  62
  63         /*
  64          * Input and output exposure models
  65          */
  66         static exposure **input_exposure;
  67         static exposure *output_exposure;
  68         static int exposure_scale;
  69
  70         /*
  71          * Default bayer pattern
  72          */
  73         static unsigned int bayer_default;
  74
  75         /*
  76          * Image-specific bayer patterns.
  77          */
  78         static unsigned int *bayer_specific;
  79
  80         /*
  81          * Pointer to the output filename
  82          */
  83         static const char *output_filename;
  84
  85         /*
  86          * Variables relating to input image files and image data structures.
  87          */
  88         static const char **filenames;
  89         static unsigned int file_count;
  90         static const image **images;
  91         static int *files_open;
  92
  93         /*
  94          * The most recently closed image number.
  95          */
  96         static int latest_close_num;
  97
  98         /*
  99          * Maximum cache size, in megabytes (2^20 * bytes), for images not most
 100          * recently closed.
 101          */
 102         static double cache_size_max;
 103
 104         /*
 105          * Actual cache size.
 106          */
 107         static double cache_size;
 108
 109         /*
 110          * Number of cached files.
 111          */
 112         static unsigned int cache_count;
 113
 114         /*
 115          * Private methods to init and shut down the file reader.
 116          */
 117
 118         /*
 119          * Initialize the image file handler
 120          */
 121         static void init_image() {
 122 #ifdef USE_MAGICK
 123                 InitializeMagick("ale");
 124 #endif
 125         }
 126
 127         /*
 128          * Destroy the image file handler
 129          */
 130         static void destroy_image() {
 131 #ifdef USE_MAGICK
 132                 DestroyMagick();
 133 #endif
 134         }
 135
 136         static image *read_image_im_unaccel(const char *filename, exposure *exp, const char *name,
 137                         unsigned int bayer, int init_reference_gain) {
 138 #ifdef USE_MAGICK
 139
 140                 if (MaxRGB < 65535 && mcv == 65535) {
 141                         fprintf(stderr, "\n\n*** Warning: 16 bit-per-channel file output was specified,\n");
 142                         fprintf(stderr, "*** but ImageMagick has not been compiled with support for 16 bits.\n");
 143                         fprintf(stderr, "*** Reading input using 8 bits per channel.\n\n\n");
 144                 }
 145
 146                 /*
 147                  * Patterned after http://www.imagemagick.org/www/api.html
 148                  * and http://www.imagemagick.org/www/smile.c
 149                  */
 150
 151                 ExceptionInfo exception;
 152                 Image *mi;
 153                 ImageInfo *image_info;
 154                 image *im;
 155                 const PixelPacket *p;
 156
 157                 unsigned int i, j;
 158
 159                 ale_real black_level = exp->get_black_level();
 160
 161                 GetExceptionInfo(&exception);
 162                 image_info = CloneImageInfo((ImageInfo *) NULL);
 163
 164                 strncpy(image_info->filename, filename, MaxTextExtent);
 165                 mi = ReadImage(image_info, &exception);
 166                 if (exception.severity != UndefinedException) {
 167                         fprintf(stderr, "\n\n");
 168                         CatchException(&exception);
 169                         fprintf(stderr, "\n");
 170                 }
 171                 if (mi == (Image *) NULL)
 172                         exit(1);
 173
 174                 if (bayer == IMAGE_BAYER_NONE)
 175                         im = new_image_ale_real(mi->rows, mi->columns, 3, name, exp);
 176                 else
 177                         im = new_image_bayer_ale_real(mi->rows, mi->columns, 3, bayer, name, exp);
 178
 179                 for (i = 0; i < mi->rows; i++) {
 180                         p = AcquireImagePixels(mi, 0, i, mi->columns, 1, &exception);
 181
 182                         if (exception.severity != UndefinedException)
 183                                 CatchException(&exception);
 184                         if (p == NULL)
 185                                 exit(1);
 186
 187                         for (j = 0; j < mi->columns; j++) {
 188
 189                                 pixel input ( ale_real_from_int(p->red, MaxRGB),
 190                                               ale_real_from_int(p->green, MaxRGB),
 191                                               ale_real_from_int(p->blue, MaxRGB) );
 192
 193                                 pixel linear_input = (exp->linearize(input) - exp->get_multiplier() * black_level)
 194                                                    / (1 - black_level);
 195
 196                                 im->set_pixel(i, j, linear_input);
 197
 198                                 p++;
 199                         }
 200                 }
 201
 202                 DestroyImage(mi);
 203                 DestroyImageInfo(image_info);
 204
 205                 return im;
 206 #else
 207                 return NULL;
 208 #endif
 209         }
 210
 211 public:
 212
 213         /*
 214          * Read an image from a file
 215          */
 216         static image *read_image(const char *filename, exposure *exp, const char *name = "file",
 217                         unsigned int bayer = IMAGE_BAYER_DEFAULT, int init_reference_gain = 0) {
 218                 image *result;
 219
 220                 if (bayer == IMAGE_BAYER_DEFAULT)
 221                         bayer = bayer_default;
 222
 223                 if (is_eppm(filename)) {
 224                         result = read_ppm(filename, exp, bayer, init_reference_gain);
 225                 }
 226
 227 #ifdef USE_MAGICK
 228                 result = read_image_im_unaccel(filename, exp, name, bayer, init_reference_gain);
 229 #else
 230                 result = read_ppm(filename, exp, bayer);
 231 #endif
 232
 233                 result->accel_domain_sequence();
 234
 235                 image *accel_result = new image_accel(result);
 236
 237                 delete result;
 238
 239                 result = accel_result;
 240
 241                 return result;
 242         }
 243
 244         /*
 245          * Initializer.
 246          *
 247          * Handle FILE_COUNT input files with names in array FILENAMES and
 248          * output file OUTPUT_FILENAME.  FILENAMES should be an array of char *
 249          * that is never freed.  OUTPUT_FILENAME should be a char * that is
 250          * never freed.
 251          *
 252          * INPUT_EXPOSURE should be an array of FILE_COUNT exposure objects
 253          * that is never freed.  OUTPUT_EXPOSURE should be an exposure * that
 254          * is never freed.
 255          */
 256         static void init(unsigned int _file_count, const char **_filenames,
 257                         const char *_output_filename, exposure **_input_exposure,
 258                         exposure *_output_exposure){
 259                 assert (_file_count > 0);
 260
 261                 init_image();
 262
 263                 filenames = _filenames;
 264                 file_count = _file_count;
 265                 output_filename = _output_filename;
 266                 input_exposure = _input_exposure;
 267                 output_exposure = _output_exposure;
 268
 269                 images = (const image **)malloc(file_count * sizeof(image *));
 270                 bayer_specific = (unsigned int *)malloc(file_count * sizeof(unsigned int));
 271                 files_open = (int *)calloc(file_count, sizeof(int));
 272
 273                 assert (images);
 274                 assert (bayer_specific);
 275                 assert (files_open);
 276
 277                 if (!images || !files_open || !bayer_specific) {
 278                         fprintf(stderr, "Unable to allocate memory for images.\n");
 279                         exit(1);
 280                 }
 281
 282                 for (unsigned int i = 0; i < file_count; i++)
 283                         bayer_specific[i] = IMAGE_BAYER_DEFAULT;
 284
 285                 ui::get()->identify_output(output_filename);
 286         }
 287
 288         static void ppm_plain() {
 289                 ppm_type = 2;
 290         }
 291
 292         static void ppm_raw() {
 293                 ppm_type = 1;
 294         }
 295
 296         static void ppm_auto() {
 297 #ifdef USE_MAGICK
 298                 ppm_type = 0;
 299 #else
 300                 fprintf(stderr, "\n\n*** Error: --auto flag not supported on this build. ***\n"
 301                                     "*** (Hint: Rebuild with IMAGEMAGICK=1)              ***\n\n");
 302                 exit(1);
 303 #endif
 304         }
 305
 306         static void set_default_bayer(unsigned int b) {
 307                 bayer_default = b;
 308         }
 309
 310         static void set_specific_bayer(unsigned int index, unsigned int b) {
 311                 assert (bayer_specific);
 312                 bayer_specific[index] = b;
 313         }
 314
 315         static void depth16() {
 316                 num_bits = 16;
 317                 mcv = 65535;
 318         }
 319
 320         static void depth8() {
 321                 num_bits = 8;
 322                 mcv = 255;
 323         }
 324
 325         static void set_cache(double size) {
 326                 cache_size_max = size;
 327         }
 328
 329         static void destroy() {
 330                 assert (file_count > 0);
 331                 destroy_image();
 332         }
 333
 334         static unsigned int count() {
 335                 assert (file_count > 0);
 336                 return file_count;
 337         }
 338
 339         static const char *name(unsigned int image) {
 340                 assert (image <  file_count);
 341
 342                 return filenames[image];
 343         }
 344
 345         static void def_nn(double _nn) {
 346                 nn_defined_radius = _nn;
 347         }
 348
 349         static const char *output_name() {
 350                 assert (file_count > 0);
 351                 return output_filename;
 352         }
 353
 354         /*
 355          * Write an image to a file
 356          */
 357         static void write_image(const char *filename, const image *im, exposure *exp = output_exposure, int rezero = 0, int exp_scale_override = 0) {
 358                 /*
 359                  * Handle ALE-specific magical filenames.
 360                  */
 361
 362                 if (!strcmp(filename, "dump:")) {
 363                         fprintf(stderr, "Image dump: ");
 364                         for (unsigned int i = 0; i < im->height(); i++)
 365                         for (unsigned int j = 0; j < im->width(); j++) {
 366                                 pixel p = im->get_pixel(i, j);
 367                                 fprintf(stderr, "(%d, %d): [%f %f %f] ", i, j, (double) p[0], (double) p[1], (double) p[2]);
 368                         }
 369                         fprintf(stderr, "\n");
 370
 371                         return;
 372                 }
 373
 374                 image *unaccel_im = im->unaccel_equiv();
 375
 376                 if (unaccel_im) {
 377                         im = unaccel_im;
 378                 }
 379
 380 #ifdef USE_MAGICK
 381
 382                 /*
 383                  * Patterned after http://www.imagemagick.org/www/api.html
 384                  * and http://www.imagemagick.org/www/smile.c
 385                  */
 386
 387                 ExceptionInfo exception;
 388                 Image *mi;
 389                 ImageInfo *image_info;
 390                 PixelPacket *p;
 391
 392                 unsigned int i, j;
 393
 394                 GetExceptionInfo(&exception);
 395                 image_info = CloneImageInfo((ImageInfo *) NULL);
 396                 strncpy(image_info->filename, filename, MaxTextExtent);
 397
 398                 mi = AllocateImage(image_info);
 399                 if (mi == (Image *) NULL)
 400                         MagickError(ResourceLimitError,
 401                                 "Unable to display image", "MemoryAllocationFailed");
 402
 403                 mi->columns = im->width();
 404                 mi->rows = im->height();
 405
 406                 /*
 407                  * Set the output image depth
 408                  */
 409
 410                 if (MaxRGB < 65535 || mcv < 65535)
 411                         mi->depth = 8;
 412                 else
 413                         mi->depth = 16;
 414
 415                 if (MaxRGB < 65535 && mcv == 65535) {
 416                         fprintf(stderr, "\n\n*** Warning: 16 bit-per-channel file output was specified,\n");
 417                         fprintf(stderr, "*** but ImageMagick has not been compiled with support for this.\n");
 418                         fprintf(stderr, "*** Writing output using 8 bits per channel.\n\n\n");
 419                 }
 420
 421                 /*
 422                  * Set compression type
 423                  */
 424
 425                 if (ppm_type == 2) {
 426                         mi->compression = NoCompression;
 427                         image_info->compression = NoCompression;
 428                         strncpy(mi->magick, "PNM", MaxTextExtent);
 429                         strncpy(image_info->magick, "PNM", MaxTextExtent);
 430                 } else if (ppm_type == 1) {
 431                         strncpy(mi->magick, "PNM", MaxTextExtent);
 432                         strncpy(image_info->magick, "PNM", MaxTextExtent);
 433                 }
 434
 435                 /*
 436                  * Automatic exposure adjustment (don't blow out highlights)
 437                  */
 438                 ale_real maxval = 1;
 439                 ale_real minval = (rezero ? im->minval() : (ale_real) 0);
 440                 if (minval > 0)
 441                         minval = 0;
 442                 pixel minval_pixel(minval, minval, minval);
 443
 444
 445                 if (exposure_scale || exp_scale_override) {
 446                         ale_real new_maxval = im->maxval();
 447
 448                         if (new_maxval > maxval)
 449                                 maxval = new_maxval;
 450                 }
 451
 452                 /*
 453                  * Write the image
 454                  */
 455
 456                 for (i = 0; i < mi->rows; i++) {
 457                         p = SetImagePixels(mi, 0, i, mi->columns, 1);
 458                         if (p == NULL)
 459                                 break;
 460
 461                         for (j = 0; j < mi->columns; j++) {
 462
 463                                 pixel value = im->get_pixel(i, j);
 464
 465                                 /*
 466                                  * Get nearest-neighbor defined values.
 467                                  *
 468                                  * XXX: While this implementation is correct, it is inefficient
 469                                  * for large radii.  A better implementation would search
 470                                  * perimeters of squares of ever-increasing radius, tracking
 471                                  * the best-so-far data until the square perimeter exceeded the
 472                                  * best-so-far radius.
 473                                  */
 474
 475                                 for (int k = 0; k < 3; k++)
 476                                 if (isnan(value[k]))
 477                                 for (int radius = 1; radius <= nn_defined_radius; radius++) {
 478                                         double nearest_radius_squared = (radius + 1) * (radius + 1);
 479                                         for (int ii = -radius; ii <= radius; ii++)
 480                                         for (int jj = -radius; jj <= radius; jj++) {
 481                                                 if (!im->in_bounds(point(i + ii, j + jj)))
 482                                                         continue;
 483                                                 if (ii * ii + jj * jj < nearest_radius_squared
 484                                                  && finite(im->get_pixel(i + ii, j + jj)[k])) {
 485                                                         value[k] = im->get_pixel(i + ii, j + jj)[k];
 486                                                         nearest_radius_squared = ii * ii + jj * jj;
 487                                                 }
 488                                         }
 489                                         if (nearest_radius_squared < (radius + 1) * (radius + 1))
 490                                                 break;
 491                                 }
 492
 493                                 /*
 494                                  * Unlinearize
 495                                  */
 496
 497                                 pixel unlinearized(exp->unlinearize((value - minval_pixel)
 498                                                                   / (maxval - minval)));
 499
 500                                 unlinearized = unlinearized.clamp();
 501
 502                                 p->red =   (Quantum) ale_real_to_int(unlinearized[0], MaxRGB);
 503                                 p->green = (Quantum) ale_real_to_int(unlinearized[1], MaxRGB);
 504                                 p->blue =  (Quantum) ale_real_to_int(unlinearized[2], MaxRGB);
 505                                 p++;
 506                         }
 507
 508                         if (!SyncImagePixels(mi))
 509                                 break;
 510                 }
 511
 512                 if (!WriteImage(image_info, mi)) {
 513
 514                         /*
 515                          * Perhaps file type was unknown?  Set to PNM by default.
 516                          */
 517
 518                         strncpy(mi->magick, "PNM", MaxTextExtent);
 519                         strncpy(image_info->magick, "PNM", MaxTextExtent);
 520
 521                         if (!WriteImage(image_info, mi)) {
 522                                 fprintf(stderr, "\n\n");
 523                                 CatchException(&mi->exception);
 524                                 fprintf(stderr, "\n");
 525                                 exit(1);
 526                         }
 527                 }
 528
 529                 DestroyImage(mi);
 530                 DestroyImageInfo(image_info);
 531 #else
 532                 write_ppm(filename, im, exp, mcv, ppm_type == 2, rezero, exposure_scale || exp_scale_override,
 533                                 nn_defined_radius);
 534 #endif
 535
 536                 if (unaccel_im) {
 537                         delete unaccel_im;
 538                 }
 539         }
 540
 541         static void output(const image *i) {
 542                 assert (file_count > 0);
 543                 write_image(output_name(), i, output_exposure);
 544         }
 545
 546         static void vise_write(const char *p, const char *s, const image *i) {
 547                 static int count = 0;
 548                 int length = strlen(p) + strlen(s) + 8;
 549                 char *output_string = (char *) malloc(length * sizeof(char));
 550
 551                 snprintf(output_string, length, "%s%08d%s", p, count, s);
 552
 553                 write_image(output_string, i, output_exposure);
 554
 555                 count++;
 556         }
 557
 558         static exposure &exp(int n) {
 559                 return *input_exposure[n];
 560         }
 561
 562         static const exposure &const_exp(int n) {
 563                 return *input_exposure[n];
 564         }
 565
 566         static exposure &exp() {
 567                 return *output_exposure;
 568         }
 569
 570         static void exp_scale() {
 571                 exposure_scale = 1;
 572         }
 573
 574         static void exp_noscale() {
 575                 exposure_scale = 0;
 576         }
 577
 578         static const exposure &const_exp() {
 579                 return *output_exposure;
 580         }
 581
 582         static const unsigned int bayer(unsigned int n) {
 583                 if (bayer_specific[n] == IMAGE_BAYER_DEFAULT)
 584                         return bayer_default;
 585                 else
 586                         return bayer_specific[n];
 587         }
 588
 589         static const image *open(unsigned int n) {
 590                 assert (n <  file_count);
 591                 assert (!files_open[n]);
 592
 593                 files_open[n] = 1;
 594
 595                 if (latest_close_num >= 0 && n == (unsigned int) latest_close_num) {
 596                         latest_close_num = -1;
 597                         return images[n];
 598                 }
 599
 600                 if (n < cache_count)
 601                         return images[n];
 602
 603                 ui::get()->loading_file();
 604                 image *i = read_image(filenames[n], input_exposure[n], "file", bayer(n), (n == 0));
 605
 606                 images[n] = i;
 607
 608                 return images[n];
 609         }
 610
 611         static void open_all() {
 612                 for (unsigned int n = 0; n < file_count; n++)
 613                         open(n);
 614         }
 615
 616         static const image *get_open(unsigned int n) {
 617                 assert (files_open[n]);
 618                 return images[n];
 619         }
 620
 621         static image *copy(unsigned int n, const char *name) {
 622                 assert (n <  file_count);
 623
 624                 if (files_open[n])
 625                         return images[n]->clone(name);
 626                 else {
 627                         image *i = read_image(filenames[n], input_exposure[n], name, bayer(n), (n == 0));
 628                         return i;
 629                 }
 630         }
 631
 632         static void close(unsigned int image) {
 633                 assert (image <  file_count);
 634                 assert (files_open[image]);
 635
 636                 files_open[image] = 0;
 637
 638                 if (image < cache_count)
 639                         return;
 640
 641                 if (image == cache_count) {
 642                         double image_size = ((double) images[image]->storage_size()) / pow(2, 20);
 643
 644                         if (image_size + cache_size < cache_size_max) {
 645                                 cache_size += image_size;
 646                                 cache_count++;
 647                                 ui::get()->cache(cache_size, cache_size_max);
 648                                 return;
 649                         } else {
 650                                 ui::get()->cache_status(0);
 651                         }
 652                 }
 653
 654                 if (latest_close_num >= 0)
 655                         delete images[latest_close_num];
 656
 657                 latest_close_num = image;
 658         }
 659
 660         static void close_all() {
 661                 for (unsigned int n = 0; n < file_count; n++)
 662                         close(n);
 663         }
 664
 665 };
 666
 667 #endif