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 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_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 *colors;
  36         image *weights;
  37
  38 public:
  39         image_weighted_simple (unsigned int dimy, unsigned int dimx, unsigned int
  40                         depth, invariant *inv, const 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         image *_extend(int top, int bottom, int left, int right) {
  58                 extend(&colors, top, bottom, left, right);
  59                 extend(&weights, top, bottom, left, right);
  60
  61                 _dimx = colors->width();
  62                 _dimy = colors->height();
  63                 _offset = colors->offset();
  64
  65                 return NULL;
  66         }
  67
  68         /*
  69          * Pre-transformation check for whether an area should be skipped.
  70          * Takes image weights as an argument.
  71          */
  72         int accumulate_norender(int i, int j) {
  73                 /*
  74                  * Initial value
  75                  */
  76                 if (inv->is_first() && weights->get_chan(i, j, 0) != 0)
  77                         return 1;
  78                 /*
  79                  * Weight limit satisfied
  80                  */
  81                 if (inv->is_avgf()
  82                  && weights->get_chan(i, j, 0) > inv->get_param()
  83                  && weights->get_chan(i, j, 1) > inv->get_param()
  84                  && weights->get_chan(i, j, 2) > inv->get_param())
  85                         return 1;
  86
  87                 return 0;
  88         }
  89
  90         /*
  91          * Accumulate pixels
  92          */
  93         void accumulate(int i, int j, int f, pixel new_value, pixel new_weight) {
  94
  95                 /*
  96                  * Perform operations separately for each channel
  97                  */
  98                 for (unsigned int k = 0; k < 3; k++) {
  99
 100                         /*
 101                          * Cases independent of the old pixel value and weight
 102                          * for which the update can be ignored.
 103                          */
 104
 105                         if (!inv->is_avgx()
 106                          && new_weight[k] < render::get_wt())
 107                                 continue;
 108
 109                         /*
 110                          * Cases independent of the old pixel value and weight for which
 111                          * previous pixel values can be ignored.
 112                          */
 113
 114                         if (inv->is_last() && new_weight[k] >= render::get_wt()) {
 115                                 colors->set_chan(i, j, k, new_value[k]);
 116                                 weights->set_chan(i, j, k, new_weight[k]);
 117                                 continue;
 118                         }
 119
 120                         /*
 121                          * Obtain the old pixel weight.
 122                          */
 123
 124                         ale_real old_weight = weights->get_chan(i, j, k);
 125
 126                         /*
 127                          * Cases independent of the old pixel value for which the
 128                          * update can be ignored.
 129                          */
 130
 131                         if (old_weight >= render::get_wt()
 132                          && inv->is_first())
 133                                 continue;
 134
 135                         if (inv->is_avgf()
 136                          && old_weight >= inv->get_param())
 137                                 continue;
 138
 139                         /*
 140                          * Cases independent of the old pixel value for which previous
 141                          * pixel values can be ignored.
 142                          */
 143
 144                         if (old_weight == 0
 145                          || (old_weight < render::get_wt()
 146                           && !inv->is_avgx())) {
 147                                 weights->set_chan(i, j, k, new_weight[k]);
 148                                 colors ->set_chan(i, j, k, new_value[k]);
 149                                 continue;
 150                         }
 151
 152                         if (inv->is_max()) {
 153
 154                                 /*
 155                                  * Cases in which the old pixel value can be ignored
 156                                  */
 157
 158                                 if (new_value[k] * (ale_real) weights->get_chan(i, j, k)
 159                                   > (ale_real) colors->get_chan(i, j, k) * new_weight[k]) {
 160                                         weights->set_chan(i, j, k, new_weight[k]);
 161                                         colors-> set_chan(i, j, k, new_value[k]);
 162                                 }
 163
 164                                 continue;
 165
 166                         } else if (inv->is_min()) {
 167                                 /*
 168                                  * Cases in which the old pixel value can be ignored
 169                                  */
 170
 171                                 if (new_value[k] * (ale_real) weights->get_chan(i, j, k)
 172                                   < (ale_real) colors->get_chan(i, j, k) * new_weight[k]) {
 173                                         weights->set_chan(i, j, k, new_weight[k]);
 174                                         colors-> set_chan(i, j, k, new_value[k]);
 175                                 }
 176
 177                                 continue;
 178                         }
 179
 180
 181                         /*
 182                          * Update weight and color values.
 183                          */
 184
 185                         weights->set_chan(i, j, k, weights->get_chan(i, j, k) + new_weight[k]);
 186                         colors->set_chan(i, j, k, colors->get_chan(i, j, k) + new_value[k]);
 187                 }
 188         }
 189
 190
 191         spixel get_pixel(unsigned int y, unsigned int x) const {
 192                 return (pixel) colors->get_pixel(y, x) / (pixel) weights->get_pixel(y, x);
 193         }
 194
 195         image *get_weights() {
 196                 return weights;
 197         }
 198
 199         image *get_colors() {
 200                 assert(0);
 201                 return colors;
 202         }
 203 };
 204
 205 #endif