reco.h

/***************************************************************************
                          reco.h  -  Parameters for image reconstruction
                             -------------------
    begin                : Thu May 06 2004
    copyright            : (C) 2000-2021 by Thies H. 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 RECO_H
#define RECO_H
 
#include <tjutils/tjvallist.h>
 
#include <odinpara/protocol.h>
 
 
// some limits
#define MAX_NUMOF_READOUT_SHAPES        10
#define MAX_NUMOF_KSPACE_TRAJS          10
#define MAX_NUMOF_ADC_WEIGHTING_VECTORS 10
 
#define PROTOCOL_BLOCK_LABEL "Protocol"
 
enum recoFlags {
  recoLastInChunkBit    =1,
  recoReflectBit        =2,
  recoEpiNavPolarityBit =4,
  recoAllBits          =255
};
 
 
 
enum recoDim                      { userdef=0, te,  dti,  average,  cycle,  slice,  line3d,  line,  echo,  epi,  templtype,  navigator,  freq,  channel,  readout,  repetition, n_recoDims};
static const char* recoDimLabel[]={"userdef", "te","dti","average","cycle","slice","line3d","line","echo","epi","templtype","navigator","freq","channel","readout","repetition"};
AVOID_CC_WARNING(recoDimLabel)
static const int n_recoIndexDims=templtype+1; // only the first dims are required for indexing of ADCs, the remaining are used only by odinreco
 
 
 
 
enum templateType                    {no_template=0, phasecorr_template, fieldmap_template, grappa_template, n_templateTypes};
static const char templateTypeChar[]={'N',           'P',                'F',               'G'};
 
 
 
enum navigatorType                    {no_navigator=0, epi_navigator, n_navigatorTypes};
static const char navigatorTypeChar[]={'n',            'e'};
 
 
 
 
struct kSpaceCoord {
 
  kSpaceCoord() {reset2defaults();}
 
  // for STD_list
  bool operator == (const kSpaceCoord& ri) const;
  bool operator <  (const kSpaceCoord& ri) const;
 
 
  static int string2index(const STD_string& str, recoDim dim);
  static STD_string index2string(int index, recoDim dim, int numof=0);
 
  STD_string printcoord(const unsigned short* numof_cache) const;
//  friend STD_ostream& operator << (STD_ostream& s,const kSpaceCoord& kcoord) { return s << kcoord.printcoord();}
  bool parsecoord(const STD_string& str);
  void reset2defaults();
 
  static STD_string print_header(const unsigned short* numof_cache);
 
 
  mutable unsigned int number;  // unique index of the ADC
  unsigned int reps;    // number of times this ADC is repeated
  unsigned short adcSize; // size with oversampling
  unsigned char channels; // coil channels
  unsigned short preDiscard;  // points to discard at the beginning of an ADC
  unsigned short postDiscard; // points to discard at the end of an ADC
  unsigned short concat; // number of concatenated acquisition this ADC is composed of
  float oversampling; // oversampling factor
  float relcenter; // relative position of k-space center
 
  short readoutIndex; // index of the readout shape to be used for ramp-sampling correction, -1 if none
  short trajIndex;   // index of the used k-space trajectory, -1 if none
  short weightIndex;   // index of the used ADC weighting vector, -1 if none
  short dtIndex; // index of the dwell time used
 
  unsigned short index[n_recoIndexDims]; // multi-dimensional reco index to locate ADC in k-space
 
  unsigned char flags; // recoFlags
 
 
 
 private:
  friend class LDRkSpaceCoords;
 
  static void assign_parsepos(const STD_string& header);
 
 
  static int parsepos_number;
  static int parsepos_reps;
  static int parsepos_adcSize;
  static int parsepos_channels;
  static int parsepos_preDiscard;
  static int parsepos_postDiscard;
  static int parsepos_concat;
  static int parsepos_oversampling;
  static int parsepos_relcenter;
  static int parsepos_readoutIndex;
  static int parsepos_trajIndex;
  static int parsepos_weightIndex;
  static int parsepos_dtIndex;
  static int parsepos_index[n_recoIndexDims];
  static int parsepos_lastinchunk;
  static int parsepos_reflect;
  static int max_parsepos;
  
};
 
 
 
class LDRkSpaceCoords : public LDRbase {
 
  enum LDRkSpaceCoords_state {coords_in_list, has_vec_cache, has_vec_alloc};
 
 public:
  LDRkSpaceCoords();
  ~LDRkSpaceCoords() {clear();}
 
  unsigned int size() const {create_vec_cache(); return vec_cache.size();}
 
  const kSpaceCoord& operator [] (unsigned int i) const {create_vec_cache(); return *(vec_cache[i]);}
 
  void clear(); // clear list before retrieving k-space ordering from sequence
 
  LDRkSpaceCoords& append_coord(const kSpaceCoord& coord);
 
 private:
  friend class RecoPars;
 
  void create_vec_cache() const;
 
  // overwriting virtual functions from LDRbase
  bool parsevalstring(const STD_string& parstring, const LDRserBase* ser=0);
  STD_string printvalstring(const LDRserBase* ser=0) const;
  STD_ostream& print2stream(STD_ostream& os, const LDRserBase& serializer) const;
  STD_string get_typeInfo(bool parx_equivtype=false) const {return "kSpaceCoords";}
  LDRbase* create_copy() const {return new LDRkSpaceCoords(*this);}
 
  mutable STD_list<kSpaceCoord> coordlist;
 
  mutable LDRkSpaceCoords_state state;
  mutable STD_vector<kSpaceCoord*> vec_cache; // use pointers for better performance
  mutable unsigned short numof_cache[n_recoIndexDims];
};
 
 
struct RecoValList : public ValList<int> {
  RecoValList(const STD_string& object_label="unnamedRecoValList", unsigned int repetitions=1) : ValList<int>(object_label,repetitions) {}
};
 
 
class LDRrecoValList : public RecoValList, public LDRbase {
 
 public:
  LDRrecoValList(const STD_string& ldrlabel="unnamedLDRrecoValList");
  LDRrecoValList(const LDRrecoValList& jdrvl) {LDRrecoValList::operator = (jdrvl);}
  LDRrecoValList& operator = (const LDRrecoValList& jdrvl);
 
  LDRrecoValList& operator = (const RecoValList& rvl); // for assignment from get_recovallist in SeqMethod
 
  // overwriting virtual functions from LDRbase
  bool parsevalstring(const STD_string& parstring, const LDRserBase* ser=0);
  STD_string printvalstring(const LDRserBase* ser=0) const;
  STD_ostream& print2stream(STD_ostream& os, const LDRserBase& serializer) const;
  STD_string get_typeInfo(bool parx_equivtype=false) const {return "RecoValList";}
  LDRbase* create_copy() const {return new LDRrecoValList(*this);}
 
};
 
 
 
 
 
class RecoPars : public LDRblock {
 
 public:
 
  RecoPars(const STD_string& label="unnamedRecoPars");
 
  RecoPars(const RecoPars& sr);
 
  RecoPars& operator = (const RecoPars& sr);
 
  const Protocol& get_protocol() const {return prot;}
 
  const LDRkSpaceCoords& get_kSpaceCoords() const {return kSpaceCoords;}
 
  const STD_string& get_DataFormat() const {return DataFormat;}
 
  bool is_LittleEndian() const {return LittleEndian;}
 
  const STD_string& get_RawFile() const {return RawFile;}
 
  unsigned int get_RawHeaderSize() const {return RawHeaderSize;}
 
  const fvector& get_RelativeOffset() const {return RelativeOffset;}
 
  const STD_string& get_ImageProc() const {return ImageProc;}
 
  const dvector& get_DimValues(recoDim dim) const {return DimValues[dim];}
 
  fvector get_ChannelScales() const {return ChannelScaling;}
 
  double get_DwellTime(unsigned int i) const;
 
 
  int get_NumOfAdcChunks() const;
 
 
  RecoPars& set_DimValues(recoDim dim, const dvector& vals);
 
 
  int append_readout_shape(const fvector& shape, unsigned int dstsize);
 
  int append_kspace_traj(const farray& kspace_traj);
 
  int append_adc_weight_vec(const cvector& weightvec);
 
  int append_dwell_time(double dt);
 
 
  void get_ReadoutShape(unsigned int i, fvector& shape, unsigned int& dstsize) const;
 
 
  unsigned int numof_kSpaceTraj() const;
 
  const farray& get_kSpaceTraj(unsigned int i) const;
 
 
  const cvector& get_AdcWeightVector(unsigned int i) const;
 
 
  LONGEST_INT get_TotalNumOfSamples(bool discard=false) const;
 
  unsigned int numof_adcs() const {return kSpaceOrdering.size();}
 
  const kSpaceCoord& get_kSpaceCoord(unsigned int i) const;
 
  RecoPars& set_Recipe(const STD_string& recipe) {Recipe=recipe; return *this;}
 
  STD_string get_Recipe() const {return Recipe;}
 
  RecoPars& set_PostProc3D(const STD_string& recipe) {PostProc3D=recipe; return *this;}
 
  STD_string get_PostProc3D() const {return PostProc3D;}
 
  RecoPars& set_PreProc3D(const STD_string& recipe) {PreProc3D=recipe; return *this;}
 
  STD_string get_PreProc3D() const {return PreProc3D;}
 
  RecoPars& set_CmdLineOpts(const STD_string& opts) {CmdLineOpts=opts; return *this;}
 
  STD_string get_CmdLineOpts() const {return CmdLineOpts;}
 
 
 private:
  friend class SeqAcq;
  friend class SeqEpiDriverParavision;
  friend class SeqMethod;
 
  void common_init();
 
  void reset();
  void create_cache() const;
 
  void append_all_members();
 
  Protocol  prot;
 
  LDRstring DataFormat;
  LDRbool   LittleEndian;
  LDRstring RawFile;
  LDRint    RawHeaderSize;
  LDRtriple RelativeOffset;
  LDRstring ImageProc;
  LDRfloatArr ChannelScaling;
  LDRdoubleArr DwellTime;
  LDRfloatArr   ReadoutShape[MAX_NUMOF_READOUT_SHAPES];
  LDRintArr     ReadoutDstSize;
  LDRfloatArr   kSpaceTraj[MAX_NUMOF_KSPACE_TRAJS];
  LDRcomplexArr AdcWeightVector[MAX_NUMOF_ADC_WEIGHTING_VECTORS];
  LDRdoubleArr DimValues[n_recoIndexDims];
  LDRstring Recipe;
  LDRstring PreProc3D;
  LDRstring PostProc3D;
  LDRstring CmdLineOpts;
 
  LDRkSpaceCoords kSpaceCoords;
  LDRrecoValList kSpaceOrdering;
 
  mutable STD_vector<int> kSpaceOrdering_cache; // fast cache of ADC indices
  mutable bool cache_is_up2date;
 
};
 
 
 
 
 
 
class CoilSensitivity : public LDRblock {
 
 public:
 
  CoilSensitivity(const STD_string& label="unnamedCoilSensitivity");
 
  CoilSensitivity(const CoilSensitivity& cs);
 
  CoilSensitivity& operator = (const CoilSensitivity& cs);
 
 
  CoilSensitivity& set_sensitivity_map(const carray& sens_map, float FOVx, float FOVy, float FOVz);
 
  STD_complex get_sensitivity_value(unsigned int channel, float x, float y, float z) const;
 
  unsigned int get_numof_channels() const {return SensitivityMap.get_extent()[0];}
 
 
 private:
  void append_all_members();
 
  LDRtriple     FOV;
  LDRcomplexArr SensitivityMap;
};
 
 
 
 
 
#endif