mod_fem_viewer/FemViewer/inc/Legend.h

Go to the documentation of this file.

#ifndef _LEGEND_H_
#define _LEGEND_H_

#include <string>
#include <vector>
#include <memory>
#include "fv_config.h"
#include "LegendValue.h"
#include "MathHelper.h"
#include "Color.h"
#include "ColorBar.h"
#include "GraphicElem.hpp"

namespace FemViewer {


/* Type of color map */
enum LegendType
{
    // Default colored style
    SOLID    = 0,
    GRADIENT = 1
};

template<typename T>
struct LegendData {
    fvmath::Vec3<T> color;
    int   numBrreaks;
    T     startValue;
    T     deltaValue;
};


class Legend
{
  private:
    // Default number of bounds of legend
    static const int _ncont = 20;
    // Default legend type
    static const LegendType _dftype = GRADIENT;
    // Handle to GL representation
    std::shared_ptr<ColorBar> _hBar;
    // Minimal and maximal values stored for legend
    double  _min, _max;
    // Begin and end of values in [_min, _max] range
    double  _start, _end;
    // Current number of ranges
    unsigned int _nranges;
    // Legend type
    LegendType _type;
    // Whether the color black is the color outside [_start,_end] range
    bool _outsideBlack;
    // Status of a legend
    bool _ok;
    // list of color ranges
    std::vector<colormap_value> _colors;

  public:
    // Current legend color and value
    colormap_value color;

  public:
    // Ctrs and dtr
    explicit Legend();
    explicit Legend(const Legend & legend);
    explicit Legend(const std::string& path);
    ~Legend();
    // Operators
    Legend & operator=(const Legend & legend);
    bool operator ==(const Legend& rhs) const;
    void Reset();
    // Accessors
    double GetMin() const  { return _min; }
    double GetMax() const  { return _max; }
    double GetStart() const { return _start; }
    double GetEnd() const  { return _end; }
    unsigned int GetRangesNumber(void) const { return _nranges;}
    LegendType GetLegendType(void) const { return _type; }
    bool GetOutsideBlack(void) const {return this->_outsideBlack; };
    bool IsValid() const { return _ok; }
    std::vector<colormap_value>& GetColors() { return _colors; }
    const std::vector<colormap_value>& GetColors() const { return _colors; }
    template<typename T> int PackValuesIntoArray(T buffer[][4],const int max_size) const;

    // Setters
    void SetMin(double minValue) {
        if (_min != minValue)
            Set(minValue,_max,_start,_end,_nranges,_type,_outsideBlack);
    }
    void SetMax(double maxValue) {
        if (_max != maxValue)
            Set(_min,maxValue,_start,_end,_nranges,_type,_outsideBlack);
    }
    void SetStart(double startValue) {
        if (_start != startValue)
        Set(_min,_max,startValue,_end,_nranges,_type,_outsideBlack);
    }
    void SetEnd(double endValue) {
        if (_end != endValue)
            Set(_min,_max,_start,endValue,_nranges,_type,_outsideBlack);
    }
    void SetRange(unsigned int numRanges) {
        if (_nranges != numRanges)
            Set(_min,_max,_start,_end,numRanges,_type,_outsideBlack);
    }
    void SetType(LegendType type) {
        if (_type != type)
            Set(_min,_max,_start,_end,_nranges,type,_outsideBlack);
    }
    void SetOutsideBlack(bool outsideBlack) {
        if (_outsideBlack != outsideBlack)
            Set(_min,_max,_start,_end,_nranges,_type,outsideBlack);
    }

    void Draw(void)   { assert(_hBar); _hBar->Draw(); }
    void Update(void) { assert(_hBar); _hBar->Create(this); }
    void Create(void);
    // Set legend parameters
    void Set(double minValue = 0.0,
             double maxValue = 1.0,
             double startValue = 0.0,
             double endValue = 1.0,
             unsigned int rangesNumber = _ncont,
             LegendType legendType = _dftype,
             bool outsideBlack = false);


    //unsigned int GetBordersCount(void)
    int GetLiczbaGranic(void) const
    {
        if (_type == SOLID) {
            unsigned int a = _colors.size() - 1;
            a >>= 1; // /= 2;
            return ++a;
        }
        else if (_type == GRADIENT) {
            return (int)_colors.size();
        }

        return(-1);
    }

    double GetWartoscGranicy(const unsigned int &i) const
    {

        if (_type == SOLID) {
            return _colors[(i << 1)].value;
        }

        return _colors[i].value;
    }



        int IsBorderNr(double value) const;



        std::vector<ColorRGB> GetColors(const std::vector<double> & vValues);


        //bool GetColors(GraphElement2<double> & ge2) const;

        //podajemy wektor graficznyc elementow i dla kazego elementuwektora wykonywana jest
        //opcja podawania koloru
        //bool GetColors(std::vector< GraphElement2<double> > & ge2) const;


        //void GetRanges(const double & d, std::vector<unsigned int> & vUi);
        std::vector<unsigned int> GetRanges(const double & d) const;

