Colormap.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_COLORMAP_H_
#define _MIRA_COLORMAP_H_

#include <factory/Factory.h>
#include <image/Color.h>

namespace mira {


class MIRA_BASE_EXPORT Colormap : public Object
{
    MIRA_ABSTRACT_OBJECT(Colormap)
public:

    virtual std::size_t size() const = 0;

    virtual Color::RGB get(std::size_t idx) const = 0;

    Color::RGB operator()(std::size_t idx) {return get(idx);}

    Color::RGB operator[](std::size_t idx) {return get(idx);}

public:

    class iterator
    {
    public:
        typedef Color::RGB value_type;
        typedef int difference_type;

        typedef const Color::RGB* pointer;
        typedef const Color::RGB& reference;
        typedef std::bidirectional_iterator_tag iterator_category;

    protected:
        friend class Colormap;
        iterator(const Colormap* colormap, std::size_t position) :
        mColormap(colormap), mPosition(position) {}

    public:
        iterator() : mColormap(NULL), mPosition(0) {}
        iterator(const iterator& other) :
        mColormap(other.mColormap), mPosition(other.mPosition) {}

    public:

        iterator& operator++() { // pre-increment
            ++mPosition;
            return *this;
        }

        iterator operator++(int) { // post-increment
            iterator old = *this;
            mPosition++;
            return old;
        }

        iterator& operator--() { // pre-decrement
            --mPosition;
            return *this;
        }

        iterator operator--(int) { // post-decrement
            iterator old = *this;
            mPosition--;
            return old;
        }

        bool operator==(const iterator& other) {
            return mColormap==other.mColormap && mPosition==other.mPosition;
        }

        bool operator!=(const iterator& other) {
            return !operator==(other);
        }

    public:

        reference operator*() const {
            assert(mColormap!=NULL);
            mCache = mColormap->get(mPosition);
            return mCache;
        }

        pointer operator->() const {
            assert(mColormap!=NULL);
            mCache = mColormap->get(mPosition);
            return &mCache;
        }

    private:
        const Colormap* mColormap;
        std::size_t mPosition;
        mutable Color::RGB mCache;
    };

    typedef iterator const_iterator;

public:

    iterator begin() {return iterator(this,0);}

    const_iterator begin() const {return const_iterator(this,0);}

    iterator end() {return iterator(this,size());}

    const_iterator end() const {return const_iterator(this,size());}
};


class MIRA_BASE_EXPORT DiscreteColormap : public Colormap
{
    MIRA_ABSTRACT_OBJECT(DiscreteColormap)
};


class MIRA_BASE_EXPORT ContinuousColormap : public Colormap
{
    MIRA_ABSTRACT_OBJECT(ContinuousColormap)
public:
    ContinuousColormap(std::size_t size=256) : mSize(size) {}

public:

    void resize(std::size_t pSize) {mSize=pSize;}

    virtual std::size_t size() const {return mSize;}

    virtual Color::RGB get(std::size_t idx) const {
        return getf((float)idx / (float)size());}

public:

    virtual Color::RGB getf(float f) const = 0;

private:
    std::size_t mSize;
};

class MIRA_BASE_EXPORT GradientColormapBase : public ContinuousColormap
{
public:

    GradientColormapBase(std::size_t size) : ContinuousColormap(size) {}

    virtual Color::RGB getf(float f) const;

protected:

    void setColorAt(float position, const Color::RGB& color);

    void setColorAt(float position, int r, int g, int b) {
        setColorAt(position, Color::RGB(r/255.0f,g/255.0f,b/255.0f));
    }


    void clear();

private:
    std::map<float, Color::RGB> mColorKeys;
};

class MIRA_BASE_EXPORT GradientColormap : public GradientColormapBase
{
public:

    GradientColormap(std::size_t size=256) : GradientColormapBase(size) {}

    void setColorAt(float position, const Color::RGB& color) {
        GradientColormapBase::setColorAt(position, color);
    }

    void clear() {
        GradientColormapBase::clear();
    }
};


class MIRA_BASE_EXPORT FormulaeColormapBase : public ContinuousColormap
{
public:

    FormulaeColormapBase(std::size_t size) : ContinuousColormap(size),
        mRFormula(7),mGFormula(5),mBFormula(15) {}

    virtual Color::RGB getf(float f) const;

protected:

    void setFormulae(int rformula, int gformula, int bformula);

private:
    int mRFormula, mGFormula, mBFormula;
};

class MIRA_BASE_EXPORT FormulaeColormap : public FormulaeColormapBase
{
public:

    FormulaeColormap(std::size_t size=256) : FormulaeColormapBase(size) {}

    FormulaeColormap(int rformula, int gformula, int bformula, std::size_t size=256) : FormulaeColormapBase(size) {
        setFormulae(rformula, gformula, bformula);
    }

    void setFormulae(int rformula, int gformula, int bformula) {
        FormulaeColormapBase::setFormulae(rformula, gformula, bformula);
    }
};


class MIRA_BASE_EXPORT TabularColormap : public DiscreteColormap
{
    MIRA_OBJECT(TabularColormap)
public:

    TabularColormap(const uint8* pData, std::size_t pSize) :
        mData(pData), mSize(pSize) {}

    virtual std::size_t size() const {return mSize;}

