DocumentationHelper.hpp

Go to the documentation of this file.

#pragma once

#include <boost/filesystem/path.hpp>
#include <boost/shared_ptr.hpp>

#include "../combinatorial_optimization/CostFunction.hpp"
#include "../combinatorial_trainer/CombinatorialTrainerParameters.hpp"
#include "../combinatorial_trainer/Topology.hpp"
#include "../combinatorial_trainer/EvaluationResult.hpp"

#include "SVGHelper.hpp"
#include "DotHelper.hpp"

namespace ISM
{
using boost::filesystem::path;

class DocumentationHelper
{
        public:
                DocumentationHelper(path outputPath, path dbPath,
                std::map<std::string, ISM::TracksPtr>& tracksPerPattern) :
            mOutputPath(outputPath), mSourceDBPath(dbPath)
                {
                        boost::filesystem::create_directories(mOutputPath);
                        boost::filesystem::create_directories(mOutputPath / SVG_SUBFOLDER_NAME);
                        boost::filesystem::create_directories(mOutputPath / CSV_SUBFOLDER_NAME);
                        boost::filesystem::create_directories(mOutputPath / TOPOLOGIES_SUBFOLDER_NAME);

                        mSVGHelper = SVGHelperPtr(new SVGHelper(mOutputPath / SVG_SUBFOLDER_NAME));
                        mDotHelper = DotHelperPtr(new DotHelper(tracksPerPattern));
                }

                void storeOptimizationRun(std::vector<std::vector<std::pair<TopologyPtr, unsigned int>>>& history,
                                CostFunctionPtr<TopologyPtr> globalCostFunction,
                                double elapsedRuntime, const std::string& patternName);

                void storeTopology(TopologyPtr toStore, const std::string& patternName,
                                const std::string& topologyName,
                                std::map<std::string, std::vector<ISM::VoteSpecifierPtr>> objectDefinitons);

                void storeIsm(const std::string& filename, const IsmPtr& ism);
                void storeIsm(const IsmPtr& ism);
                void writeResult();
                void setReferenceTopology(TopologyPtr topology, const std::string & patternName);

        private:
                const std::string SVG_SUBFOLDER_NAME = "SVG";
                const std::string CSV_SUBFOLDER_NAME = "CSV";
                const std::string TOPOLOGIES_SUBFOLDER_NAME = "Topologies";
                const std::string SELECTED_TOPOLOGIES_FOLDER = "allSelectedTopologies";

                path mOutputPath;
                path mSourceDBPath;

                SVGHelperPtr mSVGHelper;
                DotHelperPtr mDotHelper;

                bool mStoreISM = true;

                unsigned int mSelectedTopologyCounter = 1;

                TopologyPtr mReferenceTopology;

                void storeTopologiesToCSV(std::vector<TopologyPtr> selectedTopologies,
                                const std::string& patternNames);

                void storeMetadataToCSV(unsigned int numEvaluatedTopologies,
                                unsigned int numOptimizationRounds, double elapsedRuntime,
                                const std::string& patternName);

                void writeToFile(path filePath, const std::string& content);
        void writeIsmToDB(path dbPath, const IsmPtr & ism);


}; typedef boost::shared_ptr<DocumentationHelper> DocumentationHelperPtr;

}