System documentation of the GNU Image-Finding Tool

CQInvertedFile.h

/* -*- mode: c++ -*- 
*/
/* 

    GIFT, a flexible content based image retrieval system.
    Copyright (C) 1998, 1999, 2000, 2001, 2002, CUI University of Geneva

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/
// -*- mode: c++ -*-

#ifndef _CINVERTEDFILEQUERY
#define _CINVERTEDFILEQUERY
#include "libGIFTQuInvertedFile/include/uses-declarations.h"
#include <memory>
#include <map>
#include "libMRML/include/CSelfDestroyPointer.h"
#include "libMRML/include/CRelevanceLevelList.h"
#include "libMRML/include/CIDRelevanceLevelPairList.h"
#include "libGIFTQuInvertedFile/include/CWeightingFunctionPointerList.h"
#include "libGIFTQuInvertedFile/include/CWeightingFunctionPointerHash.h"
#include "libMRML/include/CAlgorithm.h"
#include "libMRML/include/CQuery.h"
#include "libGIFTAcInvertedFile/include/CAcInvertedFile.h"
#include "libGIFTQuInvertedFile/include/CWeightingFunction.h"
#include "libGIFTQuInvertedFile/include/CQueryNormalizer.h"
#include "libGIFTAcInvertedFile/include/WeightingFunctionsAndNormalizers.h"
class CScoreBoard;
class CAcInvertedFile;

#include "libGIFTQuInvertedFile/include/CWeighter.h"

class CWeighterFactory:protected map< string,CWeighter* >{
public:
  CWeighter* newWeighter(const string& inID)const;
  CWeighterFactory();
  ~CWeighterFactory();
};

class CQInvertedFile:public CQuery{

protected:


  CAlgorithm* mDeb;

  int mModulo;
  int mModuloClass;
  CWeighterFactory mWeighterFactory;
  CSelfDestroyPointer<CWeighter> mWeighter;

  CSelfDestroyPointer<CWeightingFunctionPointerHash> 
  mQueryFeatureWeighters;

  double keepScore(CScoreBoard& inoutScoreBoard,
                   const CWeightingFunctionPointerList& inFeatures,
                   bool lPositive)const;

  double keepScorePruning(CScoreBoard& inoutScoreBoard,
                          const CWeightingFunctionPointerList& inFeatures,
                          bool inPositive,
                          int inDesiredNumberOfDocuments)const;

  void buildQueryHash(CRelevanceLevelList& inQuery,
                      CWeightingFunctionPointerHash& 
                      outQueryFeatureWeighters)const;

  void buildNormalizedQueryList(double inPositiveRelevanceSum,
                                double inNegativeRelevanceSum,
                                CWeightingFunctionPointerHash& 
                                inQFW,
                                CWeightingFunctionPointerList& 
                                outQFW)const;

  void buildNormalizedQueryHash(double inPositiveRelevanceSum,
                                double inNegativeRelevanceSum,
                                CWeightingFunctionPointerHash& 
                                inQFW)const;
  
protected:
  void init();

public:
  void finishInit();
  CQInvertedFile(CAccessorAdminCollection& inAccessorAdminCollection,
                 CAlgorithm& inAlgorithm);
  ~CQInvertedFile();
  virtual bool setAlgorithm(CAlgorithm& inAlgorithm);


  virtual CIDRelevanceLevelPairList* fastQuery(const CXMLElement& inQuery,
                                               int inNumberOfInterestingImages,
                                               double inDifferenceToBest);
  
  virtual CIDRelevanceLevelPairList* fastQueryByFeature(const  CWeightingFunctionPointerList& inQuery,
                                                        int inNumberOfInterestingImages,
                                                        double inDifferenceToBest);
  
  double DIDToScore(TID inDID,
                    const CWeightingFunctionPointerHash& inQuery)const;


  double URLToScore(const string& inURL,
                    const CWeightingFunctionPointerHash& inQuery)const;

  double FeatureListToScore(TID inDID,
                            const CDocumentFrequencyList& inFeatureList,
                            const CWeightingFunctionPointerHash& inQuery)const;

  void buildNormalizedQueryHash(const CRelevanceLevel& inQuery,
                                CWeightingFunctionPointerHash& 
                                outQueryFeatureWeighters)const;


  /* variables needed for the blocking of special feature groups */

  /* the upper limit for the number of feature groups needed for the array for the blocking */
  static const int MAXIMUMNUMBEROFEATUREGROUPS=50; 
  /* you need to switch this on to activate the blocking of features */
  bool mBlockingOn;
  /* array with all the feature groups and an information if blocked or not */
  bool mBlockingArray[MAXIMUMNUMBEROFEATUREGROUPS];


  void activateBlockingFeatures();

  void releaseBlockingFeatures();

  bool featuresBlocked()const;

  void blockFeatureGroup(const int featureNumber);

  void unblockFeatureGroup(const int featureNumber);

  bool isBlocked(const int featureNumber)const;



  static const int MAX_SCOREBOARD_PRUNINGS=10; 

  bool mPruningUsed;

  bool mScoreBoardPruningUsed;
  typedef struct{ 
    double stopAfterFeature;
    double reduceTo;
  } parameterPruningType;
  parameterPruningType 
     mScoreBoardPruningArray[MAX_SCOREBOARD_PRUNINGS];
  int mNumberofUsedScoreBoardPrunings;

  /* true if feature pruning is used */
  bool mFeaturePruningUsed;
  double mPercentageofFeatures;

  /* true if time pruning is used */
  bool mTimePruningUsed;
  double mStoppingTime;

  /* if this variable is used with scoreboardpruning, the resulting 
     scoreboard will be evaluated with an uninverted file 
     @Author Henning Müller */
  bool mEvaluateAfterPruning;

  void releaseAllPrunings();


  void useFeaturePruning(double percentage);

  void releaseFeaturePruning();

  void useTimePruning(double inTimeCutoffPoint);

  void releaseTimePruning();

  void useScoreBoardPruning(double inCutAfterFraction,
                            double    inReduceToFactor);

  void releaseScoreBoardPruning();

  void useEvaluateAfterPruning();

  void releaseEvaluateAfterPruning();
  CWeighter& getWeighter();
}; /* end of class */

#endif

---

Need for discussion? Want to contribute? Contact