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-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 11, 2008. Last revision: March 8, 2008.


#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 "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> &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 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 (*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 (*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 (*it >= nVert)
                        throw "Too large attractor number.";
                attr [*it] = true;
        }

        // count the number of incoming edges
        std::vector<int> incomingEdgesCount (nVert, 0);
        for (int v = 0; v < nVert; ++ v)
        {
                int nEdges = g. countEdges (v);
                for (int e = 0; e < nEdges; ++ e)
                {
                        int 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 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 (wrong [v])
                {
                        out << "[no isolation]\\n";
                }
                else if (skipped [v])
                {
                        out << "[index skipped]\\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 v = 0; v < nVert; ++ v)
        {
                int nEdges = g. countEdges (v);
                for (int e = 0; e < nEdges; ++ e)
                {
                        int target = g. getEdge (v, e);
                        out << " v" << v << "->v" << target;
                }
        }
        out << "}";

        return out;
} /* writeDotGraph */


#endif // _CMGRAPHS_DOTGRAPH_H_

---