MetaFile.h

Go to the documentation of this file.

#ifndef __META_FILE__
#define __META_FILE__

#include <string>
#include <sstream>
#include <vector>
#include <opencv/cv.h>

#include "rapidxml.hpp"

class MetaFile
{
public:
  struct MetaData
  {
  public:
    struct tFaceDim
    {
      float Width;
      float Height;
      cv::Mat oTf; // transformation from object frame to face frame
    };
    
  public:
    
    MetaData(){ reset(); }
    
  public:
    std::string Name;
    int NFaces;
    std::string Type;
    
    struct tDimensions
    {
      // for 3D objects
      struct tVolume
      {
        float Scale; 
      } Volume;
      
      // for planar objects in metres
      struct tPlanar
      {
        float Width;
        float Height;
        float Depth;
        
        // Dimensions of each face image
        std::vector<tFaceDim> Faces;
        
      } Planar;
      
    } Dimensions;
    
    inline void reset()
    {
      Name = Type = "";
      NFaces = 0;
      Dimensions.Planar.Width = 0;
      Dimensions.Planar.Height = 0;
      Dimensions.Planar.Depth = 0;
    }
  };
  
public:
  
  static void readFile(const std::string &filename, MetaData &data);
  
  static void saveFile(const std::string &filename, const MetaData &data);
  
protected:

  template<class T>
  static T parse(const std::string &s);

  template<class T>
  static std::vector<T> parse(const std::vector<std::string> &v);

  template<class T>
  static std::string stringfy(T v);

  template<class T>
  static std::string stringfy(T* v, int N);

protected:

  static void parseDimensions(MetaFile::MetaData &meta, 
    rapidxml::xml_node<> *node);
  
  static void parseFace(MetaFile::MetaData &meta, 
    rapidxml::xml_node<> *node);

};

// ----------------------------------------------------------------------------

template<class T>
T MetaFile::parse(const std::string &s)
{
  std::stringstream ss(s);
  T v;
  ss >> v;
  return v;
}

// ----------------------------------------------------------------------------

template<class T>
std::vector<T> MetaFile::parse(const std::vector<std::string> &v)
{
  std::vector<T> ret;
  ret.reserve(v.size());
  
  std::vector<std::string>::const_iterator it;
  for(it = v.begin(); it != v.end(); ++it)
  {
    ret.push_back( MetaFile::parse<T>(*it) );
  }
  
  return ret;
}

// ----------------------------------------------------------------------------

template<class T>
std::string MetaFile::stringfy(T v)
{
  std::stringstream ss;
  ss << v;
  return ss.str();
}

// ----------------------------------------------------------------------------

template<class T>
std::string MetaFile::stringfy(T* v, int N)
{
  std::stringstream ss;
  
  for(int i = 0; i < N; ++i)
    ss << v[i] << " ";

  return ss.str();
}

// ----------------------------------------------------------------------------

#endif