chomp::homology::ColorPalette Class Reference

Provides a palette of distinct RGB colors. More...

#include <colorpal.h>

Public Member Functions
	ColorPalette (int _n, bool grays=false, bool pycolors=false)
	The constructor of a palette of a prescribed size. More...
	~ColorPalette ()
	The destructor. More...
int	operator[] (int i) const
	Returns the color with the given number. More...

Private Member Functions
	ColorPalette (const ColorPalette &src)
	The copy constructor is not allowed. More...
ColorPalette &	operator= (const ColorPalette &src)
	The assignment operator is not allowed. More...

Static Private Member Functions
static int	generateComponent (int bitMask)
	Generates a color component based on the bit mask. More...

Private Attributes
int	n
	The number of colors in the palette. More...
int *	colors
	The RBG colors in the palette. More...

Detailed Description

Provides a palette of distinct RGB colors.

The first color is black unless pycolors is set to true. If using the pycolors option, python-style color palette is provided. White is considered a background color and thus is not provided.

Definition at line 52 of file colorpal.h.

Constructor & Destructor Documentation

ColorPalette() [1/2]

chomp::homology::ColorPalette::ColorPalette ( int  _n, bool  grays = false, bool  pycolors = false  )

inline

The constructor of a palette of a prescribed size.

Definition at line 100 of file colorpal.h.

                                                                   :
        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 */

References colors, generateComponent(), and n.

~ColorPalette()

chomp::homology::ColorPalette::~ColorPalette ( )

inline

The destructor.

Definition at line 184 of file colorpal.h.

{
        if (colors)
                delete [] colors;
        return;
} /* ColorPalette::~ColorPalette */

References colors.

ColorPalette() [2/2]

chomp::homology::ColorPalette::ColorPalette ( const ColorPalette &  src )

inlineprivate

The copy constructor is not allowed.

Definition at line 191 of file colorpal.h.

{
        return;
} /* ColorPalette::ColorPalette */

Member Function Documentation

generateComponent()

int chomp::homology::ColorPalette::generateComponent ( int  bitMask )

inlinestaticprivate

Generates a color component based on the bit mask.

The nonzero bits are every 3 locations in the mask.

Definition at line 86 of file colorpal.h.

{
        int mask = 0x100;
        int result = 1;
        while (mask && bitMask)
        {
                if (bitMask & 1)
                        result = mask;
                mask >>= 1;
                bitMask >>= 3;
        }
        return (result - 1) & 0xFF;
} /* ColorPalette::generateComponent */

Referenced by ColorPalette().

operator=()

ColorPalette & chomp::homology::ColorPalette::operator= ( const ColorPalette &  src )

inlineprivate

The assignment operator is not allowed.

Definition at line 196 of file colorpal.h.

{
        return *this;
} /* ColorPalette::operator = */

operator[]()

int chomp::homology::ColorPalette::operator[] ( int  i ) const

inline

Returns the color with the given number.

The color is encoded as 0xRRGGBB.

Definition at line 201 of file colorpal.h.

{
        if ((i < 0) || (i >= n))
                return 0;
        else
                return colors [i];
} /* ColorPalette::operator [] */

References colors, and n.

Member Data Documentation

colors

int* chomp::homology::ColorPalette::colors

private

The RBG colors in the palette.

Definition at line 80 of file colorpal.h.

Referenced by ColorPalette(), operator[](), and ~ColorPalette().

n

int chomp::homology::ColorPalette::n

private

The number of colors in the palette.

Definition at line 77 of file colorpal.h.

Referenced by ColorPalette(), and operator[]().

---

The documentation for this class was generated from the following file:

• chomp/bitmaps/colorpal.h