NodeData.hpp

Go to the documentation of this file.

 
/*
 * NodeData.hpp
 *
 *  Created on: Dec 11, 2015
 *      Author: Isaak Mitschke
 */
 
#ifndef LAS_VEGAS_NODEDATA_H
#define LAS_VEGAS_NODEDATA_H
#include <boost/timer/timer.hpp>
#include <ctime>
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
 
using namespace std;
 
namespace lvr2
{
template <typename BaseVecT>
class NodeData
{
    static boost::timer::cpu_timer itimer;
    static boost::timer::cpu_timer otimer;
    static bool timer_init;
 
    // Iterator
    class Iterator;
 
  public:
    NodeData(size_t bufferSize);
    NodeData(NodeData& origin);
 
    NodeData& operator=(NodeData& origin);
 
    void open(string path);
 
    const string& getDataPath() const { return m_dataPath; }
 
    const string getFolder() const { return to_string(c_tstamp).insert(0, "node-"); }
 
    Iterator begin();
 
    Iterator end();
 
    void remove();
 
    void remove(unsigned int i);
 
    void add(BaseVecT input);
 
    void addNormal(BaseVecT input);
 
    void addBuffered(BaseVecT input);
 
    void addBufferedNormal(BaseVecT input);
 
    void writeBuffer();
 
    size_t getMaxWriteBufferSize();
    BaseVecT get(int);
 
    BaseVecT getNormal(int);
    BaseVecT next();
 
    size_t size();
 
    size_t getBufferSize();
 
    static void printTimer()
    {
        std::cout << "IO-Timer of Octree:" << std::endl
                  << "READ: " << itimer.format() << std::endl
                  << "WRITE: " << otimer.format() << std::endl;
    }
 
  private:
    // copys the data from origin to this
    void copy(NodeData& origin);
    // fills the buffer, copys from start_id to buffersize elements into buffer
    void fillBuffer(size_t start_id);
    void fillBufferNormal(size_t start_id);
    // path to data
    string m_dataPath;
 
    string m_dataPathNormal;
    // if m_gotSize is set, the m_size will be used, else the size will be calculated
    bool m_gotSize;
    // amount of points stored in data
    size_t m_size;
    // current id of the dataobject, used to generate file name
    int m_id;
    // input buffer
    vector<float> m_readBuffer;
    // output buffer
    vector<float> m_writeBuffer;
 
    vector<float> m_readBufferNormal;
    // output buffer
    vector<float> m_writeBufferNormal;
 
    // maximum buffer size
    size_t m_bufferSize;
    // current inputbuffer position
    size_t m_readBufferIndex;
 
    size_t m_readBufferIndexNormal;
    // last id
    static int c_last_id;
    // timestamp, of first creation
    static time_t c_tstamp;
};
 
template <typename BaseVecT>
class NodeData<BaseVecT>::Iterator
{
  public:
    Iterator(NodeData& nodeData, size_t pos) : m_NodeData(nodeData), m_pos(pos) {}
    Iterator(NodeData& nodeData) : m_NodeData(nodeData), m_pos(0) {}
    Iterator(const Iterator& copy) : m_pos(copy.m_pos), m_NodeData(copy.m_NodeData) {}
 
    Iterator operator++(int)
    {
        Iterator tmp(*this);
        operator++();
        return tmp;
    }
 
    bool operator==(const Iterator& rhs) { return m_pos == rhs.m_pos; }
    bool operator!=(const Iterator& rhs) { return m_pos != rhs.m_pos; }
    // Todo: more if needed
    void operator+(int i) { m_pos += i; }
    void operator-(int i) { m_pos -= i; }
    void operator++() { ++m_pos; }
    void operator--() { --m_pos; }
 
    BaseVecT operator*() { return m_NodeData.get(m_pos); }
    BaseVecT operator->() { return m_NodeData.get(m_pos); }
 
  private:
    NodeData<BaseVecT>& m_NodeData;
    size_t m_pos;
};
 
} // namespace lvr2
 
#include "NodeData.tcc"
 
#endif // LAS_VEGAS_NODEDATA_H