        int GetRanges(const double & v1, const double & v2) const;

        void GetRangeValues(unsigned int i, double & v1, double & v2) const;

        size_t GetRangesSize(void) const;



        bool GetColor(const double & value, const unsigned int & range, ColorRGB & c) const;

    /*
        //zwraca 0 dla zera, 1 dla koloru
        unsigned int GetType(void)
        {

            switch(this->legendType)
            {
                case COLOR:
                    return 0;
                case GRADIENT:
                    return 1;
            }

        }
    */


    public:
        void GetRange3(const unsigned int & range, double & sValue, ColorRGB & sColor, double & eValue, ColorRGB & eColor);
    protected:
        void GetRangeColor(const unsigned int & range, double & sValue, ColorRGB & sColor, double & eValue, ColorRGB & eColor);
        void GetRangeGradient(const unsigned int & range, double & sValue, ColorRGB & sColor, double & eValue, ColorRGB & eColor);
    public:


        void GetRange(const unsigned int & range, double & sValue, ColorRGB & sColor, double & eValue, ColorRGB & eColor)
        {
            if (range >= this->_colors.size())
                return;


            unsigned int rangeStart, rangeEnd;

            rangeStart = range;
            rangeEnd = range+1;

            sValue = _colors[rangeStart].value;
            eValue = _colors[rangeEnd].value;

            if ( (_colors[rangeStart].type & INSIDE) && (_colors[rangeEnd].type & INSIDE)   )
            {

                #ifdef DEBUG2
                    cout << endl << "*IN*" << endl;
                #endif
                //jesli obie granice s a wewnetrzne


                //w zaleznosci od ustawienia rodzaju legendy
                if (_type == SOLID)
                {
                    //jednolitym - czyli wartosc koloru pierwszego ??
                    sColor = _colors[rangeStart].GetColor();
                    eColor = _colors[rangeStart].GetColor();


                }
                else if  (_type == GRADIENT)
                {
                    //gradientem-przejsciem od do
                    sColor = _colors[rangeStart].GetColor();
                    eColor = _colors[rangeEnd].GetColor();


                }


            }
            else if ( (_colors[rangeStart].type & OUTSIDE) && (_colors[rangeEnd].type & OUTSIDE)   )
            {
                #ifdef DEBUG2
                    cout << endl << "*OUT*" << endl;
                #endif
                //jesli obie granice sa zewnetrzne

                //jesli wlaczony czarny to
                if (_outsideBlack)
                {
                    //jesli czarny
                    sColor = ColorRGB();
                    eColor = ColorRGB();
                }
                else
                {
                    //jesli wlaczony kolor to

                    //nalezy sprawdzic czy obie wartosci sa mniejszcze od start czy wieksze od end
                        //jesli mniejsze to kolor start
                        //jesli wieksze to kolor end
                    if ( ( _colors[rangeStart].value < _start ) && ( _colors[rangeEnd].value < _start) )
                    {
                        int i = GetStartIndex();
                        sColor = _colors[i].GetColor();
                        eColor = _colors[i].GetColor();

                    }
                    else if ( ( _colors[rangeStart].value > _end ) && ( _colors[rangeEnd].value > _end) )
                    {
                        int i = GetEndIndex();
                        sColor = _colors[i].GetColor();
                        eColor = _colors[i].GetColor();
                    }
                }
            }
            else
            {
                #ifdef DEBUG2
                    cout << endl << "*INOUT*" << endl;
                #endif
                //ostatni przypadek jesli jedna wew a druga zew
                if (_outsideBlack)
                {
                    //jesli czarny
                    sColor = ColorRGB(0.0, 0.0, 0.0);
                    eColor = ColorRGB(0.0, 0.0, 0.0);
                }
                else
                {
                    //jesli wlaczony kolor to

                    //sprawdzeie ktory jest inside i pobranie jego kolrow
                    if (_colors[rangeStart].type & INSIDE)
                    {
                        sColor = _colors[rangeStart].GetColor();
                        eColor = _colors[rangeStart].GetColor();
                    }
                    else if (_colors[rangeEnd].type & INSIDE)
                    {
                        sColor = _colors[rangeEnd].GetColor();
                        eColor = _colors[rangeEnd].GetColor();
                    }

                }//if (outsideBlack)
            }//else
        };

        //z sugerownaniem przedzialu,
        //jesli jest granica i na do wyboru dwie wartosci
        //a jedna z nich jest zgodna z sugerowana to wtedy wybiera sugerowana
        //jesli przedzial gugerowany jest niezgodny z zadna z wartosci to wybiera pierwsza


        double GetInterp(double value);

        double GetInterp(double a, double b, double value) const;

        double GetValue(double a, double b, double interp) const;






