OutputSequenceData.h

Go to the documentation of this file.

 
#ifndef OUTPUTSEQUENCEDATA_H_
#define OUTPUTSEQUENCEDATA_H_
 
#include "Event.h"
#include "Declarations.h"
 
#include <vector>
#include <map>
 
class SeqBlock
{
public:
        enum EventCode {
                DELAY,
                RF,
                XGRAD,
                YGRAD,
                ZGRAD,
                ADC
        };
 
        static const int NUM_EVENTS = (ADC+1);
 
        SeqBlock(){ for (int i=0; i<NUM_EVENTS; i++) events[i]=0; }
 
        int events[NUM_EVENTS];     // DELAY RF X Y Z ADC
 
};
 
class OutputSequenceData
{
        struct CompressedShape
        {
        public:
                bool operator==(const CompressedShape &other) const {
                        if (this->m_num_uncompressed_samples!=other.m_num_uncompressed_samples) return false;
                        if (this->m_samples.size()!=other.m_samples.size()) return false;
                        for (int i=0; i<this->m_samples.size(); i++) {
                                if (this->m_samples[i]!=other.m_samples[i]) return false;
                        }
                        return true;
                }
 
                int m_num_uncompressed_samples;     
                std::vector<double> m_samples;      
        };
 
 public:
 
        OutputSequenceData           () : m_duration(0.0) {
                SetRotationMatrix(0.0,0.0,0.0);
        };
 
        ~OutputSequenceData          () {};
 
        void AddEvents(std::vector<Event*> &events, double duration=0.0);
 
        void SetRotationMatrix(double alpha, double theta, double phi);
 
        void SetDefinitions(std::map<std::string,std::string> &defs) {m_definitions=defs; };
 
        void WriteFiles(const std::string &outDir, const std::string &outFile);
 
 private:
        template<typename T> int SearchLibrary(std::vector<T> &library, T &obj);
 
        void CompressShape(std::vector<double> &shape, CompressedShape *out);
 
 
        double  m_rot_matrix[3][3];     
        double  m_duration;             
        std::map<std::string,std::string> m_definitions; 
        std::vector<SeqBlock>         m_blocks;          
        std::vector<DelayEvent>       m_delay_library;   
        std::vector<RFEvent>          m_rf_library;      
        std::vector<GradEvent>        m_grad_library;    
        std::vector<ADCEvent>         m_adc_library;     
        std::vector<CompressedShape>  m_shape_library;   
};
 
#endif /*OUTPUTSEQUENCEDATA_H_*/