PColorMap.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include <stdlib.h>
#include "PColorMap.h"


PColorValue createColorValue(float value, const PString & color){
        size_t nbChannel(color.size());
        color_t red(0), green(0), blue(0), alpha(0);
        if(nbChannel >= 2lu){
                PString redHex(color.substr(0lu, 2lu));
                red = (color_t)strtol(redHex.c_str(), NULL, 16);
        }
        if(nbChannel >= 4lu){
                PString greenHex(color.substr(2lu, 2lu));
                green = (color_t)strtol(greenHex.c_str(), NULL, 16);
        }
        if(nbChannel >= 6lu){
                PString blueHex(color.substr(4lu, 2lu));
                blue = (color_t)strtol(blueHex.c_str(), NULL, 16);
        }
        if(nbChannel >= 8lu){
                PString alphaHex(color.substr(6lu, 2lu));
                alpha = (color_t)strtol(alphaHex.c_str(), NULL, 16);
        }
        return createColorValue(value, red, green, blue, alpha);
}


PColorValue createColorValue(float value, color_t red, color_t green, color_t blue, color_t alpha){
        PColorValue colorValue;
        colorValue.value = value;
        colorValue.r = red;
        colorValue.g = green;
        colorValue.b = blue;
        colorValue.a = alpha;
        return colorValue;
}


void getColorValue(color_t & red, color_t & green, color_t & blue, color_t & alpha, const PColorValue & color){
        red = color.r;
        green = color.g;
        blue = color.b;
        alpha = color.a;
}


void phoenix_interpolateColor(PColorValue & output, const PColorValue & colorMin, const PColorValue & colorMax, float value){
        float ratio((value - colorMin.value)/(colorMax.value - colorMin.value));
        
        output.r = colorMax.r*ratio + colorMin.r*(1.0f - ratio);
        output.g = colorMax.g*ratio + colorMin.g*(1.0f - ratio);
        output.b = colorMax.b*ratio + colorMin.b*(1.0f - ratio);
        output.a = colorMax.a*ratio + colorMin.a*(1.0f - ratio);
}


PColorValue phoenix_interpolateColor(const PColorValue & colorMin, const PColorValue & colorMax, float value){
        PColorValue out;
        phoenix_interpolateColor(out, colorMin, colorMax, value);
        return out;
}

PColorMap::PColorMap(){
        initialisationPColorMap();
}


PColorMap::PColorMap(const PColorMap & other){
        copyPColorMap(other);
}

PColorMap::~PColorMap(){
        
}


PColorMap & PColorMap::operator = (const PColorMap & other){
        copyPColorMap(other);
        return *this;
}


void PColorMap::addColor(float value, const PString & color){
        PColorValue colorValue = createColorValue(value, color);
        p_mapColor[value] = colorValue;
}


void PColorMap::addColor(float value, color_t red, color_t green, color_t blue, color_t alpha){
        PColorValue colorValue = createColorValue(value, red, green, blue, alpha);
        p_mapColor[value] = colorValue;
}


void PColorMap::interpolate(color_t & red, color_t & green, color_t & blue, float value) const{
        PColorValue out;
        interpolate(out, value);
        red = out.r;
        green = out.g;
        blue = out.b;
}


void PColorMap::interpolate(color_t & red, color_t & green, color_t & blue, color_t & alpha, float value) const{
        PColorValue out;
        interpolate(out, value);
        red = out.r;
        green = out.g;
        blue = out.b;
        alpha = out.a;
}


void PColorMap::interpolate(PColorValue & output, float value) const{
        if(p_mapColor.size() == 0lu){return;}   //No color
        PMapColorValue::const_iterator itMin(p_mapColor.begin());
        if(value <= itMin->second.value){       //If the value is smaller than the first colored one
                output = itMin->second;         //We copy this value
                return;
        }
        PMapColorValue::const_reverse_iterator rit(p_mapColor.rbegin());
        if(value >= rit->second.value){ //If the value is greater than the last colored one
                output = rit->second;           //We copy this value
                return;
        }
        PMapColorValue::const_iterator itMax(itMin);
        ++itMax;
        while(itMax != p_mapColor.end()){
                if(value >= itMin->second.value && value < itMax->second.value){
                        phoenix_interpolateColor(output, itMin->second, itMax->second, value);
                        break;
                }
                ++itMax;
                ++itMin;
        }
}


void PColorMap::copyPColorMap(const PColorMap & other){
        p_mapColor = other.p_mapColor;
}

void PColorMap::initialisationPColorMap(){
        
}