RigidObject3DTransformation.h

Go to the documentation of this file.

//
//
/*
    Copyright (C) 2000- 2005 , Hammersmith Imanet Ltd
    For internal GE use only
*/
 
#ifndef __stir_motion_RigidObject3DTransformation_H__
#define __stir_motion_RigidObject3DTransformation_H__
 
#include "stir_experimental/motion/ObjectTransformation.h"
#include "stir/RegisteredParsingObject.h"
#include "stir_experimental/Quaternion.h"
#include "stir/CartesianCoordinate3D.h"
#include "stir/Succeeded.h"
#include "stir/Array.h"
#include "stir/Bin.h"
#include "stir/ProjDataInfo.h"
#include <algorithm>
 
START_NAMESPACE_STIR
class Succeeded;

class RigidObject3DTransformation
    : public RegisteredParsingObject<RigidObject3DTransformation, ObjectTransformation<3, float>, ObjectTransformation<3, float>>
{
public:
  static const char* const registered_name;
  template <class Iter1T, class Iter2T>
  static Succeeded find_closest_transformation(RigidObject3DTransformation& result,
                                               Iter1T start_orig_points,
                                               Iter1T end_orig_points,
                                               Iter2T start_transformed_points,
                                               const Quaternion<float>& initial_rotation = Quaternion<float>(1.F, 0.F, 0.F, 0.F));

  template <class Iter1T, class Iter2T>
  static double RMSE(const RigidObject3DTransformation& transformation,
                     Iter1T start_orig_points,
                     Iter1T end_orig_points,
                     Iter2T start_transformed_points);
 
  RigidObject3DTransformation();


  RigidObject3DTransformation(const Quaternion<float>& quat, const CartesianCoordinate3D<float>& translation);

  RigidObject3DTransformation inverse() const;
  Quaternion<float> get_quaternion() const;

  CartesianCoordinate3D<float> get_translation() const;
 
#if 0  
  // implementation probably only works for FIRSTROT
  Coordinate3D<float> get_euler_angles() const;
    
  Succeeded set_euler_angles();
#endif

  // can't return CartesianCoordinate3D<float> anymore because virtual function
 
  BasicCoordinate<3, float> transform_point(const BasicCoordinate<3, float>& point) const override;

  float jacobian(const BasicCoordinate<3, float>& point) const override
  {
    return 1;
  }


  void transform_bin(Bin& bin, const ProjDataInfo& out_proj_data_info, const ProjDataInfo& in_proj_data_info) const;
  void get_relative_transformation(RigidObject3DTransformation& output, const RigidObject3DTransformation& reference);
#if 0  

  static void quaternion_2_euler(Coordinate3D<float>& Euler_angles, const Quaternion<float>& quat);
  static void quaternion_2_m3(Array<2,float>& mat, const Quaternion<float>& quat);
  static void m3_2_euler(Coordinate3D<float>& Euler_angles, const Array<2,float>& mat); 
  static void euler_2_quaternion(Quaternion<float>& quat,const Coordinate3D<float>& Euler_angles);           
#endif
 
private:
  Quaternion<float> quat;
  CartesianCoordinate3D<float> translation;
  friend RigidObject3DTransformation compose(const RigidObject3DTransformation& apply_last,
                                             const RigidObject3DTransformation& apply_first);
};


std::ostream& operator<<(std::ostream& out, const RigidObject3DTransformation& rigid_object_transformation);

std::istream& operator>>(std::istream&, RigidObject3DTransformation& rigid_object_transformation);


 
RigidObject3DTransformation compose(const RigidObject3DTransformation& apply_last,
                                    const RigidObject3DTransformation& apply_first);
 
END_NAMESPACE_STIR
 
#endif