PlyFile.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2015 Richard S. Smith and collaborators.
//
// If you use MorphoGraphX in your work, please cite:
//   http://dx.doi.org/10.7554/eLife.05864
//
// MorphoGraphX is free software, and is licensed under under the terms of the 
// GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
// 
#ifndef PLYFILE_HPP
#define PLYFILE_HPP
 
#include <Config.hpp>
 
#include <QHash>
#include <QList>
#include <QString>
#include <QStringList>
#include <stdint.h>
#include <vector>
 
class QFile;
 
#define FORALL_PLY_TYPES(macro) \
  macro(int8_t);                \
  macro(uint8_t);               \
  macro(int16_t);               \
  macro(uint16_t);              \
  macro(int32_t);               \
  macro(uint32_t);              \
  macro(float);                 \
  macro(double)
 
#define FORALL_PLY_TYPEIDS(macro)   \
  macro(int8_t, PlyFile::CHAR);     \
  macro(uint8_t, PlyFile::UCHAR);   \
  macro(int16_t, PlyFile::SHORT);   \
  macro(uint16_t, PlyFile::USHORT); \
  macro(int32_t, PlyFile::INT);     \
  macro(uint32_t, PlyFile::UINT);   \
  macro(float, PlyFile::FLOAT);     \
  macro(double, PlyFile::DOUBLE)
 
namespace mgx 
{
  struct mgx_EXPORT PlyFile {
    enum TYPE {
      CHAR,         
      UCHAR,        
      SHORT,        
      USHORT,       
      INT,          
      UINT,         
      FLOAT,        
      DOUBLE,       
      NB_TYPES,     
      INVALID_TYPE = NB_TYPES
    };
  
  #define INLINE_TYPE_ASSOC(T, TYPEID)                     \
    static inline TYPE getType(const T &) { return TYPEID; \
    }
    FORALL_PLY_TYPEIDS(INLINE_TYPE_ASSOC)
  #undef INLINE_TYPE_ASSOC
  
    static const unsigned int typeSizes[NB_TYPES];
    static char const* const typeNames[NB_TYPES + 1][3];
  
    enum FORMAT_TYPES {
      UNSPECIFIED_FORMAT = 0,     
      ASCII,                      
      BINARY_LITTLE_ENDIAN,       
      BINARY_BIG_ENDIAN           
    };
  
    static char const* const formatNames[4];
  
    struct Element;
  
    struct Property {
      enum KIND {
        VALUE,       
        LIST         
      };
      Property(const QString& name, Element* el = 0);
  
      ~Property();
  
      void allocate(size_t size);
  
      void deallocate();
  
      template <typename T> std::vector<std::vector<T> >* list()
      {
        if(_kind != LIST)
          return 0;
        if(getType(T()) != _memType)
          return 0;
        return (std::vector<std::vector<T> >*)_content;
      }
  
      template <typename T> std::vector<T>* value()
      {
        if(_kind != VALUE)
          return 0;
        if(getType(T()) != _memType)
          return 0;
        return (std::vector<T>*)_content;
      }
  
      template <typename T> const std::vector<std::vector<T> >* list() const
      {
        if(_kind != LIST)
          return 0;
        if(getType(T()) != _memType)
          return 0;
        return (const std::vector<std::vector<T> >*)_content;
      }
  
      template <typename T> const std::vector<T>* value() const
      {
        if(_kind != VALUE)
          return 0;
        if(getType(T()) != _memType)
          return 0;
        return (const std::vector<T>*)_content;
      }
  
      bool error(const QString& str) const;
  
      const QString& name() const {
        return _name;
      }
  
      TYPE fileType() const {
        return _fileType;
      }
  
      TYPE memType() const {
        return _memType;
      }
  
      TYPE sizeType() const {
        return _sizeType;
      }
  
      KIND kind() const {
        return _kind;
      }
  
      size_t size() const {
        return _size;
      }
  
      bool rename(const QString& n);
  
      void setFileType(TYPE ft) {
        _fileType = ft;
      }
  
      void setMemType(TYPE mt);
  
      void setSizeType(TYPE st) {
        _sizeType = st;
      }
  
      void setKind(KIND k);     // Changing the kind after allocation looses all data!
  
      Element* parent() {
        return _parent;
      }
  
      const Element* parent() const {
        return _parent;
      }
  
      bool setParent(Element* parent);
  
      void resize(size_t s);
  
