|| || || || || ||

---

Bayes.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_Bayes_h
#define Impala_Core_Table_Bayes_h

namespace Impala
{
namespace Core
{
namespace Table
{

class Bayes
{
public:

    Bayes(String annoSetName, String setName, String genreSet, String conceptSet, 
                                              String quid, int nStart,int nEnd)
    {
        mAnnoSetName = annoSetName;
        mSetName = setName;
        mGenreSet = genreSet;     //genre set: g_{j}
        mConceptSet = conceptSet; //concept set: c_{k}
        mQuid = quid;

        if (quid == "Image")
        {
            mIsImageSet = true;
            //mImgSet = (Core::ImageSet::ImageSet*) mSet;
            //mAnnoImgSet = (Core::ImageSet::ImageSet*) mAnnoSet;
        }
        else
        {
            mIsImageSet = false;
            //mVidSet = (Core::VideoSet::VideoSet*)mSet;
            //mAnnoVidSet = (Core::VideoSet::VideoSet*)mAnnoSet;
        }

        mbDumpTable = false;
        mStart = nStart;
        mEnd = nEnd;

        //mVerbose = false;
        mVerbose = true;

        mTableSize = 0;

        mMatrixFile = "Genre/" + mConceptSet + "/" + mGenreSet + "_" + "ConProb.matrix";
    
        if (mAnnoSetName != "")
        {
            if (mIsImageSet)
            {
                mAnnoImgSet = Core::ImageSet::MakeImageSet(mAnnoSetName);
                mTabGenreSet = Core::Table::AnnotationTableSet::MakeFromFile(mAnnoImgSet, mGenreSet, true,
                                                                         StringToQuidClass(mQuid));
                mTabConceptSet = Core::Table::AnnotationTableSet::MakeFromFile(mAnnoImgSet, mConceptSet, true,
                                                                           StringToQuidClass(mQuid));
            }
            else
            {
                mAnnoVidSet = Core::VideoSet::MakeVideoSet(mAnnoSetName);
                mTabGenreSet = Core::Table::AnnotationTableSet::MakeFromFile(mAnnoVidSet, mGenreSet, true,
                                                                         StringToQuidClass(mQuid));
                mTabConceptSet = Core::Table::AnnotationTableSet::MakeFromFile(mAnnoVidSet, mConceptSet, true,
                                                                           StringToQuidClass(mQuid));
            }
            mHasAnnotation = true;

                

            // need to check the existence of the data set
            if (mTabGenreSet == NULL || mTabConceptSet == NULL)
            {
                printf("ERROR: The Concept or Genre Set does NOT exist.\n");
                return;
            }

            mGenreNum = mTabGenreSet->Size();
            mConceptNum = mTabConceptSet->Size();
            //_ASSERT(mGenreNum>0 && mConceptNum>0);
            if (mGenreNum<0 || mConceptNum<0)
            {
                printf("ERROR: The number of concept or genre is Zero.\n");
                return;
            }

            tabConcept = new AnnotationTable* [mConceptNum];
            tabGenre = new AnnotationTable* [mGenreNum];

            AllocateMatrix(mProb_c_g, mConceptNum, mGenreNum);
            ResetMatrix(mProb_c_g, mConceptNum, mGenreNum);

            InitializeAnnoTables();
            VerifyAndSetAnnoTableSize();
            //_ASSERT(mAnnoTableSize>0);

            if (mAnnoTableSize<0)
            {
                printf("ERROR: The annotation table size is Zero.\n");
                return;
            }

            //mAnnoQuidTable = mTabGenreSet->GetTable(0);
        }
        else
        {
            mAnnoVidSet = NULL;         
            mAnnoImgSet = NULL;   
            mGenreNum = 0;
            mConceptNum = 0;
            tabConcept = NULL;
            tabGenre = NULL;

            std::cout << "Note: Annotation Data Set is NOT given." << std::endl;

            mHasAnnotation = false;
        }

        if (mSetName != "")
        {
            if (mIsImageSet)
                mImgSet = Core::ImageSet::MakeImageSet(mSetName);
            else
                mVidSet = Core::VideoSet::MakeVideoSet(mSetName);
            mHandleTestSet = true;
        }
        else
        {
            mVidSet = NULL;
            mImgSet = NULL;
            mHandleTestSet = false;

            std::cout << "Note: Test Data Set is NOT given." << std::endl;
        }

    }

