critical_point.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_criticalpoint_h
#define __mia_3d_criticalpoint_h
 
#include <list>
 
#include <mia/3d/matrix.hh>
 
NS_MIA_BEGIN

 
 
class EXPORT_3D C3DCriticalPoint
{
public:

       typedef std::vector< C3DCriticalPoint > List;

 
       C3DCriticalPoint();

 
 
       C3DCriticalPoint(const C3DFVector& x0_);
       C3DCriticalPoint(float x, float y, float z);

       C3DCriticalPoint(const C3DCriticalPoint& org);

       C3DCriticalPoint& operator = (const C3DCriticalPoint& org);

       const C3DFVector get_point()const;

       const C3DFMatrix get_a()const;

       float get_gamma()const;

       void set_point(const C3DFVector&);

       void  set_a(const C3DFMatrix&);
 

 
       void set_gamma(float gamma_);

       C3DFVector at(const C3DFVector& x) const;

 
       C3DFVector at_alt(const C3DFVector& x) const;

       bool operator ==(const C3DCriticalPoint& cp) const;
#ifdef UGLY_HACK
       bool operator < (const C3DCriticalPoint& cp) const;
#endif
 
 
private:
       float gamma;
       C3DFVector x0;
       C3DFMatrix A;
};

typedef C3DCriticalPoint::List C3DCriticalPointList;
 

 
class EXPORT_3D C3DCriticalPointEigen
{
 

       C3DFVector location;
 

       C3DFMatrix portrait;

       float eval1;
       float eval2;
       float eval3;

       T3DCVector<float> evec1;

       T3DCVector<float> evec2;

       T3DCVector<float> evec3;
 
public:
       enum EVType {ev_zero, 
                    ev_real,  
                    ev_real_two_equal, 
                    ev_real_three_equal, 
                    ev_complex
                   };   

       C3DCriticalPointEigen(C3DCriticalPoint cp);

       C3DCriticalPointEigen(const C3DFVector& l, const C3DFMatrix& m);

       C3DCriticalPointEigen(const C3DFVector& location_,
                             const C3DFMatrix& portrait_,
                             float eval1, float eval2, float eval3,
                             const C3DFVector& evec1, const C3DFVector& evec2, const C3DFVector& evec3,
                             EVType type);
 

       EVType get_type()const;

       float get_eval1()const;
       float get_eval2()const;
       float get_eval3()const;

       float get_real_eval2()const;
       float get_real_eval3()const;

       std::complex<float> get_complex_eval2()const;

       std::complex<float> get_complex_eval3()const;

       const C3DFMatrix get_portrait()const;

       const C3DFVector get_location()const;

       const C3DFVector get_evect1()const;

 
       const C3DFVector get_real_evect2()const;
       const C3DFVector get_real_evect3()const;
       const T3DCVector<float> get_complex_evect2()const;
       const T3DCVector<float> get_complex_evect3()const;
 
 
private:
       EVType type;
       bool estimate();
};
 
typedef std::vector< C3DCriticalPointEigen > C3DCriticalPointEigenList;
 
inline C3DCriticalPointEigen::EVType C3DCriticalPointEigen::get_type()const
{
       return type;
}
inline float C3DCriticalPointEigen::get_eval1()const
{
       return eval1;
}
inline float C3DCriticalPointEigen::get_eval2()const
{
       return eval2;
}
inline float C3DCriticalPointEigen::get_eval3()const
{
       return eval3;
}
 
inline float C3DCriticalPointEigen::get_real_eval2()const
{
       assert(type != ev_complex);
       return eval2;
}
inline float C3DCriticalPointEigen::get_real_eval3()const
{
       assert(type != ev_complex);
       return eval3;
}
inline std::complex<float> C3DCriticalPointEigen::get_complex_eval2()const
{
       assert(type == ev_complex);
       return std::complex<float>(eval2, eval3);
}
inline std::complex<float> C3DCriticalPointEigen::get_complex_eval3()const
{
       assert(type == ev_complex);
       return std::complex<float>(eval2, eval3);
}
 
inline const C3DFVector C3DCriticalPointEigen::get_evect1()const
{
       return C3DFVector(evec1.x.real(), evec1.y.real(), evec1.z.real());
}
inline const C3DFVector C3DCriticalPointEigen::get_real_evect2()const
{
       assert(type != ev_complex);
       return C3DFVector(evec2.x.real(), evec2.y.real(), evec2.z.real());
}
inline const C3DFVector C3DCriticalPointEigen::get_real_evect3()const
{
       assert(type != ev_complex);
       return C3DFVector(evec3.x.real(), evec3.y.real(), evec3.z.real()); ;
}
inline const T3DCVector<float> C3DCriticalPointEigen::get_complex_evect2()const
{
       assert(type == ev_complex);
       return evec2;
}
inline const T3DCVector<float> C3DCriticalPointEigen::get_complex_evect3()const
{
       assert(type == ev_complex);
       return evec3;
}
 
inline const C3DFVector C3DCriticalPointEigen::get_location()const
{
       return location;
}
 
 
inline const C3DFMatrix C3DCriticalPointEigen::get_portrait()const
{
       return portrait;
}
 
 
//template implementation
 
 
inline const C3DFVector  C3DCriticalPoint::get_point()const
{
       return x0;
}
 
inline const C3DFMatrix  C3DCriticalPoint::get_a()const
{
       return A;
}
 
 
inline void C3DCriticalPoint::set_point(const C3DFVector& x)
{
       x0 = x;
}
 
inline void C3DCriticalPoint::set_a(const C3DFMatrix& a)
{
       A = a;
}
 
 
inline  float C3DCriticalPoint::get_gamma()const
{
       return gamma;
}
 
inline void C3DCriticalPoint::set_gamma(float _gamma)
{
       gamma = _gamma;
}
 
 
inline bool C3DCriticalPoint::operator ==(const C3DCriticalPoint& cp) const
{
       return  gamma == cp.gamma && A == cp.A && x0 == cp.x0;
}
 
#ifdef UGLY_HACK
inline bool C3DCriticalPoint::operator < (const C3DCriticalPoint& cp) const
{
       // we shouldn't need this ...
       return x0 < cp.x0;
}
#endif
 
#endif
 
NS_MIA_END