ezc3d.h

Go to the documentation of this file.

#ifndef EZC3D_H
#define EZC3D_H


// dllexport/import declaration
#ifdef _WIN32
#  ifdef EZC3D_API_EXPORTS
#    define EZC3D_API __declspec(dllexport)
#  else
#    define EZC3D_API __declspec(dllimport)
#  endif
#else
#  define EZC3D_API
#endif

// Includes for standard library
#include <sstream>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <string.h>
#include <cmath>
#include <stdexcept>
#include <memory>
#ifdef _WIN32
#include <string>
#endif

namespace ezc3d {
    // ---- UTILS ---- //
    enum DATA_TYPE{
        CHAR = -1,
        BYTE = 1,
        INT = 2,
        WORD = 2,
        FLOAT = 4,
        NO_DATA_TYPE = 10000
    };

    enum PROCESSOR_TYPE{
        INTEL = 84,
        DEC = 85,
        MIPS = 86,
        NO_PROCESSOR_TYPE = INTEL
    };

    EZC3D_API void removeTrailingSpaces(std::string& str);

    EZC3D_API std::string toUpper(const std::string &str);


    // ---- FORWARD DECLARATION OF THE WHOLE PROJECT STRUCTURE ----//
    class c3d;
    class EZC3D_API Header;

    namespace ParametersNS {
        class EZC3D_API Parameters;

        namespace GroupNS {
                class EZC3D_API Group;
                class EZC3D_API Parameter;
            }
    }

    namespace DataNS {
        class EZC3D_API Data;

        class Frame;
        namespace Points3dNS {
            class EZC3D_API Points;
            class EZC3D_API Point;
        }
        namespace AnalogsNS {
            class EZC3D_API Analogs;
            class EZC3D_API SubFrame;
            class EZC3D_API Channel;
        }
    }
}

class EZC3D_API ezc3d::c3d {
protected:
    std::string _filePath; 

    // ---- CONSTRUCTORS ---- //
public:
    c3d();

    c3d(const std::string &filePath);

    virtual ~c3d();


    //---- STREAM ----//
public:
    void print() const;

    void write(const std::string &filePath) const;

protected:
    // Internal reading and writting function
    char * c_float; 
    char * c_float_tp; 
    char * c_int; 
    char * c_int_tp; 
    unsigned int m_nByteToRead_float; 
    unsigned int m_nByteToReadMax_int; 

    void resizeCharHolder(unsigned int nByteToRead);

    void readFile(
        std::fstream &file,
        unsigned int nByteToRead,
        char * c,
        int nByteFromPrevious = 0,
        const  std::ios_base::seekdir &pos = std::ios::cur);

    unsigned int hex2uint(const char * val, unsigned int len);

    int hex2int(const char * val, unsigned int len);

    void writeDataStart(std::fstream &file,
                        const std::streampos& dataStartPosition,
                        const DATA_TYPE &type) const;

public:
    int readInt(PROCESSOR_TYPE processorType,
                std::fstream &file,
                unsigned int nByteToRead,
                int nByteFromPrevious = 0,
                const std::ios_base::seekdir &pos = std::ios::cur);

    size_t readUint(PROCESSOR_TYPE processorType,
                    std::fstream &file,
                    unsigned int nByteToRead,
                    int nByteFromPrevious = 0,
                    const std::ios_base::seekdir &pos = std::ios::cur);

    float readFloat(PROCESSOR_TYPE processorType,
                    std::fstream &file,
                    int nByteFromPrevious = 0,
                    const std::ios_base::seekdir &pos = std::ios::cur);

    std::string readString(std::fstream &file,
                           unsigned int nByteToRead,
                           int nByteFromPrevious = 0,
                           const std::ios_base::seekdir &pos = std::ios::cur);

    void readParam(PROCESSOR_TYPE processorType,
                   std::fstream &file,
                   unsigned int dataLenghtInBytes,
                   const std::vector<size_t> &dimension,
                   std::vector<int> &param_data,
                   size_t currentIdx = 0);

    void readParam(PROCESSOR_TYPE processorType,
                   std::fstream &file,
                   const std::vector<size_t> &dimension,
                   std::vector<float> &param_data,
                   size_t currentIdx = 0);

    void readParam(std::fstream &file,
                   const std::vector<size_t> &dimension,
                   std::vector<std::string> &param_data);

protected:
    size_t _dispatchMatrix(const std::vector<size_t> &dimension,
                         const std::vector<std::string> &param_data_in,
                         std::vector<std::string> &param_data_out,
                         size_t idxInParam = 0,
                         size_t currentIdx = 1);

    void _readMatrix(std::fstream &file,
                     const std::vector<size_t> &dimension,
                     std::vector<std::string> &param_data,
                     size_t currentIdx = 0);


    // ---- C3D MAIN STRUCTURE ---- //
protected:
    std::shared_ptr<ezc3d::Header> _header; 
    std::shared_ptr<ezc3d::ParametersNS::Parameters> _parameters; 
    std::shared_ptr<ezc3d::DataNS::Data> _data; 

public:
    const ezc3d::Header& header() const;

    const ezc3d::ParametersNS::Parameters& parameters() const;

    const ezc3d::DataNS::Data& data() const;

    // ---- PUBLIC GETTER INTERFACE ---- //
public:
    const std::vector<std::string>& pointNames() const;

    size_t pointIdx(const std::string& pointName) const;

    const std::vector<std::string>& channelNames() const;

    size_t channelIdx(const std::string& channelName) const;


    // ---- PUBLIC C3D MODIFICATION INTERFACE ---- //
public:
    void parameter(const std::string &groupName, const ezc3d::ParametersNS::GroupNS::Parameter &parameter);

    void lockGroup(const std::string &groupName);

    void unlockGroup(const std::string &groupName);

    void frame(const ezc3d::DataNS::Frame &frame, size_t idx = SIZE_MAX);

    void point(const std::string &name);

    void point(const std::string &pointName, const std::vector<ezc3d::DataNS::Frame> &frames);

    void point(const std::vector<std::string> &pointNames, const std::vector<ezc3d::DataNS::Frame> &frames);

    void analog(const std::string &name);

    void analog(std::string channelName, const std::vector<ezc3d::DataNS::Frame> &frames);

    void analog(const std::vector<std::string>& channelNames, const std::vector<ezc3d::DataNS::Frame> &frames);


    // ---- UPDATER ---- //
protected:
    void updateHeader();

    void updateParameters(const std::vector<std::string> &newPoints = std::vector<std::string>(), const std::vector<std::string> &newAnalogs = std::vector<std::string>());

};

#endif