System documentation of the GNU Image-Finding Tool

CWeightingFunction.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

*/
#ifndef _CWEIGHTINGFUNCTION
#define _CWEIGHTINGFUNCTION
#include "libGIFTQuInvertedFile/include/uses-declarations.h"
#include <cmath>
#include "libMRML/include/TID.h"
#include "libGIFTAcInvertedFile/include/CDocumentFrequencyElement.h"
#include "libGIFTAcInvertedFile/include/CAcInvertedFile.h"

class CQueryNormalizer;

class CWeightingFunction{
protected:
  double mPositiveRelevanceSum;
  double mNegativeRelevanceSum;

  /* A pseudo term frequency calculated from the input
     at present by calculating the mean.

     mPositiveTermFrequency/mPositiveRelevanceSum is one term in a 
     a pseudo term frequency used for calculating query weights */
  double mPositiveTermFrequency;
  /* A pseudo term frequency calculated from the input
     at present by calculating the mean.

     mNegativeTermFrequency/mNegativeRelevanceSum is the other term in a 
     a pseudo term frequency used for calculating query weights */
  double mNegativeTermFrequency;

  int mFeatureDescription;

  TID mID;

  const CAcInvertedFile* mAccessor;

  mutable CQueryNormalizer* mQueryNormalizer;

  mutable CQueryNormalizer* mThisNormalizer;

  double mQueryFactor;
  double mDocumentFactor;

public:

  double getQueryFactor()const;

  virtual void preCalculate();

  CWeightingFunction(const CAcInvertedFile* inAccessor=0,
                     CQueryNormalizer* inQueryNormalizer=0,
                     CQueryNormalizer* inThisNormalizer=0);

  void setAccessor(const CAcInvertedFile*);

  void setNormalizers(CQueryNormalizer* inQueryNormalizer,
                      CQueryNormalizer* inThisNormalizer);

  void setID(TID);

  TID getID()const;

  void setRelevanceSum(double inPositiveRelevanceSum,
                       double inNegativeRelevanceSum);

  virtual void addQueryFeature(double inRelevanceLevel,
                               const CDocumentFrequencyElement& 
                               inQueryFeature);

  virtual double getTermFrequency()const;

  virtual double subApply(const double inDocumentFrequency,
                          const double inNormalizingFactor)const;

  virtual double apply(const CDocumentFrequencyElement& inResultFeature)const;

  double applyOnThis()const;

  virtual CWeightingFunction* constructNew(TID inID)const;

  virtual CWeightingFunction* clone()const;

  virtual ~CWeightingFunction();
  
  friend class CSortByDFTimesLogICF_WF;
};

bool operator<(const CWeightingFunction&,
               const CWeightingFunction&);

class CSortByFeatureID_WF:
  public binary_function
<CWeightingFunction,CWeightingFunction,bool>{
  inline bool operator()(const CWeightingFunction& l,
                         const CWeightingFunction& t){
    return l.getID()<t.getID();
  }
};

class CSortByDFTimesLogICF_WF:
  public binary_function
<CWeightingFunction,CWeightingFunction,bool>{
  inline bool operator()(const CWeightingFunction& l,
                         const CWeightingFunction& t){
    return 
      l.getTermFrequency()
      *
      fabs(log(l.mAccessor->FeatureToCollectionFrequency(l.getID())))
      <
      t.getTermFrequency()
      *
      fabs(log(t.mAccessor->FeatureToCollectionFrequency(t.getID())));
  };
};

class CSortByQueryFactor_WF:
  public binary_function
<CWeightingFunction,CWeightingFunction,bool>{
public:
  inline bool operator()(const CWeightingFunction& l,
                         const CWeightingFunction& t){
    return 
      l.getQueryFactor()
      <
      t.getQueryFactor();
  };
};
class CSortByAbsQueryFactor_WF:
  public binary_function
<CWeightingFunction,CWeightingFunction,bool>{
public:
  inline bool operator()(const CWeightingFunction& l,
                         const CWeightingFunction& t){
    return 
      fabs(l.getQueryFactor())
      <
      fabs(t.getQueryFactor());
  };
};

template<class CSortOp>
class CSortPointers_WF:
  binary_function<CWeightingFunction*,CWeightingFunction*,bool>{
protected:
  CSortOp mSorter;
public:
  inline CSortPointers_WF(){};
  inline bool operator()(const CWeightingFunction* l,
                         const CWeightingFunction* t){
    return mSorter(*l,*t);
  };
};

#include "libGIFTQuInvertedFile/include/CQueryNormalizer.h"

#endif

---

Need for discussion? Want to contribute? Contact