geometry.h

/***************************************************************************
                          geometry.h  -  description
                             -------------------
    begin                : Wed Apr 17 2002
    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 GEOMETRY_H
#define GEOMETRY_H


#include <odinpara/jdxblock.h>
#include <odinpara/jdxnumbers.h>
#include <odinpara/jdxarrays.h>

#include <odinpara/odinpara.h>


typedef enum sliceBoundary {lowerBound=0,upperBound,n_boundaries};


typedef enum sliceOrientation {sagittal=0,coronal,axial,n_orientations};


typedef enum geometryMode {slicepack=0,voxel_3d,n_geometry_modes};




class RotMatrix : public virtual Labeled {
 public:

  RotMatrix(const STD_string& object_label = "unnamedRotMatrix" );

   RotMatrix(const RotMatrix& sct);

   dvector& operator [] (unsigned int index) {return matrix[index%3];} // make sure index is lower than 3

   const dvector& operator [] (unsigned int index) const {return matrix[index%3];} // make sure index is lower than 3

  RotMatrix& operator = (const RotMatrix& sct);

  bool operator == (const RotMatrix& srm) const;

  // dummy comparison operator for lists
  bool operator <  (const RotMatrix& srm) const;

  dvector operator * (const dvector& vec) const;

  RotMatrix operator * (const RotMatrix& matrix) const;

  operator farray () const;

  RotMatrix& set_inplane_rotation(float phi);


  STD_string print() const;

 private:
  friend class RotMatrixVector;

  class rowVec : public dvector {
   public:
    rowVec() : dvector(3) {};
    ~rowVec() {};
  };

//  bool check_and_correct();

  rowVec matrix[3];

//  static dvector returndummy;
};




class Geometry : public JcampDxBlock {

public:

  Geometry(const STD_string& label="unnamedGeometry");

  Geometry(const Geometry& ia);

  Geometry& operator = (const Geometry& ia);

  Geometry& set_Mode(geometryMode mode);

  geometryMode get_Mode() const {return geometryMode(int(Mode));}


  Geometry& set_FOV(channelNo dir,double fov);

  double get_FOV(channelNo dir) const;

  Geometry& set_offset(channelNo dir,double offset);

  double get_offset(channelNo dir) const;

  Geometry& set_nSlices(unsigned int nslices);

  unsigned int get_nSlices() const {return nSlices;};

  Geometry& set_sliceThickness(double thick);

  Geometry& set_sliceDistance(double dist);

  double get_sliceDistance() const {return sliceDistance;}

  dvector get_readVector() const;

  dvector get_phaseVector() const;

  dvector get_sliceVector() const;

  dvector get_sliceOffsetVector() const;

  double get_sliceThickness() const {return sliceThickness;}



  darray get_cornerPoints(const Geometry& background, unsigned int backgrslice) const;


  Geometry& set_orientation(sliceOrientation orientation);

  sliceOrientation get_orientation() const;

  void get_orientation(double& heightAng, double& azimutAng, double& inplaneAng) const;

  Geometry& set_orientation(double heightAng, double azimutAng, double inplaneAng);

  Geometry& set_orientation_and_offset(const dvector& readvec, const dvector& phasevec, const dvector& slicevec, const dvector& centervec);



  dvector get_center() const;

  RotMatrix get_gradrotmatrix(bool transpose=false) const;


  dvector transform(const dvector& rpsvec, bool inverse=false) const;

  Geometry& transpose_inplane(bool reverse_read=false, bool reverse_phase=false);


  Geometry& reset();

  Geometry& update();



 private:

  dvector get_readVector_inplane() const;
  dvector get_phaseVector_inplane() const;

  void append_all_members();

  double deg2rad(double degree) const {return degree/180.0*PII;}

  JDXenum Mode;

  JDXdouble FOVread;
  JDXdouble offsetRead;
  JDXdouble FOVphase;
  JDXdouble offsetPhase;
  JDXdouble FOVslice;
  JDXdouble offsetSlice;

  JDXdouble heightAngle;
  JDXdouble azimutAngle;
  JDXdouble inplaneAngle;

  JDXint    nSlices;
  JDXdouble sliceDistance;
  JDXdouble sliceThickness;

  JDXaction Reset;
  JDXaction Transpose;


  // cache to speed up repetitive calls to transform()
  mutable bool cache_up2date;
  mutable bool inv_trans_cache;
  mutable double rotmat_cache[3][3];
  mutable double offset_cache[3];
};


#endif

---