CQInvertedFile Class Reference

#include <CQInvertedFile.h>

Inheritance diagram for CQInvertedFile:

List of all members.

Public Member Functions
void	finishInit ()
	CQInvertedFile (CAccessorAdminCollection &inAccessorAdminCollection, CAlgorithm &inAlgorithm)
	~CQInvertedFile ()
virtual bool	setAlgorithm (CAlgorithm &inAlgorithm)
virtual CIDRelevanceLevelPairList *	fastQuery (const CXMLElement &inQuery, int inNumberOfInterestingImages, double inDifferenceToBest)
	a query which returns ID/RelevanceLevel pairs instead of instead of URL/RelevanceLevel pairs; this is faster for merging tasks (to explain the name) queries for URLs are answered by query (in herited)
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
void	activateBlockingFeatures ()
void	releaseBlockingFeatures ()
bool	featuresBlocked () const
void	blockFeatureGroup (const int featureNumber)
void	unblockFeatureGroup (const int featureNumber)
bool	isBlocked (const int featureNumber) const
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 ()
Public Attributes
bool	mBlockingOn
bool	mBlockingArray [MAXIMUMNUMBEROFEATUREGROUPS]
bool	mPruningUsed
bool	mScoreBoardPruningUsed
parameterPruningType	mScoreBoardPruningArray [MAX_SCOREBOARD_PRUNINGS]
int	mNumberofUsedScoreBoardPrunings
bool	mFeaturePruningUsed
double	mPercentageofFeatures
bool	mTimePruningUsed
double	mStoppingTime
bool	mEvaluateAfterPruning
Static Public Attributes
static const int	MAXIMUMNUMBEROFEATUREGROUPS = 50
static const int	MAX_SCOREBOARD_PRUNINGS = 10
Protected Member Functions
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
	creates a list of all the features which are in one or more of the query images should be replaced by a version which operates on IDs not URLs
void	buildNormalizedQueryList (double inPositiveRelevanceSum, double inNegativeRelevanceSum, CWeightingFunctionPointerHash &inQFW, CWeightingFunctionPointerList &outQFW) const
void	buildNormalizedQueryHash (double inPositiveRelevanceSum, double inNegativeRelevanceSum, CWeightingFunctionPointerHash &inQFW) const
void	init ()
Protected Attributes
CAlgorithm *	mDeb
int	mModulo
int	mModuloClass
CWeighterFactory	mWeighterFactory
CSelfDestroyPointer< CWeighter >	mWeighter
CSelfDestroyPointer < CWeightingFunctionPointerHash >	mQueryFeatureWeighters
Classes
struct	parameterPruningType

---

Detailed Description

The Query manager for Queries on inverted Files

Definition at line 96 of file CQInvertedFile.h.

---

Constructor & Destructor Documentation

CQInvertedFile::CQInvertedFile	(	CAccessorAdminCollection &	inAccessorAdminCollection,
		CAlgorithm &	inAlgorithm
	)

New constructor, taking as parameter the algorithm structure, which contains all the algorithm configuration

Definition at line 245 of file CQInvertedFile.cc.

References CNoDelete::activate(), init(), CQuery::mAccessor, CQuery::mAccessorAdmin, CQuery::mAlgorithm, mDeb, my_diagnose, my_throw, CAccessorAdmin::openAccessor(), and CXMLElement::stringReadAttribute().

