objectIdentifier.hpp

/* $Id$ */

#ifndef _OBJECT_IDENTIFIER_HPP
#define _OBJECT_IDENTIFIER_HPP

#include "kernel/jafarException.hpp"
#include "image/Image.hpp"
#include "gfm/MatchingResult.hpp"
#include "gfm/DetectionResult.hpp"
#include "oracle/objectRecognizer.hpp"
#include "oracle/objectLoader.hpp"
#include <boost/tuple/tuple.hpp>
#include <set>
#include <string>

namespace jafar {
  
  namespace oracle {
    
    const double ORACLE_IDENTIFICATION_THRESHOLD = 0.8;
    typedef boost::tuple<std::string, oracle::ObjectLoader*, oracle::ObjectRecognizer*> Model;
    struct ltstr {
      bool operator()(const Model& m1, 
                      const Model& m2) const {
        return strcmp(m1.get<0>().c_str(), m2.get<0>().c_str()) < 0;
      }
    };
    typedef std::set<Model, ltstr> ModelsDatabase;
    typedef ModelsDatabase::iterator ModelIterator;
    typedef std::map<std::string, double> RecognitionResults;
    typedef RecognitionResults::iterator ResultIterator;
    void addModel(ModelsDatabase& _database,
                  const std::string& _modelName, 
                  oracle::ObjectLoader* _loader,
                  oracle::ObjectRecognizer* _recognizer);
    void addModel(ModelsDatabase& _database,
                  const std::string& _modelName, 
                  oracle::ObjectLoader* _loader);
    ModelIterator getModel(ModelsDatabase& _database,
                           const std::string& _modelName);
    
    class ObjectIdentifier {

      /*
       * private attributes and methodes 
       */
      typedef enum IdentificationResult{
        FAILED_IDENTIFICATION,
        CONFIRMED_IDENTIFICATION,
        AMBIGOUS_IDENTIFICATION
      };
    
      private:
      gfm::DetectionResult m_detectedFeatures;
      gfm::MatchingResult m_matchedFeatures;
      ModelsDatabase m_database;
      RecognitionResults results;
      oracle::ObjectRecognizer* m_recognizer;
      image::Image request;
      IdentificationResult m_result;
      std::vector<std::string> plausibles;
      gfm::DetectionResult remaining;

      public:
      ObjectIdentifier() {};
      ObjectIdentifier(const ModelsDatabase& database);
      ~ObjectIdentifier();
      void addModel(const std::string& _modelName, 
                    oracle::ObjectLoader* _loader);
      void addModel(const std::string& _modelName, 
                    oracle::ObjectLoader* _loader,
                    oracle::ObjectRecognizer* _recognizer);
      oracle::ModelIterator getModel(const std::string& _modelName);
      void setQueryImage(const image::Image& _query);
      void setModelsDatabase(const ModelsDatabase& database);
      std::vector<std::string> identifiedObjects() const {
        return plausibles;
      }
      void process();
      private:
      void initialTry();
      void tryAgain(const gfm::DetectionResult& dr);
      void evaluateResult();
      gfm::DetectionResult remainingFeatures(const gfm::DetectionResult& dr,
                                             const gfm::MatchingResult& mr);
      bool isMatchedFeature(gfm::InterestFeature* f,
                            const gfm::MatchingResult& mr);
      ResultIterator bestRecognitionResult();
      ModelIterator bestModel();
    };//class ObjectIdentifier

  }//namespace oracle

}//namespace jafar

#endif