d2/render/incremental.h

   1 // Copyright 2002, 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 2 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 #ifndef __incremental_h__
  22 #define __incremental_h__
  23
  24 #include "invariant.h"
  25 #include "../render.h"
  26 #include "../transformation.h"
  27 #include "../image.h"
  28 #include "../point.h"
  29
  30 /*
  31  * Class for incremental renderers.
  32  */
  33
  34 class incremental : public render {
  35 protected:
  36         image_weighted_avg *accum_image;
  37         invariant *inv;
  38
  39         /*
  40          * Set extents of image and weight according to a new image to be
  41          * merged.  This function should remove only superfluous undefined
  42          * areas.
  43          */
  44
  45         void set_extents_by_map(unsigned int frame_num, transformation t) {
  46
  47                 assert (accum_image  != NULL);
  48
  49                 ale_pos extend_offset_i = accum_image->offset()[0];
  50                 ale_pos extend_offset_j = accum_image->offset()[1];
  51
  52                 int extend_top = 0;
  53                 int extend_bottom = 0;
  54                 int extend_left = 0;
  55                 int extend_right = 0;
  56
  57                 double zero = 0;
  58                 double infinity = 1 / zero;
  59
  60                 assert (!finite(infinity));
  61                 assert (!isnan(infinity));
  62                 assert (infinity > 0);
  63
  64                 point min, max;
  65
  66                 min[0] = min[1] = infinity;
  67                 max[0] = max[1] = -infinity;
  68
  69                 for (unsigned int i = 0; i < t.unscaled_height(); i++)
  70                 for (unsigned int j = 0; j < t.unscaled_width(); j++) {
  71                         point p = t.transform_unscaled(point(i, j));
  72
  73                         if (is_excluded(accum_image->offset(), p, frame_num))
  74                                 continue;
  75
  76                         if (p[0] < min[0]) {
  77                                 min[0] = p[0];
  78                         }
  79                         if (p[0] > max[0]) {
  80                                 max[0] = p[0];
  81                         }
  82                         if (p[1] < min[1]) {
  83                                 min[1] = p[1];
  84                         }
  85                         if (p[1] > max[1]) {
  86                                 max[1] = p[1];
  87                         }
  88                 }
  89
  90                 if (!finite(max[0])
  91                  || !finite(max[1])
  92                  || !finite(min[0])
  93                  || !finite(min[1]))
  94                         return;
  95
  96                 extend_top = (int) ceil(extend_offset_i - floor(min[0]));
  97                 extend_left = (int) ceil(extend_offset_j - floor(min[1]));
  98                 extend_bottom = (int) ceil(ceil(max[0]) - (accum_image->height() - 1 + extend_offset_i));
  99                 extend_right = (int) ceil(ceil(max[1]) - (accum_image->width() - 1 + extend_offset_j));
 100
 101                 accum_image->extend(extend_top, extend_bottom,
 102                         extend_left, extend_right);
 103         }
 104
 105         void increase_extents_by_map(unsigned int frame_num, transformation t) {
 106
 107                 assert (accum_image  != NULL);
 108
 109                 ale_pos extend_offset_i = accum_image->offset()[0];
 110                 ale_pos extend_offset_j = accum_image->offset()[1];
 111
 112                 int extend_top = 0;
 113                 int extend_bottom = 0;
 114                 int extend_left = 0;
 115                 int extend_right = 0;
 116
 117                 double zero = 0;
 118                 double infinity = 1 / zero;
 119
 120                 assert (!finite(infinity));
 121                 assert (!isnan(infinity));
 122                 assert (infinity > 0);
 123
 124                 point min, max;
 125
 126                 min[0] = min[1] = infinity;
 127                 max[0] = max[1] = -infinity;
 128
 129                 for (unsigned int i = 0; i < t.unscaled_height(); i++)
 130                 for (unsigned int j = 0; j < t.unscaled_width(); j++) {
 131                         point p = t.transform_unscaled(point(i, j));
 132
 133                         if (is_excluded(point(0, 0), p, frame_num))
 134                                 continue;
 135
 136                         if (p[0] < min[0]) {
 137                                 min[0] = p[0];
 138                         }
 139                         if (p[0] > max[0]) {
 140                                 max[0] = p[0];
 141                         }
 142                         if (p[1] < min[1]) {
 143                                 min[1] = p[1];
 144                         }
 145                         if (p[1] > max[1]) {
 146                                 max[1] = p[1];
 147                         }
 148                 }
 149
 150                 if (!finite(max[0])
 151                  || !finite(max[1])
 152                  || !finite(min[0])
 153                  || !finite(min[1]))
 154                         return;
 155
 156                 if (ceil(min[0]) < extend_offset_i)
 157                         extend_top = (int) ceil(extend_offset_i - floor(min[0]));
 158                 if (ceil(min[1]) < extend_offset_j)
 159                         extend_left = (int) ceil(extend_offset_j - floor(min[1]));
 160                 if (floor(max[0]) > accum_image->height() - 1 + extend_offset_i)
 161                         extend_bottom = (int) ceil(ceil(max[0]) - (accum_image->height() - 1 + extend_offset_i));
 162                 if (floor(max[1]) > accum_image->width() - 1 + extend_offset_j)
 163                         extend_right = (int) ceil(ceil(max[1]) - (accum_image->width() - 1 + extend_offset_j));
 164
 165                 accum_image->extend(extend_top, extend_bottom,
 166                         extend_left, extend_right);
 167         }
 168
 169         /*
 170          * Merge operation for a single pixel in the accumulated image.
 171          */
 172         void _merge_pixel(int frame, const image *delta, transformation t, int i, int j, const filter::ssfe *_ssfe) {
 173
 174                 if (_ssfe->ex_is_honored() && is_excluded(i, j, frame))
 175                         return;
 176
 177                 if (accum_image->accumulate_norender(i, j))
 178                         return;
 179
 180                 /*
 181                  * Pixel value to be merged, and the associated
 182                  * confidence
 183                  */
 184
 185                 pixel value, confidence;
 186
 187                 _ssfe->filtered(i, j, frame, &value, &confidence);
 188
 189                 accum_image->accumulate(i, j, frame, value, confidence);
 190         }
 191
 192         /*
 193          * Merge part of a delta frame with part of the accumulated image using
 194          * the specified transformation.
 195          */
 196         void
 197         _merge(int frame, const image *delta, transformation t) {
 198
 199                 point offset = accum_image->offset();
 200
 201                 assert (accum_image != NULL);
 202                 assert (delta != NULL);
 203
 204                 const filter::ssfe *_ssfe = inv->ssfe();
 205
 206                 _ssfe->set_parameters(t, delta, offset);
 207
 208                 for (unsigned int i = 0; i < accum_image->height(); i++)
 209                 for (unsigned int j = 0; j < accum_image->width(); j++) {
 210
 211 #if 0
 212                         /*
 213                          * This is untested, but it should work, and is less
 214                          * verbose than what follows.
 215                          */
 216
 217                         _merge_pixel(frame, delta, t, i, j, _ssfe);
 218 #else
 219
 220                         if (_ssfe->ex_is_honored() && is_excluded(i, j, frame))
 221                                 continue;
 222
 223                         if (accum_image->accumulate_norender(i, j))
 224                                 continue;
 225
 226                         /*
 227                          * Pixel value to be merged, and the associated
 228                          * confidence
 229                          */
 230
 231                         pixel value, confidence;
 232
 233                         _ssfe->filtered(i, j, frame, &value, &confidence);
 234
 235                         accum_image->accumulate(i, j, frame, value, confidence);
 236 #endif
 237                 }
 238         }
 239
 240 public:
 241
 242         /*
 243          * Constructor
 244          */
 245         incremental(invariant *inv) {
 246                 this->inv = inv;
 247                 accum_image = NULL;
 248         }
 249
 250         /*
 251          * Invariant
 252          */
 253         const invariant *get_invariant() const {
 254                 return inv;
 255         }
 256
 257         /*
 258          * Result of rendering.
 259          */
 260
 261         virtual const image *get_image() {
 262                 assert (accum_image != NULL);
 263                 return accum_image->get_colors();
 264         }
 265
 266         /*
 267          * Definition map.  Unit-depth image whose pixels are nonzero where
 268          * the image is defined.
 269          */
 270
 271         virtual const image *get_defined() {
 272                 assert (accum_image != NULL);
 273                 return accum_image->get_weights();
 274         }
 275
 276         /*
 277          * Perform the current rendering step.
 278          */
 279         virtual void step() {
 280                 assert (get_step() >= -1);
 281                 if (get_step() == 0) {
 282                         transformation t = align::of(0);
 283
 284                         const image *im = image_rw::open(0);
 285
 286                         ui::get()->rendering();
 287
 288                         if (inv->is_median())
 289                                 accum_image = new image_weighted_median(1, 1, 3);
 290                         else
 291                                 accum_image = new image_weighted_simple(1, 1, 3, inv);
 292
 293                         set_extents_by_map(0, t);
 294
 295                         _merge(0, im, t);
 296
 297                         image_rw::close(0);
 298                 } else if (align::match(get_step())) {
 299                         transformation t = align::of(get_step());
 300                         ui::get()->rendering();
 301                         if (is_extend())
 302                                 increase_extents_by_map(get_step(), t);
 303                         const image *im = image_rw::open(get_step());
 304                         _merge(get_step(), im, t);
 305                         image_rw::close(get_step());
 306                 }
 307         }
 308
 309
 310         virtual void init_point_renderer(unsigned int h, unsigned int w, unsigned int d) {
 311                 assert(accum_image == NULL);
 312
 313                 if (inv->is_median())
 314                         accum_image = new image_weighted_median(h, w, d);
 315                 else
 316                         accum_image = new image_weighted_simple(h, w, d, inv);
 317
 318                 assert(accum_image);
 319         }
 320
 321         virtual void point_render(unsigned int i, unsigned int j, unsigned int f, transformation t) {
 322                 const image *im = d2::image_rw::get_open(f);
 323
 324                 const filter::ssfe *_ssfe = inv->ssfe();
 325
 326                 _ssfe->set_parameters(t, im, accum_image->offset());
 327                 _merge_pixel(f, im, t, i, j, _ssfe);
 328         }
 329
 330         virtual void finish_point_rendering() {
 331                 return;
 332         }
 333
 334         void free_memory() {
 335                 delete accum_image;
 336                 accum_image = NULL;
 337         }
 338 };
 339
 340 #endif