d2/trans_multi.h

   1 // Copyright 2002, 2004, 2007 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  * trans_multi.h: Represent multiple transformations, affecting different
  23  * regions of a scene.
  24  */
  25
  26 #ifndef __trans_multi_h__
  27 #define __trans_multi_h__
  28
  29 #include "trans_abstract.h"
  30 #include "trans_single.h"
  31
  32 struct trans_multi : public trans_abstract {
  33 private:
  34         std::vector<trans_single> trans_stack;
  35         int full_support;
  36         unsigned int current_element;
  37
  38 public:
  39
  40         trans_multi() : trans_stack() {
  41                 full_support = 0;
  42                 current_element = 0;
  43         }
  44
  45         trans_multi &operator=(const trans_multi &tm) {
  46                 this->trans_abstract::operator=(*((trans_abstract *) &tm));
  47
  48                 trans_stack = tm.trans_stack;
  49                 full_support = tm.full_support;
  50                 current_element = tm.current_element;
  51
  52                 return *this;
  53         }
  54
  55         trans_multi(const trans_multi &tm) : trans_stack() {
  56                 operator=(tm);
  57         }
  58
  59         trans_single get_element(unsigned int index) {
  60                 assert (index < trans_stack.size());
  61
  62                 return trans_stack[index];
  63         }
  64
  65         trans_single get_current_element() {
  66                 return get_element(current_element);
  67         }
  68
  69         void set_element(unsigned int index, trans_single t) {
  70                 assert (index < trans_stack.size());
  71
  72                 trans_stack[index] = t;
  73         }
  74
  75         void set_current_element(trans_single t) {
  76                 set_element(current_element, t);
  77         }
  78
  79         void push_element() {
  80                 assert (trans_stack.size() > 0);
  81
  82                 if (++current_element == trans_stack.size())
  83                         trans_stack.push_back(trans_stack.back());
  84         }
  85
  86         unsigned int get_current_index() const {
  87                 return current_element;
  88         }
  89
  90         void set_current_index(unsigned int i) {
  91                 assert (i < trans_stack.size());
  92
  93                 current_element = i;
  94         }
  95
  96         unsigned int stack_depth() {
  97                 return trans_stack.size();
  98         }
  99
 100         int supported(int i, int j) {
 101                 if (full_support || current_element == 0)
 102                         return 1;
 103
 104                 return 0;
 105         }
 106
 107         void use_full_support() {
 108                 full_support = 1;
 109         }
 110
 111         void use_restricted_support() {
 112                 full_support = 0;
 113         }
 114
 115         int is_nontrivial() {
 116                 return 0;
 117         }
 118
 119         void begin_calculate_scaled_region(unsigned int i_max, unsigned int j_max, point offset) {
 120                 assert(0);
 121         }
 122
 123         void begin_calculate_unscaled_region(unsigned int i_max, unsigned int j_max, point offset) {
 124                 assert(0);
 125         }
 126
 127         void end_calculate_region() {
 128                 assert(0);
 129         }
 130
 131         point get_query_point(int i, int j) {
 132                 return point::undefined();
 133         }
 134
 135         /*
 136          * Returns non-zero if the transformation might be non-Euclidean.
 137          */
 138         int is_projective() const {
 139                 return trans_stack.front().is_projective();
 140         }
 141
 142         /*
 143          * Projective/Euclidean transformations
 144          */
 145         struct point pe(struct point p) const {
 146                 return trans_stack.front().pe(p);
 147         }
 148
 149         /*
 150          * Inverse transformations
 151          */
 152         struct point pei(struct point p) const {
 153                 return trans_stack.front().pei(p);
 154         }
 155
 156
 157         /*
 158          * Calculate projective transformation parameters from a euclidean
 159          * transformation.
 160          */
 161         void eu_to_gpt() {
 162                 for (unsigned int t = 0; t < trans_stack.size(); t++)
 163                         trans_stack[t].eu_to_gpt();
 164         }
 165
 166         /*
 167          * Calculate euclidean identity transform for a given image.
 168          */
 169         static struct trans_multi eu_identity(const image *i = NULL, ale_pos scale_factor = 1) {
 170                 struct trans_multi r;
 171                 r.input_width = i ? i->width() : 2;
 172                 r.input_height = i ? i->height() : 2;
 173                 r.scale_factor = scale_factor;
 174                 r.trans_stack.push_back(trans_single::eu_identity(i, scale_factor));
 175                 r.current_element = 0;
 176                 return r;
 177         }
 178
 179         /*
 180          * Calculate projective identity transform for a given image.
 181          */
 182         static trans_multi gpt_identity(const image *i, ale_pos scale_factor) {
 183                 struct trans_multi r = eu_identity(i, scale_factor);
 184                 r.eu_to_gpt();
 185                 return r;
 186         }
 187
 188         /*
 189          * Modify a euclidean transform in the indicated manner.
 190          */
 191         void eu_modify(int i1, ale_pos diff) {
 192                 trans_stack[current_element].eu_modify(i1, diff);
 193         }
 194
 195         /*
 196          * Rotate about a given point in the original reference frame.
 197          */
 198         void eu_rotate_about_scaled(point center, ale_pos diff) {
 199                 trans_stack[current_element].eu_rotate_about_scaled(center, diff);
 200         }
 201
 202         /*
 203          * Modify all euclidean parameters at once.
 204          */
 205         void eu_set(ale_pos eu[3]) {
 206                 trans_stack[current_element].eu_set(eu);
 207         }
 208
 209         /*
 210          * Get the specified euclidean parameter
 211          */
 212         ale_pos eu_get(int param) const {
 213                 return trans_stack[current_element].eu_get(param);
 214         }
 215
 216         /*
 217          * Modify a projective transform in the indicated manner.
 218          */
 219         void gpt_modify(int i1, int i2, ale_pos diff) {
 220                 trans_stack[current_element].gpt_modify(i1, i2, diff);
 221         }
 222
 223         /*
 224          * Modify a projective transform according to the group operation.
 225          */
 226         void gr_modify(int i1, int i2, ale_pos diff) {
 227                 trans_stack[current_element].gr_modify(i1, i2, diff);
 228         }
 229
 230         /*
 231          * Modify all projective parameters at once.
 232          */
 233         void gpt_set(point x[4]) {
 234                 trans_stack[current_element].gpt_set(x);
 235         }
 236
 237         void gpt_set(point x1, point x2, point x3, point x4) {
 238                 trans_stack[current_element].gpt_set(x1, x2, x3, x4);
 239         }
 240
 241         void snap(ale_pos interval) {
 242                 trans_stack[current_element].snap(interval);
 243         }
 244
 245         /*
 246          * Get the specified projective parameter
 247          */
 248         point gpt_get(int point) const {
 249                 return trans_stack[current_element].gpt_get(point);
 250         }
 251
 252         /*
 253          * Get the specified projective parameter
 254          */
 255         ale_pos gpt_get(int point, int dim) {
 256                 return trans_stack[current_element].gpt_get(point, dim);
 257         }
 258
 259         /*
 260          * Translate by a given amount
 261          */
 262         void translate(point p) {
 263                 trans_stack[current_element].translate(p);
 264         }
 265
 266         /*
 267          * Rotate by a given amount about a given point.
 268          */
 269         void rotate(point p, ale_pos degrees) {
 270                 trans_stack[current_element].rotate(p, degrees);
 271         }
 272
 273         void reset_memos() {
 274                 for (unsigned int t = 0; t < trans_stack.size(); t++)
 275                         trans_stack[t].reset_memos();
 276         }
 277
 278         /*
 279          * Rescale a transform with a given factor.
 280          */
 281         void specific_rescale(ale_pos factor) {
 282
 283                 if (trans_stack.size() > 1) {
 284
 285                         /*
 286                          * Rescale region map.
 287                          */
 288
 289 #warning d2::trans_multi::specific_rescale() does no region map rescaling.
 290                 }
 291
 292                 for (unsigned int t = 0; t < trans_stack.size(); t++)
 293                         trans_stack[t].rescale(factor);
 294         }
 295
 296         /*
 297          * Set the dimensions of the image.
 298          */
 299         void specific_set_dimensions(const image *im) {
 300                 for (unsigned int t = 0; t < trans_stack.size(); t++)
 301                         trans_stack[t].set_dimensions(im);
 302         }
 303
 304         /*
 305          * Modify all projective parameters at once.  Accommodate bugs in the
 306          * version 0 transformation file handler (ALE versions 0.4.0p1 and
 307          * earlier).  This code is only called when using a transformation data
 308          * file created with an old version of ALE.
 309          */
 310         void gpt_v0_set(point x[4]) {
 311                 trans_stack[current_element].gpt_v0_set(x);
 312         }
 313
 314         /*
 315          * Modify all euclidean parameters at once.  Accommodate bugs in the
 316          * version 0 transformation file handler (ALE versions 0.4.0p1 and
 317          * earlier).  This code is only called when using a transformation data
 318          * file created with an old version of ALE.
 319          */
 320         void eu_v0_set(ale_pos eu[3]) {
 321                 trans_stack[current_element].eu_v0_set(eu);
 322         }
 323
 324         void debug_output() {
 325                 for (unsigned int t = 0; t < trans_stack.size(); t++)
 326                         trans_stack[t].debug_output();
 327         }
 328 };
 329
 330 #endif