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

---

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/Column/Find.h"
#include "Core/Column/Copy.h"
#include "Core/Table/Read.h"
#include "Core/Feature/FeatureDefinition.h"
#include "Core/Table/Read.h"
#include "Core/Table/Append.h"

#include "Core/Geometry/InterestPointListIO.h"
#include "Core/Geometry/InterestPointList.h"
#include "Core/Geometry/InterestCircle.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);
    }

    static PointDescriptorTable*
    ImportFromFile(FeatureDefinition def, String filename, int mStripBorder)
    {
        Core::Geometry::InterestPointList outputPointList;
        Sandbox::Koen::ReadPointListFromFile(filename, outputPointList,
                              false, mStripBorder);
        
        PointDescriptorTable* res = new PointDescriptorTable(def);
        res->FromPointList(outputPointList);
        outputPointList.EraseAndDelete();
        return res;
    }
    
    void
    ExportToFile(String filename, int mStripBorder, String mOutputFormat)
    {
        Core::Geometry::InterestPointList outputPointList;
        ToPointList(outputPointList);
        Sandbox::Koen::WritePointListToFile(filename, outputPointList, true,
                             mStripBorder, mOutputFormat);
        outputPointList.EraseAndDelete();
    }

/*    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);
    }
    
    void
    FromPointList(Core::Geometry::InterestPointList& pl)
    {
        if(pl.size() == 0) return;
        Reserve(pl.size(), false);
        int descriptorLength = (*pl.begin())->mDescriptor.size();
        Array::Array2dScalarReal64* descriptors = 0;
        if(descriptorLength > 0)
            descriptors = new Array::Array2dScalarReal64(descriptorLength, 
                                                         pl.size(), 0, 0);

        ILOG_DEBUG("extracting descriptor data");
        int idx = 0;
        for(Core::Geometry::InterestPointList::iterator it = pl.begin(); 
            it != pl.end(); it++)
        {
            Core::Geometry::InterestPoint* point = *it;
            std::string type  = point->geometryType();
            if(type != "CircleZ" && type != "RectangleZ" )
            {
                ILOG_ERROR("Geometry type mismatch: " << point->geometryType());
                return;
            }
            
            if(type == "CircleZ")
            {
                Core::Geometry::InterestCircle* circle = 
                    dynamic_cast<Core::Geometry::InterestCircle*>(point);
                Add(point->mX, point->mY, circle->mScale, circle->mOrientation, 
                    circle->mCornerness);
            }
            else if(type == "RectangleZ")
            {
                Core::Geometry::InterestRectangleZ* rect = 
                    dynamic_cast<Core::Geometry::InterestRectangleZ*>(point);
                Add(point->mX, point->mY, rect->Width(), rect->Height(), 0);
            }
            
            if(descriptorLength > 0)
            {
                Vector::VectorTem<Real64> descriptor =
                    Vector::VectorTem<Real64>(point->mDescriptor.size());
                Real64* ptr = descriptors->CPB(0, idx);
                for(int j = 0; j < point->mDescriptor.size(); j++)
                {
                    *ptr++ = point->mDescriptor[j];
                }
            }
            idx++;
        }
        if(descriptorLength > 0)
            ReplaceAllDescriptors(descriptors);
    }

    void
    ToPointList(Core::Geometry::InterestPointList& pl)
    {
        for(int i = 0; i < Size(); i++)
        {
            Core::Geometry::InterestCircle* point = 
                 new Core::Geometry::InterestCircle(Get1(i), Get2(i), Get5(i));
            point->mScale = Get3(i);
            point->mOrientation = Get4(i);
            VectorReal64 v = Get6(i);
            for(int j = 0; j < GetDescriptorLength(); j++)
                point->mDescriptor.push_back(v[j]);
            pl.push_back(point);
        }
    }

    ILOG_VAR_DEC;

private:

    FeatureDefinition mFeatureDef;

};

ILOG_VAR_INIT(PointDescriptorTable, Impala.Core.Feature);

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

#endif

---