CombinatorialTrainer.hpp

Go to the documentation of this file.

#pragma once

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

#include <utility/TableHelper.hpp>
#include <utility/DocumentationHelper.hpp>
#include <common_type/ObjectSet.hpp>
#include <common_type/Tracks.hpp>
#include <common_type/VoteSpecifier.hpp>
#include <common_type/Pattern.hpp>
#include <fstream>
#include <iostream>
#include <string>


#include "common_type/RecognitionResult.hpp"
#include "ObjectRelation.hpp"
#include "ImplicitShapeModel.hpp"
#include "TestSetGenerator.hpp"

#include "TopologyValidationResultContainer.hpp"
#include "Tester.hpp"

#include "CombinatorialTrainerParameters.hpp"
#include "Topology.hpp"
#include "../typedef.hpp"

namespace ISM
{
        using boost::filesystem::path;
class CombinatorialTrainer
{
        public:
                CombinatorialTrainer(CombinatorialTrainerParameters params);

                std::map<std::string, std::pair<double, TreePtr> > learn();
        private:
                TableHelperPtr tableHelper;

                std::vector<std::string> patternNames;
                //These are the Tracks of ALL patterns in the DB file
                std::map<std::string, ISM::TracksPtr> objectTracksPerPattern;
                //These are all objectRelations (a fully connected topology) of each Pattern in the DB file
                std::map<std::string, ISM::ObjectRelations> allObjectRelationsPerPattern;
                //contains all relations of objects to themselves
                std::map<std::string, std::vector<ISM::ObjectRelationPtr> > allSelfRelationsPerPattern;
                //filepath to the objects models for visualization
                std::map<std::string, std::map<std::string, boost::filesystem::path> > objectModelsPerPattern;
                path mOutputDataPath;
                path mDBPath;

                DocumentationHelperPtr mDocumentationHelper;

                std::map<std::string, IsmPtr> mFullyMeshedTopologyPerPattern;
                std::map<std::string, std::vector<TopologyPtr>> mStartTopologiesPerPattern;

                std::pair<PatternNameToObjectSet, PatternNameToObjectSet> mTestSets;

                CombinatorialTrainerParameters mParams;

                //Get all Tracks of all pattern in the DB file
                //I.e: Get a table where each entry marks all tracks of all objects in one distinct pattern
                const std::map<std::string, ISM::TracksPtr> getRecordedObjectsTracks();
                //Calculate all relations between all objects in the same pattern, for all patterns in the DB file
                const std::map<std::string, ISM::ObjectRelations> calculateAllObjectRelations();
                bool containsAllObjects(const ISM::ObjectRelations& topology, const std::string& patternName) const;
                void drawISM(unsigned ismId, std::string patternName, std::map<std::string, std::vector<VoteSpecifierPtr> > voteSpecifiersPerObject);
                TopologyValidationResultsPtr getValidationResultsForPattern(std::string patternName);

                std::map<std::string, IsmPtr> learnFullyMeshedTopologyPerPattern(bool naive = false);
                bool checkCorrectOrder(std::map<std::string, ISM::ObjectRelations> allObjectRelationsPerPattern);
                void storePatternToDB(std::map<std::string, IsmPtr> bestISMPerPattern);

                void storeTestSetsToDB(PatternNameToObjectSet testSet,
                                const path dbFilePath,
                                const std::string & type);

                PatternNameToObjectSet loadTestSetsFromDB(std::string fileName);

                std::pair<PatternNameToObjectSet, PatternNameToObjectSet> createTestSets(double binSize, double maxAngleDeviation,
                                double confidenceThreshold, unsigned int testSetCount);

                void initTestSets(double binSize, double maxAngleDeviation, double confidenceThreshold,
                                std::string loadValidTestSetsFrom, std::string loadInvalidTestSetsFrom, unsigned int testSetCount);

                void initStartTopologiesPerPattern(std::string loadStartTopologiesFrom);
                std::string genTimeString();

}; typedef boost::shared_ptr<CombinatorialTrainer> CombinatorialTrainerPtr;

}