dotgraph.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// @file dotgraph.h
///
/// Writing a graph in the "dot" format.
/// This file contains the definition of a function
/// which writes a Conley-Morse graph to an output stream
/// in the format suitable for plotting by the "dot" program.
///
/// @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 February 11, 2008. Last revision: July 2, 2012.
 
 
#ifndef _CMGRAPHS_DOTGRAPH_H_
#define _CMGRAPHS_DOTGRAPH_H_
 
 
// include some standard C++ header files
#include <string>
#include <ostream>
#include <cmath>
#include <vector>
 
// include selected header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/cubes/cube.h"
 
// include local header files
#include "config.h"
#include "typedefs.h"
#include "typedyns.h"
#include "eigenval.h"
 
 
// --------------------------------------------------
// ------ encoding graphs for the dot program -------
// --------------------------------------------------
 
/// Writes the given Conley-Morse graph to the output stream
/// in the format for the 'dot' program.
inline std::ostream &writeDotGraph (std::ostream &out,
        const chomp::homology::diGraph<> &g,
        const std::vector<int_t> &sizes,
        const std::vector<theConleyIndexType> &indices,
        const std::vector<IndexEigenValues> &eigenValues,
        const std::vector<int> &wrongIndices,
        const std::vector<int> &skippedIndices,
        const std::vector<int> &attractors)
{
        // determine the number of vertices in the graph
        int_t nVert = g. countVertices ();
 
        // prepare a vector of bits indicating which indices are wrong
        std::vector<bool> wrong (nVert, false);
        for (std::vector<int>::const_iterator it = wrongIndices. begin ();
                it != wrongIndices. end (); ++ it)
        {
                if (*it < 0)
                        continue;
                else if (static_cast<int_t> (*it) >= nVert)
                        throw "Too large Morse set number with wrong index.";
                wrong [*it] = true;
        }
 
        // prepare a vector of bits indicating which indices were skipped
        std::vector<bool> skipped (nVert, false);
        for (std::vector<int>::const_iterator it = skippedIndices. begin ();
                it != skippedIndices. end (); ++ it)
        {
                if (*it < 0)
                        continue;
                else if (static_cast<int_t> (*it) >= nVert)
                        throw "Too large number of a skipped index.";
                skipped [*it] = true;
        }
 
        // prepare a vector of bits indicating which sets are attractors
        std::vector<bool> attr (nVert, false);
        for (std::vector<int>::const_iterator it = attractors. begin ();
                it != attractors. end (); ++ it)
        {
                if (*it < 0)
                        continue;
                else if (static_cast<int_t> (*it) >= nVert)
                        throw "Too large attractor number.";
                attr [*it] = true;
        }
 
        // count the number of incoming edges
        std::vector<int_t> incomingEdgesCount (nVert, 0);
        for (int_t v = 0; v < nVert; ++ v)
        {
                int_t nEdges = g. countEdges (v);
                for (int_t e = 0; e < nEdges; ++ e)
                {
                        int_t target = g. getEdge (v, e);
                        if ((target < 0) || (target >= nVert))
                                throw "Wrong edge while writing dot graph.";
                        ++ (incomingEdgesCount [target]);
                }
        }
 
        // write the graph for the 'dot' program
        out << "digraph G {";
        bool first = true;
        for (int_t v = 0; v < nVert; ++ v)
        {
                // begin the definition of the vertex of the C-M graph
                out << (first ? "" : " ") << "v" << v << " [label=\"";
 
                // show the number of the Morse set and its size in cubes
                out << v << ": " << sizes [v] << "\\n";
 
                // check if there is anything nonzero to show
                bool showindex = !eigenValues [v]. trivial ();
                int dim = indices [v]. dim ();
                for (int d = 0; !showindex && (d <= dim); ++ d)
                {
                        if (indices [v]. BettiNumber (d) ||
                                (indices [v]. Coefficient (d, 0) != 0) ||
                                indices [v]. Map (d) -> getncols ())
                        {
                                showindex = true;
                        }
                }
 
                // show the Conley index
                if (skipped [v])
                {
                        out << "[index not computed]\\n";
                }
                else if (wrong [v])
                {
                        out << "[no isolation]\\n";
                }
                else if (showindex)
                {
                        // show the homology groups
                        out << "H = (" << indices [v]. HomString () <<
                                ")\\n";
 
                        // show the homomorphism in homology
                        for (int d = 0; d <= indices [v]. dim (); ++ d)
                        {
                                if (indices [v]. Map (d) -> getncols ())
                                {
                                        out << indices [v].
                                                MapString (d, "\\n");
                                }
                        }
 
                        // show the eigenvalues
                        eigenValues [v]. write (out, ", ", "\\n");
                }
 
                // finish writing the label of the vertex
                out << "\"";
 
                // add necessary features of the boxes
                if (attr [v])
                {
                        out << " shape=box style=filled color=" <<
                                (wrong [v] ? "red" : "yellow");
                }
        //      else if (g. countEdges (v) == 0)
        //      {
        //      }
                else if (incomingEdgesCount [v] == 0)
                {
                        out << " shape=box style=filled color=" <<
                                (wrong [v] ? "red" : "greenyellow");
                }
                else if (!eigenValues [v]. trivial ())
                {
                        out << " style=filled color=" <<
                                (wrong [v] ? "red" : "lightblue");
                }
                else if (wrong [v])
                {
                        out << " style=filled color=red";
                }
                out << "]";
 
                // make a note that this is no longer the first vertex
                first = false;
        }
 
        // make sure all the attractors are at the same level
        if (attractors. size () > 1)
        {
                out << " {rank=same;";
                for (std::vector<int>::const_iterator it =
                        attractors. begin ();
                        it != attractors. end (); ++ it)
                {
                        out << " v" << *it;
                }
                out << "}";
        }
 
        // the edges emanating from each vertex
        for (int_t v = 0; v < nVert; ++ v)
        {
                int_t nEdges = g. countEdges (v);
                for (int_t e = 0; e < nEdges; ++ e)
                {
                        int_t target = g. getEdge (v, e);
                        out << " v" << v << "->v" << target;
                }
        }
        out << "}";
 
        return out;
} /* writeDotGraph */
 
 
#endif // _CMGRAPHS_DOTGRAPH_H_