index.h

/***************************************************************************
                          index.h  -  description
                             -------------------
    begin                : Mon Jan 27 2007
    copyright            : (C) 2000-2021 by Thies Jochimsen
    email                : thies@jochimsen.de
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef RECOINDEX_H
#define RECOINDEX_H
 
#include <odinreco/odinreco.h>
 
#include <odindata/gridding.h>
 
class RecoIndex {
 
 public:
 
  enum indexMode {separate=0, ignore, single, collected, any};
 
 
  RecoIndex(unsigned short v=0) : mode(separate), val(v), numof(1) {}
 
  RecoIndex& operator = (unsigned short v) {val=v; return *this;}
 
  bool operator <  (const RecoIndex& ri) const {
     // comparison makes sense only in 'separate' mode.
    if( mode==separate && ri.mode==separate ) {
      return val < ri.val;
    }
    return false; // equal or ignored when comparing
  }
 
  operator unsigned short () const {if(mode==single) return 0; return val;} // return zero index in single mode for numof=1
 
  RecoIndex& set_mode(indexMode m) {mode=m; return *this;}
 
  indexMode get_mode() const {return indexMode(mode);}
 
  bool compatible(const RecoIndex& ri) const {
    if(mode==any || ri.mode==any) return true;
    if(mode==collected && ri.mode!=collected) return false;
    if(mode!=collected && ri.mode==collected) return false;
    if(mode==single && ri.mode==single && val!=ri.val) return false;
    return true;
  }
 
 
  bool prep_count(const RecoIndex& mask) {
    if(mask.mode==single) {
      if(val!=mask.val) return false;
    }
    mode=mask.mode;
    return true;
  }
 
 
  RecoIndex& set_numof(unsigned short n) {numof=n; return *this;}
 
  unsigned short get_numof() const {if(mode==single) return 1; return numof;}
 
 
  enum printMode {brief=0, all, filename};
 
  STD_string print(recoDim dim, printMode printmode=brief) const;
 
 
 private:
 
  unsigned char mode;
  unsigned short val;
  unsigned short numof;
 
 
 
};
 
 
 
typedef Data<GriddingPoint<3> ,2> KspaceTraj; //  dimension is (nsegments, npoints)
 
typedef STD_pair<Data<float,1>, int> ReadoutShape; // shape and target grid size
 
 
 
struct RecoCoord {
 
 
  RecoCoord() {common_init();}
 
 
  bool operator < (const RecoCoord& rc) const {
    for(int i=0; i<n_recoDims; i++) {
      bool rc_larger= index[i]<rc.index[i];
      bool rc_smaller=rc.index[i]<index[i];
      if(rc_larger || rc_smaller) return rc_larger; // return immediately if different
    }
    return false;
  }
 
 
  bool operator == (const RecoCoord& rc) const {
    return !((*this)<rc || rc<(*this));
  }
 
 
  bool compatible(const RecoCoord& rc) const {
    for(int i=0; i<n_recoDims; i++) {
      if(!index[i].compatible(rc.index[i])) return false;
    }
    return true;
  }
 
 
  bool prep_count(const RecoCoord& mask) {
    for(int i=0; i<n_recoDims; i++) {
      if(!index[i].prep_count(mask.index[i])) return false;
    }
    return true;
  }
 
 
  STD_string print(RecoIndex::printMode printmode=RecoIndex::brief) const;
 
 
  static RecoCoord any() {
    RecoCoord result;
    result.set_uniform_mode(RecoIndex::any);
    return result;
  }
 
 
  RecoCoord& set_uniform_mode(RecoIndex::indexMode m) {
    for(int i=0; i<n_recoDims; i++) index[i].set_mode(m);
    return *this;
  }
 
 
  RecoCoord& set_mode(RecoIndex::indexMode m, recoDim d1=n_recoDims, recoDim d2=n_recoDims, recoDim d3=n_recoDims, recoDim d4=n_recoDims, recoDim d5=n_recoDims, recoDim d6=n_recoDims, recoDim d7=n_recoDims, recoDim d8=n_recoDims) {
    if(d1<n_recoDims) index[d1].set_mode(m);
    if(d2<n_recoDims) index[d2].set_mode(m);
    if(d3<n_recoDims) index[d3].set_mode(m);
    if(d4<n_recoDims) index[d4].set_mode(m);
    if(d5<n_recoDims) index[d5].set_mode(m);
    if(d6<n_recoDims) index[d6].set_mode(m);
    if(d7<n_recoDims) index[d7].set_mode(m);
    if(d8<n_recoDims) index[d8].set_mode(m);
    return *this;
  }
 
 
  static RecoCoord coord_with_mode(RecoIndex::indexMode m, recoDim d1=n_recoDims, recoDim d2=n_recoDims, recoDim d3=n_recoDims, recoDim d4=n_recoDims, recoDim d5=n_recoDims, recoDim d6=n_recoDims, recoDim d7=n_recoDims, recoDim d8=n_recoDims) {
    RecoCoord result;
    result.set_mode(m,d1,d2,d3,d4,d5,d6,d7,d8);
    return result;
  }
 
  unsigned short numof(recoDim dim) const {return index[dim].get_numof();}
 
 
  RecoIndex index[n_recoDims];
 
 
  unsigned char flags;
 
 
  const ReadoutShape* readoutShape;
 
 
  const KspaceTraj* kspaceTraj;
 
  const ComplexData<1>* weightVec;
 
 
  double dwellTime;
 
  float overSamplingFactor;
 
  float relCenterPos;
 
  unsigned short adcstart;
 
  unsigned short adcend;
 
  float gridScaleFactor;
 
  unsigned short echopos;
 
  unsigned short echotrain;
 
 
 private:
  void common_init() {
    flags=0;
    readoutShape=0;
    kspaceTraj=0;
    weightVec=0;
    dwellTime=0.0;
    overSamplingFactor=1.0;
    relCenterPos=0.5;
    adcstart=0;
    adcend=0;
    gridScaleFactor=1.0;
    echopos=0;
    echotrain=0;
    index[readout].set_mode(RecoIndex::collected); // readout is already collected for ADCs
  }
 
};
 
 
 
typedef STD_map<RecoCoord, UInt> CoordCountMap;
 
 
template<unsigned int Ndim, recoDim d1=n_recoDims, recoDim d2=n_recoDims, recoDim d3=n_recoDims, recoDim d4=n_recoDims, recoDim d5=n_recoDims, recoDim d6=n_recoDims>
struct RecoDim {
 
  static unsigned int dim() {return Ndim;}
 
  static RecoCoord preset_coord(RecoIndex::indexMode m) {return RecoCoord::coord_with_mode(m, d1, d2, d3, d4, d5, d6);}
 
  static void modify(RecoIndex::indexMode m, RecoCoord& coord) {coord.set_mode(m, d1, d2, d3, d4, d5, d6);}
 
  static void create_index(const RecoCoord& coord, TinyVector<int,Ndim>& index) {
    unsigned int idim=0;
    if(d1!=n_recoDims) {index(idim)=coord.index[d1]; idim++;}
    if(d2!=n_recoDims) {index(idim)=coord.index[d2]; idim++;}
    if(d3!=n_recoDims) {index(idim)=coord.index[d3]; idim++;}
    if(d4!=n_recoDims) {index(idim)=coord.index[d4]; idim++;}
    if(d5!=n_recoDims) {index(idim)=coord.index[d5]; idim++;}
    if(d6!=n_recoDims) {index(idim)=coord.index[d6]; idim++;}
  }
 
  static void create_shape(const RecoCoord& coord, TinyVector<int,Ndim>& shape) {
    unsigned int idim=0;
    if(d1!=n_recoDims) {shape(idim)=coord.numof(d1); idim++;}
    if(d2!=n_recoDims) {shape(idim)=coord.numof(d2); idim++;}
    if(d3!=n_recoDims) {shape(idim)=coord.numof(d3); idim++;}
    if(d4!=n_recoDims) {shape(idim)=coord.numof(d4); idim++;}
    if(d5!=n_recoDims) {shape(idim)=coord.numof(d5); idim++;}
    if(d6!=n_recoDims) {shape(idim)=coord.numof(d6); idim++;}
  }
 
 
  static void set_index(const TinyVector<int,Ndim>& index, RecoCoord& coord) {
    unsigned int idim=0;
    if(d1!=n_recoDims) {coord.index[d1]=index(idim); idim++;}
    if(d2!=n_recoDims) {coord.index[d2]=index(idim); idim++;}
    if(d3!=n_recoDims) {coord.index[d3]=index(idim); idim++;}
    if(d4!=n_recoDims) {coord.index[d4]=index(idim); idim++;}
    if(d5!=n_recoDims) {coord.index[d5]=index(idim); idim++;}
    if(d6!=n_recoDims) {coord.index[d6]=index(idim); idim++;}
  }
 
};
 
 
 
 
 
#endif