geometry.h

/***************************************************************************
                          geometry.h  -  description
                             -------------------
    begin                : Wed Apr 17 2002
    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 GEOMETRY_H
#define GEOMETRY_H
 
 
#include <odinpara/ldrblock.h>
#include <odinpara/ldrnumbers.h>
#include <odinpara/ldrarrays.h>
 
#include <odinpara/odinpara.h>
 
 
enum sliceBoundary {lowerBound=0,upperBound,n_boundaries};
 
 
enum sliceOrientation {sagittal=0,coronal,axial,n_orientations};
 
 
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 LDRblock {
 
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(direction dir,double fov);
 
  double get_FOV(direction dir) const;
 
  Geometry& set_offset(direction dir,double offset);
 
  double get_offset(direction 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);
 
 
  static sliceOrientation get_slice_orientation(const dvector& svec);
 
  sliceOrientation get_orientation() const {return get_slice_orientation(get_sliceVector());}
 
 
  void get_orientation(double& heightAng, double& azimutAng, double& inplaneAng, bool& revSlice) const;
 
  Geometry& set_orientation(double heightAng, double azimutAng, double inplaneAng, bool revSlice=false);
 
  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;}
 
  LDRenum Mode;
 
  LDRdouble FOVread;
  LDRdouble offsetRead;
  LDRdouble FOVphase;
  LDRdouble offsetPhase;
  LDRdouble FOVslice;
  LDRdouble offsetSlice;
 
  LDRdouble heightAngle;
  LDRdouble azimutAngle;
  LDRdouble inplaneAngle;
  LDRbool   reverseSlice;
 
  LDRint    nSlices;
  LDRdouble sliceDistance;
  LDRdouble sliceThickness;
  LDRintArr sliceOrder;
 
  LDRaction Reset;
  LDRaction 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