reco.h

/***************************************************************************
                          reco.h  -  Parameters for image reconstruction
                             -------------------
    begin                : Thu May 06 2004
    copyright            : (C) 2001 by Thies H. 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 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"};
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 JDXkSpaceCoords;

  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 JDXkSpaceCoords : public JcampDxClass {

  enum JDXkSpaceCoords_state {coords_in_list, has_vec_cache, has_vec_alloc};

 public:
  JDXkSpaceCoords();
  ~JDXkSpaceCoords() {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

  JDXkSpaceCoords& append_coord(const kSpaceCoord& coord);

 private:
  friend class RecoPars;

  void create_vec_cache() const;

  // overwriting virtual functions from JcampDxClass
  bool parsevalstring (const STD_string& parstring);
  STD_string printvalstring() const;
  STD_ostream& print2stream(STD_ostream& os) const;
  const char* get_typeInfo() const {return "kSpaceCoords";}
  JcampDxClass* create_copy() const {return new JDXkSpaceCoords(*this);}

  mutable STD_list<kSpaceCoord> coordlist;

  mutable JDXkSpaceCoords_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 JDXrecoValList : public RecoValList, public JcampDxClass {

 public:
  JDXrecoValList(const STD_string& ldrlabel="unnamedJDXrecoValList");
  JDXrecoValList(const JDXrecoValList& jdrvl) {JDXrecoValList::operator = (jdrvl);}
  JDXrecoValList& operator = (const JDXrecoValList& jdrvl);

  JDXrecoValList& operator = (const RecoValList& rvl); // for assignment from get_recovallist in SeqMethod

  // overwriting virtual functions from JcampDxClass
  bool parsevalstring (const STD_string& parstring);
  STD_string printvalstring() const;
  STD_ostream& print2stream(STD_ostream& os) const;
  const char* get_typeInfo() const {return "RecoValList";}
  JcampDxClass* create_copy() const {return new JDXrecoValList(*this);}

};





class RecoPars : public JcampDxBlock {

 public:

  RecoPars(const STD_string& label="unnamedRecoPars");

  RecoPars(const RecoPars& sr);

  RecoPars& operator = (const RecoPars& sr);

  const Protocol& get_protocol() const {return prot;}

  const JDXkSpaceCoords& 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;

  JDXstring DataFormat;
  JDXbool   LittleEndian;
  JDXstring RawFile;
  JDXint    RawHeaderSize;
  JDXtriple RelativeOffset;
  JDXstring ImageProc;
  JDXfloatArr ChannelScaling;
  JDXdoubleArr DwellTime;
  JDXfloatArr   ReadoutShape[MAX_NUMOF_READOUT_SHAPES];
  JDXintArr     ReadoutDstSize;
  JDXfloatArr   kSpaceTraj[MAX_NUMOF_KSPACE_TRAJS];
  JDXcomplexArr AdcWeightVector[MAX_NUMOF_ADC_WEIGHTING_VECTORS];
  JDXdoubleArr DimValues[n_recoIndexDims];
  JDXstring Recipe;
  JDXstring PreProc3D;
  JDXstring PostProc3D;
  JDXstring CmdLineOpts;

  JDXkSpaceCoords kSpaceCoords;
  JDXrecoValList kSpaceOrdering;

  mutable STD_vector<int> kSpaceOrdering_cache; // fast cache of ADC indices
  mutable bool cache_is_up2date;

};






class CoilSensitivity : public JcampDxBlock {

 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();

  JDXtriple     FOV;
  JDXcomplexArr SensitivityMap;
};





#endif

---