TTTRRange.h

Go to the documentation of this file.

#ifndef TTTRLIB_TTTRRANGE_H
#define TTTRLIB_TTTRRANGE_H
 
#include <memory> /* std::shared_ptr */
#include <set>
#include <vector>
//#include<boost/container/flat_set.hpp>
#include "itlib/flat_set.hpp"
 
#include "TTTR.h"
 
class TTTRRange {
 
protected:
 
    //boost::container::flat_set<int> _tttr_indices{};
    //std::flat_set<int> _tttr_indices{};
 
    itlib::flat_set<int> _tttr_indices{};
 
public:
 
    TTTRRange(int start, int stop);
 
    TTTRRange(int start=-1, int stop=-1, TTTRRange* other = nullptr){
        if((start >=0) && (stop >= 0)){
            _tttr_indices.insert(start);
            _tttr_indices.insert(stop);
        } else if(other != nullptr){
            _tttr_indices.insert(other->get_start());
            _tttr_indices.insert(other->get_stop());
        }
    }
 
    virtual size_t size(){
        return _tttr_indices.size();
    }
 
    TTTRRange(const TTTRRange& p2);
 
    std::vector<int> get_tttr_indices(){
        std::vector<int> v(_tttr_indices.begin(), _tttr_indices.end());
        return v;
    }
 
    int get_start() const{
        if(!_tttr_indices.empty()){
            return *_tttr_indices.begin();
        } else{
            return -1;
        }
    }
 
    int get_stop() const{
        if(!_tttr_indices.empty()){
            return *_tttr_indices.rbegin();
        } else{
            return -1;
        }
    }
 
    std::vector<int> get_start_stop(){
        return {
            get_start(),
            get_stop()
        };
    }
 
    unsigned long get_stop_time(TTTR* tttr) const{
        unsigned long time = 0;
        if(tttr!= nullptr){
            time = tttr->macro_times[*_tttr_indices.rbegin()];
        } else{
            std::cerr << "Access to TTTRRange::get_stop_time without TTTR object" << std::endl;
        }
        return time;
    }
 
    unsigned long get_start_time(TTTR* tttr) const{
        unsigned long start_time = 0;
        if(tttr!= nullptr){
            start_time = tttr->macro_times[*_tttr_indices.begin()];
        } else{
            std::cerr << "Access to TTTRRange::get_start_time without TTTR object" << std::endl;
        }
        return start_time;
    }
 
    std::vector<unsigned long> get_start_stop_time(TTTR* tttr){
        return {
                get_start_time(tttr),
                get_stop_time(tttr)
        };
    }
 
    unsigned int get_duration(TTTR* tttr){
        return get_stop_time(tttr) - get_start_time(tttr);
    }
 
    void insert(int idx){
        _tttr_indices.insert(idx);
    }
 
    void clear(){
        _tttr_indices.clear();
    }
 
    int strip(const std::vector<int> &tttr_indices, int offset = 0){
        if(!_tttr_indices.empty()){
            for(; offset < tttr_indices.size(); offset++){
                int v = tttr_indices[offset];
                if(v >= *_tttr_indices.rbegin()){
                    break;
                } else {
                    _tttr_indices.erase(v);
                }
            }
        }
        return offset;
    }
 
    double get_mean_microtime(
            TTTR* tttr_data,
            double microtime_resolution = -1.0,
            int minimum_number_of_photons = 1
    ){
        auto v = get_tttr_indices();
        return tttr_data->get_mean_microtime(
                &v,
                microtime_resolution,
                minimum_number_of_photons
        );
    }
 
    void get_microtime_histogram(
            std::shared_ptr<TTTR> tttr,
            double** histogram, int* n_histogram,
            double** time, int* n_time,
            unsigned short micro_time_coarsening
    ){
        auto v = get_tttr_indices();
        TTTR::compute_microtime_histogram(
            tttr.get(),
            histogram, n_histogram,
            time, n_time,
            micro_time_coarsening,
            &v
        );
    }
 
    double get_mean_lifetime(
            TTTR *tttr_data,
            int minimum_number_of_photons = 3,
            TTTR *tttr_irf = nullptr,
            double m0_irf = 1.0, double m1_irf = 1.0,
            double dt = 1.0,
            std::vector<double> *background = nullptr,
            double m0_bg = 0.0, double m1_bg = 0.0,
            double background_fraction = -1.0
    );
 
    static double compute_mean_lifetime(
            std::vector<int> &tttr_indices,
            TTTR *tttr_data,
            int minimum_number_of_photons = 3,
            TTTR *tttr_irf = nullptr,
            double m0_irf = 1.0, double m1_irf = 1.0,
            double dt = 1.0,
            std::vector<double> *background = nullptr,
            double m0_bg = 0.0, double m1_bg = 0.0,
            double background_fraction = -1.0
    );
 
    bool operator==(const TTTRRange& other) const {
        return _tttr_indices == other._tttr_indices;
    }
 
    bool operator!=(const TTTRRange& other) const
    {
        return !operator==(other);
    }
 
    TTTRRange& operator+=(const TTTRRange& rhs){
        for(auto &v: rhs._tttr_indices){
            _tttr_indices.insert(v);
        }
        return *this;
    }
 
 
};
 
#endif //TTTRLIB_TTTRRANGE_H