d2/spixel.h

   1 // Copyright 2002 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 #ifndef __spixel_h__
  22 #define __spixel_h__
  23
  24 /*
  25  * Structure to describe a pixel to be used in storage.
  26  */
  27
  28 #define HALF 3
  29
  30 #if ALE_COLORS != HALF
  31
  32 typedef pixel spixel;
  33
  34 #else
  35
  36 class spixel {
  37 private:
  38         ale_sreal x[3];
  39
  40 public:
  41         spixel() {
  42                 x[0] = 0;
  43                 x[1] = 0;
  44                 x[2] = 0;
  45         }
  46
  47         spixel(pixel p) {
  48                 x[0] = p[0];
  49                 x[1] = p[1];
  50                 x[2] = p[2];
  51         }
  52
  53         spixel(ale_sreal x0, ale_sreal x1, ale_sreal x2) {
  54                 x[0] = x0;
  55                 x[1] = x1;
  56                 x[2] = x2;
  57         }
  58
  59         operator pixel() const {
  60                 pixel result;
  61
  62                 result[0] = x[0];
  63                 result[1] = x[1];
  64                 result[2] = x[2];
  65
  66                 return result;
  67         }
  68
  69         const ale_sreal &operator[](int i) const {
  70                 assert (i >= 0);
  71                 assert (i < 3);
  72
  73                 return x[i];
  74         }
  75
  76         ale_sreal &operator[](int i) {
  77                 assert (i >= 0);
  78                 assert (i < 3);
  79
  80                 return x[i];
  81         }
  82
  83         spixel operator+=(pixel p) {
  84                 return spixel(x[0] += p[0], x[1] += p[1], x[2] += p[2]);
  85         }
  86
  87         spixel operator*=(pixel p) {
  88                 return spixel(x[0] *= p[0], x[1] *= p[1], x[2] *= p[2]);
  89         }
  90
  91         spixel operator*=(ale_real d) {
  92                 return spixel(x[0] *= d, x[1] *= d, x[2] *= d);
  93         }
  94
  95         spixel operator/=(pixel p) {
  96                 return spixel(x[0] /= p[0], x[1] /= p[1], x[2] /= p[2]);
  97         }
  98
  99         spixel operator/=(ale_real d) {
 100                 return spixel(x[0] /= d, x[1] /= d, x[2] /= d);
 101         }
 102 };
 103
 104 #endif
 105
 106 #undef HALF
 107
 108 #endif