Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

vuColour.h

Go to the documentation of this file.
00001 /* Written by Steven Bergner
00002 
00003         Based on Steve Kilthau's colour classes
00004         Modified June 2002
00005         Modified by Chris Steinbach
00006         Modified to add read and write functions by sbergner so that
00007                 This would work in the CVS.
00008 */
00009 
00010 #ifndef _VUCOLOUR_H_
00011 #define _VUCOLOUR_H_
00012 
00013 #include <iostream.h>   // cgs@sfu.ca - April 2002 - modified to add the ".h" so that it would work in IRIX
00014 #include <stdio.h>
00015 #include "vuSimpleTypes.h"
00016 
00017 #define USE_GENERAL_BASIS
00018 //using specialized 31to7 and 7toRGBA instead
00019 
00030 class vuColourN
00031 {
00032 public:
00034     vuColourN(void) {};
00035 
00037     virtual ~vuColourN(void) {};
00038 
00040     virtual float& operator[](unsigned int index) { static float n=0; return n;};
00041 
00043     virtual float operator[](unsigned int index) const {return 0;};
00044 
00046     virtual float *getData() {return 0;};
00047 
00049     virtual float const* getData() const {return 0;};
00050 
00053     virtual word nComponents() const {return 0;};
00054 
00056     virtual void print() const {};
00057 };
00058 
00065 template <int S>
00066 class vuColour : public vuColourN
00067 {
00068 public:
00071     vuColour()
00072     {
00073       int i;
00074       for(i=0;i<S-1;++i)
00075         m_Data[i] = 0.0f;
00076       m_Data[S-1]=1;
00077     }
00078 
00080     vuColour(const vuColour<S>& inst)
00081     {
00082         int i;
00083         for(i=0;i<S;++i)
00084             m_Data[i] = inst.m_Data[i];
00085     }
00086 
00089     vuColour(const float *f)
00090     {
00091         int i;
00092         for(i=0;i<S;++i)
00093             m_Data[i] = f[i];
00094     }
00095 
00098     vuColour(const double *f)
00099     {
00100         int i;
00101         for(i=0;i<S;++i)
00102             m_Data[i] = f[i];
00103     }
00104 
00106     vuColour(const float f)
00107     {
00108         int i;
00109         for(i=0;i<S;++i)
00110             m_Data[i] = f;
00111     }
00112 
00114     ~vuColour()
00115     {
00116     }
00117 
00119     float getAlpha(void)
00120     {
00121       return m_Data[S-1];
00122     }
00123 
00125     void setAlpha(const float a)
00126     {
00127       m_Data[S-1] = a;
00128     }
00129 
00131     float& operator[](unsigned int index)
00132     {
00133       return m_Data[index];
00134     }
00135 
00137     float operator[](unsigned int index) const
00138     {
00139       return m_Data[index];
00140     }
00141 
00143     float *getData() { return m_Data; }
00145     float const *getData() const { return m_Data; }
00146 
00148     vuColour<S>& operator=(const double* rhs)
00149     {
00150       for(int i=0;i<S-1;++i)
00151         m_Data[i] = rhs[i];
00152       return *this;
00153     }
00154 
00156     vuColour<S>& operator=(double* rhs)
00157 
00158     {
00159       for(int i=0;i<S-1;++i)
00160         m_Data[i] = rhs[i];
00161       return *this;
00162     }
00163 
00165     vuColour<S>& operator=(const vuColour<S>& rhs)
00166     {
00167       if (this != &rhs)
00168         {
00169           for(int i=0;i<S;++i)
00170             m_Data[i] = rhs.m_Data[i];
00171         }
00172       return *this;
00173     }
00174 
00177     vuColour<S>& operator=(float rhs)
00178     {
00179       for(int i=0;i<S;++i)
00180         m_Data[i] = rhs;
00181       return *this;
00182     }
00183 
00186     vuColour<S>& operator=(const float* rhs)
00187     {
00188       for(int i=0;i<S-1;++i)
00189         m_Data[i] = rhs[i];
00190       return *this;
00191     }
00192 
00196     bool operator== (const vuColour<S>& rhs) const
00197         {
00198             for(int i=0;i<S;++i)
00199                 if(!m_Data[i] == rhs[i]) return false;
00200             return true;
00201         }
00202 
00207     vuColour<S> operator+(const vuColour<S>& rhs) const
00208     {
00209       vuColour<S> ret;
00210       for(int i=0;i<S-1;++i)
00211         ret.m_Data[i] = m_Data[i] + rhs.m_Data[i];
00212       return ret;
00213     }
00214 
00217     vuColour<S> operator+(float a) const
00218     {
00219       vuColour<S> ret;
00220       for(int i=0;i<S-1;++i)
00221         ret.m_Data[i] = m_Data[i] + a;
00222       return ret;
00223     }
00224 
00227     vuColour<S> operator-(const vuColour<S>& rhs) const
00228     {
00229       vuColour<S> ret;
00230       for(int i=0;i<S-1;++i)
00231         ret.m_Data[i] = m_Data[i] - rhs.m_Data[i];
00232       return ret;
00233     }
00234 
00237     vuColour<S> operator*(const vuColour<S>& rhs) const
00238     {
00239       vuColour<S> ret;
00240       for(int i=0;i<S-1;++i)
00241         ret.m_Data[i] = m_Data[i] * rhs.m_Data[i];
00242       return ret;
00243     }
00244 
00247     vuColour<S> operator/(const vuColour<S>& rhs) const
00248     {
00249       vuColour<S> ret;
00250       for(int i=0;i<S-1;++i)
00251         ret.m_Data[i] = m_Data[i] / rhs.m_Data[i];
00252       return ret;
00253     }
00254 
00259     vuColour<S> operator*(float rhs) const 
00260     {
00261       vuColour<S> ret;
00262       for(int i=0;i<S-1;++i)
00263         ret.m_Data[i] = m_Data[i] * rhs;
00264       return ret;
00265     }
00266 
00271     friend vuColour<S> operator*(float lhs, const vuColour<S>& rhs)
00272     {
00273       vuColour<S> ret;
00274       for(int i=0;i<S-1;++i)
00275         ret.m_Data[i] = rhs.m_Data[i] * lhs;
00276       return ret;
00277     }
00278 
00280     vuColour<S>& operator+=(const vuColour<S>& rhs)
00281     {
00282       for(int i=0;i<S-1;++i)
00283         m_Data[i] += rhs.m_Data[i];
00284       return *this;
00285     }
00286 
00288     vuColour<S>& operator-=(const vuColour<S>& rhs)
00289     {
00290       for(int i=0;i<S-1;++i)
00291         m_Data[i] -= rhs.m_Data[i];
00292       return *this;
00293     }
00294 
00296     vuColour<S>& operator*=(const vuColour<S>& rhs)
00297     {
00298       for(int i=0;i<S-1;++i)
00299         m_Data[i] *= rhs.m_Data[i];
00300       return *this;
00301     }
00302 
00304     vuColour<S>& operator/=(const vuColour<S>& rhs)
00305     {
00306       for(int i=0;i<S-1;++i)
00307         m_Data[i] /= rhs.m_Data[i];
00308       return *this;
00309     }
00310     
00312     vuColour<S>& operator*=(float rhs)
00313     {
00314         for(int i=0;i<S-1;++i)
00315           m_Data[i] *= rhs;
00316         return *this;
00317     }
00318 
00320     vuColour<S>& operator/=(float rhs)
00321     {
00322         for(int i=0;i<S-1;++i)
00323           m_Data[i] /= rhs;
00324         return *this;
00325     }
00326 
00328     vuColour<S>& clampTo01()
00329     {
00330       for(int i=0; i<S; i++)
00331         if(m_Data[i] < 0) m_Data[i] = 0;
00332         else if (m_Data[i] > 1) m_Data[i] = 1;
00333       return *this;
00334     }
00335 
00337     vuColour<S>& clampTo1()
00338     {
00339       for(int i=0; i<S; i++)
00340         if (m_Data[i] > 1) m_Data[i] = 1;
00341       return *this;
00342     }
00343 
00345     vuColour oneMinus() const
00346     {
00347       vuColour<S> ret;
00348       for(int i=0;i<S-1;++i)
00349         ret.m_Data[i] = 1-m_Data[i];
00350       return ret;
00351     }
00352 
00355     word nComponents() const
00356       {
00357         return S;
00358       }
00359 
00362     float maxComponent() const
00363     {
00364       float maxc = m_Data[0];
00365       for(int i=1;i<S-1;++i)
00366         if(maxc<m_Data[i]) maxc=m_Data[i];
00367       return maxc;
00368     }
00369 
00372     float minComponent() const 
00373     {
00374       float minc = m_Data[0];
00375       for(int i=1;i<S-1;++i)
00376         if(minc>m_Data[i]) minc=m_Data[i];
00377       return minc;
00378     }
00379 
00382     vuColour<S>& multAlpha()
00383     {
00384       if(S>1) {
00385         for(int i=0; i<S-1; i++)
00386           m_Data[i] *= m_Data[S];
00387         m_Data[S-1] = 1;
00388       }
00389       return *this;
00390     }
00391 
00393     void print() const
00394     {
00395       printf(" %3.7f", m_Data[0]);
00396       for(int i=1;i<S;++i)
00397         printf(", %3.7f", m_Data[i]);
00398       printf("\n");
00399     }
00400 
00402 //template < int T >
00403 friend ostream& operator<< (ostream& os, const vuColour<S>& A)
00404     {
00405          const float *dat = A.m_Data;
00406          os << *(dat++);
00407          for (dword j = 1; j < S; j++, dat++)
00408              os << ", " << (*dat);
00409          return os;
00410     }
00411 
00413 //template < int T >
00414 friend istream& operator>> (istream& is, vuColour<S>& A)
00415      {
00416          float *dat = A.m_Data;
00417          for (dword j = 0; j < S; j++, dat++)
00418              is >> (*dat);
00419          return is;
00420      }
00421 
00423 istream& read (istream& is)
00424      {
00425          float *dat = m_Data;
00426          for (dword j = 0; j < S; j++, dat++)
00427                  is >> (*dat);
00428          return is;
00429      }
00430 
00432         ostream& write(ostream& os) const {
00433                 const float *dat = m_Data;
00434                 for (dword j = 0; j < S; j++, dat++)
00435                          os << (*dat) << " ";
00436                 return os;
00437         }
00438 
00439 
00440 
00441  protected:
00443     template<int T>
00444     vuColour<S>& fromColourN(const vuColour<T>& src, const float* xfmat)
00445       {
00446         int i,j;
00447         for(i=0;i<S-1;i++) {
00448           m_Data[i] = *(xfmat++) * src[0];
00449           for(j=1;j<T-1;j++)
00450             m_Data[i] += *(xfmat++) * src[j];
00451         }
00452         m_Data[S-1] = src[T-1];
00453         
00454         return *this;
00455       }
00456 
00458     template<int T>
00459     vuColour<T>& toColourN(vuColour<T>& dstcol, const float* xfmat) const
00460       {
00461         int i,j;
00462         float *dst = dstcol.getData();
00463         for(i=0;i<T-1;i++) {
00464           dst[i] = *(xfmat++) * m_Data[0];
00465           for(j=1;j<S-1;j++)
00466             dst[i] += *(xfmat++) * m_Data[j];
00467         }
00468         dst[T-1] = m_Data[S-1];
00469         
00470         return dstcol;
00471       }
00472 
00473     float m_Data[S]; 
00474 };
00475 
00476 /*
00477 typedef vuColour<4>  vuColourRGBa;
00478 typedef vuColour<8>  vuColour7a;
00479 typedef vuColour<32> vuColour31a;
00480 
00481 #define vuColourRGBa    vuColour<4>
00482 #define vuColour7a      vuColour<8>
00483 #define vuColour31a     vuColour<32>
00484 */
00485 
00486 #endif

Generated on Wed Dec 15 21:20:33 2004 for vuVolume by  doxygen 1.3.9.1