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

---

InterestPointListIO.h

Go to the documentation of this file.

#ifndef Impala_Core_Geometry_InterestPointListIO_h
#define Impala_Core_Geometry_InterestPointListIO_h

#include "Core/Geometry/InterestPointList.h"
#include "Core/Geometry/InterestCircle.h"
#include "Core/Geometry/InterestRectangleZ.h"
#include "Core/Vector/VectorTem.h"

#include <iostream>
#include <fstream>

namespace Impala
{
namespace Sandbox
{
namespace Koen
{

using namespace Impala::Core::Geometry;


void
WriteRegionsToStreamFormatKoen(std::ostream& fs, InterestPointList& outputPointList, bool writeDescriptors, int borderOffset)
{
    ILOG_VAR(Sandbox.koen.WriteRegionsToStreamFormatKoen);
    /* 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
    */
    int dimensionCount = -1;
    fs << "KOEN1\n";
    if(writeDescriptors)
    {
        if(outputPointList.size() == 0)
        {
            dimensionCount = 0;
        }
        else
        {
            dimensionCount = (*(outputPointList.begin()))->mDescriptor.size();
        }
        fs << dimensionCount << "\n";
    }
    else
    {
        fs << "0\n";
    }
    fs << outputPointList.size() << "\n";
    for(InterestPointList::iterator iter = outputPointList.begin(); iter != outputPointList.end(); iter++)
    {
        InterestPoint* point = *iter;
        // 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
        fs << point->Serialize(borderOffset+1, borderOffset+1);
        if(writeDescriptors)
        {
            if(point->mDescriptor.size() != dimensionCount)
            {
                ILOG_ERROR("Your code has created descriptors with variable length!");
                throw "Dimension mismatch!";
            }
            for(int i = 0; i < dimensionCount; i++)
            {
                fs << " " << point->mDescriptor[i];
            }
        }
        fs << ";\n";
    }
}


void
WriteRegionsToBuffer(Util::IOBuffer* buffer, InterestPointList& outputPointList, bool writeDescriptors, int borderOffset)
{
    ILOG_VAR(Sandbox.koen.WriteRegionsToBuffer);
    /* 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 = outputPointList.size();
    int bytesPerElement = 8;

    String magic = "BINDESC1";
    String dataType = "UNKNOWN ";
    String geometry = "";
    if(outputPointList.size() > 0)
    {
        Core::Vector::VectorTem<Real64>* p = (*(outputPointList.begin()))->PointAsVector(borderOffset+1, borderOffset+1);
        elementsPerPoint = p->Size();
        delete p;

        dimensionCount = (*(outputPointList.begin()))->mDescriptor.size();
        geometry = (*(outputPointList.begin()))->geometryType();
        if(geometry == "CircleZ")
        {
            dataType = "CIRCLE  ";
        } 
        else if(geometry == "RectangleZ")
        {
            dataType = "RECT    ";
        }
    }
    if(!writeDescriptors) dimensionCount = 0;
    
    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(InterestPointList::iterator iter = outputPointList.begin(); iter != outputPointList.end(); iter++)
    {
        InterestPoint* point = *iter;
        // 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
        Core::Vector::VectorTem<Real64>* p = point->PointAsVector(borderOffset+1, borderOffset+1);
        if(p->Size() != elementsPerPoint)
        {
            ILOG_ERROR("Point representations do not have equal length!");
            return;
        }
        buffer->Write(p->GetData(), sizeof(Real64) * elementsPerPoint);
        delete p;
    }

    if(dimensionCount == 0) return;
    
    Core::Vector::VectorTem<Real64> v = Core::Vector::VectorTem<Real64>(dimensionCount);
    for(InterestPointList::iterator iter = outputPointList.begin(); iter != outputPointList.end(); iter++)
    {
        InterestPoint* point = *iter;
        if(point->mDescriptor.size() != dimensionCount)
        {
            ILOG_ERROR("Your code has created descriptors with variable length!");
        }
        for(int i = 0; i < dimensionCount; i++)
        {
            v[i] = point->mDescriptor[i];
        }
        buffer->Write(v.GetData(), sizeof(Real64) * dimensionCount);
    }
}


void
WritePointListToFile(String filename, InterestPointList& outputPointList, bool writeDescriptors, int borderOffset, String format, bool appendToExisting=false)
{
    if((format == "bindesc1") || (format == "binary"))
    {
        Util::IOBuffer* buffer = new Util::IOBufferFile(filename, false, false);
        WriteRegionsToBuffer(buffer, outputPointList, writeDescriptors, borderOffset);
        delete buffer;
    }
    else
    {
        std::ios::openmode flags = std::ios::ate | std::ios::out | std::ios::in;
        if(!appendToExisting)
        {
            flags = std::ios::out;
        }
        std::ofstream fs(filename.c_str(), flags);
        WriteRegionsToStreamFormatKoen(fs, outputPointList, writeDescriptors, borderOffset);
        fs.close();
    }
}


void
ReadRegionsFromStreamFormatKoen(CString content, InterestPointList& outputPointList, bool readDescriptors, int borderOffset)
{
    ILOG_VAR(Sandbox.koen.ReadRegionsFromStreamFormatKoen);
    //note: this function will probably not work on Windows due to line ending problems

    /* 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
    */

    Util::StringParser sp(content);
    //std::cout << content << "x" << fileSize << std::endl;

    // first line: KOEN1
    String header = sp.GetString('\n');
    if(header != String("KOEN1"))
    {
        ILOG_ERROR("Unsupported region format: " << header);
        return;
    }

    // second line: dimensionality
    int dimensionCount = sp.GetInt('\n');
    int regionCount = sp.GetInt('\n');
    ILOG_DEBUG("Reading file; dimensionCount = " << dimensionCount << "; regionCount = " << regionCount);
    for(int i = 0; i < regionCount; i++)
    {
        InterestPoint* point = 0;

        String line = sp.GetString('\n');
        Util::StringParser sp2(line);
        String region = sp2.GetString(';');
        if(region.substr(0, 8) == "<CIRCLE ")
        {
            // 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
            point = new InterestCircle(region, borderOffset+1, borderOffset+1);
        }
        else
        {
            ILOG_ERROR("Unsupported region: " << region);
            throw "Unsupported serialization type!";
        }

        if(readDescriptors)
        {
            String descriptor = sp2.GetString(';');
            Util::StringParser sp3(descriptor);
            if(dimensionCount > 0)
            {
                point->mDescriptor.reserve(dimensionCount);
                for(int j = 0; j < dimensionCount; j++)
                {
                    point->mDescriptor.push_back(sp3.GetDouble());
                }
            }
        }
        if(point)
        {
            outputPointList.push_back(point);
        }
    }
}


void
ReadRegionsFromStreamFormatKoen(std::istream& fs, InterestPointList& outputPointList, bool readDescriptors, int borderOffset)
{
    ILOG_VAR(Sandbox.koen.ReadRegionsFromStreamFormatKoen);
    //note: this function will probably not work on Windows due to line ending problems

    fs.seekg(0, std::ios_base::end);
    int fileSize = fs.tellg();
    fs.seekg(0, std::ios_base::beg);
    char* buffer = new char[fileSize];
    // 0 character should never be read from a file, so we should get the whole file
    fs.get(buffer, fileSize, '\0');

    String content(buffer);
    ReadRegionsFromStreamFormatKoen(content, outputPointList, readDescriptors, borderOffset);
}


void
ReadPointListFromBuffer(Util::IOBuffer* buffer, 
                        InterestPointList& pointList, 
                        bool readDescriptors, int borderOffset)
{
    ILOG_VAR(Sandbox.koen.ReadRegionsFromBuffer);
    /* 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 magic = "BINDESC1";
    String dataType = "UNKNOWN ";
    String geometry = "";
    
    char buf[9];
    for (int i=0 ; i<9 ; i++)
        buf[i] = 0;
    
    ILOG_DEBUG("Reading header...");
    // read magic
    buffer->Read(buf, 8);
    if(String(buf) != magic)
    {
        ILOG_ERROR("ReadPointListFromBuffer invalid magic");
        return;
    }
    
    // read dataType
    buffer->Read(buf, 8);
    dataType = String(buf);
    if(dataType == "CIRCLE  ")
    {
        geometry = "CircleZ";
    } 
    else if(dataType == "RECT    ")
    {
        geometry = "RectangleZ";
    }

    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;
    }

    // read the points
    Core::Vector::VectorTem<Real64> pointVector = 
        Core::Vector::VectorTem<Real64>(elementsPerPoint);
    for(int i = 0; i < pointCount; i++)
    {
        buffer->Read(pointVector.GetData(), sizeof(Real64) * elementsPerPoint);
        if(geometry == "CircleZ")
        {
            InterestCircle* point = 
                new InterestCircle(pointVector, borderOffset+1, borderOffset+1);
            pointList.push_back(point);
        }
        else if(geometry == "RectangleZ")
        {
            ILOG_ERROR("Cannot deserialize rectangles: code not written");
            //InterestRectangleZ* point = 
            //    new InterestRectangleZ(pointVector, borderOffset+1,
            //                           borderOffset+1);
            //pointList.push_back(point);
        }
    }

    if(dimensionCount == 0) return;
    if(!readDescriptors) return;
    
    Core::Vector::VectorTem<Real64> v = 
        Core::Vector::VectorTem<Real64>(dimensionCount);
    for(InterestPointList::iterator iter = pointList.begin(); iter != pointList.end(); iter++)
    {
        InterestPoint* point = *iter;
        buffer->Read(v.GetData(), sizeof(Real64) * dimensionCount);
        point->mDescriptor.reserve(dimensionCount);
        for(int i = 0; i < dimensionCount; i++)
        {
            point->mDescriptor.push_back(v[i]);
        }
    }
}


void
ReadPointListFromFile(String filename, InterestPointList& outputPointList,
                      bool readDescriptors, int borderOffset)
{
    Util::IOBuffer* buffer = new Util::IOBufferFile(filename, true, false);
    char buf[9];
    for (int i=0 ; i<9 ; i++)
        buf[i] = 0;
    buffer->Read(buf, 8);
    
    if(String(buf) == "BINDESC1")
    {
        // Format BINDESC1
        buffer->Seek(0, SEEK_SET);
        ReadPointListFromBuffer(buffer, outputPointList, readDescriptors, 
                                borderOffset);
        delete buffer;
    }
    else
    {
        delete buffer;
        
        // Format KOEN1
        std::ifstream fs(filename.c_str());
        ReadRegionsFromStreamFormatKoen
            (fs, outputPointList, false, borderOffset);
        fs.close();
    }
}


} // namespace Koen
} // namespace Sandbox
} // namespace Impala

#endif

---