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

---

AnnotationTable.h

Go to the documentation of this file.

#ifndef Impala_Core_Table_AnnotationTable_h
#define Impala_Core_Table_AnnotationTable_h

#include "Util/QuickSort.h"
#include "Util/SimpleMap.h"
#include "Core/Table/SelectQuids.h"
#include "Core/Table/Read.h"
#include "Core/Table/Criterion.h"
#include "Core/Table/CollectQuidObjects.h"
#include "Core/Table/Select.h"
#include "Core/Column/Find.h"
#include "Core/Column/FindInAscending.h"
#include "Util/QuasiRandomSequenceIterator.h"

namespace Impala
{
namespace Core
{
namespace Table
{


typedef TableTem<Column::ColumnTem<Quid>,
                 Column::ColumnTem<Real64> >
        AnnotationTableBaseType;


class AnnotationTable : public AnnotationTableBaseType
{
public:

    typedef Column::ColumnTem<Real64> ColumnReal64;
    typedef Column::ColumnTem<Quid> ColumnQuid;

    AnnotationTable() :
        AnnotationTableBaseType(ColumnQuid(0), ColumnReal64(0))
    {
        mLabel = "";
        mIsAscending = false;
        SetInfo("AnnotationTable");
        SetColName(1, "annotee");
        SetColName(2, "qualifier");
    }

