gVXR-core/2.0.10/_vec3_8h_source.html

 /*

 Copyright (c) 2017, Dr Franck P. Vidal (franck.p.vidal@fpvidal.net),
 http://www.fpvidal.net/
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
 are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice,
 this list of conditions and the following disclaimer.

 2. Redistributions in binary form must reproduce the above copyright notice,
 this list of conditions and the following disclaimer in the documentation and/or
 other materials provided with the distribution.

 3. Neither the name of the Bangor University nor the names of its contributors
 may be used to endorse or promote products derived from this software without
 specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */


 #ifndef __Vec3_h
 #define __Vec3_h


 //******************************************************************************
 //  Include
 //******************************************************************************
 #ifndef __gVirtualXRayConfig_h
 #include "gVirtualXRay/gVirtualXRayConfig.h"
 #endif

 #include <iostream>


 //******************************************************************************
 //  namespace
 //******************************************************************************
 namespace gVirtualXRay {


 //******************************************************************************
 //  class declaration
 //******************************************************************************
 template<typename T> class Vec3;


 //******************************************************************************
 //  Function declaration
 //******************************************************************************
 template<typename T> std::ostream& operator<<(std::ostream& anOutputStream,
         const Vec3<T>& aVector);


 //==============================================================================
 //==============================================================================
 template<typename T> class Vec3
 //------------------------------------------------------------------------------
 {
 //******************************************************************************
 public:
     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3(const T& aX = 0, const T& aY = 0, const T& aZ = 0);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void setX(const T& aValue);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void setY(const T& aValue);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     void setZ(const T& aValue);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     T getX() const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     T getY() const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     T getZ() const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     double length() const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 normal() const;


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     void normalize();


     //--------------------------------------------------------------------------
     //--------------------------------------------------------------------------
     void normalise();


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     double dotProduct(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 crossProduct(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     double distance(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     //double operator*(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3<T> elementWiseProduct(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 operator+(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3& operator+=(const Vec3& aVector);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 operator-(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3& operator-=(const Vec3& aVector);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 operator*(const double& aValue) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3& operator*=(const double& aValue);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 operator*(const float& aValue) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3& operator*=(const float& aValue);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 operator/(const double& aValue) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3& operator/=(const double& aValue);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 operator/(const float& aValue) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3& operator/=(const float& aValue);


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 operator^(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     Vec3 operator-() const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     bool operator==(const Vec3& aVector) const;


     //--------------------------------------------------------------------------

     //--------------------------------------------------------------------------
     bool operator!=(const Vec3& aVector) const;


     T& operator()(unsigned int i);
     const T& operator()(unsigned int i) const;

     T& operator[](unsigned int i);
     const T& operator[](unsigned int i) const;


 //******************************************************************************
 protected:
     //**************************************************************************
     T m_x;
     T m_y;
     T m_z;
 };


 //------------------------------------------------------------------------------

 //------------------------------------------------------------------------------
 template<typename T> Vec3<T> operator*(const double& aValue,
         const Vec3<T>& aVector);


 } // namespace gVirtualXRay


 //******************************************************************************
 #include "Vec3.inl"


 #endif // __Vec3_h
gVirtualXRay::Vec3::m_z
T m_z
the position along the z-axi
Definition: Vec3.h:433

gVirtualXRay::Vec3::setY
void setY(const T &aValue)
Set the position along the y-axis.
Definition: Vec3.inl:99

gVirtualXRay::Vec3::operator!=
bool operator!=(const Vec3 &aVector) const
Operator !=.
Definition: Vec3.inl:371

gVirtualXRay::Vec3::operator[]
T & operator[](unsigned int i)
Definition: Vec3.inl:430

gVirtualXRay::Vec3::distance
double distance(const Vec3 &aVector) const
Definition: Vec3.inl:209

gVirtualXRay::Vec3::operator-
Vec3 operator-() const
Operator - to get the opposite vector.
Definition: Vec3.inl:350

gVirtualXRay::Vec3::operator+=
Vec3 & operator+=(const Vec3 &aVector)
Operator +=.
Definition: Vec3.inl:230

gVirtualXRay::Vec3::m_x
T m_x
the position along the x-axis
Definition: Vec3.h:431

gVirtualXRay::Vec3::length
double length() const
Get the length of the vector.
Definition: Vec3.inl:139

gVirtualXRay::Vec3::normalise
void normalise()
Normalise the current vector so that its length is 1.
Definition: Vec3.inl:166

gVirtualXRay::Vec3
Vec3 is a template class to handle a 3D vector.
Definition: Vec3.h:88

gVirtualXRay::Vec3::getX
T getX() const
Accessor on the position along the x-axis.
Definition: Vec3.inl:115

gVirtualXRay::Vec3::getZ
T getZ() const
Accessor on the position along the z-axis.
Definition: Vec3.inl:131

gVirtualXRay::Vec3::normal
Vec3 normal() const
Get the unit vector corresponding to the normed current vector.
Definition: Vec3.inl:147

gVirtualXRay::Vec3::elementWiseProduct
Vec3< T > elementWiseProduct(const Vec3 &aVector) const
Element-wise product.
Definition: Vec3.inl:201

gVirtualXRay::Vec3::operator/
Vec3 operator/(const double &aValue) const
Operator / to divide each component of the vector by a given value.
Definition: Vec3.inl:302

gVirtualXRay::Vec3::operator*=
Vec3 & operator*=(const double &aValue)
Definition: Vec3.inl:270

gVirtualXRay::Vec3::m_y
T m_y
the position along the y-axi
Definition: Vec3.h:432

gVirtualXRay::Vec3::setX
void setX(const T &aValue)
Set the position along the x-axis.
Definition: Vec3.inl:91

gVirtualXRay::Vec3::crossProduct
Vec3 crossProduct(const Vec3 &aVector) const
Definition: Vec3.inl:182

Vec3.inl
Template class to handle 3D vectors.

gVirtualXRay::Vec3::getY
T getY() const
Accessor on the position along the y-axis.
Definition: Vec3.inl:123

gVirtualXRay::Vec3::operator^
Vec3 operator^(const Vec3 &aVector) const
Definition: Vec3.inl:342

gVirtualXRay::Vec3::operator-=
Vec3 & operator-=(const Vec3 &aVector)
Operator -=.
Definition: Vec3.inl:250

gVirtualXRay
Definition: AnatomicalMesh.h:73

gVirtualXRay::Vec3::operator+
Vec3 operator+(const Vec3 &aVector) const
Operator +.
Definition: Vec3.inl:222

gVirtualXRay::Vec3::normalize
void normalize()
Normalize the current vector so that its length is 1.
Definition: Vec3.inl:155

gVirtualXRay::operator<<
std::ostream & operator<<(std::ostream &anOutputSream, const gVirtualXRay::AtomicElement &anElement)
operator <<

gVirtualXRay::Vec3::operator==
bool operator==(const Vec3 &aVector) const
Operator ==.
Definition: Vec3.inl:358

gVirtualXRay::Vec3::operator()
T & operator()(unsigned int i)
Definition: Vec3.inl:384

gVirtualXRay::Vec3::operator*
Vec3 operator*(const double &aValue) const
Operator * to multiply each component of the vector by a given value.
Definition: Vec3.inl:262

gVirtualXRay::Vec3::dotProduct
double dotProduct(const Vec3 &aVector) const
Get the dot product between the current vector and a given vector.
Definition: Vec3.inl:174

gVirtualXRay::operator*
Image< T > operator*(const T &aValue, const Image< T > &anImage)
Definition: Image.inl:5104

gVirtualXRay::Vec3::operator/=
Vec3 & operator/=(const double &aValue)
Operator -=.
Definition: Vec3.inl:310

gVirtualXRay::Vec3::setZ
void setZ(const T &aValue)
Set the position along the z-axis.
Definition: Vec3.inl:107

gVirtualXRay::Vec3::Vec3
Vec3(const T &aX=0, const T &aY=0, const T &aZ=0)
Default Constructor.
Definition: Vec3.inl:82

gVirtualXRayConfig.h