source: src/Tesselation/TriangleMatcher/TriangleMatcher.cpp@ b9d387

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2015 Frederik Heber. All rights reserved.
 *
 *
 *   This file is part of MoleCuilder.
 *
 *    MoleCuilder 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.
 *
 *    MoleCuilder 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 MoleCuilder.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * TriangleMatcher.cpp
 *
 *  Created on: Jun 15, 2015
 *      Author: heber
 *
 *
 *  This is a small study in C++11 that compares at least two
 *  files containing the triangle index triples of tesselations
 *  for equivalence
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "CodePatterns/MemDebug.hpp"

#include <boost/exception/all.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/tokenizer.hpp>

#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <map>

#include "types.hpp"

using namespace detail;

namespace bf = boost::filesystem;

typedef boost::error_info<
                struct tag_IllegalTesselationFileContent_LineNumber,
                int> IllegalTesselationFileContent_LineNumber;

typedef boost::error_info<
                struct tag_IllegalTesselationFileContent_Entries,
                int> IllegalTesselationFileContent_Entries;

typedef boost::error_info<
                struct tag_IllegalTesselationFileContent_Line,
                int> IllegalTesselationFileContent_Line;

//!> Exception for illegal lines encountered in tesselation files
struct IllegalTesselationFileContentException:
                virtual boost::exception, virtual std::exception { };

Triangle::index_t toIndex(const std::string &_element)
{
        Triangle::index_t index;
        std::stringstream tokenstring(_element);
        tokenstring >> index;
        return index;
}

template <class T>
std::ostream& operator<<(
                std::ostream &_ost,
                const std::set<T> &elements)
{
        for( const T elem : elements)
                _ost << elem << std::endl;
        return _ost;
}

/** Parses a tesselation file into a vector of Triangles.
 *
 * \param _filename name of file to parse
 * \return tesselation_t structure filled with triangle index triples
 */
const tesselation_t parseFile(const boost::filesystem::path &_filename)
{
        tesselation_t tesselation;

        std::ifstream infile(_filename.string().c_str());
        boost::char_separator<char> sep(" \t");

        typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
        std::string line;
        int line_number = 1;
        // read up till encountering an empty line
        while (!infile.eof()) {
                std::getline(infile, line);
                if (line.empty())
                        break;
        }
        while (!infile.eof()) {
                std::getline(infile, line);
                tokenizer tokens(line, sep);
                Triangle::indices_t indices;
                const int entries = std::distance( tokens.begin(), tokens.end() );
                // check for empty lines
                if (entries == 0)
                        continue;
                // entries must be exactly three if any
                if ( entries !=  NUMBERINDICESTRIANGLE )
                        throw IllegalTesselationFileContentException()
                                << IllegalTesselationFileContent_LineNumber(line_number)
                                << IllegalTesselationFileContent_Entries(entries);
                std::transform(
                                tokens.begin(),
                                tokens.end(),
                                indices.begin(),
                                toIndex);
                tesselation.insert(Triangle(indices));

                ++line_number;
        }
        infile.close();

        return tesselation;
}

int main(int argc, char **argv) {

        /// check arguments and give usage
        if (argc <= 2) {
                std::cerr << "Usage: " << argv[0] << " <list of files>\n";
                std::cerr << "At least two tesselation files need to be specified that contain\n";
                std::cerr << "each three indices per line.\n";

                return 255;
        }

        /// read in files and parse into structures
        typedef std::multimap<tesselation_t, std::string> tesselations_filename_t;
        //!> contains all tesselations parsed from files
        tesselations_filename_t tesselations;
        for (int i=1; i<argc;++i) {
                const bf::path filename(argv[i]);
                if (bf::exists(filename)) {
                        try {
                                tesselation_t tesselation = parseFile(filename);
                                tesselations.insert(
                                                std::make_pair(tesselation, filename.string()) );
                        } catch (IllegalTesselationFileContentException &e) {
                                std::cerr << "Illegal line at "
                                                << *boost::get_error_info<IllegalTesselationFileContent_LineNumber>(e)
                                                << " encountered with "
                                                << *boost::get_error_info<IllegalTesselationFileContent_Entries>(e)
                                                << " entries in "
                                                << filename.string()
                                                << ", aborting.\n";
                                return 5;
                        }
                } else {
                        std::cerr << "The following file does not exist "
                                        << filename.string() << ", aborting.\n";
                        return 5;
                }
        }

        /// make comparison for equivalence
        assert( tesselations.size() >= 2 );
        tesselations_filename_t::const_iterator advancer = tesselations.begin();
        tesselations_filename_t::const_iterator iter = advancer++;

        bool AllEqual = true;
        while( advancer != tesselations.end() ) {
                if (advancer->first == iter->first) {
                        std::cout << "MATCH: "
                                        << advancer->second << " and " << iter->second
                                        << std::endl;
                } else {
                        std::cout << advancer->first << " and " << iter->first
                                        << " don't match.\n";
                        AllEqual = false;
                }
                iter = advancer++;
        }

        // exit (convert bool to int)
        return (AllEqual ? 0 : 1);
}