00247               :
00248   CQuery(inAccessorAdminCollection,
00249    inAlgorithm){
00250   assert(&inAccessorAdminCollection);
00251   assert(&inAlgorithm);
00252   assert(&inAlgorithm==mAlgorithm);
00253   mDeb=mAlgorithm;
00254   mAlgorithm->activate();
00255   my_diagnose(&inAlgorithm);
00256 
00257   // mproxy has been filled in a reasonable way 
00258   // by CQuery::CQuery
00259   
00260   pair<bool,string> lSubType=inAlgorithm.stringReadAttribute("cui-sub-type");
00261 
00262   if(lSubType.first){
00263     if(lSubType.second=="mysql"){
00264       mAccessor=mAccessorAdmin->openAccessor("if_mysql");
00265     }else{
00266       mAccessor=mAccessorAdmin->openAccessor("inverted_file");
00267     }
00268   }else{
00269     mAccessor=mAccessorAdmin->openAccessor("inverted_file");
00270   }
00271   cout << "1st Checking accessor" << endl;
00272   //  mAccessor->checkNPrint();
00273 
00274   //there is something wrong between the generated 
00275   //accessor and what we want
00276   if(!mAccessor){
00277     cout << "throwing: "
00278    << (VEWrongAccessor("InvertedFileQuery"))
00279    << endl
00280    << flush;
00281     try{
00282       my_throw(VEWrongAccessor("InvertedFileQuery"));
00283     }
00284     catch(...){
00285       cout << "locally caught and rethrown"
00286      << flush;
00287       my_throw(VEWrongAccessor("InvertedFileQuery"));
00288     }
00289   }
00290 
00291   //here do additional things with the algorithm, if wanted and needed
00292   //which probably is the case
00293   init();
00294   cout << "++Accessor: " << mAccessor << flush << endl;
00295   cout << "Checking Accessor II"
00296        << endl;
00297   //mAccessor->checkNPrint();
00298   
00299   cout << "CQInvertedFile THIS:" << this << endl;
00300 };
CQInvertedFile::~CQInvertedFile(){

CQInvertedFile::~CQInvertedFile

(

)

destructor

Definition at line 301 of file CQInvertedFile.cc.

References CXMLElement::check(), CAccessorAdmin::closeAccessor(), CNoDelete::deActivate(), CQuery::mAccessorAdmin, CQuery::mAlgorithm, mDeb, and CXMLElement::stringReadAttribute().

                               {

  cout << "begin KILLING INVERTED FILE QUERY" << endl;
  assert(mDeb==mAlgorithm);
  if(mAlgorithm){
    mAlgorithm->check();
    pair<bool,string> lSubType=mAlgorithm->stringReadAttribute("cui-sub-type");
    if(lSubType.first){
      if(lSubType.second=="mysql"){
  mAccessorAdmin->closeAccessor("if_mysql");
      }else{
  mAccessorAdmin->closeAccessor("inverted_file");
      }
    }else{
      mAccessorAdmin->closeAccessor("inverted_file");
    }
  }
  mAlgorithm->deActivate();
  cout << "end KILLING INVERTED FILE QUERY" << endl;
}

---

Member Function Documentation

double CQInvertedFile::keepScore	(	CScoreBoard &	inoutScoreBoard,
		const CWeightingFunctionPointerList &	inFeatures,
		bool	lPositive
	)			const [protected]

calculates the score for all the images based on a list of features

Author:

Wolfgang Müller

Definition at line 1030 of file CQInvertedFile.cc.

References CDocumentFrequencyList::begin(), CDocumentFrequencyList::end(), and CQuery::mAccessor.

Referenced by fastQueryByFeature().

                                  {
  double lQueryScore=0;
  int lMaximumNumberofEvaluatedFeatures=int (inFeatures.size()*0.9);

  //For all query features
  int lCount=0;
  for(CWeightingFunctionPointerList::const_iterator i=inFeatures.begin();
      (i!=inFeatures.end()); 
      i++)
    {
    
      lCount++;



#ifndef _NO_FIDPRINT    
      cout << "[FID"
     << dec
     << (*i)->getID()
     << "]"
     << flush;
#endif

      /* adjusts the query score for one more feature, this does it for the
         query image itself to have a number to normalize with */
      lQueryScore+=
  (*i)->applyOnThis();
    
      //load list of documents which contain features
      CDocumentFrequencyList* lOneFeatureResult=
  ((CAcInvertedFile*)mAccessor)->FeatureToList((*i)->getID());

      //then adjust the score for the documents
      if(lOneFeatureResult)
  {
    for(CDocumentFrequencyList::iterator j=lOneFeatureResult->begin();
        j!=lOneFeatureResult->end();
        j++)
      {
        inoutScoreBoard(*(*i),*j);//one could say inoutScoreBoard.adjust(.,.)
      };
  }
      else{
  cerr << "FAILED:OneFeatureResult" 
       << endl 
       << flush;
      }
      delete lOneFeatureResult;

    }

  return lQueryScore;
};

double CQInvertedFile::keepScorePruning	(	CScoreBoard &	inoutScoreBoard,
		const CWeightingFunctionPointerList &	inFeatures,
		bool	inPositive,
		int	inDesiredNumberOfDocuments
	)			const [protected]

calculates the results for the images using some sort of pruning

Author:

Henning Müller

Definition at line 1100 of file CQInvertedFile.cc.

References CDocumentFrequencyList::begin(), CDocumentFrequencyList::end(), CScoreBoard::limitNumberTo(), CQuery::mAccessor, mFeaturePruningUsed, mNumberofUsedScoreBoardPrunings, mPercentageofFeatures, mScoreBoardPruningArray, mScoreBoardPruningUsed, mStoppingTime, mTimePruningUsed, CQInvertedFile::parameterPruningType::reduceTo, CScoreBoard::setIgnore(), and timeReached().

Referenced by fastQueryByFeature().

                    {
  double lQueryScore=0;
  int lNumberofFeatures=inFeatures.size();
  int lMaximumNumberofEvaluatedFeatures=int (lNumberofFeatures*mPercentageofFeatures/100);

  cout << "Pruning: I will evaluate "
       << lMaximumNumberofEvaluatedFeatures
       << " Features."
       << flush
       << endl;

  int lNextScoreBoardNumber=0;

  //For all query features
  int lCount=0;
  for(CWeightingFunctionPointerList::const_iterator i=inFeatures.begin();
      (i!=inFeatures.end())//FIXME for loop comparison
  && (!(mTimePruningUsed 
        && (timeReached(mStoppingTime)) 
        && (lCount>100)))
  && (!(mFeaturePruningUsed 
        && (lCount==lMaximumNumberofEvaluatedFeatures))); 
      i++)
    {
 
      lCount++;
      
      if(mScoreBoardPruningUsed)
  {
    if(mNumberofUsedScoreBoardPrunings>lNextScoreBoardNumber)
      {
        if(lCount== 
     (int (mScoreBoardPruningArray[lNextScoreBoardNumber]
           .stopAfterFeature*lNumberofFeatures)))
    {
#ifndef NOSCREENOUTPUT
      cout << mScoreBoardPruningArray[lNextScoreBoardNumber].reduceTo;
      cout<<"\n";
#endif
      inoutScoreBoard
        .limitNumberTo(int(mScoreBoardPruningArray
               [lNextScoreBoardNumber]
               .reduceTo
               *inElementsToRetrieve));
      inoutScoreBoard.setIgnore();
      lNextScoreBoardNumber++;
    }
      }
  }

#ifndef _NO_FIDPRINT    
      cout << "[FID"
     << dec
     << (*i)->getID()
     << "]"
     << flush;
#endif

      /* adjusts the query score for one more feature, this does it for the
         query image itself to have a number to normalize with */
      lQueryScore+=
  (*i)->applyOnThis();
    
      //load list of documents which contain features
      CDocumentFrequencyList* lOneFeatureResult=
  ((CAcInvertedFile*)mAccessor)->FeatureToList((*i)->getID());

      //then adjust the score for the documents
      if(lOneFeatureResult)
  {
    for(CDocumentFrequencyList::iterator j=lOneFeatureResult->begin();
        j!=lOneFeatureResult->end();
        j++)
      {
        inoutScoreBoard(*(*i),
            *j);//one could say inoutScoreBoard.adjust(.,.)
      };
  }
      else
  cerr << "FAILED:OneFeatureResult" 
       << endl 
       << flush;
      
      delete lOneFeatureResult;

    }
  /* this is only to reduce the list to a special number at the end */
  /*      inoutScoreBoard.limitNumberTo(20);*/


  return lQueryScore;
};

void CQInvertedFile::buildQueryHash	(	CRelevanceLevelList &	inQuery,
		CWeightingFunctionPointerHash &	outQueryFeatureWeighters
	)			const [protected]

creates a list of all the features which are in one or more of the query images should be replaced by a version which operates on IDs not URLs

Author:

Wolfgang Müller + Pruning: Henning Müller/reprogrammed WM 09-10-00

Definition at line 528 of file CQInvertedFile.cc.

References CWeightingFunctionPointerHash::addFeature(), CDocumentFrequencyList::begin(), CDocumentFrequencyList::end(), featuresBlocked(), isBlocked(), CQuery::mAccessor, mModulo, and mModuloClass.

Referenced by buildNormalizedQueryHash(), and fastQuery().

                                          {
  

  /* checks all the relevant images which were selected */
  for(CRelevanceLevelList::const_iterator i=inQuery.begin();
      i!=inQuery.end();
      i++){
    //Get the feature list for the URL of *i (that means: for each input image)
#ifndef NOSCREENOUTPUT
    cout<< "input image to URL: _"
  << (*i).getURL() 
  << "_"
  << endl
  << flush;
#endif
    
    CDocumentFrequencyList* lReadFeatures=
      ((CAcInvertedFile*)mAccessor)->URLToFeatureList((*i).getURL());

    /* 
       Build a new feature list without blocked features.
       There are several cases
    */
    if(featuresBlocked() && !mModulo){// adding features which are not blocked
      for(CDocumentFrequencyList::iterator 
      j=lReadFeatures->begin();
    j!=lReadFeatures->end();
    j++
    ){
  if(isBlocked(((CAcInvertedFile*)mAccessor)->getFeatureDescription(j->getID()))==false){
    outQueryFeatureWeighters.addFeature((*i).getRelevanceLevel(),
                *j);
  }
      } 
    }// END: adding features which are not blocked
    if(featuresBlocked() && mModulo){// adding features which are not blocked,
      // and for which the feature number has the right modulo
      // use of this: dispatching multiple query processors
      for(CDocumentFrequencyList::iterator 
      j=lReadFeatures->begin();
    j!=lReadFeatures->end();
    j++
    ){
  if((isBlocked(((CAcInvertedFile*)mAccessor)->getFeatureDescription(j->getID()))==false)
     && ((j->getID()) % mModulo == mModuloClass)){
    outQueryFeatureWeighters.addFeature((*i).getRelevanceLevel(),
                *j);
  } /* end of the loop for all the features of one image */
      } /* end of removing the blocked features from the list */
    }
    if(!featuresBlocked() && mModulo){
      for(CDocumentFrequencyList::iterator 
      j=lReadFeatures->begin();
    j!=lReadFeatures->end();
    j++
    ){
  if((j->getID()) % mModulo == mModuloClass){// adding features with the right modulo
    /* adds one of the features for a special image to the list */
    outQueryFeatureWeighters.addFeature((*i).getRelevanceLevel(),
                *j);
  } /* end of the loop for all the features of one image */
      } /* end of removing the blocked features from the list */
    }
    if(!featuresBlocked() && !mModulo){// adding all features
      for(CDocumentFrequencyList::iterator 
      j=lReadFeatures->begin();
    j!=lReadFeatures->end();
    j++
    ){
  /* adds one of the features for a special image to the list */
  outQueryFeatureWeighters.addFeature((*i).getRelevanceLevel(),
              *j);
      }
    }
    
#ifndef NOSCREENOUTPUT
    cout << "gotten HERE"
   << flush
   << endl;
#endif  

   
#ifdef PRINT
    cout << endl
   << (*i).getURL()
   << " "
   << lRelevanceLevel
   << endl;
#endif
    delete(lReadFeatures);    
  }/* end of the loop for every image in the query */
}

void CQInvertedFile::buildNormalizedQueryList	(	double	inPositiveRelevanceSum,
		double	inNegativeRelevanceSum,
		CWeightingFunctionPointerHash &	inQFW,
		CWeightingFunctionPointerList &	outQFW
	)			const [protected]

Building a list of normalized WF from a hash of Weighting functions

Definition at line 677 of file CQInvertedFile.cc.

References buildNormalizedQueryHash(), CQuery::mAccessor, mWeighter, and stampTime().

Referenced by fastQuery().

{
  //Just to make sure...
  mWeighter->getQueryNormalizer()->reset();
  mWeighter->getDocumentNormalizer()->reset();


  buildNormalizedQueryHash(inPositiveRelevanceSum,
         inNegativeRelevanceSum,
         inoutQFW);

#ifndef NOSCREENOUTPUT
  cout<<"normalized List build\n";
  stampTime();
#endif

  for(CWeightingFunctionPointerHash::const_iterator i=inoutQFW.begin();
      i!=inoutQFW.end();
      i++){
    outQFW.push_back((*i).second);
  }

  
  outQFW.sort(CSortPointers_WF <CSortByAbsQueryFactor_WF>());
  outQFW.reverse();


  /* test to print out the list with the sorted features */
#ifndef _NO_PRINT_QFW
  cout << "--------------------"
       << "The query feature weighters: "
       << endl;

  for(CWeightingFunctionPointerList::const_iterator j=outQFW.begin();
      j!=outQFW.end();
      j++)
      {
      cout<<(*j)->getID();
      cout<<";";
      cout<<((CAcInvertedFile*)mAccessor)->FeatureToCollectionFrequency((*j)->getID());
      
      cout<<";";
      cout<<(*j)->getTermFrequency();
      cout<<";";
      cout<<((CAcInvertedFile*)mAccessor)->getFeatureDescription((*j)->getID());
      cout<<"\n";
    }
#endif
}

void CQInvertedFile::buildNormalizedQueryHash	(	double	inPositiveRelevanceSum,
		double	inNegativeRelevanceSum,
		CWeightingFunctionPointerHash &	inQFW
	)			const [protected]

Building a list of normalized WF from a hash of Weighting functions

Definition at line 637 of file CQInvertedFile.cc.

References CQueryNormalizer::considerQueryFeature(), and mWeighter.

Referenced by buildNormalizedQueryHash(), and buildNormalizedQueryList().

                                                     {
  //Just to make sure...
  mWeighter->getQueryNormalizer()->reset();
  mWeighter->getDocumentNormalizer()->reset();
  
  /* for every weighting function, meaning for every element in the list of important features */


  {//for limiting the scope of the following variable definitions
    CQueryNormalizer* lDocumentNormalizer=mWeighter->getDocumentNormalizer();
    CQueryNormalizer* lQueryNormalizer=mWeighter->getQueryNormalizer();
    for(CWeightingFunctionPointerHash::const_iterator j=inoutQFW.begin();
  j!=inoutQFW.end();
  j++)
      {
  /* calculates the relevant values for the normalizing of the function */
  lQueryNormalizer->considerQueryFeature(*(*j).second);
  lDocumentNormalizer->considerQueryFeature(*(*j).second);
  
  (*j).second->setRelevanceSum(inPositiveRelevanceSum,
             inNegativeRelevanceSum);
  (*j).second->preCalculate();
    }
  }
}

void CQInvertedFile::init

(

)

[protected, virtual]

Initializer, used by both construcors

Implements CQuery.

Definition at line 361 of file CQInvertedFile.cc.

References blockFeatureGroup(), CXMLElement::boolReadAttribute(), COL_HST, COL_POS, mrml_const::cui_block_color_blocks, mrml_const::cui_block_color_histogram, mrml_const::cui_block_texture_blocks, mrml_const::cui_block_texture_histogram, mrml_const::cui_pr_modulo, mrml_const::cui_pr_modulo_class, mrml_const::cui_pr_percentage_of_features, mrml_const::cui_pr_score_board_reduced_at, mrml_const::cui_pr_score_board_reduced_to, mrml_const::cui_pr_time_cutoff_point, mrml_const::cui_weighting_function, CXMLElement::doubleReadAttribute(), GABOR_HST, GABOR_POS, CXMLElement::longReadAttribute(), CQuery::mAccessor, CQuery::mAlgorithm, MAX_SCOREBOARD_PRUNINGS, MAXIMUMNUMBEROFEATUREGROUPS, mBlockingArray, mBlockingOn, mEvaluateAfterPruning, mFeaturePruningUsed, mModulo, mModuloClass, mNumberofUsedScoreBoardPrunings, mPercentageofFeatures, mPruningUsed, mQueryFeatureWeighters, mScoreBoardPruningArray, mScoreBoardPruningUsed, mStoppingTime, mTimePruningUsed, mWeighter, mWeighterFactory, my_diagnose, CWeighterFactory::newWeighter(), CQInvertedFile::parameterPruningType::reduceTo, releaseBlockingFeatures(), CQInvertedFile::parameterPruningType::stopAfterFeature, CXMLElement::stringReadAttribute(), CXMLElement::toXML(), useFeaturePruning(), useScoreBoardPruning(), and useTimePruning().

Referenced by CQInvertedFile().

                         {
  int i;

  if(mAlgorithm){
    string lString("");
    mAlgorithm->toXML(lString,5);
    
    cout << "çççççççççççççççççççççççççççççççççççççççç" << endl
   << lString
   << "çççççççççççççççççççççççççççççççççççççççç" << endl
   << flush;
  }
    
  if(mAlgorithm){
    mWeighter=mWeighterFactory
      .newWeighter(mAlgorithm
       ->stringReadAttribute(mrml_const::cui_weighting_function).second);
  }

  mQueryFeatureWeighters= 
    new CWeightingFunctionPointerHash(*mWeighter->getWeightingFunction());


  mWeighter->setAccessor((*(CAcInvertedFile*)mAccessor));


  /* parameter for the seperate normalization of positive and 
     negative feedback */
  /*  mSeperateNormalizationofPositiveandNegativeImages=false;*/

  /* turns off the blocking of features */
  mBlockingOn=false; 

  /* clears the file with the selective blocking, all features
     need to be blocked actively, if wanted */
  for(i=0;i<MAXIMUMNUMBEROFEATUREGROUPS;i++)
    {
      mBlockingArray[i]=false;
    }
  
  /* parameters for pruning (Henning)*/
  mPruningUsed=false;
  mScoreBoardPruningUsed=false;
  mNumberofUsedScoreBoardPrunings=0;
  mFeaturePruningUsed=false;
  mTimePruningUsed=false;
  mStoppingTime=0;
  mPercentageofFeatures=0;
  for(i=0;i<MAX_SCOREBOARD_PRUNINGS;i++)
    {
      mScoreBoardPruningArray[i].stopAfterFeature=0;
      mScoreBoardPruningArray[i].reduceTo=0;
   }
  mEvaluateAfterPruning=false;


  /* now set the pruning parameters 
     this is made by me, WOLFGANG, so there can be some
     BUGS.
  */
  if(mAlgorithm){

    string lString("");
    mAlgorithm->toXML(lString,5);
    my_diagnose(lString);


    releaseBlockingFeatures();
    {
      pair<bool,bool> lBlock=
  mAlgorithm->boolReadAttribute(string(mrml_const::cui_block_color_histogram));

      cout << "%%%%%%%%%%%%%%%%%%%%"
     << mAlgorithm->stringReadAttribute(string(mrml_const::cui_block_color_histogram)).second
     << endl;
      if(lBlock.first && lBlock.second){
  blockFeatureGroup(COL_HST);
      }
    }
    {
      pair<bool,bool> lBlock=
  mAlgorithm->boolReadAttribute(string(mrml_const::cui_block_texture_histogram));
      if(lBlock.first && lBlock.second){
  blockFeatureGroup(GABOR_HST);
      }
    }
    {
      pair<bool,bool> lBlock=
  mAlgorithm->boolReadAttribute(string(mrml_const::cui_block_color_blocks));
      if(lBlock.first && (lBlock.second)){
  blockFeatureGroup(COL_POS);
      }
    }
    {
      pair<bool,bool> lBlock=
  mAlgorithm->boolReadAttribute(string(mrml_const::cui_block_texture_blocks));
      if(lBlock.first && (lBlock.second)){
  blockFeatureGroup(GABOR_POS);
      }
    }
    {
      pair<bool,double> lTimeCutoffPoint=
  mAlgorithm->doubleReadAttribute(string(mrml_const::cui_pr_time_cutoff_point));
      if(lTimeCutoffPoint.first){
  useTimePruning(lTimeCutoffPoint.second);
      }
    }
    {
      pair<bool,double> lPercentageOfFeatures=
  mAlgorithm->doubleReadAttribute(string(mrml_const::cui_pr_percentage_of_features));
      if(lPercentageOfFeatures.first){
  useFeaturePruning(lPercentageOfFeatures.second);
      }
    }
    {
      pair<bool,double> lScoreBoardReducedAt=
  mAlgorithm->doubleReadAttribute(string(mrml_const::cui_pr_score_board_reduced_at));

      pair<bool,int> lScoreBoardReducedTo=
  mAlgorithm->longReadAttribute(string(mrml_const::cui_pr_score_board_reduced_to));

      if(lScoreBoardReducedAt.first
   &&
   lScoreBoardReducedTo.first){
  useScoreBoardPruning(lScoreBoardReducedAt.second,
           lScoreBoardReducedTo.second);
      }
    }
    {
      pair<bool,int> lModulo=
  mAlgorithm->longReadAttribute(string(mrml_const::cui_pr_modulo));

      pair<bool,int> lModuloClass=
  mAlgorithm->longReadAttribute(string(mrml_const::cui_pr_modulo_class));
      
      if(lModulo.first){
  mModulo=lModulo.second;
  if(lModuloClass.first){
    mModuloClass=lModuloClass.second;
  }else{
    mModuloClass=0;
  }
      }else{
  mModulo=0;
  mModuloClass=0;
      }
    }
  }
  cout << "Init finished " 
       << flush
       << endl;
};

void CQInvertedFile::finishInit

(

)

[virtual]

finish the initialisation phase make the weighting function know who its normalizers are

Reimplemented from CQuery.

Definition at line 1673 of file CQInvertedFile.cc.

References CQuery::mAccessor, mWeighter, and my_throw.

                               {
  CAcInvertedFile* lAccessor=
    dynamic_cast<CAcInvertedFile*>(mAccessor);
  
  if(!lAccessor){
    my_throw(VEWrongAlgorithm("finishInit"));
  }

  mWeighter->setAccessor(*lAccessor);

  
}

bool CQInvertedFile::setAlgorithm

(

CAlgorithm &

inAlgorithm

)

[virtual]

set the Algorithm. same scheme as in setCollection

Reimplemented from CQuery.

Definition at line 328 of file CQInvertedFile.cc.

References CAccessorAdmin::closeAccessor(), CAlgorithm::getCollectionID(), CAccessorAdminCollection::getProxy(), CQuery::mAccessor, CQuery::mAccessorAdmin, CQuery::mAccessorAdminCollection, CQuery::mAlgorithm, CAccessorAdmin::openAccessor(), and CQuery::setAlgorithm().

                                                        {
  cout << "SETALGORITHM" << endl;

  if(mAlgorithm->getCollectionID()==inAlgorithm.getCollectionID()){
    
    return true;
    
  }else{
    cout << "OPENACCESSOR" << endl;
    //close the old collection
    mAccessorAdmin->closeAccessor("inverted_file");

    //
    mAccessorAdmin=&mAccessorAdminCollection->getProxy(inAlgorithm.getCollectionID());
    mAccessor=mAccessorAdmin->openAccessor("inverted_file");

    //
    return (mAccessor && CQuery::setAlgorithm(inAlgorithm));
  }
};

CIDRelevanceLevelPairList * CQInvertedFile::fastQuery	(	const CXMLElement &	inQuery,
		int	inNumberOfInterestingImages,
		double	inDifferenceToBest
	)			[virtual]

a query which returns ID/RelevanceLevel pairs instead of instead of URL/RelevanceLevel pairs; this is faster for merging tasks (to explain the name) queries for URLs are answered by query (in herited)

Implements CQuery.

Definition at line 747 of file CQInvertedFile.cc.

References buildNormalizedQueryList(), buildQueryHash(), CXMLElement::child_list_begin(), CXMLElement::child_list_end(), fastQueryByFeature(), CQuery::getRandomIDs(), mrml_const::image_location, CQuery::mAccessor, mQueryFeatureWeighters, mWeighter, stampTime(), mrml_const::user_relevance, mrml_const::user_relevance_element, and mrml_const::user_relevance_element_list.

                                    {

  cout << "--Accessor: " 
       << flush 
       << mAccessor 
       << flush 
       << endl;

  mQueryFeatureWeighters->clearFeatures();


  double lPositiveSum(0);
  double lNegativeSum(0);


  CRelevanceLevelList lQuery;

  // In the query tree I got, i simply look for 
  // the element containing a user-relevance-list
  
  bool lIsEmpty(true);// is there no image in the query?
  for(list<CXMLElement*>::const_iterator i=inQuery.child_list_begin();
      i!=inQuery.child_list_end();
      i++){

//     cout << "I:The name of this tree element: "
//   << endl
//   << (*i)->getName()
//   << endl;
    if((*i)->getName()=="cui-inverted-file-query-by-feature"){
      for(list<CXMLElement*>::const_iterator j=(*i)->child_list_begin();
    j!=(*i)->child_list_end();
    j++){
  if((*j)->getName()=="cui-term-frequency-element"){
    pair<bool,int> lFeatureID((*j)->longReadAttribute("feature-id"));
    pair<bool,double> lTermFrequency((*j)->doubleReadAttribute("term-frequency"));
    
    if(lFeatureID.first){
      if(lTermFrequency.first){
          mQueryFeatureWeighters->addFeature(lTermFrequency.second,CDocumentFrequencyElement(lFeatureID.second,
                           1));
      }else{
        mQueryFeatureWeighters->addFeature(1,CDocumentFrequencyElement(lFeatureID.second,
                       1));
      }
    }
  }
      }
    }
    if((*i)->getName()==mrml_const::user_relevance_element_list){
      for(list<CXMLElement*>::const_iterator j=(*i)->child_list_begin();
    j!=(*i)->child_list_end();
    j++){
//  cout << "J:The name of this tree element: "
//       << endl
//       << (*j)->getName()
//       << endl;
  if((*j)->getName()==mrml_const::user_relevance_element){
    if(((*j)->stringReadAttribute(mrml_const::image_location).first)
       &&
       ((*j)->stringReadAttribute(mrml_const::user_relevance).first)){
      
      if(fabs((*j)->doubleReadAttribute(mrml_const::user_relevance).second)>0.001){
        lQuery.push_back(CRelevanceLevel((*j)->stringReadAttribute(mrml_const::image_location).second,
                 (*j)->doubleReadAttribute(mrml_const::user_relevance).second));
        if(lQuery.back().getRelevanceLevel()>0){
    lIsEmpty=false;
    lPositiveSum+=lQuery.back().getRelevanceLevel();
        }else{
    lIsEmpty=false;
    lNegativeSum+=lQuery.back().getRelevanceLevel();
        }
      }
    }
  }
      }
    }
  }
  
  if(lIsEmpty){
    cout << "THE QUERY IS EMPTY" << endl;
    //which means, random images are requested
    return getRandomIDs(inNumberOfInterestingImages);
    cout << "RETURNING" << endl;
  }



  //... but more successfully
  cout << "Query number of documents: "
       << lQuery.size()
       << "The document: ";
  if(lQuery.size()){
    cout << lQuery.front().getRelevanceLevel()
   << ","
   << lQuery.front().getURL()
   << "\n"
   << endl;
  }else{
    cout << "NO DOCUMENT"
   << endl;
  }
#ifndef NOSCREENOUTPUT
#endif

  //in case of an empty query
  if(!lQuery.size()){
    return new CIDRelevanceLevelPairList();
  }

  double lRelevanceSum=0; /* */
  
  //resets the normalizer for the query
  mWeighter->getQueryNormalizer()->reset();
  mWeighter->getDocumentNormalizer()->reset();

#ifndef NOSCREENOUTPUT
  cout << "building query" 
       << endl 
       << flush;
  stampTime();
#endif  

  /* creates a list of a all the features in all the input images */
  buildQueryHash(lQuery,
     *mQueryFeatureWeighters);
  
#ifndef NOSCREENOUTPUT
  stampTime();
  cout << "..finished:left:" << mQueryFeatureWeighters->size() << endl;
#endif
  
  /* this is a list with all the weightings for every feature */
  CWeightingFunctionPointerList lParameters;
  
  /* and the list for every feature and its weighting is created here */
  buildNormalizedQueryList(lPositiveSum,
         lNegativeSum,
         *mQueryFeatureWeighters,
         lParameters);


  return fastQueryByFeature(lParameters,
          inNumberOfInterestingImages,
          inThreshold);
}

CIDRelevanceLevelPairList * CQInvertedFile::fastQueryByFeature	(	const CWeightingFunctionPointerList &	inQuery,
		int	inNumberOfInterestingImages,
		double	inThreshold
	)			[virtual]

Assuming that a correct CWeightingFunctionPointerHash has been built by fastQuery (or another function), this function will do the rest

Definition at line 902 of file CQInvertedFile.cc.

References keepScore(), keepScorePruning(), mPruningUsed, and stampTime().

Referenced by fastQuery().

                                       {
  

#ifndef NOSCREENOUTPUT
  cout << "query." << flush << endl;
  stampTime();
#endif

  //A score for each document, 
  //each score is initialized with zero
  CScoreBoard lScoreBoard;
  
  double lQueryScore;
  
  /* calculates the value for the answer images */
  if (mPruningUsed)
    {
      cout << "Pruning used!"
     << endl;


      lQueryScore=(keepScorePruning(lScoreBoard,
            inQuery,
            true,
            inNumberOfInterestingImages
            ));
    }
  else
    {
      cout << "Pruning NOT used!"
     << endl;

      lQueryScore=(keepScore(lScoreBoard,
           inQuery,
           true));
    }

#ifndef NOSCREENOUTPUT
  stampTime();
  cout << ".query" << flush << endl;
#endif

  //Normalizing scores by query score and building a list from it
  CIDRelevanceLevelPairList* lReturnValue=new CIDRelevanceLevelPairList(); // list for the contents of the ScoreBoard
  for(CScoreBoard::iterator i=lScoreBoard.begin();
      i!=lScoreBoard.end();
      i++){
    (*i).second/=fabs(lQueryScore);
    lReturnValue->push_back(CIDRelevanceLevelPair(i->first,
              i->second));
  }
  
#ifndef NOSCREENOUTPUT
  cout << "presort" << flush << endl;
  stampTime();
#endif
  
  lReturnValue->sort();
  lReturnValue->reverse();
  
  //Iterate over the wanted elements
  CIDRelevanceLevelPairList::iterator iWantedElements=lReturnValue->begin(); 

  //skip inNumberOfInterestingImages and delete the rest of the
  //output list
  for(int lNumberOfSkippedImages=0;
      (lNumberOfSkippedImages
       <
       inNumberOfInterestingImages)
  && 
  (iWantedElements!=lReturnValue->end());
      iWantedElements++,
  lNumberOfSkippedImages++
      ){
  }
  
  if(iWantedElements!=lReturnValue->end()){
    lReturnValue->erase(iWantedElements,lReturnValue->end());
  }
  
  
  //Delete all results below threshold if threshold>0.0
  if(inThreshold>0.0001){
    for(CIDRelevanceLevelPairList::iterator i=lReturnValue->begin();
  i!=lReturnValue->end();){
      if((*i).getRelevanceLevel()<inThreshold){
  cout << "eliminating:" 
       << inNumberOfInterestingImages
       << ":"
       << inThreshold
       << ">"
       << (*i).getRelevanceLevel()
       << endl;
  
  lReturnValue->erase(i++);
      }else{
  i++;
      }
    }
  }

#ifndef NOSCREENOUTPUT
  stampTime();
  cout << "postsort" 
       << flush 
       << endl;
#endif
  return lReturnValue;
}

double CQInvertedFile::DIDToScore	(	TID	inDID,
		const CWeightingFunctionPointerHash &	inQuery
	)			const

Returns t