cxTransform3D.h

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#ifndef CXTRANSFORM3D_H_
#define CXTRANSFORM3D_H_
 
#include "cxResourceExport.h"
#include "cxPrecompiledHeader.h"
 
#include <boost/array.hpp>
#include <boost/shared_ptr.hpp>
#include <QString>
#include "cxVector3D.h"
#include "cxDefinitions.h"
 
 
namespace cx_transform3D_internal
{
cxResource_EXPORT boost::array<double, 16> flatten(const Eigen::Affine3d* self);
 
cxResource_EXPORT void fill(Eigen::Affine3d* self, vtkMatrix4x4Ptr m);
cxResource_EXPORT void fill(Eigen::Affine3d* self, float m[4][4]);
cxResource_EXPORT void fill(Eigen::Affine3d* self, const double* raw);
cxResource_EXPORT vtkMatrix4x4Ptr getVtkMatrix(const Eigen::Affine3d* self);
cxResource_EXPORT std::ostream& put(const Eigen::Affine3d* self, std::ostream& s, int indent, char newline);
cxResource_EXPORT Eigen::Affine3d fromString(const QString& text, bool* _ok);
cxResource_EXPORT vtkTransformPtr getVtkTransform(const Eigen::Affine3d* self);
}
 
namespace Eigen
{
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
std::ostream& operator<<(std::ostream& s, const Eigen::Transform<_Scalar, _Dim, _Mode, _Options>& t)
{
        s << t.matrix().format(IOFormat()); // hack: force OK output even when the default in sscMathBase.h is Veector3D-centered.
        //  t.put(s);
        return s;
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Vector3d Transform<_Scalar, _Dim, _Mode, _Options>::vector(const Vector3d& v) const 
{
        return this->linear() * v;
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Vector3d Transform<_Scalar, _Dim, _Mode, _Options>::unitVector(const Vector3d& v) const
{
        return (this->linear() * v).normal();
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Vector3d Transform<_Scalar, _Dim, _Mode, _Options>::coord(const Vector3d& v) const
{
        return (*this) * v;
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Transform<_Scalar, _Dim, _Mode, _Options> Transform<_Scalar, _Dim, _Mode, _Options>::inv() const
{
        return this->inverse();
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
boost::array<double, 16> Transform<_Scalar, _Dim, _Mode, _Options>::flatten() const
{
        return cx_transform3D_internal::flatten(this);
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Transform<_Scalar, _Dim, _Mode, _Options>::Transform(vtkMatrix4x4* m)
{
        cx_transform3D_internal::fill(this, m);
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Transform<_Scalar, _Dim, _Mode, _Options>::Transform(double* raw)
{
        cx_transform3D_internal::fill(this, raw);
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
vtkMatrix4x4Ptr Transform<_Scalar, _Dim, _Mode, _Options>::getVtkMatrix() const
{
        return cx_transform3D_internal::getVtkMatrix(this);
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
vtkTransformPtr Transform<_Scalar, _Dim, _Mode, _Options>::getVtkTransform() const
{
        return cx_transform3D_internal::getVtkTransform(this);
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
std::ostream& Transform<_Scalar, _Dim, _Mode, _Options>::put(std::ostream& s, int indent, char newline) const
{
        return cx_transform3D_internal::put(this, s, indent, newline);
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Transform<_Scalar, _Dim, _Mode, _Options> Transform<_Scalar, _Dim, _Mode, _Options>::fromString(const QString& text,
        bool* _ok)
{
        return cx_transform3D_internal::fromString(text, _ok);
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Transform<_Scalar, _Dim, _Mode, _Options> Transform<_Scalar, _Dim, _Mode, _Options>::fromVtkMatrix(vtkMatrix4x4Ptr m)
{
        Transform<_Scalar, _Dim, _Mode, _Options> retval;
        cx_transform3D_internal::fill(&retval, m);
        return retval;
}
 
template<typename _Scalar, int _Dim, int _Mode, int _Options>
Transform<_Scalar, _Dim, _Mode, _Options> Transform<_Scalar, _Dim, _Mode, _Options>::fromFloatArray(float m[4][4])
{
    Transform<_Scalar, _Dim, _Mode, _Options> retval;
    cx_transform3D_internal::fill(&retval, m);
    return retval;
}
 
 
} // namespace Eigen
 
// --------------------------------------------------------
namespace cx
{
class DoubleBoundingBox3D;
 
typedef Eigen::Affine3d Transform3D;
 
cxResource_EXPORT bool similar(const Transform3D& a, const Transform3D& b, double tol = 1.0E-4);
 
cxResource_EXPORT DoubleBoundingBox3D transform(const Transform3D& m, const DoubleBoundingBox3D& bb);
 
cxResource_EXPORT Transform3D createTransformNormalize(const DoubleBoundingBox3D& in, const DoubleBoundingBox3D& out);
 
cxResource_EXPORT Transform3D createTransformScale(const Vector3D& scale);
 
cxResource_EXPORT Transform3D createTransformTranslate(const Vector3D& translation);
 
cxResource_EXPORT Transform3D createTransformRotateX(const double angle);
 
cxResource_EXPORT Transform3D createTransformRotateY(const double angle);
 
cxResource_EXPORT Transform3D createTransformRotateZ(const double angle);
 
cxResource_EXPORT Transform3D createTransformIJC(const Vector3D& ivec, const Vector3D& jvec, const Vector3D& center);
 
cxResource_EXPORT Transform3D createTransformRotationBetweenVectors(Vector3D from, Vector3D to);
 
 
cxResource_EXPORT Transform3D createTransformLPS2RAS();
 
cxResource_EXPORT Transform3D createTransformFromReferenceToExternal(PATIENT_COORDINATE_SYSTEM external);
 
 
 
// --------------------------------------------------------
typedef boost::shared_ptr<Transform3D> Transform3DPtr;
 
cxResource_EXPORT std::string matrixAsSingleLineString(Transform3D transform);
 
} // namespace cx
// --------------------------------------------------------
 
#endif /*CXTRANSFORM3D_H_*/