fingerprint.h

Go to the documentation of this file.

/**********************************************************************
fingerprint.h - Base class for fingerprints and fast searching 
 
Copyright (C) 2005 by Chris Morley
 
This file is part of the Open Babel project.
For more information, see <http://openbabel.sourceforge.net/>
 
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 version 2 of the License.
 
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.
***********************************************************************/

#ifndef OB_FINGERPRINT_H
#define OB_FINGERPRINT_H

#include <list>
#include <map>
#include <set>
#include <vector>
#include <string>

namespace OpenBabel
{
        class OBBase; //Forward declaration; used only as pointer.

class OBAPI OBFingerprint
{
//see end of cpp file for detailed documentation
public:
        void SetBit(std::vector<unsigned int>& vec, unsigned int n);    

        void Fold(std::vector<unsigned int>& vec, unsigned int nbits); 

        virtual bool GetFingerprint(OBBase* pOb, std::vector<unsigned int>& fp, int nbits=0)=0;

        virtual std::string Description()=0;

        enum FptFlag{FPT_UNIQUEBITS=1};
        virtual unsigned int Flags() { return 0;}; 

        static bool GetNextFPrt(std::string& id, OBFingerprint*& pFPrt);

        static OBFingerprint* FindFingerprint(std::string& ID);

        static double Tanimoto(const std::vector<unsigned int>& vec1, const std::vector<unsigned int>& vec2);
        
        static double Tanimoto(const std::vector<unsigned int>& vec1, const unsigned int* p2) 
        {
                int andbits=0, orbits=0;
                unsigned int i;
                for (i=0;i<vec1.size();++i)
                {
                        int andfp = vec1[i] & p2[i];
                        int orfp = vec1[i] | p2[i];
                        //Count bits
                        for(;andfp;andfp=andfp<<1)
                                if(andfp<0) ++andbits;
                        for(;orfp;orfp=orfp<<1)
                                if(orfp<0) ++orbits;
                }
                        return((double)andbits/(double)orbits);
        };
        
        static unsigned int Getbitsperint(){ return bitsperint; }

private:
        struct bit_or
        {
                unsigned int operator()(const unsigned int a, const unsigned int b)
                {
                        return a | b;   
                }
        };
        
        typedef std::map<std::string, OBFingerprint*> FPMapType;
        typedef FPMapType::iterator Fptpos;

protected:
        static FPMapType& FPtsMap()
        {
                static FPMapType* fptm = NULL;
                if (!fptm)
                  fptm = new FPMapType;
                return *fptm;
        };

        OBFingerprint(std::string ID, bool IsDefault=false)
        {
                FPtsMap()[ID] = this; //registers the derived fingerprint class
                if(IsDefault || FPtsMap().empty())
                        _pDefault=this;
        };
        
private:
        static OBFingerprint* _pDefault;
        static const unsigned int bitsperint;// = 8 * sizeof(unsigned int);
        static int rubbish;
};




//*************************************************************
//Fast search routines
struct OBAPI FptIndexHeader
{
        unsigned int headerlength;
        unsigned int nEntries;    
        unsigned int words;                             
        char fpid[16];            
        char datafilename[256];   
};
struct OBAPI FptIndex
{
        FptIndexHeader header;
        std::vector<unsigned int> fptdata;
        std::vector<unsigned int> seekdata;
        bool Read(std::istream* pIndexstream);
        OBFingerprint* CheckFP();
};

class OBAPI FastSearch
{
//see end of cpp file for detailed documentation
public:
  std::string ReadIndex(std::istream* pIndexstream);
        virtual ~FastSearch(){};

        bool    Find(OBBase* pOb, std::vector<unsigned int>& SeekPositions, unsigned int MaxCandidates);

        bool    FindSimilar(OBBase* pOb, std::multimap<double, unsigned int>& SeekposMap,
                double MinTani);

        bool    FindSimilar(OBBase* pOb, std::multimap<double, unsigned int>& SeekposMap,
                int nCandidates=0);

        OBFingerprint* GetFingerprint() const{ return _pFP;};

private:
        FptIndex   _index;
        OBFingerprint* _pFP;
};

//**********************************************
class OBAPI FastSearchIndexer
{
//see end of cpp file for detailed documentation
public:
        FastSearchIndexer(std::string& datafilename, std::ostream* os, std::string& fpid,
                        int FptBits=0);

        FastSearchIndexer(FptIndex* pindex, std::ostream* os);
        
        ~FastSearchIndexer();

        bool Add(OBBase* pOb, std::streampos seekpos);

private:
        std::ostream* _indexstream;
        FptIndex*               _pindex;
        OBFingerprint* _pFP;
        int _nbits;
};

} //namespace OpenBabel
#endif

---

This file is part of the documentation for Open Babel, version 2.0.2.

Documentation copyright © 1998-2005, the Open Babel Developers.
Open Babel is hosted by:
Generated on Thu Nov 30 20:18:00 2006 by  1.5.1.