d2/image_bayer_ale_real.h

   1 // Copyright 2002, 2003, 2004 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_bayer_ale_real.h: Bayer-patterned image represented by an array of ale_reals
  23  */
  24
  25 #ifndef __image_bayer_ale_real_h__
  26 #define __image_bayer_ale_real_h__
  27
  28 #include "exposure/exposure.h"
  29 #include "point.h"
  30 #include "image.h"
  31 #include "image_ale_real.h"
  32
  33 template <int disk_support>
  34 class image_bayer_ale_real : public image {
  35 private:
  36         /*
  37          * Data structures without file support.
  38          */
  39
  40         ale_sreal *_p;
  41
  42         /*
  43          * Data structures for file support.
  44          */
  45
  46         FILE *support;
  47         mutable ale_sreal *_p_segments[RESIDENT_DIVISIONS];
  48         mutable int dirty_segments[RESIDENT_DIVISIONS];
  49         mutable int resident_list[RESIDENT_DIVISIONS];
  50         mutable int resident_next;
  51         int resident_max;
  52         int rows_per_segment;
  53         mutable thread::rwlock_t rwlock;
  54
  55 private:
  56         /*
  57          * X offset of 'R' element
  58          */
  59         unsigned int r_x_offset() const {
  60                 return bayer & 0x1;
  61         }
  62
  63         /*
  64          * Y offset of 'R' element
  65          */
  66         unsigned int r_y_offset() const {
  67                 return (bayer & 0x2) >> 1;
  68         }
  69
  70 public:
  71         /*
  72          * Return the color of a given pixel.
  73          */
  74         unsigned int bayer_color(unsigned int i, unsigned int j) const {
  75                 return (i + r_y_offset()) % 2 + (j + r_x_offset()) % 2;
  76         }
  77
  78         char get_channels(int i, int j) const {
  79                 return (1 << bayer_color(i, j));
  80         }
  81
  82 public:
  83
  84         /*
  85          * Wrapper encapsulating details of the separation between the
  86          * resident-checking implementation and non-checking.
  87          */
  88         static inline image *new_image_bayer_ale_real(unsigned int dimy,
  89                                          unsigned int dimx,
  90                                          unsigned int depth,
  91                                          unsigned int bayer,
  92                                          const char *name = "anonymous",
  93                                          exposure *exp = NULL) {
  94
  95                 unsigned int resident = image::get_resident();
  96
  97                 if (resident == 0 || resident * 1000000 > dimy * dimx)
  98                         return new image_bayer_ale_real<0>(dimy, dimx, depth, bayer, name, exp);
  99
 100                 return new image_bayer_ale_real<1>(dimy, dimx, depth, bayer, name, exp);
 101
 102         }
 103
 104         image_bayer_ale_real (unsigned int dimy, unsigned int dimx, unsigned int depth,
 105                         unsigned int bayer, const char *name = "anonymous", exposure *exp = NULL)
 106                         : image(dimy, dimx, depth, name, exp, bayer) {
 107
 108                 assert (bayer == IMAGE_BAYER_BGRG
 109                      || bayer == IMAGE_BAYER_GBGR
 110                      || bayer == IMAGE_BAYER_GRGB
 111                      || bayer == IMAGE_BAYER_RGBG);
 112
 113                 if (disk_support == 0) {
 114                         _p = new ale_sreal[dimx * dimy];
 115
 116                         assert (_p);
 117
 118                         if (!_p) {
 119                                 fprintf(stderr, "Could not allocate memory for image data.\n");
 120                                 exit(1);
 121                         }
 122
 123                         for (unsigned int i = 0; i < dimx * dimy; i++) {
 124                                 _p[i] = 0;
 125                         }
 126                 } else {
 127                         rows_per_segment = (int) ceil((double) dimy / (double) RESIDENT_DIVISIONS);
 128
 129                         assert (rows_per_segment > 0);
 130
 131                         for (int i = 0; i < RESIDENT_DIVISIONS; i++) {
 132                                 _p_segments[i] = NULL;
 133                                 dirty_segments[i] = 0;
 134                                 resident_list[i] = -1;
 135                         }
 136
 137                         resident_max = (unsigned int) floor((image::get_resident() * 1000000)
 138                                                           / (rows_per_segment * dimx));
 139
 140                         assert (resident_max <= RESIDENT_DIVISIONS);
 141
 142                         if (resident_max == 0) {
 143                                 ui::get()->error_hint(
 144                                         "No segments resident in image array.",
 145                                         "Try recompiling with more RESIDENT_DIVISIONS");
 146                         }
 147
 148                         resident_next = 0;
 149
 150                         support = tmpfile();
 151
 152                         if (!support) {
 153                                 ui::get()->error_hint(
 154                                         "Unable to create temporary file to support image array.",
 155                                         "Set --resident 0, or Win32/64 users might run as admin.");
 156                         }
 157
 158                         ale_sreal *zero = new ale_sreal[dimx];
 159
 160                         assert(zero);
 161
 162                         for (unsigned int i = 0; i < dimx; i++)
 163                                 zero[i] = 0;
 164
 165                         for (unsigned int i = 0; i < dimy; i++) {
 166                                 unsigned int c = fwrite(zero, sizeof(ale_sreal), dimx, support);
 167                                 if (c < dimx)
 168                                         ui::get()->error_hint("Image array support file error.",
 169                                                               "Submit a bug report.");
 170                         }
 171
 172                         delete[] zero;
 173                 }
 174         }
 175
 176         virtual ~image_bayer_ale_real() {
 177                 if (disk_support == 0) {
 178                         delete[] _p;
 179                 } else {
 180                         for (int i = 0; i < RESIDENT_DIVISIONS; i++) {
 181                                 if (_p_segments[i])
 182                                         delete[] _p_segments[i];
 183                         }
 184
 185                         fclose(support);
 186                 }
 187         }
 188
 189         void resident_begin(unsigned int segment) const {
 190                 rwlock.rdlock();
 191                 if (_p_segments[segment])
 192                         return;
 193                 rwlock.unlock();
 194
 195                 rwlock.wrlock();
 196
 197                 if (_p_segments[segment])
 198                         return;
 199
 200                 if (resident_list[resident_next] >= 0) {
 201                         /*
 202                          * Eject a segment
 203                          */
 204
 205                         if (dirty_segments[resident_list[resident_next]]) {
 206                                 fseek(support, rows_per_segment * _dimx * sizeof(ale_sreal)
 207                                              * resident_list[resident_next],
 208                                                SEEK_SET);
 209                                 assert(_p_segments[resident_list[resident_next]]);
 210                                 size_t fwrite_result = fwrite(_p_segments[resident_list[resident_next]],
 211                                         sizeof(ale_sreal), rows_per_segment * _dimx, support);
 212
 213                                 assert(fwrite_result == rows_per_segment * _dimx);
 214
 215                                 dirty_segments[resident_list[resident_next]] = 0;
 216                         }
 217
 218                         delete[] _p_segments[resident_list[resident_next]];
 219                         _p_segments[resident_list[resident_next]] = NULL;
 220                 }
 221
 222                 resident_list[resident_next] = segment;
 223
 224                 _p_segments[segment] = new ale_sreal[_dimx * rows_per_segment];
 225
 226                 assert (_p_segments[segment]);
 227
 228                 fseek(support, rows_per_segment * _dimx * sizeof(ale_sreal)
 229                              * segment,
 230                              SEEK_SET);
 231
 232                 size_t fread_result = fread(_p_segments[segment], sizeof(ale_sreal), rows_per_segment * _dimx, support);
 233
 234                 assert(fread_result == rows_per_segment * _dimx);
 235
 236                 /*
 237                  * Update the next ejection candidate.
 238                  */
 239                 resident_next++;
 240                 if (resident_next >= resident_max)
 241                         resident_next = 0;
 242         }
 243
 244         void resident_end(unsigned int segment) const {
 245                 rwlock.unlock();
 246         }
 247
 248         void set_chan(unsigned int y, unsigned int x, unsigned int k, ale_sreal c) {
 249                 assert (k == bayer_color(y, x));
 250                 if (disk_support == 0) {
 251                         _p[y * _dimx + x] = c;
 252                 } else {
 253                         int segment = y / rows_per_segment;
 254                         assert (segment < RESIDENT_DIVISIONS);
 255
 256                         resident_begin(segment);
 257
 258                         _p_segments[segment][(y % rows_per_segment) * _dimx + x] = c;
 259                         dirty_segments[segment] = 1;
 260
 261                         resident_end(segment);
 262                 }
 263         }
 264
 265         void add_chan(unsigned int y, unsigned int x, unsigned int k, ale_sreal c) {
 266                 assert (k == bayer_color(y, x));
 267                 if (disk_support == 0) {
 268                         _p[y * _dimx + x] += c;
 269                 } else {
 270                         int segment = y / rows_per_segment;
 271                         assert (segment < RESIDENT_DIVISIONS);
 272
 273                         resident_begin(segment);
 274
 275                         _p_segments[segment][(y % rows_per_segment) * _dimx + x] += c;
 276                         dirty_segments[segment] = 1;
 277
 278                         resident_end(segment);
 279                 }
 280         }
 281
 282         void div_chan(unsigned int y, unsigned int x, unsigned int k, ale_sreal c) {
 283                 assert (k == bayer_color(y, x));
 284                 if (disk_support == 0) {
 285                         _p[y * _dimx + x] /= c;
 286                 } else {
 287                         int segment = y / rows_per_segment;
 288                         assert (segment < RESIDENT_DIVISIONS);
 289
 290                         resident_begin(segment);
 291
 292                         _p_segments[segment][(y % rows_per_segment) * _dimx + x] /= c;
 293                         dirty_segments[segment] = 1;
 294
 295                         resident_end(segment);
 296                 }
 297         }
 298
 299         ale_sreal get_chan(unsigned int y, unsigned int x, unsigned int k) const {
 300 #if 0
 301                 /*
 302                  * This may be expensive.
 303                  */
 304                 assert (k == bayer_color(y, x));
 305 #endif
 306                 if (disk_support == 0) {
 307                         return _p[y * _dimx + x];
 308                 } else {
 309                         int segment = y / rows_per_segment;
 310                         assert (segment < RESIDENT_DIVISIONS);
 311
 312                         resident_begin(segment);
 313
 314                         ale_sreal result = _p_segments[segment]
 315                                                       [(y % rows_per_segment) * _dimx + x];
 316
 317                         resident_end(segment);
 318
 319                         return result;
 320                 }
 321         }
 322
 323         /*
 324          * This method throws away data not stored at this pixel
 325          * position.
 326          */
 327         void set_pixel(unsigned int y, unsigned int x, spixel p) {
 328                 set_chan(y, x, bayer_color(y, x), p[bayer_color(y, x)]);
 329         }
 330
 331         /*
 332          * This method uses bilinear interpolation.
 333          */
 334         spixel get_pixel(unsigned int y, unsigned int x) const {
 335                 pixel result;
 336                 unsigned int k = bayer_color(y, x);
 337                 ale_real sum;
 338                 unsigned int num;
 339
 340                 result[k] = get_chan(y, x, k);
 341
 342                 if (k == 1) {
 343                         unsigned int k1 = bayer_color(y + 1, x);
 344                         unsigned int k2 = 2 - k1;
 345
 346                         sum = 0; num = 0;
 347                         if (y > 0) {
 348                                 sum += get_chan(y - 1, x, k1);
 349                                 num++;
 350                         }
 351                         if (y < _dimy - 1) {
 352                                 sum += get_chan(y + 1, x, k1);
 353                                 num++;
 354                         }
 355                         assert (num > 0);
 356                         result[k1] = sum / num;
 357
 358                         sum = 0; num = 0;
 359                         if (x > 0) {
 360                                 sum += get_chan(y, x - 1, k2);
 361                                 num++;
 362                         }
 363                         if (x < _dimx - 1) {
 364                                 sum += get_chan(y, x + 1, k2);
 365                                 num++;
 366                         }
 367                         assert (num > 0);
 368                         result[k2] = sum / num;
 369
 370                         return result;
 371                 }
 372
 373                 sum = 0; num = 0;
 374                 if (y > 0) {
 375                         sum += get_chan(y - 1, x, 1);
 376                         num++;
 377                 }
 378                 if (x > 0) {
 379                         sum += get_chan(y, x - 1, 1);
 380                         num++;
 381                 }
 382                 if (y < _dimy - 1) {
 383                         sum += get_chan(y + 1, x, 1);
 384                         num++;
 385                 }
 386                 if (x < _dimx - 1) {
 387                         sum += get_chan(y, x + 1, 1);
 388                         num++;
 389                 }
 390                 assert (num > 0);
 391                 result[1] = sum / num;
 392
 393                 sum = 0; num = 0;
 394                 if (y > 0 && x > 0) {
 395                         sum += get_chan(y - 1, x - 1, 2 - k);
 396                         num++;
 397                 }
 398                 if (y > 0 && x < _dimx - 1) {
 399                         sum += get_chan(y - 1, x + 1, 2 - k);
 400                         num++;
 401                 }
 402                 if (y < _dimy - 1 && x > 0) {
 403                         sum += get_chan(y + 1, x - 1, 2 - k);
 404                         num++;
 405                 }
 406                 if (y < _dimy - 1 && x < _dimx - 1) {
 407                         sum += get_chan(y + 1, x + 1, 2 - k);
 408                         num++;
 409                 }
 410                 result[2 - k] = sum/num;
 411
 412                 return result;
 413         }
 414
 415         spixel get_raw_pixel(unsigned int y, unsigned int x) const {
 416                 pixel result;
 417                 int k = bayer_color(y, x);
 418
 419                 result[k] = get_chan(y, x, k);
 420
 421                 return result;
 422         }
 423
 424         /*
 425          * Make a new image suitable for receiving scaled values.
 426          */
 427         virtual image *scale_generator(int height, int width, int depth, const char *name) const {
 428                 return new_image_ale_real(height, width, depth, name, _exp);
 429         }
 430
 431         /*
 432          * Extend the image area to the top, bottom, left, and right,
 433          * initializing the new image areas with black pixels.
 434          */
 435         image *_extend(int top, int bottom, int left, int right) {
 436                 /*
 437                  * Bayer-patterned images should always represent inputs,
 438                  * which should not ever be extended.
 439                  */
 440                 assert(0);
 441
 442                 return NULL;
 443         }
 444
 445 private:
 446         void trigger(pixel multiplier) {
 447                 for (unsigned int i = 0; i < _dimy; i++)
 448                 for (unsigned int j = 0; j < _dimx; j++) {
 449                         unsigned int k = bayer_color(i, j);
 450                         set_chan(i, j, k, get_chan(i, j, k) * multiplier[k]);
 451                 }
 452         }
 453
 454 };
 455
 456 /*
 457  * Wrapper encapsulating details of the separation between the
 458  * resident-checking implementation and non-checking.
 459  */
 460 static inline image *new_image_bayer_ale_real(unsigned int dimy,
 461                                  unsigned int dimx,
 462                                  unsigned int depth,
 463                                  unsigned int bayer,
 464                                  const char *name = "anonymous",
 465                                  exposure *exp = NULL) {
 466
 467         return image_bayer_ale_real<0>::new_image_bayer_ale_real(dimy, dimx, depth, bayer, name, exp);
 468 }
 469
 470 #endif