        void GetBorders(const double &s, const double &e, std::vector<double> &vD) const
        {

            double dTmp;

            vD.clear();

            vD.push_back(s);

            //sprawdzenie czy sa sobie rowne
            if ( fvmath::Compare(s,e) )
            {
                vD.push_back(e);
                return;
            }

            //sprawdzenie czy s i e sa w tej samej granicy
            if ( GetRanges(s, e) >= 0  )
            {
                vD.push_back(e);
                return;
            }

            if (s < e)
            {
                //#ifdef DEBUG4
                //    cout << "<" << endl;
                //#endif
                //vD.push_back(s);
                for (int i = 0; i < GetLiczbaGranic(); ++i)
                {
                    dTmp = GetWartoscGranicy(i);

                    if (  (dTmp > s) && (dTmp < e)  )
                        vD.push_back(dTmp);
                }
                //vD.push_back(e);
            }
            else if (s > e)
            {
                //#ifdef DEBUG4
                //    cout << ">" << endl;
                //#endif
                //vD.push_back(s);

                //for (unsigned int i = 0; i < GetLiczbaGranic(); ++i)
                for (int i = GetLiczbaGranic(); i > 0; --i)
                {
                    dTmp = GetWartoscGranicy(i-1);

                    //if (  (dTmp > e) && (dTmp < s)  )
                    //if (  (dTmp < s) && (dTmp > e)  )

                    //#ifdef DEBUG4
                    //    cout << dTmp << "<" << s << " && " << dTmp<< ">"<< e ;
                    //#endif

                    //if (  (s > dTmp) && (dTmp > e)  )
                    if (  (dTmp < s) && (dTmp > e)  )
                    {
                        vD.push_back(dTmp);
                        //#ifdef DEBUG4
                        //    cout << " tak";
                        //#endif
                    }
                    //cout << endl;
                }

                //vD.push_back(e);

            }
            vD.push_back(e);

        };









    protected:



    public:
        bool GetRangesBorder(const double & value, double & s, double &e) const;

        bool IsBorder2(double value) const;

        bool IsBorder3(double value) const;

    protected:


        void MinMaxPos(int & mi, int & mx);

        void FillStartEndColor(void);

        void FillStartEndGradient(void);

        void AddMinMaxColor(void);

        void AddMinMaxGradient(void);




    //protected:
    public:


            //sprawdzenie czy min i max sa w odpowiedzeniej kolejnisci i to samo dla start end

        //void SetMinMax2(double min, double max);

        //ustawienia domysle z parametrami min, max
        //jaki start, end ustawia odpowiedni min, max
        //z podzialem na ilosc elementow i ustaleniem na tryb kolor lub gradient


        //void SetDefault(double min, double max, double start, double end, unsigned int rangesNumber, LegendType legendType, bool outsideBlack);


        //void SetMinMax
        //(
        //double min,
        //double max
        //);

        //int SetMinMax(double min, double max, double start, double end, unsigned int num);

        //unsigned int GetIndex(double value);

        int GetIndexMax(void){return (int)_colors.size();};

        void GetColor(double value);

        // Get 3 byte color
        float GetColor3b(double value) {
            GetColor(value, color);
            return color.rgb.r + color.rgb.g*256.0 + color.rgb.b*256.0*256.0;
        }

        double GetValue(const ColorRGB& rgb);

        void GetColor(double value, colormap_value &lv);

        bool IsBorder(double value);



        bool IsInStartEnd(double value);


        int GetStartIndex(void)
        {
            for (unsigned int i = 0; i < _colors.size(); ++i)
            {
                if (_colors[i].type ==  START)
                    return i;
            }
            return -1;
        }

        int GetEndIndex(void)
        {

            for (unsigned int i = 0; i < _colors.size(); ++i)
            {
                if (_colors[i].type ==  END)
                    return i;
            }
            return -1;

        };

    public:

        void GetInterval(double valueStart, double valueEnd);

#ifdef DEBUG
        void Dump()
        {
            std::cout   << "Legend"
                        << "\n\tColor:\t\t\t" << color.AsString()
                        << "\n\tType:\t\t\t" << (_type ? "GRADIENT" : "SOLID")
                        << "\n\tMin/Max value:\t\t" << _min << " | " << _max
                        << "\n\tStart/End value:\t" << _start << " | " << _end
                        << "\n\t# of ranges\t\t" << _nranges
                        << "\n\tIs ou black:\t\t" << (_outsideBlack ? "TRUE" : "FALSE")
                        << std::endl;


        }
#endif
    public:


};

template<typename T>
int Legend::PackValuesIntoArray(T buffer[][4],const int max_size) const
{
    if (buffer == nullptr) return(-1);

    int num = static_cast<int>(_colors.size());
    num = num > max_size ? max_size : num;
    for (int i = 0; i < num; ++i) {
        buffer[i][0] = _colors[i].rgb.r;
        buffer[i][1] = _colors[i].rgb.g;
        buffer[i][2] = _colors[i].rgb.b;
        buffer[i][3] = static_cast<float>(_colors[i].value);
        //buffer[i] = static_cast<float>(_colors[i].value);
        //printf("value%d = %f\n",i,buffer[i][3]);
    }
    return num;
}




} // end namespace FemViewer

#endif /* _LEGEND_H_
  */

---