  protected:
      QString _name;        // Name of the property
      TYPE _fileType;       // type of the elements on the file
      TYPE _memType;        // type of the elements in memory (INVALID_TYPE if the property should not be loaded)
      TYPE _sizeType;       // type used to hold the number of elements (if any)
      KIND _kind;           // Single value or list (later .. vector?)
      Element* _parent;     // Element containing the property (if any)
      void* _content;       // Content of the property, if allocated
      size_t _size;         // Number of elements
    };
  
    struct Element {
      Element(const QString& name, PlyFile* parent = 0);
  
      ~Element();
  
      void allocate();
  
      void clear();
  
      size_t nbProperties() const {
        return _properties.size();
      }
  
      size_t size() const {
        return _nbElements;
      }
  
      void resize(size_t n);
  
      QStringList properties() const;
  
      Property* property(size_t pos);
      const Property* property(size_t pos) const;
      Property* property(const QString& name);
      const Property* property(const QString& name) const;
  
      Property* createValue(const QString& name, TYPE file, TYPE mem = INVALID_TYPE);
      Property* createList(const QString& name, TYPE size, TYPE file, TYPE mem = INVALID_TYPE);
  
      bool error(const QString& str) const;
  
      bool hasProperty(const QString& name) const;
  
      bool attach(Property* prop);
  
      bool detach(Property* prop);
  
      Property* detach(const QString& name);
  
      const QString& name() const {
        return _name;
      }
  
      bool rename(const QString& n);
  
      bool allocated() const {
        return _allocated;
      }
  
      bool setParent(PlyFile* p);
      PlyFile* parent() {
        return _parent;
      }
      const PlyFile* parent() const {
        return _parent;
      }
  
      void _rename_prop(Property* prop, const QString& new_name);     // Don't call this yourself!
      void _attach(Property* prop);
      void _detach(Property* prop);
  
  protected:
      QString _name;
      size_t _nbElements;
      QList<Property*> _properties;
      QHash<QString, int> _property_map;
      PlyFile* _parent;
      bool _allocated;
    };
  
    PlyFile();
  
    void clear();
  
    bool init(FORMAT_TYPES format = BINARY_LITTLE_ENDIAN, const QString& version = "1.0");
  
    bool validate();
  
    void allocate();
  
    FORMAT_TYPES format() const {
      return _format;
    }
    bool setFormat(FORMAT_TYPES f)
    {
      if(f != UNSPECIFIED_FORMAT) {
        _format = f;
        return true;
      }
      return false;
    }
  
    bool setVersion(QString version);
    const QString& version() const {
      return _version;
    }
  
    Element* element(size_t idx);
    const Element* element(size_t idx) const;
    Element* element(const QString& name);
    const Element* element(const QString& name) const;
    Element* createElement(const QString& name, size_t nb_elements);
  
    Element* currentElement() {
      return current_element;
    }
    bool hasElement(const QString& name) const;
  
    size_t nbElements() const {
      return _elements.size();
    }
  
    bool attach(Element* el);
  
    bool detach(Element* el);
  
    bool parseHeader(const QString& filename);
  
    bool parseContent();   // Parse the content of the file whose header has been parsed last
  
    bool error(const QString err) const;
  
    bool save(const QString& filename) const;
  
    qint64 contentPosition() const {
      return _contentPosition;
    }
  
    bool isValid() const {
      return is_valid;
    }
    operator bool() const { return is_valid; }
  
    const QStringList& comments() const {
      return _comments;
    }
  
    void addComment(QString line);
  
    void clearComments() {
      _comments.clear();
    }
  
    void _attach(Element* el);
    void _detach(Element* el);
  
  protected:
    bool parseAsciiContent(QFile& f);
    bool parseBinaryContent(QFile& f, bool little_endian);
  
    bool readFormat(const QStringList& fields);
    bool readElement(const QStringList& fields);
    bool readProperty(const QStringList& fields);
  
    bool writeHeader(QFile& f) const;
    bool writeAsciiContent(QFile& f) const;
    bool writeBinaryContent(QFile& f, bool little_endian) const;
  
    TYPE parseType(QString typeName) const;
  
    QList<Element*> _elements;
    QHash<QString, int> _element_map;
  
    Element* current_element;
  
    QString filename;
    int line_nb;
  
    FORMAT_TYPES _format;
    QString _version;
    QStringList _comments;
    int _version_major, _version_minor;
    bool is_valid;
    qint64 _contentPosition;
  };
}
#endif