cub2sim.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A program that saves a simplicial set obtained from
/// a cubical set by means of simplicial subdivision.
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2009-2016 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 <http://www.gnu.org/licenses/>.

// Started on August 3, 2015. Last revision: August 3, 2015.


// include the string hashing definitions (before including "hashsets.h")
#include "chaincon/stringhash.h"

// include selected header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/system/timeused.h"
#include "chomp/system/arg.h"
#include "chomp/struct/hashsets.h"

// include relevant local header files
#include "chaincon/ringzp.h"
#include "chaincon/simplex.h"
#include "chaincon/cubcell.h"
#include "chaincon/emptycell.h"
#include "chaincon/wrapping.h"
#include "chaincon/prodcell.h"
#include "chaincon/cubproduct.h"
#define SPACE_WRAPPING


// --------------------------------------------------
// -------------------- OVERTURE --------------------
// --------------------------------------------------

/// The title of the program and licensing information.
const char *title = "\
* * * UNDER CONSTRUCTION * * *\n\
Converts a cubical set into an equivalent simplicial complex.\n\
Version 0.00 (August 4, 2015). Copyright (C) 1997-2016 by Pawel Pilarczyk.\n\
This is free software. No warranty. Consult 'license.txt' for details.";

/// Brief help information on the program's usage.
const char *helpinfo = "\
This program saves a simplicial set obtained from a cubical set by means of\n\
simplicial subdivision, using the representation of cubical cells by means of\n\
the Cartesian product of the 2D simplices that correspond to the edges.\n\
Please, beware of the fact that this is a very inefficient way of subdividing\n\
each hypercube into the union of simplices; a much smarter algorithm\n\
is possible, but I needed this specific one to check some features.\n\
Call with:\n\
input.cub - the name of a file that contains a list of cubical cells,\n\
output.sim - the name of a file that will contain a list of simplices,\n\
Switches and additional arguments:\n\
--log filename - save the output to a file (without progress indicators),\n\
--quiet - suppress data output to the screen (whcih can be still logged),\n\
--help - display this brief help information only and exit.\n\
For more information please consult the accompanying documentation\n\
or ask the program's author at http://www.PawelPilarczyk.com/.";


// --------------------------------------------------
// -------------------- routines --------------------
// --------------------------------------------------

template <class CellT>
void flattenProduct (const tProdCell<CellT> &prod, std::vector<CellT> &cells)
{
        if (prod. product ())
        {
                flattenProduct (prod. getLeft (), cells);
                flattenProduct (prod. getRight (), cells);
        }
        else
        {
                cells. push_back (prod. getCell ());
        }
        return;
} /* flattenProduct */

template <class ProdCellT, class SimCellT>
inline void prod2simplex (const ProdCellT &prod, SimCellT &simplex)
{
        using chomp::homology::sbug;

        int cellDim (prod. dim ());
        if (cellDim >= chomp::homology::MaxBasDim)
                throw "Too high dimension of a product cell.";
        std::vector<int_t> pointNumbers (cellDim + 1);
        typedef typename ProdCellT::CellType CellT;
        typedef typename CellT::VertexType CoordT;
        std::vector<CellT> cells;
        sbug << "DEBUG: prod = " << prod << "\n";
        flattenProduct (prod, cells);
        int spaceDim = cells. size ();
        for (int i = 0; i <= cellDim; ++ i)
        {
                CoordT c [chomp::homology::MaxBasDim];
                for (int j = 0; j < spaceDim; ++ j)
                        c [j] = cells [j] [i];
                pointNumbers [i] = chomp::homology::tPointBase<CoordT>::number
                        (c, spaceDim) + 1;
        }
        std::sort (pointNumbers. begin (), pointNumbers. end ());
        simplex = SimCellT (cellDim, pointNumbers);
        sbug << "DEBUG: simplex = " << simplex << "\n\n";
        return;
} /* prod2simplex */


// --------------------------------------------------
// ---------------------- main ----------------------
// --------------------------------------------------

/// The main procedure of the program.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
int main (int argc, char *argv [])
{
        using namespace chomp::homology;

        // prepare the types for coordinates, cubes, and simplices
        typedef short int CoordT;
        typedef tCubCell<CoordT,SettableWrapping<CoordT>,SettableEmptyCell>
                CubCellT;
        typedef tProdCell<tSimplex<CoordT,SettableEmptyCell> > ProdCellT;

        // turn on a message that will appear if the program does not finish
        program_time = "Aborted after";

        // prepare user-configurable data
        char *inName = 0;
        char *outName = 0;
#ifdef SPACE_WRAPPING
        const int maxWrapping = 100;
        char *wrapping [maxWrapping];
        int nWrapping = 0;
#endif

        // analyze the command line
        arguments a;
        arg (a, NULL, inName);
        arg (a, NULL, outName);
#ifdef SPACE_WRAPPING
        arg (a, "w", wrapping, nWrapping, maxWrapping);
#endif
        arghelp (a);

        argstreamprepare (a);
        int argresult = a. analyze (argc, argv);
        argstreamset ();

        // show the program's title
        if (argresult >= 0)
                sout << title << '\n';

        // if something was incorrect, show an additional message and exit
        if (argresult < 0)
        {
                sout << "Call with '--help' for help.\n";
                return 2;
        }

        // if help requested or no filename present, show help information
        if ((argresult > 0) || !outName)
        {
                sout << helpinfo << '\n';
                return 1;
        }

        // try running the main function and catch an error message if thrown
        try
        {
#ifdef SPACE_WRAPPING
                // set wrapping as desired
                for (int i = 0; i < nWrapping; ++ i)
                {
                        setWrapping<typename CubCellT::WrapType>
                                (std::string (wrapping [i]));
                }
#endif

                // say what you are doing
                sout << "Transforming cubical cells into simplices:\n'" <<
                        inName << "' --> '" << outName << "'...\n";

                // open the file with the cubical cells
                std::ifstream in (inName);
                if (!in)
                        fileerror (inName);

                // create a file for the simplices
                std::ofstream out (outName);
                if (!out)
                        fileerror (outName, "create");

                // read the cubes one by one, subdivide them,
                // and write the corresponding simplices
                int_t cubCounter (0);
                int_t simCounter (0);
                ignorecomments (in);
                while (!in. eof ())
                {
                        // read a cubical cell
                        CubCellT q;
                        in >> q;
                        ++ cubCounter;
                        ignorecomments (in);

                        // transform the cell into simplices and normalize
                        tSimplSet<ProdCellT> prodCells;
                        cube2product (q, prodCells);
                        prodCells. normalize ();

                        // process all the simplices
                        int_t prodSize (prodCells. size ());
                        for (int_t n = 0; n < prodSize; ++ n)
                        {
                                const ProdCellT &prod (prodCells [n]);
                                if (prod. dim () != q. dim ())
                                        continue;

                                // convert the product into a simplex
                                tSimplex<int_t,WithEmptyCell> simplex;
                                prod2simplex (prod, simplex);

                                // write the simplex to the output file
                                out << simplex << "\n";
                                ++ simCounter;
                        }
                }
                in. close ();
                out. close ();
                sout << cubCounter << " cubical cells read.\n";
                sout << simCounter << " simplices written.\n";

                program_time = "Total time used:";
                program_time = 1;
                return 0;
        }
        catch (const char *msg)
        {
                sout << "ERROR: " << msg << '\n';
                return -1;
        }
        catch (const std::exception &e)
        {
                sout << "ERROR: " << e. what () << '\n';
                return -1;
        }
        catch (...)
        {
                sout << "ABORT: An unknown error occurred.\n";
                return -1;
        }
} /* main */