vctMatrixRotation2.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:   2005-02-23

  (C) Copyright 2005-2007 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 _vctMatrixRotation2_h
#define _vctMatrixRotation2_h

#include <cisstVector/vctFixedSizeMatrix.h>
#include <cisstVector/vctMatrixRotation2Base.h>

#include <cisstVector/vctExport.h>

template <class _elementType>
class vctMatrixRotation2: public vctMatrixRotation2Base<vctFixedSizeMatrix<_elementType, 2, 2> >
{
public:
    /* no need to document, inherit doxygen documentation from base class */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    enum {ROWS = 2, COLS = 2};
    enum {DIMENSION = 2};
    typedef vctFixedSizeMatrix<value_type, ROWS, COLS> ContainerType;
    typedef vctMatrixRotation2Base<ContainerType> BaseType;
    typedef vctMatrixRotation2<value_type> ThisType;

    typedef cmnTypeTraits<value_type> TypeTraits;

    inline vctMatrixRotation2():
        BaseType()
    {}

    inline vctMatrixRotation2(const ThisType & other):
        BaseType(other)
    {}

    inline vctMatrixRotation2(const BaseType & other):
        BaseType(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));
    }

    /* documented in base class */
    inline vctMatrixRotation2(const value_type & element00, const value_type & element01,
                              const value_type & element10, const value_type & element11)
        throw(std::runtime_error):
        BaseType(element00, element01,
                 element10, element11)
    {}

    template <stride_type __stride1, class __dataPtrType1,
              stride_type __stride2, class __dataPtrType2>
    inline vctMatrixRotation2(const vctFixedSizeConstVectorBase<DIMENSION, __stride1, value_type, __dataPtrType1>& v1,
                              const vctFixedSizeConstVectorBase<DIMENSION, __stride2, value_type, __dataPtrType2>& v2,
                              bool vectorsAreColumns = true)
        throw(std::runtime_error):
        BaseType(v1, v2, vectorsAreColumns)
    {}

    template <class __vectorOwnerType1,
              class __vectorOwnerType2>
    inline vctMatrixRotation2(const vctDynamicConstVectorBase<__vectorOwnerType1, value_type>& v1,
                              const vctDynamicConstVectorBase<__vectorOwnerType2, value_type>& v2,
                              bool vectorsAreColumns = true)
        throw(std::runtime_error):
        BaseType(v1, v2, vectorsAreColumns)
    {}

    inline vctMatrixRotation2(const vctAngleRotation2 & angleRotation)
        throw(std::runtime_error):
        BaseType(angleRotation)
    {}

    inline vctMatrixRotation2(const value_type & element00, const value_type & element01,
                              const value_type & element10, const value_type & element11,
                              bool normalizeInput):
        BaseType(element00, element01,
                 element10, element11,
                 normalizeInput)
    {}

    template <stride_type __stride1, class __dataPtrType1,
              stride_type __stride2, class __dataPtrType2>
    inline vctMatrixRotation2(const vctFixedSizeConstVectorBase<DIMENSION, __stride1, value_type, __dataPtrType1>& v1,
                              const vctFixedSizeConstVectorBase<DIMENSION, __stride2, value_type, __dataPtrType2>& v2,
                              bool vectorsAreColumns, bool normalizeInput):

        BaseType(v1, v2, vectorsAreColumns, normalizeInput)
    {}

    template <class __vectorOwnerType1,
              class __vectorOwnerType2>
    inline vctMatrixRotation2(const vctDynamicConstVectorBase<__vectorOwnerType1, value_type>& v1,
                              const vctDynamicConstVectorBase<__vectorOwnerType2, value_type>& v2,
                              bool vectorsAreColumns, bool normalizeInput):
        BaseType(v1, v2, vectorsAreColumns, normalizeInput)
    {}

    inline vctMatrixRotation2(const vctAngleRotation2 & angleRotation,
                              bool normalizeInput):
        BaseType(angleRotation, normalizeInput)
    {}

    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    explicit inline
    vctMatrixRotation2(const vctFixedSizeMatrixBase<ROWS, COLS, __rowStride, __colStride, value_type, __dataPtrType> & matrix):
        BaseType(matrix)
    {}

};


#endif  // _vctMatrixRotation2_h