plotmdec.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file plotmdec.h
///
/// Plotting a Morse decomposition in a PNG picture.
/// This file contains the definition of a procedure which can be used
/// to save a Morse decomposition to a PNG bitmap picture file.
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 1997-2008 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 2 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, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started on February 14, 2007. Last revision: March 15, 2008.


#ifndef _CMGRAPHS_PLOTMDEC_H_
#define _CMGRAPHS_PLOTMDEC_H_


#include "pngimage.h"
#include "colorpal.h"


// --------------------------------------------------
// ------------ Plot Morse Decomposition ------------
// --------------------------------------------------

/// Saves all the Morse sets in the provided Morse decomposition
/// to a PNG file. The coordinates of all the boxes in the Morse sets
/// must be non-negative and they should not exceed the size provided
/// unless the size is zero and then the size of the file is adjusted
/// so that all the Morse sets are contained in the picture.
/// Throws an error message in case of failure.
template <class MorseDecType>
inline void plotMorseDecompositionPNG (const MorseDecType &m,
        const char *filename, int size = 0, bool colorBar = true,
        bool copyright = false)
{
        typedef typename MorseDecType::CubSetType CubSetType;
        typedef typename MorseDecType::CubeType CubeType;
        typedef typename MorseDecType::CubeType::CoordType CoordType;

        // determine the dimension of the cubes in the Morse sets
        int dim = 0;
        int nSets = m. count ();
        for (int n = 0; n < nSets; ++ n)
        {
                if (m [n]. empty ())
                        continue;
                dim = m [n] [0]. dim ();
                break;
        }

        // prepare a temporary array for coordinates of boxes
        CoordType *coord = new CoordType [(dim < 2) ? 2 : dim];
        coord [0] = coord [1] = 0;

        // determine the size of the bitmap file
        int width = size;
        int height = size;
        int xoffset = 0;
        int yoffset = 0;
        int nColors = nSets;
        if (!size)
        {
                xoffset = 0x7FFFFFFF;
                yoffset = 0x7FFFFFFF;
                for (int n = 0; n < nSets; ++ n)
                {
                        const CubSetType &theSet = m [n];
                        if (theSet. empty ())
                        {
                                -- nColors;
                                continue;
                        }
                        int setSize = theSet. size ();
                        for (int i = 0; i < setSize; ++ i)
                        {
                                const CubeType &q = theSet [i];
                                int d = q. dim ();
                                if (d != dim)
                                        throw "Varying dim of Morse sets.";
                                q. coord (coord);
                                if (width <= coord [0])
                                        width = coord [0] + 1;
                                if (height <= coord [1])
                                        height = coord [1] + 1;
                                if (xoffset > coord [0])
                                        xoffset = coord [0];
                                if (yoffset > coord [1])
                                        yoffset = coord [1];
                        }
                }
                if (xoffset > width)
                        xoffset = 0;
                if (yoffset > height)
                        yoffset = 0;
                width -= xoffset;
                height -= yoffset;
        }
        if (width < 16)
                width = 16;
        if (height < 16)
                height = 16;

        // reserve space for a color bar if necessary
        int colorBoxSize = 16;
        int colorBarHeight = colorBar ? (colorBoxSize + 1) : 0;
        int colorBarWidth = colorBar ?
                (nColors * colorBoxSize + nColors - 1) : 0;
        height += colorBarHeight;
        if (width < colorBarWidth)
                width = colorBarWidth;
        int bottomHeight = colorBarHeight;

        // prepare space for the copyright message bitmap
        const int copyrightWidth = 152;
        const int copyrightHeight = 8;
        const int copyrightCount = 342;
        const short int copyrightPixels [2 * copyrightCount] = {
                11,0,15,0,16,0,27,0,28,0,43,0,44,0,45,0,77,0,78,0,142,0,
                143,0,1,1,2,1,3,1,7,1,8,1,11,1,17,1,21,1,24,1,29,1,31,1,
                34,1,36,1,37,1,42,1,46,1,50,1,51,1,52,1,53,1,56,1,57,1,
                61,1,62,1,66,1,67,1,73,1,74,1,75,1,79,1,86,1,92,1,93,1,
                94,1,97,1,101,1,105,1,106,1,107,1,110,1,115,1,121,1,123,1,
                126,1,127,1,128,1,130,1,134,1,135,1,138,1,139,1,140,1,
                144,1,148,1,151,1,0,2,4,2,6,2,9,2,11,2,12,2,13,2,17,2,
                18,2,21,2,24,2,27,2,28,2,29,2,31,2,34,2,36,2,41,2,44,2,
                45,2,47,2,50,2,55,2,58,2,60,2,63,2,65,2,68,2,73,2,76,2,
                79,2,80,2,86,2,91,2,94,2,97,2,101,2,104,2,110,2,115,2,
                121,2,123,2,125,2,128,2,130,2,133,2,136,2,138,2,144,2,
                145,2,148,2,150,2,0,3,6,3,9,3,11,3,14,3,16,3,19,3,21,3,
                24,3,26,3,29,3,31,3,34,3,36,3,41,3,43,3,47,3,51,3,55,3,
                58,3,60,3,63,3,65,3,68,3,73,3,76,3,78,3,81,3,86,3,92,3,
                93,3,94,3,96,3,98,3,100,3,102,3,104,3,105,3,106,3,107,3,
                110,3,115,3,121,3,123,3,126,3,127,3,128,3,130,3,133,3,
                139,3,143,3,146,3,148,3,149,3,0,4,6,4,9,4,11,4,14,4,16,4,
                19,4,21,4,24,4,26,4,29,4,31,4,34,4,36,4,41,4,43,4,47,4,
                52,4,55,4,58,4,60,4,63,4,66,4,67,4,73,4,76,4,78,4,81,4,
                86,4,87,4,88,4,89,4,94,4,96,4,99,4,102,4,104,4,107,4,
                109,4,110,4,115,4,116,4,117,4,118,4,121,4,123,4,128,4,
                130,4,133,4,136,4,140,4,143,4,146,4,148,4,150,4,0,5,7,5,
                8,5,11,5,12,5,13,5,16,5,19,5,21,5,22,5,24,5,27,5,28,5,
                29,5,31,5,32,5,33,5,36,5,37,5,41,5,44,5,45,5,47,5,53,5,
                55,5,58,5,60,5,63,5,65,5,68,5,73,5,74,5,75,5,78,5,81,5,
                86,5,90,5,92,5,93,5,96,5,99,5,102,5,105,5,106,5,110,5,
                111,5,115,5,119,5,121,5,123,5,126,5,127,5,130,5,131,5,
                134,5,135,5,138,5,139,5,140,5,143,5,146,5,148,5,151,5,
                0,6,4,6,31,6,36,6,42,6,46,6,50,6,53,6,55,6,58,6,60,6,
                63,6,65,6,68,6,73,6,86,6,90,6,110,6,115,6,119,6,123,6,
                148,6,1,7,2,7,3,7,24,7,31,7,43,7,44,7,45,7,51,7,52,7,
                56,7,57,7,61,7,62,7,66,7,67,7,73,7,86,7,87,7,88,7,89,7,
                110,7,115,7,116,7,117,7,118,7,121,7,123,7,148,7};
        if (copyright)
        {
                if (width < copyrightWidth + colorBarWidth + 1)
                {
                        width = copyrightWidth + colorBarWidth +
                                (colorBar ? 1 : 0);
                }
                if (colorBarHeight < copyrightHeight + 1)
                {
                        height += copyrightHeight + 1 - colorBarHeight;
                        bottomHeight = copyrightHeight + 1;
                }
        }
        int copyrightX = width - copyrightWidth;
        int copyrightY = height - copyrightHeight;

        // prepare an empty PNG image
        PngImage img (width, height);

        // plot the copyright pixels in the default color (black)
        if (copyright)
        {
                const short int *pixelPtr = copyrightPixels;
                for (int i = 0; i < copyrightCount; ++ i)
                {
                        int x = copyrightX + *(pixelPtr ++);
                        int y = copyrightY + copyrightHeight -
                                *(pixelPtr ++) - 1;
                        img. putPixel (x, y);
                }
        }

        // prepare a color palette and draw the color bar if required
        ColorPalette col (nColors);
        if (colorBar)
        {
                for (int n = 0; n < nColors; ++ n)
                {
                        int xMin = n * (colorBoxSize + 1);
                        int xMax = xMin + colorBoxSize;
                        int yMin = height - colorBarHeight + 1;
                        int yMax = yMin + colorBarHeight;
                        int color = col [n];
                        for (int x = xMin; x < xMax; ++ x)
                        {
                                for (int y = yMin; y < yMax; ++ y)
                                {
                                        img. putPixel (x, y, color);
                                }
                        }
                }
        }

        // plot the Morse sets in the PNG image
        int colorNumber = 0;
        for (int n = 0; n < nSets; ++ n)
        {
                const CubSetType &theSet = m [n];
                if (theSet. empty ())
                        continue;
                int color = col [colorNumber ++];
                int setSize = theSet. size ();
                for (int i = 0; i < setSize; ++ i)
                {
                        const CubeType &q = theSet [i];
                        int d = q. dim ();
                        if (d != dim)
                                throw "Varying dim of Morse sets.";
                        q. coord (coord);
                        img. putPixel (coord [0] - xoffset, height -
                                coord [1] + yoffset - 1 - bottomHeight,
                                color);
                }
        }
        delete [] coord;

        // save the PNG file
        img. save (filename);

        return;
} /* plotMorseDecomposition */


#endif // _CMGRAPHS_PLOTMDEC_H_

---