    virtual Color::RGB get(std::size_t idx) const {
        return Color::RGB((float)mData[idx*3]/255.0f,
                          (float)mData[idx*3+1]/255.0f,
                          (float)mData[idx*3+2]/255.0f);
    }

private:
    const uint8* mData;
    std::size_t mSize;
};


class MIRA_BASE_EXPORT GrayscaleColormap : public ContinuousColormap
{
    MIRA_OBJECT(GrayscaleColormap)
public:

    GrayscaleColormap(std::size_t size=256) : ContinuousColormap(size) {}

    static Color::RGB sGetf(float f)
    {
        if(f<=0.0f)
            return Color::RGB(0,0,0);
        if(f<=1.0f)
            return Color::RGB(f,f,f);

        return Color::RGB(1.0f,1.0f,1.0f);
    }

    virtual Color::RGB getf(float f) const {
        return GrayscaleColormap::sGetf(f);
    }

};


class MIRA_BASE_EXPORT HSVColormap : public ContinuousColormap
{
    MIRA_OBJECT(HSVColormap)
public:

    HSVColormap(std::size_t size=256) : ContinuousColormap(size) {}

    static Color::RGB sGetf(float f)
    {
        /*
         0.0000 - 1   0   0
         0.1667 - 1   1   0
         0.3333 - 0   1   0
         0.5000 - 0   1   1
         0.6667 - 0   0   1
         0.8333 - 1   0   1
         1.0000 - 1   0   0
         */

        if(f<=0.0f)
            return Color::RGB(1,0,0);
        if(f<=0.1667f)
            return Color::RGB(1,f*6,0);
        if(f<=0.3333f)
            return Color::RGB(1-(f-0.1667f)*6,1,0);
        if(f<=0.5000f)
            return Color::RGB(0,1,(f-0.3333f)*6);
        if(f<=0.6667f)
            return Color::RGB(0,1-(f-0.5000f)*6,1);
        if(f<=0.8333f)
            return Color::RGB((f-0.6667f)*6,0,1);
        if(f<=1.0000f)
            return Color::RGB(1,0,1-(f-0.8333f)*6);

        return Color::RGB(1,0,0);
    }

    virtual Color::RGB getf(float f) const
    {
        return HSVColormap::sGetf(f);
    }
};


class MIRA_BASE_EXPORT JetColormap : public ContinuousColormap
{
    MIRA_OBJECT(JetColormap)
public:

    JetColormap(std::size_t size=256) : ContinuousColormap(size) {}

    static Color::RGB sGetf(float f)
    {
        /*
         0.000 - 0   0   0.5
         0.125 - 0   0   1.0
         0.375 - 0   1.0 1.0
         0.625 - 1.0 1.0 0.0
         0.875 - 1.0 0.0 0.0
         1.000 - 0.5 0.0 0.0
         */

        if(f<=0.0f)
            return Color::RGB(0,0,0.5f);
        if(f<=0.125f)
            return Color::RGB(0,0,0.5f+f*4.0f);
        if(f<=0.375f)
            return Color::RGB(0,(f-0.125f)*4.0f,1.0f);
        if(f<=0.625f) {
            float alpha = (f-0.375f)*4.0f;
            return Color::RGB(alpha,1.0f,1.0f-alpha);
        }
        if(f<=0.875f)
            return Color::RGB(1.0f,1.0f-(f-0.625f)*4.0f,0.0f);
        if(f<=1.0f)
            return Color::RGB(1.0f-(f-0.875f)*4,0.0f,0.0f);

        return Color::RGB(0.5f,0,0);
    }

    virtual Color::RGB getf(float f) const
    {
        return JetColormap::sGetf(f);
    }
};


class MIRA_BASE_EXPORT RedBlueColormap: public ContinuousColormap {
    MIRA_OBJECT(RedBlueColormap)
public:

    RedBlueColormap(std::size_t size = 256) :
        ContinuousColormap(size) {
    }

    static Color::RGB sGetf(float f)
    {
        if (f < 0.0f)
            return Color::RGB(0.0f, 0.0f, 1.0f);
        if (f < 1.0f)
            return Color::RGB(f, 0.0f, 1.0f - f);
        return Color::RGB(1.0f, 0.0f, 0.0f);
    }

    virtual Color::RGB getf(float f) const {
        return RedBlueColormap::sGetf(f);
    }
};


class MIRA_BASE_EXPORT Pm3dColormap: public FormulaeColormapBase {
    MIRA_OBJECT(Pm3dColormap)
public:
    Pm3dColormap(std::size_t size=256);
};


class MIRA_BASE_EXPORT Complementary10Colormap : public TabularColormap
{
    MIRA_OBJECT(Complementary10Colormap)
public:
    Complementary10Colormap() : TabularColormap(colormap, 10) {}
private:
    const static uint8 colormap[3*10];
};


class MIRA_BASE_EXPORT Complementary6Colormap : public TabularColormap
{
    MIRA_OBJECT(Complementary6Colormap)
public:
    Complementary6Colormap() : TabularColormap(colormap, 6) {}
private:
    const static uint8 colormap[3*6];
};

}

MIRA_NO_PUBLIC_DEFAULT_CONSTRUCTOR( mira::TabularColormap )

#endif