    AnnotationTable(String label, int tableSize) :
        AnnotationTableBaseType(ColumnQuid(tableSize), ColumnReal64(tableSize))
    {
        mLabel = label;
        mIsAscending = false;
        SetInfo("AnnotationTable : " + label);
        SetColName(1, "annotee");
        SetColName(2, "qualifier " + label);
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    static AnnotationTable*
    MakeFromFile(String label, String fileName, Util::Database* db)
    {
        AnnotationTable* res = new AnnotationTable(label, 0);
        Read(res, fileName, db);
        //res->UpdateQuidMap();
        return res;
    }
#endif // REPOSITORY_USED

    String
    GetLabel() const
    {
        return mLabel;
    }

    void
    SetLabel(String label)
    {
        mLabel = label;
    }

    int
    GetQuidClass() const
    {
        if (Size() < 1) // cannot tell
            return QUID_CLASS_UNKNOWN;
        return QuidClass(Get1(0));
    }

    bool
    ContainsFrames() const
    {
        return GetQuidClass() == QUID_CLASS_FRAME;
    }

    bool
    ContainsShots() const
    {
        return GetQuidClass() == QUID_CLASS_SHOT;
    }

    int
    GetNrPositive() const
    {
        int res = 0;
        for (int i=0 ; i<Size() ; i++)
            if (IsPositive(i))
                res++;
        return res;
    }

    int
    GetNrNegative() const
    {
        int res = 0;
        for (int i=0 ; i<Size() ; i++)
            if (IsNegative(i))
                res++;
        return res;
    }

    QuidTable*
    GetPositive() const
    {
        CriterionElement2Equals<AnnotationTableBaseType> c(1.);
        return SelectQuids(this, c);
    }

    QuidTable*
    GetNegative() const
    {
        CriterionElement2Equals<AnnotationTableBaseType> c(-1.);
        return SelectQuids(this, c);
    }

    QuidTable*
    GetAnnotatedQuids() const
    {
        CriterionElement2NotEquals<AnnotationTableBaseType> c(0.);
        return SelectQuids(this, c);
    }

    int
    GetIndex(Quid annotee) const
    {
        int index = Size();
        if (mQuidMap.Get(annotee, index))
            return index;
        if (mIsAscending)
            return Column::FindInAscending(GetColumn1(), annotee, 0, Size());
        return Column::Find(GetColumn1(), annotee, 0, Size());
    }

    bool
    IsAnnotated(Quid annotee) const
    {
        return (GetIndex(annotee) != Size());
    }

    Real64
    GetQualification(Quid annotee) const
    {
        int index = GetIndex(annotee);
        if (index != Size())
            return Get2(index);
        return -2.0;
    }

    String
    GetQualificationString(Quid annotee) const
    {
        int index = GetIndex(annotee);
        if (index == Size())
            return "UNK";
        if (IsPositive(index))
            return "POS";
        if (IsNegative(index))
            return "NEG";
        if (IsSkip(index))
            return "SKIP";
        return "ERROR";
    }

    bool
    IsPositive(int idx) const
    {
        return Get2(idx) == 1.0;
    }

    bool
    IsPositive(Quid annotee) const
    {
        int index = GetIndex(annotee);
        if (index != Size())
            return IsPositive(index);
        return false;
    }

    void
    SetPositive(int idx)
    {
        Set2(idx, 1.0);
    }

    bool
    IsNegative(int idx) const
    {
        return Get2(idx) == -1.0;
    }

    bool
    IsNegative(Quid annotee) const
    {
        int index = GetIndex(annotee);
        if (index != Size())
            return IsNegative(index);
        return false;
    }

    void
    SetNegative(int idx)
    {
        Set2(idx, -1.0);
    }

    bool
    IsSkip(int idx) const
    {
        return Get2(idx) == 0.0;
    }

    bool
    IsSkip(Quid annotee) const
    {
        int index = GetIndex(annotee);
        if (index != Size())
            return IsSkip(index);
        return false;
    }

    void
    SetSkip(int idx)
    {
        Set2(idx, 0.0);
    }

    void
    AddPositive(Quid annotee)
    {
        Add(annotee, 1.0);
    }

    void
    AddNegative(Quid annotee)
    {
        Add(annotee, -1.0);
    }

    void
    AddSkip(Quid annotee)
    {
        Add(annotee, 0.0);
    }

    // limit annotations to those within the given QuidObject (video) id
    void
    SelectQuidObjectMaxId(int maxId)
    {
        if (maxId == -1)
            return;

        CriterionQuidObjectMaxId<AnnotationTable> crit(maxId);
        Select(this, this, crit, true);
    }

    // limit the number of positive annotations per QuidObject (video)
    void
    SelectQuidObjectMaxPositive(int number)
    {
        if (number == -1)
            return;

        CriterionQuidObjectMaxNumberElement2<AnnotationTable> crit(1.0, number);
        Select(this, this, crit, true);
    }

    // limit the number of negative annotations per QuidObject (video)
    void
    SelectQuidObjectMaxNegative(int number)
    {
        if (number == -1)
            return;

        CriterionQuidObjectMaxNumberElement2<AnnotationTable> crit(-1.0, number);
        Select(this, this, crit, true);
    }

    // limit the number of skip annotations per QuidObject (video)
    void
    SelectQuidObjectMaxSkip(int number)
    {
        if (number == -1)
            return;

        CriterionQuidObjectMaxNumberElement2<AnnotationTable> crit(0.0, number);
        Select(this, this, crit, true);
    }

    void
    UpdateQuidMap()
    {
        mIsAscending = true;
        for (int i=0 ; i<Size()-1 ; i++)
        {
            if (Get1(i+1) < Get1(i))
            {
                mIsAscending = false;
                break;
            }
        }
        if (!mIsAscending)
        {
            for (int i=0 ; i<Size() ; i++)
                mQuidMap.Add(Get1(i), i);
        }
    }

    // Merge tables, annotee is positive if this or arg is positive
    void
    Merge(AnnotationTable* arg)
    {
        for (int i=0 ; i<arg->Size() ; i++)
        {
            Quid annotee = arg->Get1(i);
            int index = GetIndex(annotee);
            if (index == Size())
            {
                Add(annotee, arg->Get2(i));
            }
            else
            {
                Real64 qualification = Max(Get2(index), arg->Get2(i));
                Set2(index, qualification);
            }
        }
    }

    void
    Correct(AnnotationTable* corrections)
    {
        for (int i=0 ; i<corrections->Size() ; i++)
        {
            Quid annotee = corrections->Get1(i);
            int index = GetIndex(annotee);
            if (index == Size())
            {
                Add(annotee, corrections->Get2(i));
            }
            else
            {
                Set2(index, corrections->Get2(i));
            }
        }
    }

    int
    Diff(AnnotationTable* arg) const
    {
        if (Size() != arg->Size())
        {
            ILOG_ERROR("Diff: Size differs: " << Size() << " vs " <<
                       arg->Size());
            return 1;
        }
        int nDiff = 0;
        for (int i=0 ; i<Size() ; i++)
        {
            if (Get1(i) != arg->Get1(i))
            {
                ILOG_DEBUG("Quid " << i << " differs " << Get1(i) <<
                           " vs " << arg->Get1(i));
                nDiff++;
            }
            else if (::fabs(Get2(i) -arg->Get2(i)) > 0.00001)
            {
                ILOG_DEBUG("Anno " << i << " differs " << Get2(i) <<
                           " vs " << arg->Get2(i));
                nDiff++;
            }
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences");
        return nDiff;
    }

    virtual void
    Dump(int from = 0, int to = -1)
    {
        if (to == -1 || to > Size())
            to = Size();
        if (to < from)
            to = from;
        if (to <= from)
            return ;

        std::cout << "Dumping table from " << from << " to " << to
                  << " (table size=" << Size() << ", capacity=" << Capacity()
                  << ")" << std::endl;
        for (int i=0 ; i<2 ; i++)
            std::cout << i+1 << "=" << GetColName(i+1) << ", ";
        std::cout << std::endl;
        for (int i=from ; i<to ; i++)
        {
            std::cout << QuidObj(Get1(i)) << ", " << Get2(i) << std::endl;
        }
        std::cout << std::endl;
    }

    virtual void
    Dump(Database::RawDataSet* dataSet, int from = 0, int to = -1)
    {
        if (dataSet == 0)
            return Dump(from, to);

        if (to == -1 || to > Size())
            to = Size();
        if (to < from)
            to = from;
        if (to <= from)
            return ;

        std::cout << "Dumping table from " << from << " to " << to
                  << " (table size=" << Size() << ", capacity=" << Capacity()
                  << ")" << std::endl;
        for (int i=0 ; i<2 ; i++)
            std::cout << i+1 << "=" << GetColName(i+1) << ", ";
        std::cout << std::endl;
        for (int i=from ; i<to ; i++)
        {
            Quid quid = Get1(i);
            std::cout << dataSet->QuidToString(quid, true) << ", " << Get2(i)
                      << std::endl;
        }
        std::cout << std::endl;
    }

    void
    DumpSummary()
    {
        int pos=0, neg=0, skip=0;
        for (int i=0 ; i<Size() ; ++i)
        {
            if (IsPositive(i))
                ++pos;
            else if (IsNegative(i))
                ++neg;
            else
                ++skip;
        }
        std::cout << GetLabel() << " : " << pos << " positive, " << neg
                  << " negative, " << skip << " skip, " << Size() << " total"
                  << std::endl;
    }

    void
    DumpSummaryObject()
    {
        std::vector<int> objs = CollectQuidObjects(this);
        for (int i=0 ; i<objs.size() ; i++)
        {
            std::cout << "  obj=" << objs[i] << " : ";
            std::vector<int> oneObj;
            oneObj.push_back(objs[i]);
            CriterionQuidObjectInSet<AnnotationTable> crit(oneObj);
            AnnotationTable* tmp = Select(this, crit);
            tmp->DumpSummary();
            delete tmp;
        }
    }


    std::vector<QuidTable*>
    MakeEpisodeFolds(int foldCount, int repetition)
    {
        ILOG_DEBUG("entering MakeEpisodeFolds");

        int quidclass = GetQuidClass();
        if(quidclass != QUID_CLASS_SHOT &&
           quidclass != QUID_CLASS_KEYFRAME &&
           quidclass != QUID_CLASS_FRAME)
        {
            ILOG_WARNING_HEADNODE("annotees of wrong quidclass, cannot do episode " <<
                              "constrained");
            return MakeRandomFolds(foldCount, repetition);
        }

        if(foldCount <= 1)
        {
            ILOG_ERROR("we need at least 2 folds");
            return std::vector<QuidTable*>(1, GetAnnotatedQuids());
        }

        QuidTable* positive = GetPositive();
        QuidTable* negative = GetNegative();
        ILOG_DEBUG_NODE("make episode folds: #annotations = " <<
                        positive->Size() + negative->Size());

        // group per video
        std::vector<int> positiveVideos;
        std::vector<int> negativeVideos;
        GroupPerVideo(positive, negative, positiveVideos, negativeVideos);
        delete positive;
        delete negative;

        std::vector<QuidTable*> folds;
        for(int i=0 ; i<foldCount ; i++)
            folds.push_back(new QuidTable(0));

        // distribute 'positive' videos
        int lastFold=0;
        Util::QuasiRandomSequenceIterator pos(positiveVideos.size(),repetition);
        for(int i=0 ; i<positiveVideos.size() ; ++i)
        {
            CriterionQuidObjectEquals<AnnotationTable>
                c(positiveVideos[*pos]);
            SelectOneColumn(folds[lastFold], this, 1, c, false);
            ++pos;
            ++lastFold;
            if(lastFold >= foldCount)
                lastFold = 0;
        }

        // distribute 'negative' videos
        Util::QuasiRandomSequenceIterator neg(negativeVideos.size(),repetition);
        for(int i=0 ; i<negativeVideos.size() ; ++i)
        {
            CriterionQuidObjectEquals<AnnotationTable>
                c(negativeVideos[*neg]);
            SelectOneColumn(folds[lastFold], this, 1, c, false);
            ++neg;
            ++lastFold;
            if(lastFold >= foldCount)
                lastFold = 0;
        }

        ILOG_DEBUG("leaving MakeFolds");
        return folds;
    }

    std::vector<QuidTable*>
    MakeRandomFolds(int foldCount, int repetition)
    {
        if(foldCount <= 1)
        {
            ILOG_ERROR("we need at least 2 folds");
            return std::vector<QuidTable*>(1, GetAnnotatedQuids());
        }

        QuidTable* positive = GetPositive();
        QuidTable* negative = GetNegative();
        ILOG_DEBUG_NODE("make random folds: #annotations = " <<
                        positive->Size() + negative->Size());

        std::vector<QuidTable*> folds;
        for(int i=0 ; i<foldCount ; ++i)
            folds.push_back(new QuidTable(0));

        int lastFold=0;
        Util::QuasiRandomSequenceIterator pos(positive->Size(), repetition);
        for(int i=0 ; i<positive->Size() ; ++i)
        {
            folds[lastFold]->Add(positive->Get1(*pos));
            ++pos;
            ++lastFold;
            if(lastFold >= foldCount)
                lastFold = 0;
        }
        for (int i=0 ; i<foldCount ; i++)
        {
            ILOG_DEBUG("fold "<< i <<" has "<< folds[i]->Size() <<" positives");
            if (folds[i]->Size() == 0)
                ILOG_ERROR("fold "<< i <<" has NO positives");
        }

        Util::QuasiRandomSequenceIterator neg(negative->Size(), repetition);
        for(int i=0 ; i<negative->Size() ; ++i)
        {
            folds[lastFold]->Add(negative->Get1(*neg));
            ++neg;
            ++lastFold;
            if(lastFold >= foldCount)
                lastFold = 0;
        }

        delete positive;
        delete negative;
        return folds;
    }

    void Sort()
    {
        Util::QuickSortDescCo
            (GetColumn2()->GetData(), GetColumn1()->GetData(), 0, Size()-1);
        //sort positive examples
        int to;
        for(int i=0 ; i<Size() ; ++i)
        {
            to = i;
            if(Get2(i) != 1)
                break;
        }
        Util::QuickSort(GetColumn1()->GetData(), 0, to-1);
        //sort negative examples
        int from;
        for(int i=to ; i<Size() ; ++i)
        {
            from = i;
            if(Get2(i) == -1)
                break;
        }
        Util::QuickSort(GetColumn1()->GetData(), from, Size()-1);
    }

private:

    String                     mLabel;
    bool                       mIsAscending;
    Util::SimpleMap<Quid, int> mQuidMap;

    /* helper function for MakeFolds, facilitates episode constraining by
    grouping video ids (QuidObject(Quid q)) of videos that contain positive
    examples vs. videos that do not */ 
    void GroupPerVideo(const QuidTable* positive,
                       const QuidTable* negative,
                       std::vector<int>& positiveVideos,
                       std::vector<int>& negativeVideos)
    {
        Quid lastQuid=0;
        // collect all the videoIDs with a positive annotated framequide
        for(int i=0 ; i<positive->Size() ; i++)
        {
            Quid q = positive->Get1(i);
            /* QuidObjectEqual is false initially because 0 is not a valid quid.
            The object of a framequid is a video. */
            if(!QuidObjectEqual(lastQuid,q)) 
            {
                lastQuid = q;
                int videoID = QuidObject(q);
                if(find(positiveVideos.begin(), positiveVideos.end(), videoID)
                    == positiveVideos.end())
                {
                    positiveVideos.push_back(videoID);
                }
            }
        }

        lastQuid=0;
        // collect all the videoIDs with no positive annotated frame, which can
        // of course not be in positiveVideos
        for(int i=0 ; i<negative->Size() ; i++)
        {
            Quid q = negative->Get1(i);
            if(!QuidObjectEqual(lastQuid,q))
            {
                lastQuid = q;
                int videoID = QuidObject(q);
                if(find(positiveVideos.begin(), positiveVideos.end(), videoID)
                    == positiveVideos.end())
                {
                    if(find(negativeVideos.begin(), negativeVideos.end(),
                            videoID) == negativeVideos.end())
                    {
                        negativeVideos.push_back(videoID);
                    }
                }
            }
        }
    }



    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(AnnotationTable, Impala.Core.Table);

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

#endif

---