    virtual ~Bayes()
    {
        for (int k=0;k<mConceptNum;k++)
        {
            delete []tabConcept[k];
        }
        for (int j=0;j<mGenreNum;j++)
        {
            delete []tabGenre[j];
        }
        delete []tabConcept;
        delete []tabGenre;
     
        delete mTabGenreSet;
        delete mTabConceptSet;

        if (mIsImageSet)
        {
            if (NULL != mAnnoImgSet)
                delete mAnnoImgSet;
            if (NULL != mImgSet)
                delete mImgSet;
        }
        else
        {
            if (NULL != mAnnoVidSet)
                delete mAnnoVidSet;
            if (NULL != mVidSet)
                delete mVidSet;
        }

        //delete mAnnoQuidTable;

        ReleaseMatrix(mProb_c_g, mConceptNum);

    }

    bool
    HasAnnotation()
    {
        return mHasAnnotation;
    }

    int
    GetGenreNum() const
    {
        return mGenreNum;
    }

    int
    GetConceptNum() const
    {
        return mConceptNum;
    }

    int
    GetAnnoTableSize() const
    {
        return mAnnoTableSize;
    }

    int
    GetTableSize() const
    {
        return mTableSize;
    }

    void
    InitializeAnnoTables()
    {
        InitializeConceptAnnoTables();
        InitializeGenreAnnoTables();
    }

    void
    InitializeConceptAnnoTables()
    {
        // initialize all concept tables
        for (int k=0 ; k< mConceptNum ; k++)
        {
            //AnnotationTable* tabConcept = mTabConceptSet->GetTable(k);
            tabConcept[k] = mTabConceptSet->GetTable(k);
            if (mbDumpTable)
            {
                if (mIsImageSet)
                    tabConcept[k]->Dump(mAnnoImgSet, mStart, mEnd);
                else
                    tabConcept[k]->Dump(mAnnoVidSet, mStart, mEnd);
                //tabConcept[k]->DumpSummary();
            }  

        }

    }

    void
    InitializeGenreAnnoTables()
    {
        // initialize all genre tables
        for (int j=0 ; j < mGenreNum ; j++)
        {
            //AnnotationTable* tabGenre = mTabGenreSet->GetTable(j);
            tabGenre[j] = mTabGenreSet->GetTable(j);
            if (mbDumpTable)
            {
                if (mIsImageSet)
                    tabGenre[j]->Dump(mAnnoImgSet, mStart, mEnd);
                else
                    tabGenre[j]->Dump(mAnnoVidSet, mStart, mEnd);
                //tabGenre[j]->DumpSummary();
            }
            
        }

    }

    void
    VerifyAndSetAnnoTableSize()
    {
        // the table size should be the same as the total keyframes
        int nTempTabSize = 0;

        bool bIsConceptValid = true;
        bool bIsGenreValid = true;

        // loop for all concepts c_{k}
        for (int k=0 ; k< mConceptNum ; k++)
        {
            int tabSize = tabConcept[k]->Capacity();

            if (0 == nTempTabSize)
            {
                nTempTabSize = tabSize;

            } else {
                if (nTempTabSize != tabSize)
                {
                    printf("Warnning: Concept %d table size %d is different.\n", k, tabSize);
                    bIsConceptValid = false;
                }
            }
            
        }

        // loop for all video genres
        for (int j=0 ; j < mGenreNum ; j++)
        {
            int tabSize = tabGenre[j]->Capacity();

            if (0 == nTempTabSize)
            {
                nTempTabSize = tabSize;

            } else {
                if (nTempTabSize != tabSize)
                {
                    printf("Warnning: Genre %d table size %d is different.\n", j, tabSize);
                    bIsGenreValid = false;
                }
            }
        }

        if (!bIsConceptValid || !bIsGenreValid)
        {
            printf("Warnning: Attention! Some tables have different size.\n");
        }

        // set table size
        mAnnoTableSize = nTempTabSize;
        //_ASSERT(mAnnoTableSize>0);

        std::cout << "Anno Table Size = " << mAnnoTableSize << std::endl;

    }

