OptimizationRunnerFactory.cpp

Go to the documentation of this file.

#include "OptimizationRunnerFactory.hpp"

#include "../typedef.hpp"
#include "TreeValidator.hpp"
#include "HeightChecker.hpp"

#include "TopologyGenerator.hpp"
#include "TopologyGeneratorPaper.hpp"
#include "TopologyGeneratorNaive.hpp"

#include "Evaluator.hpp"
#include "Tester.hpp"

#include "utility/LogHelper.hpp"
//#include "utility/TopologyHelper.hpp"
#include "utility/SVGHelper.hpp"

#include "OptimizationRunner.hpp"
#include "../combinatorial_optimization/HillClimbingAlogrithm.hpp"
#include "../combinatorial_optimization/SimulatedAnnealingAlgorithm.hpp"
#include "../combinatorial_optimization/ExponentialCoolingSchedule.hpp"

namespace ISM {

                OptimizationRunnerPtr OptimizationRunnerFactory::createOptimizationRunner(EvaluatorParameters evaluatorParams,
                        TopologyGeneratorParameters topologyGeneratorParams,
                        OptimizationAlgorithmParameters optimizationAlgorithmParameters,
                        CostFunctionParameters costFunctionParameters,
                        TreeValidatorParameters treeValidatorParams,
                        std::pair<PatternNameToObjectSet, PatternNameToObjectSet> testSets,
                        std::map<std::string, ISM::ObjectRelations> allObjectRelationsPerPattern,
                        DocumentationHelperPtr documentationHelper,
                        bool storeFullyMeshedISM,
                        bool storeStartTopologyISM)
        {
                TreeValidatorPtr treeValidator ;

                switch (treeValidatorParams.treeValidatorId)
                {
                        case 0:
                                treeValidator = TreeValidatorPtr(new HeightChecker(treeValidatorParams.maxTreeHeight));
                                break;
                        default:
                                std::string errorMessage = std::to_string(treeValidatorParams.treeValidatorId)
                                        + " is not a valid treeEvaluatorId!";
                                LogHelper::logMessage(errorMessage, LOG_ERROR);
                                throw std::runtime_error(errorMessage);
                }

                EvaluatorPtr evaluator;
                RecognizerPtr recognizer;
                ObjectSetValidatorPtr objectSetValidator;

                switch (evaluatorParams.evaluatorId)
                {
                        case 0:
                                recognizer = ISM::RecognizerPtr(new ISM::Recognizer("", evaluatorParams.binSize,
                            evaluatorParams.maxAngleDeviation, false));
                                objectSetValidator = ISM::ObjectSetValidatorPtr(new ObjectSetValidator(recognizer,
                                                        evaluatorParams.confidenceThreshold));
                                evaluator = EvaluatorPtr(new Tester(objectSetValidator, testSets.first, testSets.second,
                                                                                                        evaluatorParams.testForFalseNegatives));
                                break;
                        default:
                                std::string errorMessage = std::to_string(evaluatorParams.evaluatorId) + " is not a valid evaluatorId!";
                                LogHelper::logMessage(errorMessage, LOG_ERROR);
                                throw std::runtime_error(errorMessage);
                }


                TopologyGeneratorPtr topologyGenerator;

                switch (topologyGeneratorParams.topologyGeneratorId)
                {
                        case 0 :
                                topologyGenerator = TopologyGeneratorPaperPtr(new TopologyGeneratorPaper(allObjectRelationsPerPattern,
                                                        topologyGeneratorParams.maxNeighbourCount,
                                                        topologyGeneratorParams.swapRelations,
                                                        topologyGeneratorParams.removeRelations));
                                break;
                        case 1:
                                topologyGenerator = TopologyGeneratorNaivePtr(new TopologyGeneratorNaive(allObjectRelationsPerPattern,
                                                        topologyGeneratorParams.maxNeighbourCount));
                                break;
                        default :
                                std::string errorMessage = std::to_string(topologyGeneratorParams.topologyGeneratorId) +
                                        " is not a valid successorGeneratorId!";
                                LogHelper::logMessage(errorMessage, LOG_ERROR);
                                throw std::runtime_error(errorMessage);
                }

                TopologyManagerPtr topologyManager = TopologyManagerPtr(new TopologyManager(evaluator, treeValidator,
                                        topologyGenerator, documentationHelper));

                return OptimizationRunnerPtr(new OptimizationRunner(
                                        topologyManager, documentationHelper,
                                        optimizationAlgorithmParameters, costFunctionParameters,
                                        storeFullyMeshedISM, storeStartTopologyISM
                                ));

        }

}