vctMatrixRotation3.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:   2004-01-12
 
  (C) Copyright 2004-2018 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 _vctMatrixRotation3_h
#define _vctMatrixRotation3_h

 
#include <cisstVector/vctFixedSizeMatrix.h>
#include <cisstVector/vctDynamicMatrixRef.h>
#include <cisstVector/vctMatrixRotation3Base.h>
 
// Always include last
#include <cisstVector/vctExport.h>

template <class _elementType, bool _rowMajor>
class vctMatrixRotation3: public vctMatrixRotation3Base<vctFixedSizeMatrix<_elementType, 3, 3, _rowMajor> >
{
 public:
    /* no need to document, inherit doxygen documentation from base class */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    enum {ROWS = 3, COLS = 3};
    enum {DIMENSION = 3};
    typedef vctFixedSizeMatrix<value_type, ROWS, COLS, _rowMajor> ContainerType;
    typedef vctMatrixRotation3Base<ContainerType> BaseType;
    typedef vctMatrixRotation3ConstBase<ContainerType> ConstBaseType;
    typedef vctMatrixRotation3<value_type, _rowMajor> ThisType;
    typedef cmnTypeTraits<value_type> TypeTraits;

    inline vctMatrixRotation3(void):
        BaseType()
    {
        this->Assign(this->Identity());
    }
 
    inline vctMatrixRotation3(const ThisType & other):
        BaseType()
    {
        this->Assign(other);
    }
 
    inline vctMatrixRotation3(const BaseType & other):
        BaseType()
    {
        this->Assign(other);
    }
 
    inline vctMatrixRotation3(const ConstBaseType & other):
        BaseType()
    {
        this->Assign(other);
    }
 
    explicit inline vctMatrixRotation3(const vctDynamicMatrixRef<value_type> & other):
        BaseType()
    {
        this->Assign(other);
    }

    inline ThisType & operator = (const ContainerType & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }
 
    inline ThisType & operator = (const ThisType & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }
 
    inline ThisType & operator = (const BaseType & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }
 

 

    inline vctMatrixRotation3(const value_type & element00, const value_type & element01, const value_type & element02,
                              const value_type & element10, const value_type & element11, const value_type & element12,
                              const value_type & element20, const value_type & element21, const value_type & element22)
        CISST_THROW(std::runtime_error)
    {
        this->From(element00, element01, element02,
                   element10, element11, element12,
                   element20, element21, element22);
    }

    template <stride_type __stride1, class __dataPtrType1,
              stride_type __stride2, class __dataPtrType2,
              stride_type __stride3, class __dataPtrType3>
    inline vctMatrixRotation3(const vctFixedSizeConstVectorBase<DIMENSION, __stride1, value_type, __dataPtrType1>& v1,
                              const vctFixedSizeConstVectorBase<DIMENSION, __stride2, value_type, __dataPtrType2>& v2,
                              const vctFixedSizeConstVectorBase<DIMENSION, __stride3, value_type, __dataPtrType3>& v3,
                              bool vectorsAreColumns = true)
        CISST_THROW(std::runtime_error)
    {
        this->From(v1, v2, v3, vectorsAreColumns);
    }

    template <class __vectorOwnerType1,
              class __vectorOwnerType2,
              class __vectorOwnerType3>
    inline vctMatrixRotation3(const vctDynamicConstVectorBase<__vectorOwnerType1, value_type>& v1,
                              const vctDynamicConstVectorBase<__vectorOwnerType2, value_type>& v2,
                              const vctDynamicConstVectorBase<__vectorOwnerType3, value_type>& v3,
                              bool vectorsAreColumns = true)
        CISST_THROW(std::runtime_error)
    {
        this->From(v1, v2, v3, vectorsAreColumns);
    }

    explicit inline vctMatrixRotation3(const vctAxisAngleRotation3<value_type> & axisAngleRotation)
        CISST_THROW(std::runtime_error)
    {
        this->From(axisAngleRotation);
    }

    template <class __containerType>
    explicit inline vctMatrixRotation3(const vctQuaternionRotation3Base<__containerType> & quaternionRotation)
        CISST_THROW(std::runtime_error)
    {
        this->From(quaternionRotation);
    }

