procshape.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file procshape.h
///
/// A plug-in for post-processing of Morse decompositions
/// which saves the real exit sets of all the Morse sets
/// and also makes some shape analysis of the computed sets.
/// This is a replacement for "procmdec.h".
///
/// @author Pawel Pilarczyk
///
/////////////////////////////////////////////////////////////////////////////
 
// Copyright (C) 1997-2014 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 October 27, 2010. Last revision: April 28, 2011.
 
 
#ifndef _CMGRAPHS_PROCSHAPE_H_
#define _CMGRAPHS_PROCSHAPE_H_
 
// include some standard C++ header files
#include <sstream>
#include <fstream>
#include <string>
 
// include selected header files from the CHomP library
#include "chomp/system/textfile.h"
#include "chomp/system/timeused.h"
#include "chomp/struct/digraph.h"
#include "chomp/struct/flatmatr.h"
#include "chomp/struct/multitab.h"
#include "chomp/cubes/neighbor.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
#include "conindex.h"
#include "morsedec.h"
#include "typedyns.h"
#include "utils.h"
 
 
namespace custom {
 
/// Post-processing of Morse decompositions by means of cycle decomposition.
namespace procMorseDecShape {
 
/// Computes the boundary of a set of cubes.
template <class CubSetType>
void computeBoundary (const CubSetType &X, CubSetType &bd)
{
        using namespace chomp::homology;
 
        if (X. empty ())
                return;
 
        int_t maxNeighbors = getmaxneighbors (X [0]. dim ());
        int_t size = X. size ();
        for (int_t n = 0; n < size; ++ n)
        {
                if (getneighbors (X [n], static_cast<BitField *> (0),
                        X, static_cast<CubSetType *> (0), 0) !=
                        maxNeighbors)
                {
                        bd. add (X [n]);
                }
        }
 
        return;
} /* computeBoundary */
 
 
// --------------------------------------------------
// ------- post-process a Morse decomposition -------
// --------------------------------------------------
 
/// Post-processes a Morse decomposition by computing a decomposition
/// of each Morse set into cycle sets and analyzing this decomposition.
template <class CubSetType, class MorseDecType, class GraphType,
        class CubMapType>
inline void processMorseDec (const MorseDecType &morseDec,
        const CubSetType &allCubes, const GraphType &g,
        const CubMapType &theCubMap, const CubMapType &,
        const std::string &cubesFilePrefix,
        const std::string &procFilePrefix)
{
        using namespace chomp::homology;
 
        sout << "===== Post-processing the Morse sets. =====\n";
        timeused timePostProc;
        timePostProc = 0;
 
        // analyze each Morse set
        int nSets = morseDec. count ();
        for (int n = 0; n < nSets; ++ n)
        {
                const CubSetType &morseCubes = morseDec [n];
                int_t morseCount = morseCubes. size ();
 
                // restrict the analysis to the given Morse set
                sbug << "Morse set no. " << n << ": " <<
                        morseCount << " cubes.\n";
 
                // compute the real exit set for the Morse set
                sbug << "Exit set: ";
                CubSetType exitSet;
                for (int i = 0; i < morseCount; ++ i)
                        theCubMap (morseCubes [i], &exitSet, 0, 0, false);
                exitSet. remove (morseCubes);
                sbug << exitSet. size () << " cubes.\n";
 
                // save the exit set to a file if requested to
                if (!cubesFilePrefix. empty ())
                {
                        // prepare a file name for this set
                        std::ostringstream exitFileNameStr;
                        exitFileNameStr << cubesFilePrefix << n << "e.cub";
                        std::string exitFileName = exitFileNameStr. str ();
 
                        // save the exit set to a file
                        sbug << "Saving the exit set to '" <<
                                exitFileName << "'... ";
                        std::ofstream f (exitFileName. c_str ());
                        f << "; The exit set for the corresponding Morse "
                                "set (" << exitSet. size () << " cubes).\n";
                        f << exitSet;
                        f. close ();
                        sbug << "Done.\n";
                }
 
                // compute the boundary of the exit set
                sbug << "Computing the boundary of the exit set... ";
                CubSetType exitSetBd;
                computeBoundary (exitSet, exitSetBd);
                sbug << exitSetBd. size () << " cubes.\n";
                if (!exitSetBd. empty ())
                {
                        sbug << "Exit set bounding box: ";
                        CoordMinMax rangeExit;
                        rangeExit (exitSetBd);
                        sbug << rangeExit << ".\n";
                }
 
                // save the boundary of the exit set if necessary
                if (!cubesFilePrefix. empty ())
                {
                        // prepare a file name for this set
                        std::ostringstream exitBdFileNameStr;
                        exitBdFileNameStr << cubesFilePrefix << n <<
                                "eb.cub";
                        std::string exitBdFileName =
                                exitBdFileNameStr. str ();
 
                        // save the computed boundary to a file
                        sbug << "Saving this boundary to '" <<
                                exitBdFileName << "'... ";
                        std::ofstream f (exitBdFileName. c_str ());
                        f << "; The boundary of the exit set "
                                "for the corresponding Morse set (" <<
                                exitSetBd. size () << " cubes).\n";
                        f << exitSet;
                        f. close ();
                        sbug << "Done.\n";
                }
 
                // compute the boundary of the Morse set
                sbug << "Computing the boundary of the Morse set... ";
                CubSetType morseBoundary;
                computeBoundary (morseCubes, morseBoundary);
                sbug << morseBoundary. size () << " cubes.\n";
                sbug << "Morse set bounding box: ";
                CoordMinMax rangeSet;
                rangeSet (morseBoundary);
                sbug << rangeSet << ".\n";
 
                // save the boundary of the Morse set if necessary
                if (!cubesFilePrefix. empty ())
                {
                        // prepare a file name for this set
                        std::ostringstream bdFileNameStr;
                        bdFileNameStr << cubesFilePrefix << n << "b.cub";
                        std::string bdFileName = bdFileNameStr. str ();
 
                        // save the computed boundary to a file
                        sbug << "Saving this boundary to '" <<
                                bdFileName << "'... ";
                        std::ofstream f (bdFileName. c_str ());
                        f << "; The boundary of the Morse set (" <<
                                morseBoundary. size () << " cubes).\n";
                        f << morseBoundary;
                        f. close ();
                        sbug << "Done.\n";
                }
 
                // compute the maximal distance from the boundary
                // and do some other post-processing if necessary
                // TODO
        }
 
        sout << "===== Post-processing completed in " << timePostProc <<
                ". =====\n";
 
        return;
} /* processMorseDec */
 
 
} // namespace procMorseDecShape
} // namespace custom
 
 
#endif // _CMGRAPHS_PROCSHAPE_H_