d2/image_weighted_simple.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 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 /*
  22  * image_weighted_simple.h: Image representing a weighted average of inputs.
  23  * Covers simple cases that require space constant with frame count.
  24  */
  25
  26 #ifndef __image_weighted_simple_h__
  27 #define __image_weighted_simple_h__
  28
  29 #include "image_weighted_avg.h"
  30 #include "render/invariant.h"
  31
  32 class image_weighted_simple : public image_weighted_avg {
  33 private:
  34         invariant *inv;
  35         image_ale_real *colors;
  36         image_ale_real *weights;
  37
  38 public:
  39         image_weighted_simple (unsigned int dimy, unsigned int dimx, unsigned int
  40                         depth, invariant *inv, char *name = "anonymous")
  41                         : image_weighted_avg(dimy, dimx, depth, name) {
  42                 colors = new image_ale_real(dimy, dimx, depth);
  43                 weights = new image_ale_real(dimy, dimx, depth);
  44                 this->inv = inv;
  45         }
  46
  47         virtual ~image_weighted_simple() {
  48                 delete colors;
  49                 delete weights;
  50         }
  51
  52         /*
  53          * Extend the image area to the top, bottom, left, and right,
  54          * initializing the new image areas with black pixels.  Negative values
  55          * shrink the image.
  56          */
  57         void extend(int top, int bottom, int left, int right) {
  58                 colors->extend(top, bottom, left, right);
  59                 weights->extend(top, bottom, left, right);
  60
  61                 _dimx = colors->width();
  62                 _dimy = colors->height();
  63                 _offset = colors->offset();
  64         }
  65
  66         /*
  67          * Pre-transformation check for whether an area should be skipped.
  68          * Takes image weights as an argument.
  69          */
  70         int accumulate_norender(int i, int j) {
  71                 /*
  72                  * Initial value
  73                  */
  74                 if (inv->is_first() && weights->get_pixel(i, j)[0] != 0)
  75                         return 1;
  76
  77                 return 0;
  78         }
  79
  80         /*
  81          * Accumulate pixels
  82          */
  83         void accumulate(int i, int j, int f, pixel new_value, pixel new_weight) {
  84
  85                 /*
  86                  * Perform operations separately for each channel
  87                  */
  88                 for (unsigned int k = 0; k < 3; k++) {
  89
  90                         /*
  91                          * Cases independent of the old pixel value and weight
  92                          * for which the update can be ignored.
  93                          */
  94
  95                         if (!inv->is_avg() && new_weight[k] < render::get_wt())
  96                                 continue;
  97
  98                         /*
  99                          * Cases independent of the old pixel value and weight for which
 100                          * previous pixel values can be ignored.
 101                          */
 102
 103                         if (inv->is_last() && new_weight[k] >= render::get_wt()) {
 104                                 colors->chan(i, j, k) = new_value[k] * new_weight[k];
 105                                 weights->chan(i, j, k) = new_weight[k];
 106                                 continue;
 107                         }
 108
 109                         /*
 110                          * Obtain the old pixel weight.
 111                          */
 112
 113                         ale_real old_weight = weights->chan(i, j, k);
 114
 115                         /*
 116                          * Cases independent of the old pixel value for which the
 117                          * update can be ignored.
 118                          */
 119
 120                         if (old_weight >= render::get_wt()
 121                          && inv->is_first())
 122                                 continue;
 123
 124                         /*
 125                          * Cases independent of the old pixel value for which previous
 126                          * pixel values can be ignored.
 127                          */
 128
 129                         if (old_weight == 0
 130                          || (old_weight < render::get_wt()
 131                           && !inv->is_avg())) {
 132                                 weights->chan(i, j, k) = new_weight[k];
 133                                 colors ->chan(i, j, k) = new_value[k] * new_weight[k];
 134                                 continue;
 135                         }
 136
 137                         /*
 138                          * Obtain the old pixel value
 139                          */
 140
 141                         ale_real old_value = colors->chan(i, j, k) / weights->chan(i, j, k);
 142
 143                         /*
 144                          * Cases in which the old pixel value can be ignored
 145                          */
 146
 147                         if ((inv->is_max()
 148                           && new_value[k] > old_value)
 149                          || (inv->is_min()
 150                           && new_value[k] < old_value)) {
 151                                 weights->chan(i, j, k) = new_weight[k];
 152                                 colors-> chan(i, j, k) = new_value[k] * new_weight[k];
 153                                 continue;
 154                         }
 155
 156                         /*
 157                          * Cases in which the new pixel value can be ignored
 158                          */
 159
 160                         if ((inv->is_max()
 161                           && old_value > new_value[k])
 162                          || (inv->is_min()
 163                           && old_value < new_value[k])) {
 164                                 continue;
 165                         }
 166
 167                         /*
 168                          * Update weight and color values.
 169                          */
 170
 171                         weights->chan(i, j, k) += new_weight[k];
 172                         colors->chan(i, j, k) += new_weight[k] * new_value[k];
 173                 }
 174         }
 175
 176
 177         pixel get_pixel(unsigned int y, unsigned int x) const {
 178                 return colors->get_pixel(y, x) / weights->get_pixel(y, x);
 179         }
 180
 181         image *get_weights() {
 182                 return weights;
 183         }
 184
 185         image *get_colors() {
 186                 assert(0);
 187                 return colors;
 188         }
 189 };
 190
 191 #endif