controller.h

/***************************************************************************
                          controller.h  -  description
                             -------------------
    begin                : Sat Dec 30 2006
    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 RECOCONTROLLER_H
#define RECOCONTROLLER_H

#include <tjutils/tjthread.h>
#include <tjutils/tjfeedback.h>

#include <odinreco/odinreco.h>
#include <odinreco/blackboard.h>
#include <odinreco/step.h>



class RecoReaderInterface; // forward declaration
class RecoStep; // forward declaration





class RecoController {

 public:

  RecoController(JcampDxBlock& parblock);

  ~RecoController();

  bool init(RecoReaderInterface* reader, JcampDxBlock& opts, int argc, char* argv[]);

  bool start();

  dvector dim_values(recoDim dim) const;

  TinyVector<float,3> reloffset() const;

  STD_string image_proc() const;

  TinyVector<int,3> image_size() const;

  TinyVector<float,3> kspace_extent() const;

  const Protocol& protocol() const {return prot_cache;}


  void announce_data(const STD_string& label) {blackboard.announce(label);}

  void post_data(const STD_string& label, const RecoData& data) {blackboard.post(label,data);}

  bool data_announced(const STD_string& label) {return blackboard.announced(label);}

  bool inquire_data(const STD_string& label, RecoData& data);


  const CoordCountMap* create_count_map(const RecoCoord& mask) const;

  bool create_numof(const RecoCoord& mask, unsigned short numof[n_recoDims], STD_string& printed) const;


  RecoStep* create_pipeline(const STD_string& rec, const RecoCoord* initial_coord=0, int argc=0, char* argv[]=0) const;


  STD_string stepmanual() const;


 private:
  friend class RecoThread;


  // Options
  JDXint jobs;
  JDXstring recipe;
  JDXstring recipeFile;
  JDXstring select;
  JDXint    timeout;
  JDXint    maxrecursion;
  JDXbool   conjPhaseFT;
  JDXbool   slidingWindow;
  JDXbool   keyhole;
  JDXbool   sepChannels;
  JDXbool   dumpKspace;
  JDXbool   disableHomodyne;
  JDXbool   disableMultiFreq;
  JDXbool   disableSliceTime;
  JDXbool   phaseCourse;
  JDXstring preproc3d;
  JDXstring postproc3d;
  JDXstring dumpRawPrefix;
  JDXstring fieldmapFile;

  bool execute_pipeline();
  bool prepare_pipeline();
  bool finalize_pipeline();

  bool feed_pipeline();

  bool dump_raw() const;

  static void tracefunction(const LogMessage& msg);
  static int controlthread;

  template<recoDim Dim, recoDim OrthoDim>
  bool get_kspace_sampling_pattern(const RecoCoord& mask, unsigned int& reduction_factor, bool& partial_fourier) const;

  bool autorecipe(const RecoCoord& mask, STD_string& result) const;

  typedef STD_map<int, STD_string> WaitingMap;
  WaitingMap waiting;
  STD_string waiting_error;
  Mutex waiting_mutex;

  void incr_waiting_threads(const STD_string& condition) {MutexLock lock(waiting_mutex); waiting[Thread::self()]=condition;}
  void decr_waiting_threads() {MutexLock lock(waiting_mutex); waiting.erase(waiting.find(Thread::self()));}
  unsigned int numof_waiting_threads() {MutexLock lock(waiting_mutex); return waiting.size();}

  STD_map<int, UInt> thread_depth; // trace the depth (recursion level) of each thread

  RecoReaderInterface* input;
  mutable Mutex inputmutex;

  RecoStep* pipeline;
  RecoStepFactory* factory;

  RecoBlackBoard blackboard;

  ProgressDisplayConsole display; // Create display before pmeter
  ProgressMeter pmeter; // ProgressMeter is thread-safe


  unsigned short numof_cache[n_recoDims];
  mutable bool has_readoutshape;
  mutable unsigned char has_flag_cache;
  mutable bool has_templcorr_cache[n_templateTypes];
  mutable bool has_navigator_cache[n_navigatorTypes];
  mutable bool has_traj;
  mutable bool has_oversampling_cache;
  mutable bool has_relcenter_cache;

  Protocol prot_cache;

  volatile bool status; // Although it is used in different threads, we will assume that reads/writes to bool are atomic

  mutable STD_map<STD_string,const CoordCountMap*> countmap_cache; // cache countmap since the same countmap is calculated several times in create_count_map()
  void delete_countmap_cache();

};



#endif

---