ColorManager.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

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.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#ifndef COLOR_MANAGER_H
#define COLOR_MANAGER_H

#include <vector>
#include <map>
#include <string>
#include <sstream>

#include "SingletonHolder.h"

#include "Color.h"
#include "Vector.h"
#include "Displayable.h"



class ColorManager {
    public:
        ColorManager();

        ColorManager(Displayable *);

        virtual ~ColorManager() { }

        virtual void setFunction(Displayable *);

        Displayable *getFunction() const { return f; }

        virtual void calibrateColor(const VecMath::Vector<4> &x,
                                    const Color &col = Color()) = 0;

        void setRGB(const Color &);

        virtual void setColor(const VecMath::Vector<4> &);


        virtual Color getColor(const VecMath::Vector<4> &x) = 0;

        virtual void depthCueColor(double wmax, double wmin, double w,
                                   const VecMath::Vector<4> &x) = 0;

        virtual std::string getContents() { return ""; }

    protected:

        typedef std::vector<Color> colorvec1D;
        typedef std::vector<colorvec1D> colorvec2D;
        typedef std::vector<colorvec2D> colorvec3D;
        typedef std::vector<colorvec3D> colorvec4D;
        typedef std::map<VecMath::Vector<4>, Color> colormap;

        double getoffset4Ddepthcue() { return offset4Ddepthcue; }

        double getAlpha() { return ALPHA; }

    private:
        Displayable* f;      

        double ambientColorModifier;
        double specularColorModifier;
        double specularColorMinimum;
        double SHININESS;
        double ALPHA;
        double offset4Ddepthcue;
};


class ColorManagerManager {
    public:
        struct BadColorManagerException: public std::runtime_error {
            BadColorManagerException(const std::string &);
        };

        struct ColorManagerUnsetException: public std::logic_error {
            ColorManagerUnsetException(const std::string &);
        };

        typedef ColorManager *(*CreateColMgrCallback)();

        void setColorManager(ColorManager *cm);

        void setFunction(Displayable *_f);

        void calibrateColor(const VecMath::Vector<4> &, const Color & = Color());

        void setColor(const VecMath::Vector<4> &x);

        Color getColor(const VecMath::Vector<4> &x);

        void depthCueColor(double wmax, double wmin, double w,
                           const VecMath::Vector<4> &x);

        void setRGB(const Color &_col);

        std::string getContents();

        bool registerColorManager(const std::string &, CreateColMgrCallback);

        bool unregisterColorManager(const std::string &);

        std::vector<std::string> getRegisteredColorManagers();

        void setColorManager(const std::string &);

        bool isColorManagerSet() const;

    private:
        typedef std::map<std::string, CreateColMgrCallback> CallbackMap;

        ColorManagerManager(): callbacks() { }
        ColorManagerManager(const ColorManagerManager &);
        ColorManagerManager &operator=(const ColorManagerManager &);
        ~ColorManagerManager() { }

        std::auto_ptr<ColorManager> colorManager;   

        CallbackMap callbacks;              

        friend class Loki::CreateUsingNew<ColorManagerManager>;

};

typedef Loki::SingletonHolder<ColorManagerManager> ColMgrMgr;



class xyz2RGBColorManager: public ColorManager {
    public:
        xyz2RGBColorManager(): ColorManager(), col(colormap()) { }


        xyz2RGBColorManager(Displayable *_f): ColorManager(_f), col(colormap()) { }

        virtual ~xyz2RGBColorManager() { }

        virtual void setFunction(Displayable *);

        virtual void calibrateColor(const VecMath::Vector<4> &x,
                                    const Color &_col = Color());

        virtual Color getColor(const VecMath::Vector<4> &x);

        virtual void depthCueColor(double wmax, double wmin, double w,
                                   const VecMath::Vector<4> &);

        virtual std::string getContents();

    private:
        Color computeColorFromNeighbors(const VecMath::Vector<4> &x);
        std::pair<std::vector<VecMath::Vector<4> >, std::vector<double> >
                findClosestPoints(const VecMath::Vector<4> &, unsigned = 5);
        Color averageColors(const std::vector<Color> &);

        colormap col; 
};

namespace {
    ColorManager *createXYZ2RGB() { return new xyz2RGBColorManager(); }
    const bool registeredC0 =
            ColMgrMgr::Instance().registerColorManager("XYZ to RGB", createXYZ2RGB);
}


class Fastxyz2RGBColorManager: public ColorManager {
    public:
        Fastxyz2RGBColorManager();

        Fastxyz2RGBColorManager(Displayable *);

        virtual ~Fastxyz2RGBColorManager() { }

        virtual void setFunction(Displayable *);

        virtual void calibrateColor(const VecMath::Vector<4> &,
                                    const Color & = Color());

        virtual Color getColor(const VecMath::Vector<4> &);

        virtual void depthCueColor(double wmax, double wmin, double w,
                                   const VecMath::Vector<4> &);

        virtual std::string getContents();

    private:
        float _xmin;            
        float _xmax;            
        float _ymin;            
        float _ymax;            
        float _zmin;            
        float _zmax;            
        float _wmin;            
        float _wmax;            

        float _opacityRange;    
};

namespace {
    ColorManager *createFastXYZ2RGB() { return new Fastxyz2RGBColorManager(); }
    const bool registeredC1 =
            ColMgrMgr::Instance().registerColorManager("XYZ to RGB (fast)", createFastXYZ2RGB);
}


class depth2RGBColorManager: public ColorManager {
    public:
        depth2RGBColorManager(): ColorManager(), _wmin(1e6), _wmax(-1e6) { }


        depth2RGBColorManager(Displayable *_f):
            ColorManager(_f), _wmin(1e6), _wmax(-1e6) { }

        virtual ~depth2RGBColorManager() { }

        virtual void setFunction(Displayable *);

        virtual void calibrateColor(const VecMath::Vector<4> &,
                                    const Color & = Color());

        virtual Color getColor(const VecMath::Vector<4> &);

        virtual void depthCueColor(double, double, double,
                                   const VecMath::Vector<4> &);

        virtual std::string getContents();

    private:
        Color computeColorFromW(double);

        double _wmin;   
        double _wmax;   
};

namespace {
    ColorManager *createDepth2RGB() { return new depth2RGBColorManager(); }
    const bool registeredC2 =
            ColMgrMgr::Instance().registerColorManager("W coordinate to RGB",
                                                       createDepth2RGB);
}


class monochromeColorManager: public ColorManager {
    public:
        monochromeColorManager(): ColorManager() { }


        monochromeColorManager(Displayable *_f): ColorManager(_f) { }

        virtual ~monochromeColorManager() { }

        virtual void calibrateColor(const VecMath::Vector<4> &,
                                    const Color & = Color()) { }

        virtual Color getColor(const VecMath::Vector<4> &) {
            return Color(1., 1., 1.);
        }

        virtual void depthCueColor(double, double, double,
                                   const VecMath::Vector<4> &) { }
};

namespace {
    ColorManager *createMonochrome() { return new monochromeColorManager(); }
    const bool registeredC3 =
            ColMgrMgr::Instance().registerColorManager("Monochrome",
                                                       createMonochrome);
}

#endif