    void
    SaveQuidTablePerGenre(bool bWrite)
    {
        if (mAnnoTableSize == 0)
        {
            std::cout << "The table size is zero: NOT acceptable" <<std::endl;
            return;
        }
        std::cout<<std::endl<<"Genre Prior Probability:" <<std::endl <<std::endl;

        // loop for all video genres
        for (int j=0 ; j < mGenreNum ; j++)
        {
            // we do not consider skipped samples currectly
            int posNum = tabGenre[j]->GetNrPositive();
            int negNum = tabGenre[j]->GetNrNegative();
            String strGenre = tabGenre[j]->GetLabel();

            Core::Table::QuidTable* posQuidTable = new Core::Table::QuidTable(posNum);
            Core::Table::QuidTable* negQuidTable = new Core::Table::QuidTable(negNum);

            for (int i=0 ; i<mAnnoTableSize ; i++)
            {
                Quid q = tabGenre[j]->Get1(i);
                if ( tabGenre[j]->IsPositive(i) )
                {
                    posQuidTable->Add(q);
                }
                if ( tabGenre[j]->IsNegative(i))
                {
                    negQuidTable->Add(q);
                }
            }

            if (bWrite)
            {
                String fPosName = "Annotations/Genre/" + mGenreSet + "/" + strGenre + "_pos.tab";
                String fNegName = "Annotations/Genre/" + mGenreSet + "/" + strGenre + "_neg.tab";
                //String fName = mAnnoVidSet->GetFilePathAnnotation(name,true,false);
                //String fName = mAnnoImgSet->GetFilePathAnnotation(name,true,false);
                if (!fPosName.empty())
                {
                    if (mIsImageSet)
                        Core::Table::Write(posQuidTable, fPosName, mAnnoImgSet->GetDatabase(), true);
                    else
                        Core::Table::Write(posQuidTable, fPosName, mAnnoVidSet->GetDatabase(), true);
                    std::cout << "Saved: [" << posNum << "] " << fPosName << std::endl; 
                }
                if (!fNegName.empty())
                {
                    if (mIsImageSet)
                        Core::Table::Write(negQuidTable, fNegName, mAnnoImgSet->GetDatabase(), true);
                    else
                        Core::Table::Write(negQuidTable, fNegName, mAnnoVidSet->GetDatabase(), true);
                    std::cout << "Saved: [" << negNum << "] " << fNegName << std::endl; 
                }
            }

            delete posQuidTable;
            delete negQuidTable;

        }

        int x=0;
    }

    void
    DumpMatrix(char* name, double** matrix, int nRow, int nCol, bool bDumpFloat = true)
    {
        std::cout << std::endl << name <<" (" << nRow << " x " << nCol << "):" << std::endl;

        // dump order: row 0, row 1, ...
        for (int j=0; j<nCol; j++)
        {
            for (int i=0; i<nRow; i++)
            {
                //std::cout << matrix[i][j] << " ";
                if (bDumpFloat)
                    printf("%.3f ", matrix[i][j]);
                else
                    printf("%.4d ", int(matrix[i][j]) );
            }
            std::cout << std::endl;

        }
    }

    void
    DumpMatrix(char* name, double** matrix, int nRow, int nCol, const char* file, bool bDumpFloat = true)
    {
        FILE* fp = fopen(file, "wt");
        if (NULL == fp)
        {
            std::cout << "File path does NOT exist: " << file << std::endl;
            return;
        }

        fprintf(fp,"%d\t%d\n",nRow,nCol);

        // dump order: row 0, row 1, ...
        for (int j=0; j<nCol; j++)
        {
            for (int i=0; i<nRow; i++)
            {
                if (bDumpFloat)
                    fprintf(fp,"%.3f\t", matrix[i][j]);
                else
                    fprintf(fp,"%d\t",  int(matrix[i][j]) );
            }
            fprintf(fp,"\n");
        }

        fclose(fp);
    }

