map.hpp

Go to the documentation of this file.

#ifndef GENESIS_UTILS_COLOR_MAP_H_
#define GENESIS_UTILS_COLOR_MAP_H_
 
/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2024 Lucas Czech
 
    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 3 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, see <http://www.gnu.org/licenses/>.
 
    Contact:
    Lucas Czech <lczech@carnegiescience.edu>
    Department of Plant Biology, Carnegie Institution For Science
    260 Panama Street, Stanford, CA 94305, USA
*/
 
#include "genesis/utils/color/color.hpp"
 
#include <cmath>
#include <limits>
#include <vector>
 
namespace genesis {
namespace utils {
 
// =================================================================================================
//     Forward Declarations
// =================================================================================================
 
class ColorNormalization;
 
// =================================================================================================
//     Color Map
// =================================================================================================
 
class ColorMap
{
public:
 
    // -------------------------------------------------------------------------
    //     Constructors and Rule of Five
    // -------------------------------------------------------------------------
 
    ColorMap() = default;
 
    explicit ColorMap( std::vector<Color> const& colors )
    {
        palette( colors );
    }
 
    ~ColorMap() = default;
 
    ColorMap(ColorMap const&) = default;
    ColorMap(ColorMap&&)      = default;
 
    ColorMap& operator= (ColorMap const&)     = default;
    ColorMap& operator= (ColorMap&&)      = default;
 
    // -------------------------------------------------------------------------
    //     Accessors
    // -------------------------------------------------------------------------
 
    Color const& mask_color() const
    {
        return mask_color_;
    }
 
    Color const& over_color() const
    {
        return over_color_;
    }
 
    Color const& under_color() const
    {
        return under_color_;
    }
 
    bool clip_under() const
    {
        return clip_under_;
    }
 
    bool clip_over() const
    {
        return clip_over_;
    }
 
    bool reverse() const
    {
        return reverse_;
    }
 
    // -------------------------------------------------------------------------
    //     Modificators
    // -------------------------------------------------------------------------
 
    ColorMap& mask_color( Color value )
    {
        mask_color_ = value;
        return *this;
    }
 
    ColorMap& over_color( Color value )
    {
        over_color_ = value;
        return *this;
    }
 
    ColorMap& under_color( Color value )
    {
        under_color_ = value;
        return *this;
    }
 
    ColorMap& clip( bool value )
    {
        clip_under_ = value;
        clip_over_  = value;
        return *this;
    }
 
    ColorMap& clip_under( bool value )
    {
        clip_under_ = value;
        return *this;
    }
 
    ColorMap& clip_over( bool value )
    {
        clip_over_ = value;
        return *this;
    }
 
    ColorMap& reverse( bool value )
    {
        reverse_ = value;
        return *this;
    }
 
    ColorMap& palette( std::vector<Color> const& value )
    {
        palette_ = value;
        return *this;
    }
 
    // -------------------------------------------------------------------------
    //     Palette
    // -------------------------------------------------------------------------
 
    std::vector<Color> const& palette() const
    {
        return palette_;
    }
 
    bool empty() const
    {
        return palette_.empty();
    }
 
    size_t size() const
    {
        return palette_.size();
    }
 
    Color color( size_t index ) const
    {
        if( palette_.size() == 0 ) {
            return Color();
        }
        return get_entry_( index % palette_.size() );
    }
 
    std::vector<Color> color_list( size_t n = 256 ) const;
 
    // -------------------------------------------------------------------------
    //     Mapping
    // -------------------------------------------------------------------------
 
    Color operator() ( double value ) const;
 
    std::vector<Color> operator() ( std::vector<double> const& values ) const;
 
    template <class ForwardIterator>
    std::vector<Color> operator()( ForwardIterator first, ForwardIterator last ) const
    {
        std::vector<Color> result;
        while( first != last ) {
            result.push_back( operator()( *first ) );
            ++first;
        }
        return result;
    }
 
    Color operator() ( ColorNormalization const& norm, double value ) const;
 
    std::vector<Color> operator() (
        ColorNormalization const& norm, std::vector<double> const& values
    ) const;
 
    template <class ForwardIterator>
    std::vector<Color> operator()(
        ColorNormalization const& norm,
        ForwardIterator first,
        ForwardIterator last
    ) const {
        std::vector<Color> result;
        while( first != last ) {
            result.push_back( operator()( norm, *first ) );
            ++first;
        }
        return result;
    }
 
    // -------------------------------------------------------------------------
    //     Internal Functions
    // -------------------------------------------------------------------------
 
private:
 
    Color get_entry_( size_t index ) const
    {
        if( reverse_ ) {
            index = palette_.size() - index - 1;
        }
        return palette_[ index ];
    }
 
    // -------------------------------------------------------------------------
    //     Data Members
    // -------------------------------------------------------------------------
 
private:
 
    Color mask_color_  = { 1.0, 1.0, 0.0 };
    Color over_color_  = { 1.0, 0.0, 1.0 };
    Color under_color_ = { 0.0, 1.0, 1.0 };
 
    bool clip_under_ = false;
    bool clip_over_  = false;
    bool reverse_    = false;
 
    std::vector<Color> palette_;
 
};
 
} // namespace utils
} // namespace genesis
 
#endif // include guard