VotingResultCalculator.hpp

Go to the documentation of this file.

#include <map>
#include <stack>
#include <set>
#include <vector>
#include <iostream>

//Local includes
#include "common_type/Pattern.hpp"
#include "common_type/ObjectSet.hpp"
#include "VotingSpace.hpp"
#include "VotingResult.hpp"
#include "rating/SimpleRater.hpp"
#include "rating/APORater.hpp"
#include "rating/RatingData.hpp"
#include "typedef.hpp"

namespace ISM {
  //Searches scene instances in given sets of votes and lets VotingSpace perform radius search if that features is requested.
  class VotingResultCalculator
  {
  public:

    VotingResultCalculator(VotingSpacePtr votingSpaceInEval, bool enabledSelfVoteCheck, int raterType = 0);

    //Compute VotingResults (result) from a set of VotedPoses (votedReferencePoses). Calls searchFittingVotes.
    bool computeVotingResult(VotingResultPtr& result, TypeToInnerMap votedReferencePoses);

  private:

    //Matches given votes to a originForFitting, chosen beforehand.
    void searchFittingVotes(TypeToInnerMap votes);

    //Voting space used for radius search.
    VotingSpacePtr mVotingSpaceInEval;
    //Simple or APO-Rater
    ISM::RaterPtr mRater;

    //VotedPose for reference, used as starting point (reference) for fitting process (either in bin or in sphere).
    VotedPosePtr originForFitting;
    //The pose inside originForFitting.
    PosePtr originPose;
    //Used to recognize votes from originForFitting
    std::string originType;
    std::string originId;

    //All votedPoses that fit current originForFitting are counted and added to RecognitionResult.
    SummarizedVotedPosePtrs summarizedFittingVotes;

    //Cache data for rating to prevent calculating already calculated data again.
    RatingDataPtr ratingCache;

    //To prevent that the same object votes multiple times when evaluating an originForFitting (could happen in ism tree during iterative scene recognition).
    std::set<ObjectPtr> sourcesWithFittingVotes;

    //If SelfVoteCheck is active, the use of votedPose from a selfvoting object as originForFitting, in case such an object exists, is ensured.
    bool enabledSelfVoteCheck;

    //Both following methods inlined for performance reasons.

    //For the type and id combination providing originForFitting: Calculate all its votes that fit.
    unsigned int countSupportingOriginForFittingVotes(VotedPosePtrs originForFittingVotes)
    {
      
      VotedPosePtr currentVotedPose;
      unsigned int fittingVoteCounter = 0;

      //Go through all votes for current type and id combination.
      for (VotedPosePtrs::iterator voteIt = originForFittingVotes.begin(); voteIt != originForFittingVotes.end(); voteIt++)
        {
          currentVotedPose = *voteIt;
          //Prevent that fitting takes place multiple times for the same object when using the same originForFitting.
          if ((sourcesWithFittingVotes.find(currentVotedPose->source) != sourcesWithFittingVotes.end()))
            continue;

          //Reject all votes whose deviation form originForFitting exceed given thresholds. They cannot be regarded as supporting originForFitting.
          if (mRater->isVoteSupportingReference(currentVotedPose, originPose, ratingCache))
            //Count it as a supporting vote for origin for fitting
            fittingVoteCounter++;
        }

      return fittingVoteCounter;

    }

    //For a given type and id combination: Calculate all parameters required for summarizedFittingVotes
    void countSupportingOriginForFittingVotes(VotedPosePtrs votes, unsigned int& fittingVoteCounter, double& bestWeight, VotedPosePtr& bestVotedPose)
    {
    
      VotedPosePtr currentVotedPose;  
      double newWeight;
      fittingVoteCounter = 0;
      bestWeight = -mVotingSpaceInEval->epsilon;
  
      //Go through all votes for current type and id combination.
      for (VotedPosePtrs::iterator voteIt = votes.begin(); voteIt != votes.end(); voteIt++)
        {
          currentVotedPose = *voteIt;
          //Prevent that fitting takes place multiple times for the same object when using the same originForFitting.
          if ((sourcesWithFittingVotes.find(currentVotedPose->source) != sourcesWithFittingVotes.end()))
            continue;

      //Reject all votes whose deviation from originForFitting exceed given thresholds. They cannot be regarded as supporting originForFitting.
          if (mRater->isVoteSupportingReference(currentVotedPose, originPose, ratingCache))
            {
              //Count it as a supporting vote for origin for fitting
              fittingVoteCounter++;
              //If we already found a perfectly rated VotedPose for the current type and id, we do not need to rate the rest.
              if(bestWeight >= currentVotedPose->weight - VotingSpace::epsilon)
                continue;

              newWeight = mRater->rateAtBackProjectionLevel(currentVotedPose, ratingCache);
              if(newWeight > bestWeight)
                {
                  bestVotedPose = currentVotedPose;
                  bestWeight = newWeight;
                }
            }
        }
    }

  };

  typedef boost::shared_ptr<VotingResultCalculator> VotingResultCalculatorPtr;

}