    void
    DumpMatrixProb_c_gAsList()
    {
        std::cout << std::endl << "mProb_c_g[k][j]" <<" (" << mConceptNum << " x " << mGenreNum << "):" << std::endl;
        for (int j=0; j<mGenreNum; j++)
        {
            for (int k=0; k<mConceptNum; k++)
            {
                String strGenre = tabGenre[j]->GetLabel();
                String strConcept = tabConcept[k]->GetLabel();
                String name = strGenre + "-" + strConcept;
                printf("%s\t\t%.3f\n",name.c_str(), mProb_c_g[k][j]);
            }
            printf("\n");
        }
    }

    void
    SaveConditionalProbMatrix(const char* file)
    {
        DumpMatrix("mProb_c_g[k][j] - Bayes (file)", mProb_c_g, mConceptNum, mGenreNum, file);        
    }

    void
    ResetMatrix(double**& matrix, int nRow, int nCol)
    {
        for (int k=0; k<nRow; k++)
            memset(matrix[k],0,sizeof(double)*nCol);
    }

    void
    ReleaseMatrix(double**& matrix, int nRow)
    {
        for (int k=0; k<nRow; k++)
            delete []matrix[k];

        delete []matrix;
    }

    void
    SaveMatrix()
    {
        SaveMatrixConceptConditionalProbability(mMatrixFile,mProb_c_g, mConceptNum, mGenreNum);

        printf("\nSaving Prob_c_g[k][j] into file.\n");
    }

    bool
    LoadMatrix(bool bAnnoSet = true)
    {
        bool flag = LoadMatrixConceptConditionalProbability(mMatrixFile,mProb_c_g, mConceptNum, mGenreNum, bAnnoSet);

        if (flag)
        {
            DumpMatrix("mProb_c_g[k][j] - Bayes (file)", mProb_c_g, mConceptNum, mGenreNum);
            printf("\nLoading Prob_c_g[k][j] into file.\n");
            return true;

        } else {

            printf("\nLoading Prob_c_g[k][j] fails.\n");
            return false;
        }
        
    }

    void
    SaveMatrixConceptConditionalProbability(String name, double** matrix, int& nRow, int& nCol)
    {
        // mMatrixFile, mProb_c_g, mConceptNum, mGenreNum

        std::string fName;
        if (mIsImageSet)
            fName = mAnnoImgSet->GetFilePathAnnotation(name,true,false);
        else
            fName = mAnnoVidSet->GetFilePathAnnotation(name,true,false);
        /*String strAnnoSetName = mAnnoSetName;
        strAnnoSetName.resize(strAnnoSetName.size()-4);
        String fName = "../" + strAnnoSetName + "/Annotations/" + name;*/

        FILE* fp = fopen(fName.c_str(),"wb");

        if (NULL == fp)
        {
            std::cout << "File has existed, or path does NOT exist: [" << name << "]" << std::endl;
            return;
        }

        fwrite(&nRow, sizeof(int), 1, fp);  //mConceptNum
        fwrite(&nCol, sizeof(int), 1, fp);  //mGenreNum

        // data file: first column, second column, ...
        // be sure to be consistent with load funcion
        for (int i=0; i<nRow; i++)
        {
            for (int j=0; j<nCol; j++)
            {
                //printf("%.3f ", matrix[i][j]);
                fwrite( &(matrix[i][j]), sizeof(double), 1, fp);
            }
            //std::cout << std::endl;

        }
        fclose(fp);

    }

