orientation.hh

Go to the documentation of this file.

/* -*- mia-c++  -*-
 *
 * This file is part of MIA - a toolbox for medical image analysis 
 * Copyright (c) Leipzig, Madrid 1999-2017 Gert Wollny
 *
 * MIA 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with MIA; if not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef __mia_3d_oriantation_hh
#define __mia_3d_oriantation_hh

#include <ostream>
#include <istream>

#include <mia/core/attributes.hh>
#include <mia/3d/quaternion.hh>
#include <mia/3d/matrix.hh>
#include <mia/core/vector.hh>

NS_MIA_BEGIN


enum E3DImageOrientation {

        ior_undefined = 0,  
        ior_default = 1,   
        ior_xyz         = 1,       
        ior_xyz_flipped = 2,       
        ior_yxz         = 3,       
        ior_yxz_flipped = 4,       
        ior_xzy         = 5,       
        ior_xzy_flipped = 6,       
        ior_zxy         = 7,       
        ior_zxy_flipped = 8,       
        ior_yzx         = 9,        
        ior_yzx_flipped =10,        
        ior_zyx         =11,        
        ior_zyx_flipped =12,        
        ior_axial = 1,     
        ior_axial_flipped = 2,     
        ior_coronal = 5,   
        ior_coronal_flipped = 6,   
        ior_saggital = 9,  
        ior_saggital_flipped =10,  
        ior_unknown = 13,   
};


extern const TDictMap<E3DImageOrientation> g_image_orientation_map; 

class EXPORT_3D C3DOrientationAndPosition {
public: 
        C3DOrientationAndPosition(); 
        
        explicit C3DOrientationAndPosition(E3DImageOrientation axis); 

        C3DOrientationAndPosition(E3DImageOrientation axis, 
                                  const C3DFVector& origin, 
                                  const C3DFVector& scale, 
                                  const Quaternion& rot); 
        
        void get_transform_parameters(CDoubleVector& params) const; 
        
        void get_inverse_transform_parameters(CDoubleVector& params) const; 

        C3DOrientationAndPosition& operator +=(const C3DOrientationAndPosition& other); 
        
        bool operator == (const C3DOrientationAndPosition& other) const; 

        bool operator < (const C3DOrientationAndPosition& other) const; 
        

        void print(std::ostream& os) const; 

        E3DImageOrientation get_axis_orientation() const; 

        const mia::C3DFVector& get_scale() const; 

        const mia::C3DFVector& get_origin()const; 

        const mia::Quaternion& get_rotation()const;

private:
        
        const C3DFMatrix& get_axis_switch_matrix() const; 
        
        E3DImageOrientation m_axisorder; 
        C3DFVector m_origin; 
        C3DFVector m_scale; 
        Quaternion m_rotation; 

        static const C3DFMatrix ms_order_XYZ; 
        static const C3DFMatrix ms_order_YXZ;
        static const C3DFMatrix ms_order_XZY;
        static const C3DFMatrix ms_order_ZYX;
        static const C3DFMatrix ms_order_ZXY;
        static const C3DFMatrix ms_order_YZX;

        static const C3DFMatrix ms_order_XYZ_F; 
        static const C3DFMatrix ms_order_YXZ_F;
        static const C3DFMatrix ms_order_XZY_F;
        static const C3DFMatrix ms_order_ZXY_F;
        static const C3DFMatrix ms_order_ZYX_F;
        static const C3DFMatrix ms_order_YZX_F;

}; 


enum E3DPatientPositioning {
        ipp_undefined = 0, 
        ipp_hfp, 
        ipp_hfs, 
        ipp_hfdr, 
        ipp_hfdl, 
        ipp_ffp, 
        ipp_ffs, 
        ipp_ffdr, 
        ipp_ffdl, 
        ipp_lastindex
};
 

extern const TDictMap<E3DPatientPositioning> g_patient_position_map; 

EXPORT_3D  std::ostream& operator << (std::ostream& os, E3DImageOrientation orient);

EXPORT_3D  std::istream& operator >> (std::istream& is, E3DImageOrientation& orient);


inline std::ostream& operator << (std::ostream& os, const C3DOrientationAndPosition& orient) 
{
        orient.print(os); 
        return os; 
}

EXPORT_3D  std::istream& operator >> (std::istream& is, C3DOrientationAndPosition& orient);


EXPORT_3D  std::ostream& operator << (std::ostream& os, E3DPatientPositioning pp);

EXPORT_3D  std::istream& operator >> (std::istream& is, E3DPatientPositioning& pp);

typedef TAttribute<E3DImageOrientation> C3DImageOrientation;
extern template class EXPORT_3D TAttribute<E3DImageOrientation>; 

typedef TTranslator<E3DImageOrientation> COrientationTranslator;
extern template class EXPORT_3D TTranslator<E3DImageOrientation>; 


typedef TAttribute<E3DPatientPositioning> CPatientPositionAttribute;
extern template class EXPORT_3D TAttribute<E3DPatientPositioning>; 

typedef TAttribute<C3DOrientationAndPosition> C3DImageOrientationPositionAttribute;
typedef TTranslator<C3DOrientationAndPosition> COrientationPositionTranslator;

extern template class EXPORT_3D TAttribute<C3DOrientationAndPosition>; 
extern template class EXPORT_3D TTranslator<C3DOrientationAndPosition>; 

typedef TTranslator<E3DPatientPositioning> CPatientPositionTranslator;

template <> 
struct attribute_type<E3DImageOrientation> : public EAttributeType {
        static const int value = 3000;
}; 

template <> 
struct attribute_type<E3DPatientPositioning> : public EAttributeType {
        static const int value = 3001;
}; 

template <> 
struct attribute_type<C3DOrientationAndPosition>: public EAttributeType {
        static const int value = 3002;
}; 



extern EXPORT_3D const char * IDPatientPosition; 

NS_MIA_END

#endif