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

---

PointDescriptorTable.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_PointDescriptorTable_h
#define Impala_Core_Feature_PointDescriptorTable_h

#include "Core/Array/Arrays.h"
#include "Core/Vector/VectorSet.h"
#include "Core/Feature/FeatureDefinition.h"
#include "Core/Feature/PointDescriptorIO.h"
#include "Core/Matrix/MatFunc.h"
#include "Core/Table/TableTem.h"
#include "Util/IOBufferFile.h"

namespace Impala
{
namespace Core
{
namespace Feature
{


typedef Table::TableTem<Column::ColumnTem<Real64>,
                        Column::ColumnTem<Real64>,
                        Column::ColumnTem<Real64>,
                        Column::ColumnTem<Real64>,
                        Column::ColumnTem<Real64>,
                        Vector::VectorSet<Array::Array2dScalarReal64> >
        PointDescriptorTableBaseType;


class PointDescriptorTable : public PointDescriptorTableBaseType
{
public:
    typedef Column::ColumnTem<Real64> ColumnReal64;
    typedef Vector::VectorSet<Array::Array2dScalarReal64> ColumnVectorSet;
    typedef Vector::VectorTem<Real64> VectorReal64;

    PointDescriptorTable(FeatureDefinition def=FeatureDefinition("")) :
        PointDescriptorTableBaseType(ColumnReal64(0), ColumnReal64(0), 
                    ColumnReal64(0), ColumnReal64(0), ColumnReal64(0),
                                     ColumnVectorSet(true, 0, 0))
    {
        mFeatureDef = def;
        SetColName(1, "x");
        SetColName(2, "y");
        SetColName(3, "scale");
        SetColName(4, "orientation");
        SetColName(5, "cornerness");
        SetColName(6, mFeatureDef.GetName());
    }

    PointDescriptorTable(FeatureDefinition def, int tableSize, int vecLen) :
        PointDescriptorTableBaseType(ColumnReal64(tableSize),
                                     ColumnReal64(tableSize), 
                                     ColumnReal64(tableSize), 
                                     ColumnReal64(tableSize), 
                                     ColumnReal64(tableSize), 
                                     ColumnVectorSet(true, vecLen, tableSize))
    {
        mFeatureDef = def;
        SetColName(1, "x");
        SetColName(2, "y");
        SetColName(3, "scale");
        SetColName(4, "orientation");
        SetColName(5, "cornerness");
        SetColName(6, mFeatureDef.GetName());
    }

    inline Real64
    GetX(int index) const
    {
        return Get1(index);
    }

    inline Real64
    GetY(int index) const
    {
        return Get2(index);
    }

    inline Real64
    GetScale(int index) const
    {
        return Get3(index);
    }

    inline Real64
    GetOrientation(int index) const
    {
        return Get4(index);
    }
    
    void
    SetDescriptor(int index, VectorReal64& v)
    {
        GetColumn6()->GetVector(index, true) = v;
    }
    
    Real64*
    GetDescriptorData(int index)
    {
        return GetColumn6()->GetVectorData(index);
    }
    
    Matrix::Mat*
    GetDescriptorMatrix()
    {
        return GetColumn6()->GetStorage();
    }

    static PointDescriptorTable*
    ImportFromBuffer(FeatureDefinition def, Util::IOBuffer* buffer, int mStripBorder)
    {
        using namespace Impala::Core::Matrix;
        Mat* points = 0;
        Mat* descriptors = 0;

        String dataType = ReadBINDESC1FromBuffer(points, descriptors, buffer, true, true);
        if(dataType.substr(0, 6) != "CIRCLE")
        {
            ILOG_WARN("Data type of file read is not CIRCLE, but '" << dataType << "'");
        }
        ILOG_DEBUG("Loaded file: rows=" << MatNrRow(points) << "; cols=" << MatNrCol(points));
        PointDescriptorTable* res = new PointDescriptorTable(def);
        for(int i = 0; i < MatNrRow(points); i++)
        {
            // shift by 1 for consistency with the public file format (which uses 1..n instead of 0..n-1)
            // make coordinates equal to the original image, without the borders removed
            res->Add(*MatE(points, i, 0) - 1 - mStripBorder, 
                     *MatE(points, i, 1) - 1 - mStripBorder, 
                     *MatE(points, i, 2), *MatE(points, i, 3), 
                     *MatE(points, i, 4));
        }
        // callee takes ownership
        res->ReplaceAllDescriptors(descriptors);
        delete points;

        return res;
    }

    static PointDescriptorTable*
    ImportFromFile(FeatureDefinition def, String filename, int mStripBorder)
    {

        Util::IOBuffer* buffer = new Util::IOBufferFile(filename, true, false);
        PointDescriptorTable* res = ImportFromBuffer(def, buffer, mStripBorder);
        delete buffer;
        return res;
    }
    
    void
    ExportToFile(String filename, int mStripBorder, String mOutputFormat)
    {
        using namespace Impala::Core::Matrix;
        
        Util::IOBuffer* buffer = new Util::IOBufferFile(filename, false, false);
        Mat* points = MatCreate<Mat>(Size(), 5);
        for(int i = 0; i < Size(); i++)
        {
            // shift by 1 for consistency with the public file format (which uses 1..n instead of 0..n-1)
            // make coordinates equal to the original image, without the borders removed
            *MatE(points, i, 0) = Get1(i) + 1 + mStripBorder;
            *MatE(points, i, 1) = Get2(i) + 1 + mStripBorder;
            *MatE(points, i, 2) = Get3(i);
            *MatE(points, i, 3) = Get4(i);
            *MatE(points, i, 4) = Get5(i);
        }
        Mat* descriptorWrapper = MatCreate<Mat>(Size(), 
                   MatNrCol(GetColumn6()->GetStorage()),
                   MatE(GetColumn6()->GetStorage(), 0, 0), true);
        if((mOutputFormat == "bindesc1") || (mOutputFormat == "binary"))
        {
            WriteBINDESC1ToBuffer(buffer, points, descriptorWrapper, "CIRCLE  ");
        }
        else
        {
            WriteKOEN1ToBuffer(buffer, points, descriptorWrapper, "CIRCLE");
        }
        delete descriptorWrapper;
        delete points;
        delete buffer;
    }

/*    static PointDescriptorTable*
    MakeFromFile(FeatureDefinition def, String fileName, Util::Database* db)
    {
        PointDescriptorTable* res = new PointDescriptorTable(def);
        Read(res, fileName, db);
        return res;
    }*/

    FeatureDefinition
    GetFeatureDefinition()
    {
        return mFeatureDef;
    }

    void
    SetFeatureDefinition(FeatureDefinition def)
    {
        mFeatureDef = def;
    }

    int
    GetDescriptorLength()
    {
        return GetColumn6()->GetVectorLength(0);
    }

    void
    SetDescriptorLength(int descriptorLength)
    {
        int storageSize = GetColumn6()->GetStorage()->CH();
        Array::Array2dScalarReal64* descriptors = new 
             Array::Array2dScalarReal64(descriptorLength, storageSize, 0, 0);
        GetColumn6()->SetStorage(descriptors);
    }

    void
    ReplaceAllDescriptors(Array::Array2dScalarReal64* descriptors)
    {
        // this call takes ownership of descriptors memory
        GetColumn6()->SetStorage(descriptors);
    }
    
    ILOG_VAR_DEC;

private:

    FeatureDefinition mFeatureDef;

};

ILOG_VAR_INIT(PointDescriptorTable, Impala.Core.Feature);

} // namespace Feature
} // namespace Core
} // namespace Impala

#endif

---