    bool
    LoadMatrixConceptConditionalProbability(String name, double** matrix, int& nRow, int& nCol, bool bAnnoSet = true)
    {
        // mMatrixFile, mProb_c_g, mConceptNum, mGenreNum

        std::string fName;

        if (bAnnoSet)
        {
            // loading from annotation set (training set)

            if (mIsImageSet)
                fName = mAnnoImgSet->GetFilePathAnnotation(name,false,false);
            else
                fName = mAnnoVidSet->GetFilePathAnnotation(name,false,false);

            /*String strAnnoSetName = mAnnoSetName;
            strAnnoSetName.resize(strAnnoSetName.size() - 4);
            fName = String("../") + strAnnoSetName + "/Annotations/" + name;*/
       }
        else
        {
            // loading from test set itself.

            if (mIsImageSet)
            {
                if (NULL != mImgSet)
                {
                    fName = mImgSet->GetFilePathAnnotation(name,false,false);

                    /*String strSetName = mSetName;
                    strSetName.resize(strSetName.size()-4);
                    fName = String("../") + strSetName + "/Annotations/" + name;*/

                }
                else
                {
                    std::cout << "mImgSet: Not initialized." << std::endl;
                    return false;
                }
            }
            else
            {
                if (NULL != mVidSet)
                {
                    fName = mVidSet->GetFilePathAnnotation(name,false,false);

                    /*String strSetName = mSetName;
                    strSetName.resize(strSetName.size()-4);
                    fName = String("../") + strSetName + "/Annotations/" + name;*/

                }
                else
                {
                    std::cout << "mVidSet: Not initialized." << std::endl;
                    return false;
                }
            }

            
        }

        FILE* fp = fopen(fName.c_str(),"rb");

        if (NULL == fp)
        {
            std::cout << "File does NOT exist: [" << fName << "]" << std::endl;
            return false;
        }

        int nLocalRow, nLocalCol;

        fread(&nLocalRow, sizeof(int), 1, fp);  //mConceptNum
        fread(&nLocalCol, sizeof(int), 1, fp);  //mGenreNum

        // verify the dimension of matrix
        if ( nRow == nLocalRow && nCol == nLocalCol)
        {
            // data file: first column, second column, ...
            // be sure to be consistent with save funcion
            for (int i=0; i<nRow; i++)
            {
                for (int j=0; j<nCol; j++)
                {
                    //printf("%.3f ", matrix[i][j]);
                    fread( &(matrix[i][j]), sizeof(double), 1, fp);
                }
                //std::cout << std::endl;

            }

            fclose(fp);
            return true;

        } else {

            // verification fails
            std::cout << "Loaded Matrix dimension is not the same as Annotation" << std::endl;

            fclose(fp);
            return false;
        }

        //fclose(fp);

    }

    void
    AllocateMatrix(double**& matrix, int nRow, int nCol)
    {
        // first looping rows, then looping columns
        matrix = new double* [nRow];
        for (int k=0; k<nRow; k++)
        {
            matrix[k] = new double [nCol];
            memset(matrix[k],0,sizeof(double)*nCol);
        }
    }

protected:

    String mSetName;
    String mAnnoSetName;

    String mGenreSet;   //genre set: g_{j}
    String mConceptSet; //concept set: c_{k}

    //Core::Database::RawDataSet* mSet;
    //Core::Database::RawDataSet* mAnnoSet;

    Core::VideoSet::VideoSet* mVidSet;
    Core::VideoSet::VideoSet* mAnnoVidSet;

    Core::ImageSet::ImageSet* mImgSet;
    Core::ImageSet::ImageSet* mAnnoImgSet;

    AnnotationTableSet* mTabGenreSet;
    AnnotationTableSet* mTabConceptSet;

    AnnotationTable** tabConcept;
    AnnotationTable** tabGenre;

    //Core::Table::QuidTable* mAnnoQuidTable;

    String mMatrixFile; // file saving mProb_c_g[k][j]

    String mQuid;       // "Frame", or "Shot"

    bool mHasAnnotation;    //mAnnoSetName is not empty
    bool mHandleTestSet;    //mSetName is not empty

    bool mVerbose;
    bool mbDumpTable;

    int mIsImageSet;

    int mGenreNum;
    int mConceptNum;

    int mAnnoTableSize;
    int mTableSize;

    int mStart;
    int mEnd;

    double** mProb_c_g;      // conditional probability P(c_{k}|g_{j})

};

} // namespace Table
} // namespace Core
} // namespace Impala

#endif

---