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

---

PointDescriptorIO.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_PointDescriptorIO_h
#define Impala_Core_Feature_PointDescriptorIO_h

#include "Core/Matrix/Mat.h"
#include "Core/Matrix/MatFunc.h"
#include "Util/StringParser.h"

#include <iostream>
#include <fstream>

namespace Impala
{
namespace Core
{
namespace Feature
{


void
WriteBINDESC1ToBuffer(Util::IOBuffer* buffer, Matrix::Mat* points, Matrix::Mat* descriptors, String theDataType)
{
    ILOG_VAR(Core.Feature.PointDescriptorIO.WriteBINDESC1ToBuffer);
    
    using namespace Impala::Core::Matrix;    
    /* Format BINDESC1
       -----------------------
       First 8 bytes: BINDESC1
       Second 8 bytes: data type (CIRCLE is typical)
       Next 16 bytes: 4 integers:
                        elementsPerPoint = values[0]
                        dimensionCount = values[1]
                        pointCount = values[2]
                        bytesPerElement = values[3]
    */
    int elementsPerPoint = MatNrCol(points);
    int dimensionCount = 0;
    int pointCount = MatNrRow(points);
    int bytesPerElement = 8;
    
    if(descriptors)
    {
        if(MatNrRow(descriptors) > 0)
        {
            dimensionCount = MatNrCol(descriptors);
            if(MatNrRow(descriptors) != pointCount)
            {
                ILOG_ERROR("Dimension mismatch in points/descriptors: " << 
                           pointCount << " " << MatNrRow(descriptors));
            }
        }
    }

    String magic = "BINDESC1";
    String dataType = "UNKNOWN ";
    if(theDataType.size() == 8)
    {
        dataType = theDataType;
    }
    else
    {
        ILOG_ERROR("Coding error: your datatype specification should be 8 bytes long");
    }
    
    ILOG_DEBUG("Writing header...");
    buffer->Write(magic.c_str(), 8);
    buffer->Write(dataType.c_str(), 8);
    buffer->Write(&elementsPerPoint, 4);
    buffer->Write(&dimensionCount, 4);
    buffer->Write(&pointCount, 4);
    buffer->Write(&bytesPerElement, 4);
    ILOG_DEBUG("Wrote full header");

    for(int i = 0; i < pointCount; i++)
    {
        buffer->Write(MatE(points, i, 0), sizeof(Real64) * elementsPerPoint);
    }

    if(dimensionCount == 0) return;
    
    for(int i = 0; i < pointCount; i++)
    {
        buffer->Write(MatE(descriptors, i , 0), sizeof(Real64) * dimensionCount);
    }
}


void
WriteKOEN1ToBuffer(Util::IOBuffer* buffer, Matrix::Mat* points, Matrix::Mat* descriptors, String theDataType)
{
    ILOG_VAR(Core.Feature.PointDescriptorIO.WriteKOEN1ToBuffer);

    using namespace Impala::Core::Matrix;    
    /* Format KOEN version 1.0
       -----------------------
       First line:  KOEN1 (format version)
       Second line: Descriptor dimensionality count (0 if only interest items)
       Third line:  Number of interest items
    */
    buffer->Write("KOEN1\n", 6);
    int elementsPerPoint = MatNrCol(points);
    int dimensionCount = 0;
    int pointCount = MatNrRow(points);
    int bytesPerElement = 8;
    
    if(descriptors)
    {
        if(MatNrRow(descriptors) > 0)
        {
            dimensionCount = MatNrCol(descriptors);
            if(MatNrRow(descriptors) != pointCount)
            {
                ILOG_ERROR("Dimension mismatch in points/descriptors: " << 
                           pointCount << " " << MatNrRow(descriptors));
            }
        }
    }
    
    String tmp = MakeString(dimensionCount) + "\n" + MakeString(pointCount) + "\n";
    buffer->Write(tmp.c_str(), tmp.size());

    for(int i = 0; i < pointCount; i++)
    {
        String line = "<" + theDataType;
        for(int j = 0; j < elementsPerPoint; j++)
        {
            line += " " + MakeString(*MatE(points, i, j));
        }
        line += ">;";
        if(dimensionCount)
        {
            for(int j = 0; j < dimensionCount; j++)
            {
                line += " " + MakeString(*MatE(descriptors, i, j));
            }
        }
        line += ";\n";
        
        buffer->Write(line.c_str(), line.size());
    }
}


String
ReadBINDESC1FromBuffer(Matrix::Mat*& points, Matrix::Mat*& descriptors, Util::IOBuffer* buffer, bool readPoints, bool readDescriptors)
{
    ILOG_VAR(Core.Feature.PointDescriptorIO.ReadBINDESC1FromBuffer);

    using namespace Impala::Core::Matrix;    
    char buf[9];
    for (int i=0 ; i<9 ; i++)
        buf[i] = 0;
    buffer->Read(buf, 8);
    
    if(String(buf) == "BINDESC1")
    {
        /* Format BINDESC1
           -----------------------
           First 8 bytes: BINDESC1
           Second 8 bytes: data type (CIRCLE is typical)
           Next 16 bytes: 4 integers:
                            elementsPerPoint = values[0]
                            dimensionCount = values[1]
                            pointCount = values[2]
                            bytesPerElement = values[3]
        */
        int elementsPerPoint = 0;
        int dimensionCount = 0;
        int pointCount = 0;
        int bytesPerElement = 8;
    
        String dataType = "UNKNOWN ";
        
        char buf[9];
        for (int i=0 ; i<9 ; i++)
            buf[i] = 0;
        
        ILOG_DEBUG("Reading header...");
        
        // read dataType
        buffer->Read(buf, 8);
        dataType = String(buf);
    
        buffer->Read(&elementsPerPoint, 4);
        buffer->Read(&dimensionCount, 4);
        buffer->Read(&pointCount, 4);
        buffer->Read(&bytesPerElement, 4);
        ILOG_DEBUG("Read full header");
        if(bytesPerElement != 8)
        {
            ILOG_ERROR("Can only read BINDESC1 with 8 bytes per element (double)");
            return "";
        }
    
        if(!readPoints)
        {
            buffer->Seek(elementsPerPoint * pointCount * bytesPerElement, SEEK_CUR);
        }
        else
        {
            points = MatCreate<Mat>(pointCount, elementsPerPoint);
            buffer->Read(points->mData, elementsPerPoint * pointCount * bytesPerElement);
        }
    
        if(readDescriptors)
        {
            descriptors = MatCreate<Mat>(pointCount, dimensionCount);
            if(dimensionCount > 0)
                buffer->Read(descriptors->mData, dimensionCount * pointCount * 
                             bytesPerElement);
        }

        return dataType;
    }
    else if(String(buf).substr(0, 5) == "KOEN1")
    {
        /* Format KOEN version 1.0
           -----------------------
           First line:  KOEN1 (format version)
           Second line: Descriptor dimensionality count (0 if only interest items)
           Third line:  Number of interest items
        */
        buffer->Seek(0, SEEK_SET);
        
        // first line: KOEN1
        String header = buffer->ReadLine();
        if(header != String("KOEN1"))
        {
            ILOG_ERROR("Unsupported region format: " << header);
            return "";
        }
    
        // second line: dimensionality
        int dimensionCount = Util::StringParser(buffer->ReadLine()).GetInt();
        int pointCount = Util::StringParser(buffer->ReadLine()).GetInt();
        ILOG_DEBUG("Reading file; dimensionCount = " << dimensionCount << "; pointCount = " << pointCount);
        if(readPoints)
            points = MatCreate<Mat>(pointCount, 5);
        if(readDescriptors) 
            descriptors = MatCreate<Mat>(pointCount, dimensionCount);

        for(int i = 0; i < pointCount; i++)
        {
            String line = buffer->ReadLine();
            Util::StringParser sp2(line);
            String region = sp2.GetString(';');
            if(readPoints)
            {
                if(region.substr(0, 8) == "<CIRCLE ")
                {
                    Util::StringParser sp(region);
                    String temp = sp.GetString(' ');   // ignore <CIRCLE
                    *MatE(points, i, 0) = sp.GetDouble(' ');
                    *MatE(points, i, 1) = sp.GetDouble(' ');
                    *MatE(points, i, 2) = sp.GetDouble(' ');
                    *MatE(points, i, 3) = sp.GetDouble(' ');
                    *MatE(points, i, 4) = sp.GetDouble('>');
                }
                else
                {
                    ILOG_ERROR("Unsupported region: " << region);
                    throw "Unsupported serialization type!";
                }
            }
    
            if(readDescriptors)
            {
                String descriptor = sp2.GetString(';');
                Util::StringParser sp3(descriptor);
                if(dimensionCount > 0)
                {
                    for(int j = 0; j < dimensionCount; j++)
                    {
                        *MatE(descriptors, i, j) = sp3.GetDouble();
                    }
                }
            }
        }
        return "CIRCLE";
    }
    else
    {
        ILOG_ERROR("Unknown format to read point descriptors from: " << String(buf));
        return "ERROR";
    }
}


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

#endif

---