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