Recognizer.hpp

Go to the documentation of this file.

#pragma once

//Global includes
#include <string>
#include <boost/shared_ptr.hpp>

//Local includes
#include "common_type/ObjectSet.hpp"
#include "utility/TableHelper.hpp"
#include "common_type/RecognitionResult.hpp"
#include "VotedPose.hpp"
#include "typedef.hpp"

namespace ISM {
  class Recognizer {

    //Accessor to db, containing isms.
    TableHelperPtr tableHelper;
    //Object constellation in which scene is to be recognized.
    ObjectSetPtr inputSet;

    //Parameters of voting space.
    double bin_size;
    double maxProjectionAngleDeviation;

    //All types of objects in sqlite table we got as input (for all scenes in this table)
    std::set<std::string> objectTypes;

    //Votes for all objects in db, extracted from db and held in memory to calculate votesPoses.
    ObjectTypeToVoteMap voteSpecifiersPerObject;
    //Used to get max expected weight per pattern.
    PatternNameToPatternMap patternDefinitions;

    //All patterns in db, arranged according to their height.
    TreeHeightToPatternName patternPerTreeHeight;
    //All voted poses, calculated during voting, arranged according to the pattern, in which voxel grid evaluation should take place.
    PatternNameToVotedPoses patternToVotedPoses;

    bool enabledSelfVoteCheck;

    //Simple or APO-Rater enum.
    const int mRaterType;

    std::vector<RecognitionResultPtr> ismResults;
    //Required to ensure that objects only vote once since, object voting and ism evaluation throughout the tree is decoupled.
    std::map<ObjectPtr, std::vector<VotedPosePtr> > votingCache;

    std::string patternForVotingSpaceViz;
    //Copy of a voting space, filled by an ism, for its visualization.
    PatternNameAndVotingSpaceTuple votingSpaceBuffer;

  public:
    Recognizer(const std::string& dbfilename, double bin_size, double maxProjectionAngleDeviation, bool enabledSelfVoteCheck, int raterType = 0);

    const std::vector<RecognitionResultPtr> recognizePattern(const ObjectSetPtr& objectSet,
                                 const double filterThreshold = 0.0, const int resultsPerPattern = -1, const std::string targetPatternName = "");
    
    std::map<ObjectPtr, std::vector<VotedPosePtr> > getVotingCache()
    {
      return votingCache;
    }

    //Interfaces to change settings of recognizer during runtime.

    void setVoteSpecifiersPerObject(ISM::ObjectTypeToVoteMap voteSpecifiersPerObject)
    {
      this->voteSpecifiersPerObject = voteSpecifiersPerObject;
    }

    void setObjectTypes(std::set<std::string> objectTypes)
    {
      this->objectTypes = objectTypes;
    }

    void setPatternDefinitions(ISM::PatternNameToPatternMap patternDefinitions)
    {
      this->patternDefinitions = patternDefinitions;
    }

    //Create mapping that assigns all isms in the trees in db to their height in their tree.
    void arrangePatternsAccordingToTreeHeight();
        
    //Reset everything before looking for another scene

    void clearData()
    {
      objectTypes.clear();
      assert(objectTypes.size() == 0);
      voteSpecifiersPerObject.clear();
      assert(voteSpecifiersPerObject.size() == 0);
      patternDefinitions.clear();
      assert(patternDefinitions.size() == 0);
    }

    //Interfaces for ISM voting visualization

    void setVotingSpaceToBeBuffered(std::string patternName)
    {
      this->patternForVotingSpaceViz = patternName;
    }

    PatternNameAndVotingSpaceTuple getBufferedVotingSpace()
    {
      this->patternForVotingSpaceViz.clear();
      return votingSpaceBuffer;
    }

  private:

    //Two methods that make up iteration step of iterative scene recognition process.

    //Calculates voted poses (reference pose hypotheses), using resp. filling the voting cache, and assigns them to a pattern.
    void calculateVotedPosesForAllObjects();
    //For all ISMs at a given tree height: Inserts all voted poses into voxel grids and evaluates each element of the grid.
    void fillAndEvalVotingSpaceAtTreeHeight(unsigned int treeHeight);

    int resultAlreadyExisting(const RecognitionResultPtr& res);
    int objectAlreadyInSet(const ObjectPtr& o);
    PosePtr calculatePoseFromVote(const PosePtr& pose, const VoteSpecifierPtr& vote) const;

    //Create mapping from patternname String to patterns in db.
    void getPatternDefinitions();

    //After having performed iterative scene recognition process, gather tree like scene recognition result from the single RecognitionResults from all sub-ISMs in the ISM tree. Uses getSubPatternsForResult.
    static std::vector<RecognitionResultPtr> assembleIsmTrees(const std::vector<RecognitionResultPtr>& ismResults,
                                  const double filterThreshold, const int resultsPerPattern, const std::string targetPatternName);

    //Search matching RecognitionResults in child ISMs in tree to build up tree structure of scene recognition result.
    static std::vector<RecognitionResultPtr> getSubPatternsForResult(RecognitionResultPtr result,
                                                                     std::map<std::string, std::vector<RecognitionResultPtr> > patternNameToResults);

  };
  typedef boost::shared_ptr<Recognizer> RecognizerPtr;

}