colorpal.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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 software 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 software; see the file "license.txt". If not,
// please, see <https://www.gnu.org/licenses/>.
 
// Started on February 14, 2007. Last revision: February 20, 2022.
 
 
#ifndef _CHOMP_BITMAPS_COLORPAL_H_
#define _CHOMP_BITMAPS_COLORPAL_H_
 
#include "chomp/system/config.h"
 
namespace chomp {
namespace homology {
 
 
// --------------------------------------------------
// ----------------- Color Palette ------------------
// --------------------------------------------------
 
class ColorPalette
{
public:
        ColorPalette (int _n, bool grays = false, bool pycolors = false);
 
        ~ColorPalette ();
 
        int operator [] (int i) const;
 
private:
        ColorPalette (const ColorPalette &src);
 
        ColorPalette &operator = (const ColorPalette &src);
 
        static int generateComponent (int bitMask);
 
        int n;
 
        int *colors;
 
}; /* ColorPalette */
 
// --------------------------------------------------
 
inline int ColorPalette::generateComponent (int bitMask)
{
        int mask = 0x100;
        int result = 1;
        while (mask && bitMask)
        {
                if (bitMask & 1)
                        result = mask;
                mask >>= 1;
                bitMask >>= 3;
        }
        return (result - 1) & 0xFF;
} /* ColorPalette::generateComponent */
 
inline ColorPalette::ColorPalette (int _n, bool grays, bool pycolors):
        n (_n), colors (0)
{
        if (n <= 0)
                return;
        colors = new int [n];
 
        if (grays)
        {
                for (int i = 0; i < n; ++ i)
                {
                        int shade = i * 255 / n;
                        colors [i] = shade | (shade << 8) | (shade << 16);
                }
                return;
        }
 
        // prepare a collection of nice colors (previous version)
        const int niceCountPrevious = 14;
        const int niceColorsPrevious [niceCountPrevious] = {
                0x000000, 0x0000FF, 0xFF0000, 0x00FF00,
                0x00FFFF, 0xFF00FF, 0x7F007F, 0xFF7F00,
                0x007F00, 0x7F7F7F, 0xAFAFAF, 0x00007F,
                0x7F00FF, 0xFFFF00,
        };
 
        // prepare a collection of nice colors (Python-like version)
        // (note: pycolors.py)
        const int niceCountPython = 44;
        const int niceColorsPython [niceCountPython] = {
                0x1F77B4, 0x2CA02C, 0x9467BD, 0x8C564B,
                0xE377C2, 0x7F7F7F, 0x17BECF, 0xBCBD22,
                0xFF7F0E, 0xD62728, 0x1B9E77, 0xFFD92F,
                0x5254A3, 0x637939, 0x8C6D31, 0xBD9E39,
                0xE7BA52, 0xE7CB94, 0x9C9ED3, 0x8CA252,
                0x6B6ECF, 0xB5CF8B, 0xCEDB9C, 0xD6616B,
                0xE7969C, 0xA55194, 0xDE9ED6, 0x6BAED6,
                0x9ECAE1, 0xE65503, 0xFDAE6B, 0x74C476,
                0xA1D99B, 0x756BB1, 0x9E9AC8, 0xBCBDDC,
                0x636363, 0x909090, 0xC7C7C7, 0x843C39,
                0x7B4173, 0xCE6DBD, 0xAD494A, 0x393B79,
        };
 
        int niceCount = pycolors ? niceCountPython : niceCountPrevious;
 
        int counter = 1;
        int pos = 0;
        while (pos < n)
        {
                // take a nice color if possible
                if (pos < niceCount)
                {
                        colors [pos] = (pycolors ? niceColorsPython :
                                niceColorsPrevious) [pos];
                        ++ pos;
                        continue;
                }
 
                // create a color based on the current counter
                int red = generateComponent (counter >> 1);
                int green = generateComponent (counter >> 2);
                int blue = generateComponent (counter);
                int color = (red << 16) | (green << 8) | blue;
 
                // check whether this color has already appeared before
                bool repeated = false;
                for (int i = 0; i < pos; ++ i)
                {
                        if (colors [i] == color)
                        {
                                repeated = true;
                                break;
                        }
                }
 
                // if the color is not repeated and it is not white then ok
                if (!repeated && (color != 0xFFFFFF) && (color != 0xFFFF7F))
                        colors [pos ++] = color;
                ++ counter;
        }
 
        return;
} /* ColorPalette::ColorPalette */
 
inline ColorPalette::~ColorPalette ()
{
        if (colors)
                delete [] colors;
        return;
} /* ColorPalette::~ColorPalette */
 
inline ColorPalette::ColorPalette (const ColorPalette &)
{
        return;
} /* ColorPalette::ColorPalette */
 
inline ColorPalette &ColorPalette::operator = (const ColorPalette &)
{
        return *this;
} /* ColorPalette::operator = */
 
inline int ColorPalette::operator [] (int i) const
{
        if ((i < 0) || (i >= n))
                return 0;
        else
                return colors [i];
} /* ColorPalette::operator [] */
 
 
} // namespace homology
} // namespace chomp
 
#endif // _CHOMP_BITMAPS_COLORPAL_H_