mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
659 lines
14 KiB
659 lines
14 KiB
/////////////////////////////////////////////////////////////////////////// |
|
// |
|
// Copyright (c) 2004, Industrial Light & Magic, a division of Lucas |
|
// Digital Ltd. LLC |
|
// |
|
// All rights reserved. |
|
// |
|
// Redistribution and use in source and binary forms, with or without |
|
// modification, are permitted provided that the following conditions are |
|
// met: |
|
// * Redistributions of source code must retain the above copyright |
|
// notice, this list of conditions and the following disclaimer. |
|
// * 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. |
|
// * Neither the name of Industrial Light & Magic 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 |
|
// OWNER 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 INCLUDED_IMATHSHEAR_H |
|
#define INCLUDED_IMATHSHEAR_H |
|
|
|
//---------------------------------------------------- |
|
// |
|
// Shear6 class template. |
|
// |
|
//---------------------------------------------------- |
|
|
|
#include "ImathExc.h" |
|
#include "ImathLimits.h" |
|
#include "ImathMath.h" |
|
#include "ImathVec.h" |
|
|
|
#include <iostream> |
|
|
|
|
|
namespace Imath { |
|
|
|
|
|
|
|
|
|
template <class T> class Shear6 |
|
{ |
|
public: |
|
|
|
//------------------- |
|
// Access to elements |
|
//------------------- |
|
|
|
T xy, xz, yz, yx, zx, zy; |
|
|
|
T & operator [] (int i); |
|
const T & operator [] (int i) const; |
|
|
|
|
|
//------------- |
|
// Constructors |
|
//------------- |
|
|
|
Shear6 (); // (0 0 0 0 0 0) |
|
Shear6 (T XY, T XZ, T YZ); // (XY XZ YZ 0 0 0) |
|
Shear6 (const Vec3<T> &v); // (v.x v.y v.z 0 0 0) |
|
template <class S> // (v.x v.y v.z 0 0 0) |
|
Shear6 (const Vec3<S> &v); |
|
Shear6 (T XY, T XZ, T YZ, // (XY XZ YZ YX ZX ZY) |
|
T YX, T ZX, T ZY); |
|
|
|
|
|
//--------------------------------- |
|
// Copy constructors and assignment |
|
//--------------------------------- |
|
|
|
Shear6 (const Shear6 &h); |
|
template <class S> Shear6 (const Shear6<S> &h); |
|
|
|
const Shear6 & operator = (const Shear6 &h); |
|
template <class S> |
|
const Shear6 & operator = (const Vec3<S> &v); |
|
|
|
|
|
//---------------------- |
|
// Compatibility with Sb |
|
//---------------------- |
|
|
|
template <class S> |
|
void setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY); |
|
|
|
template <class S> |
|
void setValue (const Shear6<S> &h); |
|
|
|
template <class S> |
|
void getValue (S &XY, S &XZ, S &YZ, |
|
S &YX, S &ZX, S &ZY) const; |
|
|
|
template <class S> |
|
void getValue (Shear6<S> &h) const; |
|
|
|
T * getValue(); |
|
const T * getValue() const; |
|
|
|
|
|
//--------- |
|
// Equality |
|
//--------- |
|
|
|
template <class S> |
|
bool operator == (const Shear6<S> &h) const; |
|
|
|
template <class S> |
|
bool operator != (const Shear6<S> &h) const; |
|
|
|
//----------------------------------------------------------------------- |
|
// Compare two shears and test if they are "approximately equal": |
|
// |
|
// equalWithAbsError (h, e) |
|
// |
|
// Returns true if the coefficients of this and h are the same with |
|
// an absolute error of no more than e, i.e., for all i |
|
// |
|
// abs (this[i] - h[i]) <= e |
|
// |
|
// equalWithRelError (h, e) |
|
// |
|
// Returns true if the coefficients of this and h are the same with |
|
// a relative error of no more than e, i.e., for all i |
|
// |
|
// abs (this[i] - h[i]) <= e * abs (this[i]) |
|
//----------------------------------------------------------------------- |
|
|
|
bool equalWithAbsError (const Shear6<T> &h, T e) const; |
|
bool equalWithRelError (const Shear6<T> &h, T e) const; |
|
|
|
|
|
//------------------------ |
|
// Component-wise addition |
|
//------------------------ |
|
|
|
const Shear6 & operator += (const Shear6 &h); |
|
Shear6 operator + (const Shear6 &h) const; |
|
|
|
|
|
//--------------------------- |
|
// Component-wise subtraction |
|
//--------------------------- |
|
|
|
const Shear6 & operator -= (const Shear6 &h); |
|
Shear6 operator - (const Shear6 &h) const; |
|
|
|
|
|
//------------------------------------ |
|
// Component-wise multiplication by -1 |
|
//------------------------------------ |
|
|
|
Shear6 operator - () const; |
|
const Shear6 & negate (); |
|
|
|
|
|
//------------------------------ |
|
// Component-wise multiplication |
|
//------------------------------ |
|
|
|
const Shear6 & operator *= (const Shear6 &h); |
|
const Shear6 & operator *= (T a); |
|
Shear6 operator * (const Shear6 &h) const; |
|
Shear6 operator * (T a) const; |
|
|
|
|
|
//------------------------ |
|
// Component-wise division |
|
//------------------------ |
|
|
|
const Shear6 & operator /= (const Shear6 &h); |
|
const Shear6 & operator /= (T a); |
|
Shear6 operator / (const Shear6 &h) const; |
|
Shear6 operator / (T a) const; |
|
|
|
|
|
//---------------------------------------------------------- |
|
// Number of dimensions, i.e. number of elements in a Shear6 |
|
//---------------------------------------------------------- |
|
|
|
static unsigned int dimensions() {return 6;} |
|
|
|
|
|
//------------------------------------------------- |
|
// Limitations of type T (see also class limits<T>) |
|
//------------------------------------------------- |
|
|
|
static T baseTypeMin() {return limits<T>::min();} |
|
static T baseTypeMax() {return limits<T>::max();} |
|
static T baseTypeSmallest() {return limits<T>::smallest();} |
|
static T baseTypeEpsilon() {return limits<T>::epsilon();} |
|
|
|
|
|
//-------------------------------------------------------------- |
|
// Base type -- in templates, which accept a parameter, V, which |
|
// could be either a Vec2<T> or a Shear6<T>, you can refer to T as |
|
// V::BaseType |
|
//-------------------------------------------------------------- |
|
|
|
typedef T BaseType; |
|
}; |
|
|
|
|
|
//-------------- |
|
// Stream output |
|
//-------------- |
|
|
|
template <class T> |
|
std::ostream & operator << (std::ostream &s, const Shear6<T> &h); |
|
|
|
|
|
//---------------------------------------------------- |
|
// Reverse multiplication: scalar * Shear6<T> |
|
//---------------------------------------------------- |
|
|
|
template <class S, class T> Shear6<T> operator * (S a, const Shear6<T> &h); |
|
|
|
|
|
//------------------------- |
|
// Typedefs for convenience |
|
//------------------------- |
|
|
|
typedef Vec3 <float> Shear3f; |
|
typedef Vec3 <double> Shear3d; |
|
typedef Shear6 <float> Shear6f; |
|
typedef Shear6 <double> Shear6d; |
|
|
|
|
|
|
|
|
|
//----------------------- |
|
// Implementation of Shear6 |
|
//----------------------- |
|
|
|
template <class T> |
|
inline T & |
|
Shear6<T>::operator [] (int i) |
|
{ |
|
return (&xy)[i]; |
|
} |
|
|
|
template <class T> |
|
inline const T & |
|
Shear6<T>::operator [] (int i) const |
|
{ |
|
return (&xy)[i]; |
|
} |
|
|
|
template <class T> |
|
inline |
|
Shear6<T>::Shear6 () |
|
{ |
|
xy = xz = yz = yx = zx = zy = 0; |
|
} |
|
|
|
template <class T> |
|
inline |
|
Shear6<T>::Shear6 (T XY, T XZ, T YZ) |
|
{ |
|
xy = XY; |
|
xz = XZ; |
|
yz = YZ; |
|
yx = 0; |
|
zx = 0; |
|
zy = 0; |
|
} |
|
|
|
template <class T> |
|
inline |
|
Shear6<T>::Shear6 (const Vec3<T> &v) |
|
{ |
|
xy = v.x; |
|
xz = v.y; |
|
yz = v.z; |
|
yx = 0; |
|
zx = 0; |
|
zy = 0; |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline |
|
Shear6<T>::Shear6 (const Vec3<S> &v) |
|
{ |
|
xy = T (v.x); |
|
xz = T (v.y); |
|
yz = T (v.z); |
|
yx = 0; |
|
zx = 0; |
|
zy = 0; |
|
} |
|
|
|
template <class T> |
|
inline |
|
Shear6<T>::Shear6 (T XY, T XZ, T YZ, T YX, T ZX, T ZY) |
|
{ |
|
xy = XY; |
|
xz = XZ; |
|
yz = YZ; |
|
yx = YX; |
|
zx = ZX; |
|
zy = ZY; |
|
} |
|
|
|
template <class T> |
|
inline |
|
Shear6<T>::Shear6 (const Shear6 &h) |
|
{ |
|
xy = h.xy; |
|
xz = h.xz; |
|
yz = h.yz; |
|
yx = h.yx; |
|
zx = h.zx; |
|
zy = h.zy; |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline |
|
Shear6<T>::Shear6 (const Shear6<S> &h) |
|
{ |
|
xy = T (h.xy); |
|
xz = T (h.xz); |
|
yz = T (h.yz); |
|
yx = T (h.yx); |
|
zx = T (h.zx); |
|
zy = T (h.zy); |
|
} |
|
|
|
template <class T> |
|
inline const Shear6<T> & |
|
Shear6<T>::operator = (const Shear6 &h) |
|
{ |
|
xy = h.xy; |
|
xz = h.xz; |
|
yz = h.yz; |
|
yx = h.yx; |
|
zx = h.zx; |
|
zy = h.zy; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline const Shear6<T> & |
|
Shear6<T>::operator = (const Vec3<S> &v) |
|
{ |
|
xy = T (v.x); |
|
xz = T (v.y); |
|
yz = T (v.z); |
|
yx = 0; |
|
zx = 0; |
|
zy = 0; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline void |
|
Shear6<T>::setValue (S XY, S XZ, S YZ, S YX, S ZX, S ZY) |
|
{ |
|
xy = T (XY); |
|
xz = T (XZ); |
|
yz = T (YZ); |
|
yx = T (YX); |
|
zx = T (ZX); |
|
zy = T (ZY); |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline void |
|
Shear6<T>::setValue (const Shear6<S> &h) |
|
{ |
|
xy = T (h.xy); |
|
xz = T (h.xz); |
|
yz = T (h.yz); |
|
yx = T (h.yx); |
|
zx = T (h.zx); |
|
zy = T (h.zy); |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline void |
|
Shear6<T>::getValue (S &XY, S &XZ, S &YZ, S &YX, S &ZX, S &ZY) const |
|
{ |
|
XY = S (xy); |
|
XZ = S (xz); |
|
YZ = S (yz); |
|
YX = S (yx); |
|
ZX = S (zx); |
|
ZY = S (zy); |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline void |
|
Shear6<T>::getValue (Shear6<S> &h) const |
|
{ |
|
h.xy = S (xy); |
|
h.xz = S (xz); |
|
h.yz = S (yz); |
|
h.yx = S (yx); |
|
h.zx = S (zx); |
|
h.zy = S (zy); |
|
} |
|
|
|
template <class T> |
|
inline T * |
|
Shear6<T>::getValue() |
|
{ |
|
return (T *) &xy; |
|
} |
|
|
|
template <class T> |
|
inline const T * |
|
Shear6<T>::getValue() const |
|
{ |
|
return (const T *) &xy; |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline bool |
|
Shear6<T>::operator == (const Shear6<S> &h) const |
|
{ |
|
return xy == h.xy && xz == h.xz && yz == h.yz && |
|
yx == h.yx && zx == h.zx && zy == h.zy; |
|
} |
|
|
|
template <class T> |
|
template <class S> |
|
inline bool |
|
Shear6<T>::operator != (const Shear6<S> &h) const |
|
{ |
|
return xy != h.xy || xz != h.xz || yz != h.yz || |
|
yx != h.yx || zx != h.zx || zy != h.zy; |
|
} |
|
|
|
template <class T> |
|
bool |
|
Shear6<T>::equalWithAbsError (const Shear6<T> &h, T e) const |
|
{ |
|
for (int i = 0; i < 6; i++) |
|
if (!Imath::equalWithAbsError ((*this)[i], h[i], e)) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
template <class T> |
|
bool |
|
Shear6<T>::equalWithRelError (const Shear6<T> &h, T e) const |
|
{ |
|
for (int i = 0; i < 6; i++) |
|
if (!Imath::equalWithRelError ((*this)[i], h[i], e)) |
|
return false; |
|
|
|
return true; |
|
} |
|
|
|
|
|
template <class T> |
|
inline const Shear6<T> & |
|
Shear6<T>::operator += (const Shear6 &h) |
|
{ |
|
xy += h.xy; |
|
xz += h.xz; |
|
yz += h.yz; |
|
yx += h.yx; |
|
zx += h.zx; |
|
zy += h.zy; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
inline Shear6<T> |
|
Shear6<T>::operator + (const Shear6 &h) const |
|
{ |
|
return Shear6 (xy + h.xy, xz + h.xz, yz + h.yz, |
|
yx + h.yx, zx + h.zx, zy + h.zy); |
|
} |
|
|
|
template <class T> |
|
inline const Shear6<T> & |
|
Shear6<T>::operator -= (const Shear6 &h) |
|
{ |
|
xy -= h.xy; |
|
xz -= h.xz; |
|
yz -= h.yz; |
|
yx -= h.yx; |
|
zx -= h.zx; |
|
zy -= h.zy; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
inline Shear6<T> |
|
Shear6<T>::operator - (const Shear6 &h) const |
|
{ |
|
return Shear6 (xy - h.xy, xz - h.xz, yz - h.yz, |
|
yx - h.yx, zx - h.zx, zy - h.zy); |
|
} |
|
|
|
template <class T> |
|
inline Shear6<T> |
|
Shear6<T>::operator - () const |
|
{ |
|
return Shear6 (-xy, -xz, -yz, -yx, -zx, -zy); |
|
} |
|
|
|
template <class T> |
|
inline const Shear6<T> & |
|
Shear6<T>::negate () |
|
{ |
|
xy = -xy; |
|
xz = -xz; |
|
yz = -yz; |
|
yx = -yx; |
|
zx = -zx; |
|
zy = -zy; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
inline const Shear6<T> & |
|
Shear6<T>::operator *= (const Shear6 &h) |
|
{ |
|
xy *= h.xy; |
|
xz *= h.xz; |
|
yz *= h.yz; |
|
yx *= h.yx; |
|
zx *= h.zx; |
|
zy *= h.zy; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
inline const Shear6<T> & |
|
Shear6<T>::operator *= (T a) |
|
{ |
|
xy *= a; |
|
xz *= a; |
|
yz *= a; |
|
yx *= a; |
|
zx *= a; |
|
zy *= a; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
inline Shear6<T> |
|
Shear6<T>::operator * (const Shear6 &h) const |
|
{ |
|
return Shear6 (xy * h.xy, xz * h.xz, yz * h.yz, |
|
yx * h.yx, zx * h.zx, zy * h.zy); |
|
} |
|
|
|
template <class T> |
|
inline Shear6<T> |
|
Shear6<T>::operator * (T a) const |
|
{ |
|
return Shear6 (xy * a, xz * a, yz * a, |
|
yx * a, zx * a, zy * a); |
|
} |
|
|
|
template <class T> |
|
inline const Shear6<T> & |
|
Shear6<T>::operator /= (const Shear6 &h) |
|
{ |
|
xy /= h.xy; |
|
xz /= h.xz; |
|
yz /= h.yz; |
|
yx /= h.yx; |
|
zx /= h.zx; |
|
zy /= h.zy; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
inline const Shear6<T> & |
|
Shear6<T>::operator /= (T a) |
|
{ |
|
xy /= a; |
|
xz /= a; |
|
yz /= a; |
|
yx /= a; |
|
zx /= a; |
|
zy /= a; |
|
return *this; |
|
} |
|
|
|
template <class T> |
|
inline Shear6<T> |
|
Shear6<T>::operator / (const Shear6 &h) const |
|
{ |
|
return Shear6 (xy / h.xy, xz / h.xz, yz / h.yz, |
|
yx / h.yx, zx / h.zx, zy / h.zy); |
|
} |
|
|
|
template <class T> |
|
inline Shear6<T> |
|
Shear6<T>::operator / (T a) const |
|
{ |
|
return Shear6 (xy / a, xz / a, yz / a, |
|
yx / a, zx / a, zy / a); |
|
} |
|
|
|
|
|
//----------------------------- |
|
// Stream output implementation |
|
//----------------------------- |
|
|
|
template <class T> |
|
std::ostream & |
|
operator << (std::ostream &s, const Shear6<T> &h) |
|
{ |
|
return s << '(' |
|
<< h.xy << ' ' << h.xz << ' ' << h.yz |
|
<< h.yx << ' ' << h.zx << ' ' << h.zy |
|
<< ')'; |
|
} |
|
|
|
|
|
//----------------------------------------- |
|
// Implementation of reverse multiplication |
|
//----------------------------------------- |
|
|
|
template <class S, class T> |
|
inline Shear6<T> |
|
operator * (S a, const Shear6<T> &h) |
|
{ |
|
return Shear6<T> (a * h.xy, a * h.xz, a * h.yz, |
|
a * h.yx, a * h.zx, a * h.zy); |
|
} |
|
|
|
|
|
} // namespace Imath |
|
|
|
#endif
|
|
|