    template <class __containerType>
    explicit inline vctMatrixRotation3(const vctRodriguezRotation3Base<__containerType> & rodriguezRotation)
        CISST_THROW(std::runtime_error)
    {
        this->From(rodriguezRotation);
    }

    template <vctEulerRotation3Order::OrderType __order>
    explicit inline vctMatrixRotation3(const vctEulerRotation3<__order> & eulerRotation)
        CISST_THROW(std::runtime_error)
    {
        this->From(eulerRotation);
    }

 

    inline vctMatrixRotation3(const value_type & element00, const value_type & element01, const value_type & element02,
                              const value_type & element10, const value_type & element11, const value_type & element12,
                              const value_type & element20, const value_type & element21, const value_type & element22,
                              bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(element00, element01, element02,
                                 element10, element11, element12,
                                 element20, element21, element22);
        } else {
            this->FromRaw(element00, element01, element02,
                          element10, element11, element12,
                          element20, element21, element22);
        }
    }

    template <stride_type __stride1, class __dataPtrType1,
              stride_type __stride2, class __dataPtrType2,
              stride_type __stride3, class __dataPtrType3>
    inline vctMatrixRotation3(const vctFixedSizeConstVectorBase<DIMENSION, __stride1, value_type, __dataPtrType1>& v1,
                              const vctFixedSizeConstVectorBase<DIMENSION, __stride2, value_type, __dataPtrType2>& v2,
                              const vctFixedSizeConstVectorBase<DIMENSION, __stride3, value_type, __dataPtrType3>& v3,
                              bool vectorsAreColumns, bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(v1, v2, v3, vectorsAreColumns);
        } else {
            this->FromRaw(v1, v2, v3, vectorsAreColumns);
        }
    }

    template <class __vectorOwnerType1,
              class __vectorOwnerType2,
              class __vectorOwnerType3>
    inline vctMatrixRotation3(const vctDynamicConstVectorBase<__vectorOwnerType1, value_type>& v1,
                              const vctDynamicConstVectorBase<__vectorOwnerType2, value_type>& v2,
                              const vctDynamicConstVectorBase<__vectorOwnerType3, value_type>& v3,
                              bool vectorsAreColumns, bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(v1, v2, v3, vectorsAreColumns);
        } else {
            this->FromRaw(v1, v2, v3, vectorsAreColumns);
        }
    }

    inline vctMatrixRotation3(const vctAxisAngleRotation3<value_type> & axisAngleRotation,
                              bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(axisAngleRotation);
        } else {
            this->FromRaw(axisAngleRotation);
        }
    }

    template <class __containerType>
    inline vctMatrixRotation3(const vctQuaternionRotation3Base<__containerType> & quaternionRotation,
                              bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(quaternionRotation);
        } else {
            this->FromRaw(quaternionRotation);
        }
    }

    template <class __containerType>
    inline vctMatrixRotation3(const vctRodriguezRotation3Base<__containerType> & rodriguezRotation,
                              bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(rodriguezRotation);
        } else {
            this->FromRaw(rodriguezRotation);
        }
    }

    template <vctEulerRotation3Order::OrderType __order>
    inline vctMatrixRotation3(const vctEulerRotation3<__order> & eulerRotation,
                              bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(eulerRotation);
        } else {
            this->FromRaw(eulerRotation);
        }
    }


    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    explicit inline
    vctMatrixRotation3(const vctFixedSizeMatrixBase<ROWS, COLS, __rowStride, __colStride, value_type, __dataPtrType> & matrix)
    {
        this->Assign(matrix);
    }
 
};
 
 
// declared in vctMatrixRotation3ConstBase.h
template <class _containerType>
typename vctMatrixRotation3ConstBase<_containerType>::RotationValueType
vctMatrixRotation3ConstBase<_containerType>::Normalized(void) const {
    RotationValueType result(*this);
    result.NormalizedSelf();
    return result;
}
 
// declared in vctMatrixRotation3ConstBase.h
template <class _containerType>
typename vctMatrixRotation3ConstBase<_containerType>::RotationValueType
vctMatrixRotation3ConstBase<_containerType>::Inverse(void) const {
    RotationValueType result(*this);
    result.InverseSelf();
    return result;
}
 
 
#endif  // _vctMatrixRotation3_h