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-2022 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 15, 2022.
 
 
#ifndef _CMGRAPHS_PLOTMDEC_H_
#define _CMGRAPHS_PLOTMDEC_H_
 
 
#include "pngimage.h"
#include "chomp/bitmaps/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 xCoord, int yCoord,
        int size = 0, bool colorBar = true)
{
        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;
        }
 
        // make sure that the requested coordinates are in the range
        if (nSets && ((xCoord >= dim) || (yCoord >= dim)))
                throw "Coordinates out of range for plotting Morse decomp.";
 
        // 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 ? nSets : 1;
        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 "Inconsistent dim of cubes.";
                                q. coord (coord);
                                if (width <= coord [xCoord])
                                        width = coord [xCoord] + 1;
                                if (height <= coord [yCoord])
                                        height = coord [yCoord] + 1;
                                if (xoffset > coord [xCoord])
                                        xoffset = coord [xCoord];
                                if (yoffset > coord [yCoord])
                                        yoffset = coord [yCoord];
                        }
                }
                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 an empty PNG image
        PngImage img (width, height);
 
        // prepare a color palette and draw the color bar if required
        chomp::homology::ColorPalette col (nColors);
        if (colorBar && nColors && nSets)
        {
                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 "Inconsistent dim of cubes to plot.";
                        q. coord (coord);
                        img. putPixel (coord [xCoord] - xoffset, height -
                                coord [yCoord] + yoffset - 1 - bottomHeight,
                                color);
                }
        }
        delete [] coord;
 
        // save the PNG file
        img. save (filename);
 
        return;
} /* plotMorseDecomposition */
 
 
#endif // _CMGRAPHS_PLOTMDEC_H_