RelativeTestSetGenerator.cpp

Go to the documentation of this file.

#include "learner/foreground/ocm/combinatorial_optimization/RelativeTestSetGenerator.h"

namespace ProbabilisticSceneRecognition {

RelativeTestSetGenerator::RelativeTestSetGenerator(boost::shared_ptr<AbstractTopologyEvaluator> pEvaluator, boost::shared_ptr<SceneModel::Topology> pFullyMeshedTopology, const std::vector<std::string>& pObjectTypes):
    TestSetGenerator(pEvaluator, pFullyMeshedTopology, pObjectTypes)
{ }

RelativeTestSetGenerator::~RelativeTestSetGenerator()
{ }

std::vector<boost::shared_ptr<TestSet>> RelativeTestSetGenerator::generateRandomSets(std::vector<boost::shared_ptr<ISM::ObjectSet>> pExamplesList, unsigned int pTestSetCount)
{
    TestSetGenerator::mPrintHelper.printAsHeader("Generating " + boost::lexical_cast<std::string>(pTestSetCount) + " random test sets.");

    std::random_device rd;
    boost::mt19937  eng;    // Mersenne Twister
    eng.seed(rd());
    boost::uniform_int<> dist(0,RAND_MAX);  // Normal Distribution
    boost::variate_generator<boost::mt19937,boost::uniform_int<>>  gen(eng,dist);  // Variate generator

    ROS_INFO_STREAM("Found " << TestSetGenerator::mTypes.size() << " object types.");

    std::vector<boost::shared_ptr<TestSet>> testSets(pTestSetCount);

    for (unsigned int i = 0; i < pTestSetCount; i++)
    {
        // pick random reference:
        unsigned int randomTimestep = gen() % pExamplesList.size();
        unsigned int randomObjectIndex = gen() % pExamplesList[randomTimestep]->objects.size();
        ISM::ObjectPtr referenceObject(new ISM::Object(*pExamplesList[randomTimestep]->objects[randomObjectIndex])); // deep copy the object

        testSets[i].reset(new TestSet());
        testSets[i]->mObjectSet->insert(referenceObject);

        for (std::string objectType: mTypes)
        {
            if (objectType != referenceObject->type)
            {
                ISM::ObjectPtr object;

                unsigned int counter = 0;
                while (!object && counter < pExamplesList.size())   // does not iterate over all timesteps; using example list size to scale
                {
                    unsigned int newRandomTimestep = gen() % pExamplesList.size();
                    for (ISM::ObjectPtr currentObject: pExamplesList[newRandomTimestep]->objects)
                    {
                        if (currentObject->type == objectType)
                        {
                            object = ISM::ObjectPtr(new ISM::Object(*currentObject)); // deep copy the object.
                            break;
                        }
                    }
                    counter++;
                }

                if (!object)
                    throw std::runtime_error("In TestSetGenerator::generateTestSets(): Failed to find object of type " + objectType + " in evidence list.");
                setPoseOfObjectRelativeToReference(object, referenceObject);
                testSets[i]->mObjectSet->insert(object);
            }
        }

        setPoseOfObjectRelativeToReference(referenceObject, referenceObject);
    }

    return testSets;
}

}