colour.h

/* *************************************************************************
                          colour.h  -  description
                             -------------------
    begin                : Wed Oct 15 2002
    copyright            : (C) 2002 by Micha Riser
    email                : mriser@gmx.net

    $Id: colour_8h-source.html,v 1.1 2005/02/04 21:02:27 micha Exp $
    
 ************************************************************************* */

/* *************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ************************************************************************* */


#ifndef COLOUR_H
#define COLOUR_H

#include<cmath>
#include "types.h"

class Colour;

class ColourA {

    friend class Colour;

private: // constants
    static const CNT8 RED = 0, GREEN = 1, BLUE = 2;
    static const CNT8 ALPHA = 3;    

public: // Constructors and destructor
    
    ColourA(CLR r, CLR g, CLR b, CLR a) {
        c[0]=r; c[1]=g; c[2]=b; c[3]=a;
    }

    ColourA(const CLR& a) {
        for(int i=0; i<4; i++) c[i]=a;
    }

    ColourA(const Colour& d);

private: // Private constructor
    ColourA() {};
            
public: // Public methods

    CLR red() const {return c[RED];}
    CLR green() const {return c[GREEN];}
    CLR blue() const {return c[BLUE];}
    CLR alpha() const {return c[ALPHA];}


    void add(const ColourA &d) {for(int i=0; i<4; i++) c[i] += d.c[i];}

    void sub(const ColourA &d) {for(int i=0; i<4; i++) c[i] -= d.c[i];}

    void scale(CLR s) {for(int i=0; i<4; i++) c[i] *= s;}

    void scale(const ColourA& d) {for(int i=0; i<4; i++) c[i] *= d.c[i];}

    void scale(const Colour& d);

    ColourA scaled(CLR s) const {ColourA ret; for(int i=0; i<4; i++) ret.c[i]=c[i]*s; return ret;}

    CLR norm() const {
        // calculate maximum (infinity) norm / what with alpha?
        CLR ret = c[0];
        for(int i=1; i<3; i++) if (c[i]>ret) ret = c[i];
        return ret;
    }

private: // Private attributes
    CLR c[4]; // colour RGBA

};


class Colour {

    friend class ColourA;

public: // Private constants
    static const char RGB_LOOP = 3;
private:    
    static const CNT8 RED = 0, GREEN = 1, BLUE = 2;
    
public: // Constructors and destructor

    Colour(CLR r, CLR g, CLR b) {c[0]=r; c[1]=g; c[2]=b;}

    Colour(const CLR& a) {for(int i=0; i<RGB_LOOP; i++) c[i]=a;}

    Colour(const ColourA& a) {for(int i=0; i<RGB_LOOP; i++) c[i]=a.c[i];}

private:
    Colour() {};

public: // Public methods

    CLR red() const {return c[RED];}
    CLR green() const {return c[GREEN];}
    CLR blue() const {return c[BLUE];}

    void add(const Colour &d) {for(int i=0; i<RGB_LOOP; i++) c[i] += d.c[i];}

    void add(const ColourA &d) {for(int i=0; i<RGB_LOOP; i++) c[i] += d.c[i];}

    void sub(const Colour &d) {for(int i=0; i<RGB_LOOP; i++) c[i] -= d.c[i];}

    void scale(CLR s) {for(int i=0; i<RGB_LOOP; i++) c[i] *= s;}

    void scale(const ColourA& d) {for(int i=0; i<RGB_LOOP; i++) c[i] *= d.c[i];}

    void scale(const Colour& d) {for(int i=0; i<RGB_LOOP; i++) c[i] *= d.c[i];}

    void exp() {for(int i=0; i<RGB_LOOP; i++) c[i] = std::exp(c[i]);}

    void negExp() {for(int i=0; i<RGB_LOOP; i++) c[i] = std::exp(-c[i]);}

    Colour scaled(CLR s) const {Colour ret; for(int i=0; i<RGB_LOOP; i++) ret.c[i]=c[i]*s; return ret;}

    Colour scaled(const Colour &d) const {
        Colour ret;
        for(int i=0; i<RGB_LOOP; i++) ret.c[i] = c[i]*d.c[i];
        return ret;
    }

    Colour divided(const Colour& d) const {
        Colour ret;
        for(int i=0; i<RGB_LOOP; i++) ret.c[i] = c[i]/d.c[i];
        return ret;
    }
    
    Colour scaled(const ColourA &d) const {
        Colour ret;
        for(int i=0; i<RGB_LOOP; i++) ret.c[i] = c[i]*d.c[i];
        return ret;
    }

    CLR norm() const {
        CLR ret = fabs(c[0]);
        for(int i=1; i<RGB_LOOP; i++) if (fabs(c[i])>ret) ret = fabs(c[i]);
        return ret;
    }

    CLR minElement() const {
        CLR ret = c[0];
        for(int i=1; i<RGB_LOOP; i++) if (c[1]<ret) ret = c[1];
        return ret;
    }

    CLR maxElement() const {
        CLR ret = c[0];
        for(int i=1; i<RGB_LOOP; i++) if (c[1]>ret) ret = c[1];
        return ret;
    }

public: // Static methods

    static Colour add(const Colour& c1, const Colour& c2) {
        Colour ret;
        for(int i=0; i<RGB_LOOP; i++) ret.c[i]=c1.c[i]+c2.c[i];
        return ret;
    }

    Colour operator+(const Colour& c1) const {

        return add(*this,c1);
    }

    Colour operator*(const CLR d) const {

        return scaled(d);
    }

    Colour operator*(const Colour& d) const {

        return scaled(d);
    }

    Colour operator/(const Colour& d) const {

        return divided(d);
    }
    
    Colour operator-(const Colour& d) const {

        return sub(*this,d);
    }

    static Colour sub(const Colour& c1, const Colour& c2) {
        Colour ret;
        for(int i=0; i<RGB_LOOP; i++) ret.c[i]=c1.c[i]-c2.c[i];
        return ret;
    }

    static Colour sqrt(const Colour& d) {
        Colour ret;
        for(int i=0; i<RGB_LOOP; i++) ret.c[i]=std::sqrt(d.c[i]);
        return ret;
    }

    static Colour exp(const Colour& d) {
        Colour ret;
        for(int i=0; i<RGB_LOOP; i++) ret.c[i]=std::exp(d.c[i]);
        return ret;
    }

    static Colour negExp(const Colour& d) {
        Colour ret;
        for(int i=0; i<RGB_LOOP; i++) ret.c[i]=std::exp(-d.c[i]);
        return ret;
    }    


private: // Public members
    CLR c[RGB_LOOP];
    
};

#endif

---