vctFrame4x4Base.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):    Anton Deguet
  Created on:   2007-09-13

  (C) Copyright 2007-2012 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/

#pragma once
#ifndef _vctFrame4x4Base_h
#define _vctFrame4x4Base_h

#include <cisstVector/vctFrame4x4ConstBase.h>
#include <cisstVector/vctExport.h>

template<class _containerType>
class vctFrame4x4Base:
    public vctFrame4x4ConstBase<_containerType>
{
public:
    enum {ROWS = 4, COLS = 4};
    enum {DIMENSION = 3};
    typedef _containerType ContainerType;
    typedef vctFrame4x4ConstBase<ContainerType> BaseType;
    typedef vctFrame4x4Base<ContainerType> ThisType;

    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(typename ContainerType::value_type);

    typedef typename BaseType::RowRefType RowRefType;
    typedef typename BaseType::ColumnRefType ColumnRefType;
    typedef typename BaseType::ConstRowRefType ConstRowRefType;
    typedef typename BaseType::ConstColumnRefType ConstColumnRefType;
    typedef typename BaseType::DiagonalRefType DiagonalRefType;
    typedef typename BaseType::ConstDiagonalRefType ConstDiagonalRefType;
    typedef typename BaseType::RefTransposeType RefTransposeType;
    typedef typename BaseType::ConstRefTransposeType ConstRefTransposeType;
    typedef typename BaseType::MatrixValueType MatrixValueType;

    typedef typename BaseType::TranslationRefType TranslationRefType;
    typedef typename BaseType::ConstTranslationRefType ConstTranslationRefType;
    typedef typename BaseType::PerspectiveRefType PerspectiveRefType;
    typedef typename BaseType::ConstPerspectiveRefType ConstPerspectiveRefType;
    typedef typename BaseType::RotationRefType RotationRefType;
    typedef typename BaseType::ConstRotationRefType ConstRotationRefType;

    typedef cmnTypeTraits<value_type> TypeTraits;

public:


    vctFrame4x4Base(void):
        BaseType()
    {}


    inline ConstTranslationRefType Translation(void) const {
        return this->TranslationRef;
    }

    inline ConstRotationRefType Rotation(void) const {
        return this->RotationRef;
    }

    inline ConstPerspectiveRefType Perspective(void) const {
        return this->PerspectiveRef;
    }

    inline TranslationRefType Translation(void) {
        return this->TranslationRef;
    }

    inline RotationRefType Rotation(void) {
        return this->RotationRef;
    }

    inline PerspectiveRefType Perspective(void) {
        return this->PerspectiveRef;
    }


    template <class __rotationType, class __translationType>
    ThisType & From(const __rotationType & rotation,
                    const __translationType & translation)
        throw (std::runtime_error)
    {
        this->RotationRef.From(rotation);
        this->TranslationRef.Assign(translation);
        this->PerspectiveRef.SetAll(static_cast<value_type>(0.0));
        this->Element(DIMENSION, DIMENSION) = static_cast<value_type>(1.0);
        return *this;
    }

    template <class __rotationType, class __translationType>
    ThisType & FromNormalized(const __rotationType & rotation,
                              const __translationType & translation)
    {
        this->RotationRef.FromNormalized(rotation);
        this->TranslationRef.Assign(translation);
        this->PerspectiveRef.SetAll(static_cast<value_type>(0.0));
        this->Element(DIMENSION, DIMENSION) = static_cast<value_type>(1.0);
        return *this;
    }

    template <class __rotationType, class __translationType>
    ThisType & FromRaw(const __rotationType & rotation,
                       const __translationType & translation)
    {
        this->RotationRef.FromRaw(rotation);
        this->TranslationRef.Assign(translation);
        this->PerspectiveRef.SetAll(static_cast<value_type>(0.0));
        this->Element(DIMENSION, DIMENSION) = static_cast<value_type>(1.0);
        return *this;
    }


    template <class __rotationType>
    ThisType & From(const vctFrameBase<__rotationType> & frame)
        throw (std::runtime_error)
    {
        this->From(frame.Rotation(), frame.Translation());
        return *this;
    }

    template <class __rotationType>
    ThisType & FromNormalized(const vctFrameBase<__rotationType> & frame)
    {
        this->FromNormalized(frame.Rotation(), frame.Translation());
        return *this;
    }

    template <class __rotationType>
    ThisType & FromRaw(const vctFrameBase<__rotationType> & frame)
    {
        this->FromRaw(frame.Rotation(), frame.Translation());
        return *this;
    }


    ThisType & NormalizedSelf(void) {
        this->Rotation().NormalizedSelf();
        this->PerspectiveRef.SetAll(static_cast<value_type>(0.0));
        this->Element(DIMENSION, DIMENSION) = static_cast<value_type>(1.0);
        return *this;
    }


    inline ThisType & InverseSelf(void) {
        // R -> Rinv
        this->RotationRef.InverseSelf();
        // T -> Rinv * (-T)
        vctFixedSizeVector<value_type, DIMENSION> temp;
        temp.Assign(this->TranslationRef);
        temp.NegationSelf();
        this->RotationRef.ApplyTo(temp, this->TranslationRef);
        return *this;
    }


    template <class __containerType>
    inline ThisType & InverseOf(const vctFrame4x4ConstBase<__containerType> & otherFrame) {
        this->TranslationRef.Assign(otherFrame.Translation());
        this->RotationRef.Assign(otherFrame.Rotation());
        this->InverseSelf();
        return *this;
    }

};


#endif  // _vctFrame4x4Base_h