fsstream.h

Go to the documentation of this file.

#ifndef FSSTREAM_H
#define FSSTREAM_H

#include <QDataStream>
#include <QTextStream>
#include <QByteArray>
#include <vector>

#include <OgreQuaternion.h>
#include <OgreVector3.h>

namespace fs {

class fsTrackingData
{
public:
    double m_timestamp;

    bool m_trackingSuccessful;

    Ogre::Quaternion m_headRotation;
    Ogre::Vector3 m_headTranslation;

    float m_eyeGazeLeftPitch;
    float m_eyeGazeLeftYaw;
    float m_eyeGazeRightPitch;
    float m_eyeGazeRightYaw;

    std::vector<float> m_coeffs;

    std::vector< Ogre::Vector3 > m_markers;

    bool operator==(const fsTrackingData & other);

public:

};



class fsDataStream : public QDataStream
{
public:
    fsDataStream( QByteArray * data, QIODevice::OpenMode mode ):QDataStream(data,mode) {
        setVersion( QDataStream::Qt_4_5 );          // minimum  Qt_4_5 stream
        setByteOrder(QDataStream::LittleEndian);    // little endian encoding
    }
    fsDataStream( const QByteArray & data):QDataStream(data) {
        setVersion( QDataStream::Qt_4_5 );          // minimum  Qt_4_5 stream
        setByteOrder(QDataStream::LittleEndian);    // little endian encoding
    }
    virtual ~fsDataStream() {}
};

class fsTextStream : public QTextStream
{
public:
    fsTextStream( QByteArray * data, QIODevice::OpenMode mode ):QTextStream(data,mode){}
    fsTextStream( const QByteArray & data ):QTextStream(data){}
    virtual ~fsTextStream() {}
};


class fsDataBlock
{
public:
    fsDataBlock();
    fsDataBlock( quint16 blockID, quint16 version, const QByteArray & data );

    QByteArray encode();

    bool decode( const QByteArray & data );

    static bool headerAvailable( const QByteArray & data );

    static bool blockAvailable( const QByteArray & data );

    static quint16 nextBlockID( const QByteArray & data );

    quint32 getTotalSize() { return m_data.size() + 2*sizeof(quint16) + sizeof(quint32); }
    quint32 getBlockSize() { return m_data.size(); }

    quint16 m_blockID;
    quint16 m_version;
    QByteArray m_data;
};


class fsBinaryTrackingStream {
public:
    void clear()  { m_data.clear(); }

    void append(const QByteArray & data) { m_data.append( data ); }

    void encode(const fsTrackingData & _trackingData);

    bool decode( fsTrackingData & _trackingData, bool _removeDataAfterDecoding = true );

    const QByteArray & getData() { return m_data; }

    bool isValid() const { return m_valid; }

private:
    QByteArray encodeInfo(const fsTrackingData & _trackingData);
    QByteArray encodePose(const fsTrackingData & _trackingData);
    QByteArray encodeBlendshapes(const fsTrackingData & _trackingData);
    QByteArray encodeEyeGaze(const fsTrackingData & _trackingData);
    QByteArray encodeMarkers(const fsTrackingData & _trackingData);

    void decodeInfo(fsTrackingData & _trackingData,const QByteArray & data);
    void decodePose(fsTrackingData & _trackingData,const QByteArray & data);
    void decodeBlendshapes(fsTrackingData & _trackingData,const QByteArray & data);
    void decodeEyeGaze(fsTrackingData & _trackingData,const QByteArray & data);
    void decodeMarkers(fsTrackingData & _trackingData,const QByteArray & data);

    QByteArray m_data;

    bool m_valid;
};



class fsAsciiTrackingStream {
public:
    void clear()  { m_data.clear(); }

    void append(const QByteArray & data) { m_data.append( data ); }

    void encode(const fsTrackingData & _trackingData);

    bool decode( fsTrackingData & _trackingData, bool _removeDataAfterDecoding = true );

    const QByteArray & getData() { return m_data; }

    bool isValid() const { return m_valid; }

private:
    QByteArray encodeInfo(const fsTrackingData & _trackingData);
    QByteArray encodePose(const fsTrackingData & _trackingData);
    QByteArray encodeBlendshapes(const fsTrackingData & _trackingData);
    QByteArray encodeEyeGaze(const fsTrackingData & _trackingData);
    QByteArray encodeMarkers(const fsTrackingData & _trackingData);

    void decodeInfo(fsTrackingData & _trackingData, fs::fsTextStream & stream);
    void decodePose(fsTrackingData & _trackingData, fs::fsTextStream & stream);
    void decodeBlendshapes(fsTrackingData & _trackingData, fs::fsTextStream & stream);
    void decodeEyeGaze(fsTrackingData & _trackingData, fs::fsTextStream & stream);
    void decodeMarkers(fsTrackingData & _trackingData, fs::fsTextStream & stream);

    QByteArray m_data;

    bool m_valid;
};

}

#endif // FSSTREAM_H