referential.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
#ifndef CARTODATA_TRANSFORMATION_REFERENTIAL_H
#define CARTODATA_TRANSFORMATION_REFERENTIAL_H
 
#include <soma-io/transformation/affinetransformation3d_base.h>
#include <cartobase/smart/rcobject.h>
 
 
namespace carto
{

  class Referential: RCObject
  {
  public:
    enum Orientation
    {
      Undefined,
      L,
      R,
      A,
      P,
      S,
      I,
      T,
      t,
      U,
      u,
      V,
      v,
      W,
      w,
      X,
      x,
      Y,
      y,
      Z,
      z
    };

    Referential( unsigned ndim = 3 );
    Referential( const Referential & ref );
    Referential( Object ref );
    ~Referential();
 
    Referential & operator = ( const Referential & ref );

    unsigned order() const { return _orientation.size(); }
    void ensureOrder( unsigned ndim );
    const std::string & uuid() const { return _uuid; }
    std::string & uuid() { return _uuid; }
    std::string orientationStr() const;
    std::string orientationStr( const std::string & orient ) const;
    std::vector<int> axesOrientation() const { return _orientation; }
    bool isDirect() const;
    rc_ptr<Transformation>
    toOrientation(
      const std::string & orient,
      const std::vector<float> & transl = std::vector<float>(),
      bool allow_resize = false ) const;
    rc_ptr<Transformation>
    toOrientation(
      const std::string & orient,
      const std::vector<int> & transl,
      bool allow_resize = false ) const
      {
        return toOrientation( orient,
                              std::vector<float>( transl.begin(),
                                                  transl.end() ),
                              allow_resize );
      }

    rc_ptr<Transformation>
    toOrientation(
      const std::vector<int> & orient,
      const std::vector<float> & transl = std::vector<float>() ) const;
    std::string lpiReferentialUuid() const
    {
      if( isLpiOriented() && _uuid != _lpi_uuid )
        _lpi_uuid = _uuid;
      return _lpi_uuid;
    }

    void setUuid( const std::string & uuid );
    void setOrientation( const std::string & orient,
                         bool allow_resize = false );
    void setOrientation( const std::vector<int> & orient );
    void setLpiReferential( const std::string & lpi_uuid );

    Object header() const { return _header; }
    void setHeader( const Object header );
    Object exportedHeader() const;
    bool is3DOriented() const;
    bool is3DOriented( const std::string & orient ) const;
    bool isLpiOriented() const;
    std::vector<int> orientationFromTransform(
      const AffineTransformationBase & tr ) const;

    static std::string orientationStr( Orientation orient );
    static std::string orientationStr( const std::vector<int> & orient );
    static Orientation orientationCode( const std::string & orient );
    static std::vector<int> orientationVector( const std::string & orient,
                                               unsigned dim = 0 );
    static void setAxisTransform( AffineTransformationBase & tr,
                                  int src_axis, int dst_axis, int inv_mult,
                                  const std::vector<float> & transl
                                  = std::vector<float>() );
    static bool is3DOriented( const std::vector<int> & orient );
    static Referential fromHeader( const Object header,
                                   bool except_if_undefined = false );
 
  private:
    std::string _uuid;
    mutable std::string _lpi_uuid;
    std::vector<int> _orientation;
    Object _header;
  };
 
}
 
#endif