index.h

/***************************************************************************
                          index.h  -  description
                             -------------------
    begin                : Mon Jan 27 2007
    copyright            : (C) 2001 by Thies Jochimsen
    email                : jochimse@cns.mpg.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) {
    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);
    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) {
    RecoCoord result;
    result.set_mode(m,d1,d2,d3,d4,d5);
    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>
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);}

  static void modify(RecoIndex::indexMode m, RecoCoord& coord) {coord.set_mode(m, d1, d2, d3, d4, d5);}

  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++;}
  }

  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++;}
  }


  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++;}
  }

};





#endif

---