vctRodriguezRotation3.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-01-13
 
  (C) Copyright 2005-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 _vctRodriguezRotation3_h
#define _vctRodriguezRotation3_h

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

template <class _elementType>
class vctRodriguezRotation3: public vctRodriguezRotation3Base<vctFixedSizeVector<_elementType, 3> >
{
public:
    /* no need to document, inherit doxygen documentation from vctFixedSizeVectorBase */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    enum {DIMENSION = 3};
    typedef vctFixedSizeVector<value_type, 3> ContainerType;
    typedef vctRodriguezRotation3Base<ContainerType> BaseType;
    typedef vctRodriguezRotation3<value_type> ThisType;
    typedef cmnTypeTraits<value_type> TypeTraits;
 
public:

    inline vctRodriguezRotation3():
        BaseType(BaseType::Identity())
    {}
 
    inline vctRodriguezRotation3(const ThisType & other):
        BaseType(other)
    {}
 
    inline vctRodriguezRotation3(const BaseType & other):
        BaseType(other)
    {}
 

 

    template <stride_type __stride, class __dataPtrType>
    explicit inline
    vctRodriguezRotation3(const vctFixedSizeConstVectorBase<DIMENSION, __stride, value_type, __dataPtrType> & axis)
        CISST_THROW(std::runtime_error)
    {
        this->From(axis);
    }

    inline vctRodriguezRotation3(value_type x, value_type y, value_type z)
        CISST_THROW(std::runtime_error)
    {
        this->From(x, y, z);
    }

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

    template <class __containerType>
    explicit inline
    vctRodriguezRotation3(const vctMatrixRotation3Base<__containerType> & matrixRotation)
        CISST_THROW(std::runtime_error)
    {
        this->From(matrixRotation);
    }

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

 
 


    template <stride_type __stride, class __dataPtrType>
    inline vctRodriguezRotation3(const vctFixedSizeConstVectorBase<DIMENSION, __stride, value_type, __dataPtrType> & axis,
                                 bool normalizeInput)
    {
        if (normalizeInput) {
            FromNormalized(axis);
        } else {
            FromRaw(axis);
        }
    }

    inline vctRodriguezRotation3(value_type x, value_type y, value_type z,
                                 bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(x, y, z);
        } else {
            this->FromRaw(x, y, z);
        }
    }

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

    template <class __containerType>
    inline vctRodriguezRotation3(const vctMatrixRotation3Base<__containerType> & matrixRotation,
                                 bool normalizeInput)
    {
        if (normalizeInput) {
            this->FromNormalized(matrixRotation);
        } else {
            this->FromRaw(matrixRotation);
        }
    }

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

};
 
 
#endif  // _vctRodriguezRotation3_h