recording.h

Go to the documentation of this file.

// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

 
#ifndef _RECORDING_H
#define _RECORDING_H

 
#include <ctime>
#include <string>
#include <string.h>     // declaration of memcpy
#include <vector>
 
#include "./channel.h"
// #include "./section.h"
// #include "./stfio.h"
 
class Section;


class StfioDll Recording {
 public:
 
    //ctor/dtor-------------------------------------------------------
    explicit Recording();


    explicit Recording(const Channel& c_Channel); 


    explicit Recording(const std::deque<Channel>& ChannelList); 


    explicit Recording( std::size_t c_n_channels, std::size_t c_n_sections = 0, std::size_t c_n_points = 0 );

    virtual ~Recording();
 
    //member access functions: read-----------------------------------
    

    std::size_t GetChannelSize(std::size_t n_channel) const;


    const std::deque<Channel>& get() const { return ChannelArray; }
    

    std::deque<Channel>& get() { return ChannelArray; }
    

    const std::string& GetFileDescription() const { return file_description; }


    const std::string& GetGlobalSectionDescription() const { return global_section_description; }


    const std::string& GetScaling() const { return scaling; }


    struct tm GetDateTime() const { return datetime; };


    const std::string& GetComment() const { return comment; }
    

    const std::string& GetXUnits() const { return xunits; }


    std::size_t size() const { return ChannelArray.size(); }
    

    double GetXScale() const { return dt; }
    

    double GetSR() const { return 1.0/dt; }


    std::size_t GetCurChIndex() const { return cc; }


    std::size_t GetSecChIndex() const { return sc; }


    std::size_t GetCurSecIndex() const { return cs; }
    

    const std::vector<std::size_t>& GetSelectedSections() const { return selectedSections; } 


    std::vector<std::size_t>& GetSelectedSectionsW() { return selectedSections; } 


    const Vector_double& GetSelectBase() const { return selectBase; } 


    Vector_double& GetSelectBaseW() { return selectBase; }


    const Section& cursec() const { return (*this)[cc][cs]; }


    Section& cursec() { return (*this)[cc][cs]; }


    const Section& secsec() const { return (*this)[sc][cs]; }


    const Channel& curch() const { return (*this)[cc]; }


    Channel& curch() { return (*this)[cc]; }


    const Channel& secch() const { return (*this)[sc]; }


    const Channel& at(std::size_t n_c) const;


    Channel& at(std::size_t n_c);
 
    //member access functions: write---------------------------------


    void SetFileDescription(const std::string& value) { file_description=value; }


    void SetGlobalSectionDescription(const std::string& value) {
        global_section_description=value;
    }


    void SetScaling(const std::string& value) { scaling=value; }
 

    int SetTime(const std::string& value);
    int SetTime(int hour, int minute, int sec);


    int SetDate(const std::string& value);
    int SetDate(int year, int month, int mday);


    void SetDateTime(const struct tm &value) { memcpy(&datetime, &value, sizeof(struct tm)); }
    void SetDateTime(int year, int month, int mday, int hour, int minute, int sec) ;


    void SetComment(const std::string& value) { comment=value; }
    

    void SetGlobalYUnits(std::size_t n_channel, const std::string& value);


    void SetXUnits(const std::string& value) { xunits=value; }


    void SetXScale(double value);


    void SetCurChIndex(std::size_t value);


    void SetSecChIndex(std::size_t value);


    void SetCurSecIndex(std::size_t value);
 
    //misc-----------------------------------------------------------


    virtual void resize(std::size_t c_n_channels);


    virtual void InsertChannel(Channel& c_Channel, std::size_t pos);


    void CopyAttributes(const Recording& c_Recording);


    void MakeAverage( Section& AverageReturn, Section& SigReturn, std::size_t channel,
                      const std::vector<std::size_t>& section_index, bool isSig,
                      const std::vector<int>& shift) const;


    void AddRec(const Recording& toAdd);


    void SelectTrace(std::size_t sectionToSelect, std::ptrdiff_t base_start, std::ptrdiff_t base_end);


    bool UnselectTrace(std::size_t sectionToUnselect);
    
    //operators------------------------------------------------------


    Channel& operator[](std::size_t at) { return ChannelArray[at]; }


    const Channel& operator[](std::size_t at) const { return ChannelArray[at]; }

    std::string GetEventDescription(int type);

    void SetEventDescription(int type, const char* Description);

    void InitSectionMarkerList(size_t n);

    int GetSectionType(size_t section_number);

    void SetSectionType(size_t section_number, int type);
 
 private:
    std::deque<Channel> ChannelArray;
    std::string global_section_description, scaling;
 
    /* public: */
    
    double dt;
    std::string file_description, comment, xunits;
    struct tm datetime;
 
 
    // currently accessed channel:
    std::size_t cc;
    // second channel:
    std::size_t sc;
    // currently accessed section:
    std::size_t cs;
 
    // Indices of the selected sections
    std::vector<std::size_t> selectedSections;
    // Base line value for each selected trace
    Vector_double selectBase;
    
    // defined when data is loaded
    const char* listOfMarkers[256];
 
    /* SectionMarker contains, for each section, it's type
       as defined event table. 
       currently only one event type per segment is supported. 
     */
        std::vector<int> sectionMarker;
 
    void init();
 
};

 
#endif