Graphics.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-or-later
/***********************************************************************************/
/*  Copyright 2011 WSL Institute for Snow and Avalanche Research    SLF-DAVOS      */
/***********************************************************************************/
/* This file is part of MeteoIO.
    MeteoIO is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    MeteoIO 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 Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public License
    along with MeteoIO.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef GRAPHICS_H
#define GRAPHICS_H
 
#include <meteoio/dataClasses/Array2D.h>
 
#include <vector>
 
namespace mio {
 
class Legend {
        public:
                Legend(const unsigned int &height, const double &minimum, const double &maximum);
 
                static unsigned int getLegendWidth();
 
                const Array2D<double> getLegend() const;
 
                static const double bg_color; 
                static const double text_color; 
 
        private:
                Array2D<double> grid;
                void simpleLegend(const unsigned int &height, const double &minimum, const double &maximum);
                void smartLegend(const unsigned int &height, const double &minimum, const double &maximum);
                void drawLegend(const unsigned int &height, const double &minimum, const double &maximum);
                void writeLine(const double& val, const unsigned int& px_row);
                void writeChar(const unsigned int i_char[10][6], const unsigned int& px_col, const unsigned int& px_row);
 
                static constexpr unsigned int char_width = 6;
                static constexpr unsigned int char_height = 10;
 
                static constexpr unsigned int text_chars_nb = 9; //each label will contain 9 chars
                static constexpr unsigned int char_space = 1; //horizontal space between two chars
                static constexpr unsigned int text_width = text_chars_nb*(char_width+char_space); //whole text line
                static constexpr unsigned int sample_width = char_width*1; //color sample 2 chars wide
                static constexpr unsigned int sample_text_space = 6; //width of the color sample
                static constexpr unsigned int legend_plot_space = char_width*1;
                static constexpr unsigned int total_width = legend_plot_space+sample_width+sample_text_space+text_width;
 
                static constexpr unsigned int interline = 5;
                static constexpr unsigned int label_height = char_height+interline; //1 char + interline
                static constexpr unsigned int nb_labels = 12+1; //every decile + 0 level
                static constexpr unsigned int total_height = nb_labels*label_height+interline;
 
                static const unsigned int font_0[10][6], font_1[10][6], font_2[10][6], font_3[10][6], font_4[10][6];
                static const unsigned int font_5[10][6], font_6[10][6], font_7[10][6], font_8[10][6], font_9[10][6];
                static const unsigned int font_plus[10][6], font_minus[10][6], font_dot[10][6], font_E[10][6];
};
 
namespace Color {
        void RGBtoHSV(const double& r, const double& g, const double& b, double &h, double &s, double &v);
 
        void HSVtoRGB(const double& h, const double& s, const double& v, double &r, double &g, double &b);
}
 
// Gradient class
//This class is the base class for the various gradients.
//DO NOT USE pure white in a gradient, since this might be interpreted as a transparent pixel!
//Gradients scale between 0 and 1, but might receive some out of range values for special effects (below sea level, above snow line, etc)
class Gradient_model {
        public:
                Gradient_model() : X(), v_h(), v_s(), v_v() {} //do not use this constructor!
                virtual ~Gradient_model() {}
                Gradient_model(const double& i_min, const double& i_max, const bool& i_autoscale) : X(), v_h(), v_s(), v_v() { (void)i_min; (void)i_max; (void)i_autoscale;}
                //setBgColor()
                //setFgColor()
 
                //val MUST be between 0 and 1
                virtual void getColor(const double &val, double &r, double &g, double &b) const;
        protected:
                double getInterpol(const double& val, const std::vector<double>& i_X, const std::vector<double>& i_Y) const;
                void HSV2RGB(const double& h, const double& s, const double& v, unsigned char &r, unsigned char &g, unsigned char &b) const;
 
                std::vector<double> X, v_h, v_s, v_v; 
};
 
class Gradient {
        public:
                typedef enum TYPE {
                            none, 
                            terrain, 
                            slope, 
                            azi, 
                            heat, 
                            freeze, 
                            blue_pink, 
                            pastel, 
                            bg_isomorphic, 
                            bluewhitered, 
                            whitetoblk, 
                            blktowhite, 
                            blue 
                } Type;
 
                Gradient() : min(0.), max(0.), delta(0.), type(none), model(nullptr), nr_unique_cols(0), autoscale(true) {}
 
                Gradient(const Type& i_type, const double& min_val, const double &max_val, const bool& i_autoscale);
 
                Gradient(const Gradient& c);
 
                ~Gradient() {delete model;}
 
                void set(const Type& i_type, const double& min_val, const double &max_val, const bool& i_autoscale);
                //setBgColor()
                //setFgColor()
 
                void setNrOfLevels(const unsigned char& i_nr_unique_levels);
 
                void getColor(const double &val, unsigned char &r, unsigned char &g, unsigned char &b, bool &a) const;
 
                void getColor(const double& val, unsigned char& index) const;
 
                void getPalette(std::vector<unsigned char> &palette, size_t &nr_colors) const;
 
                Gradient& operator=(const Gradient& source);
 
                static const unsigned char channel_max_color; 
        private:
                void setModel(const Type& i_type);
 
                double min, max, delta;
                Type type;
                Gradient_model *model;
                unsigned char nr_unique_cols; 
                static const unsigned char reserved_idx; 
                static const unsigned char reserved_cols; 
                bool autoscale;
};
 
class gr_heat : public Gradient_model {
        public:
                gr_heat(const double& i_min, const double& i_max, const bool& i_autoscale) {(void)i_min; (void)i_max; (void)i_autoscale;}
                void getColor(const double &i_val, double &r, double &g, double &b) const override;
};
 
class gr_blue_pink : public Gradient_model {
        public:
                gr_blue_pink(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_freeze : public Gradient_model {
        public:
                gr_freeze(const double& i_min, const double& i_max, const bool& i_autoscale);
                void getColor(const double &val, double &r, double &g, double &b) const override;
        private:
                //This gradient is interpolated in RGB color space
                std::vector<double> v_r, v_g, v_b; 
};
 
class gr_bluewhitered : public Gradient_model {
        public:
                gr_bluewhitered(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_whitetoblk : public Gradient_model {
        public:
                gr_whitetoblk(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_blktowhite : public Gradient_model {
        public:
                gr_blktowhite(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_blue : public Gradient_model {
        public:
                gr_blue(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_bg_isomorphic : public Gradient_model {
        public:
                gr_bg_isomorphic(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_terrain : public Gradient_model {
        public:
                gr_terrain(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_slope : public Gradient_model {
        public:
                gr_slope(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_azi : public Gradient_model {
        public:
                gr_azi(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
class gr_pastel : public Gradient_model {
        public:
                gr_pastel(const double& i_min, const double& i_max, const bool& i_autoscale);
};
 
} //namespace
#endif