Search  

---

C:/temp/src/j2k/Deprecated/old_18mar_diff/Vector/Vector3D.cpp

Go to the documentation of this file.

#ifndef __J2K__JVector3D_CPP__
#define __J2K__JVector3D_CPP__

#include <j2k/Fred/Math/Vector/Vector3D.hpp>

void JVector3D::Mix( const JVector3D& v ) {  // ??????
  X *= v.Y;
  X *= v.Z;
  Y *= v.Z;
}

JVector3D::JVector3D()
  : X(0.0), Y(0.0), Z(0.0) { }

JVector3D::JVector3D( const double x, const double y, const double z )
  : X( x ), Y( y ), Z( z ) { }

JVector3D::JVector3D( const JVector3D& v )
  : X( v.X ), Y( v.Y ), Z( v.Z ) { }

BOOL JVector3D::Compare( const JVector3D& v ) const {
  if (v.X != X)  return FALSE;
  if (v.Y != Y)  return FALSE;
  if (v.Z != Z)  return FALSE;

  return TRUE;
}

inline BOOL JVector3D::operator==( const JVector3D& v ) const {
  return Compare( v );
}

inline BOOL JVector3D::operator!=( const JVector3D& v ) const {
  return !Compare( v );
}

JVector3D operator+( const JVector3D& v1, const JVector3D& v2 ) {
  return JVector3D( v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z );
}

JVector3D operator-( const JVector3D& v1, const JVector3D& v2 ) {
  return JVector3D( v1.X - v2.X, v1.Y - v2.Y, v1.Z - v2.Z );
}

JVector3D operator*( const JVector3D& v1, const JVector3D& v2 ) {
  return JVector3D( v1.X * v2.X, v1.Y * v2.Y, v1.Z * v2.Z );
}

JVector3D operator/( const JVector3D& v1, const JVector3D& v2 ) {
  return JVector3D( v1.X / v2.X, v1.Y / v2.Y, v1.Z / v2.Z );
}

JVector3D operator+( const JVector3D& v, const double r ) {
  return JVector3D( v.X + r, v.Y + r, v.Z + r );
}

JVector3D operator-( const JVector3D& v, const double r ) {
  return JVector3D( v.X - r, v.Y - r, v.Z - r );
}

JVector3D operator*( const JVector3D& v, const double r ) {
  return JVector3D( v.X * r, v.Y * r, v.Z * r );
}

JVector3D operator/( const JVector3D& v, const double r ) {
  return JVector3D( v.X / r, v.Y / r, v.Z / r );
}

void JVector3D::operator+=( const JVector3D& v ) {
  X += v.X;
  Y += v.Y;
  Z += v.Z;
}

void JVector3D::operator-=( const JVector3D& v ) {
  X -= v.X;
  Y -= v.Y;
  Z -= v.Z;
}

void JVector3D::operator*=( const JVector3D& v ) {
  X *= v.X;
  Y *= v.Y;
  Z *= v.Z;
}

void JVector3D::operator/=( const JVector3D& v ) {
  X /= v.X;
  Y /= v.Y;
  Z /= v.Z;
}

void JVector3D::operator+=( const double r ) {
  X += r;
  Y += r;
  Z += r;
}

void JVector3D::operator-=( const double r ) {
  X -= r;
  Y -= r;
  Z -= r;
}

void JVector3D::operator*=( const double r ) {
  X *= r;
  Y *= r;
  Z *= r;
}

void JVector3D::operator/=( const double r ) {
 if ( r == 0 ) return;
  X /= r;
  Y /= r;
  Z /= r;
}

inline void JVector3D::Abs() {
  X = abs(X);
  Y = abs(Y);
  Z = abs(Z);
}

inline BOOL JVector3D::bAtOrg() const {
  return ( (X == 0.0) && (Y == 0.0) && (Z == 0.0) );
}

BOOL JVector3D::bWithinLimits( const double r ) const {
  return !( (X >  r) || (Y >  r) || (Z >  r)
         || (X < -r) || (Y < -r) || (Z < -r) );
}

inline double JVector3D::Dot( const JVector3D& v ) const {
  return (X * v.X) + (Y * v.Y) + (Z * v.Z);
}

inline double JVector3D::Magnitude() const {
  return sqrt( (X * X) + (Y * Y) + (Z * Z) );
}

void JVector3D::ClipToDegrees() {
  if (X > 360.0) 
    X = mod(X, 360.0);

  if (Y > 360.0)
    Y = mod(Y, 360.0);

  if (Z > 360.0)
    Z = mod(Z, 360.0);
}

void JVector3D::Normalize() {
  double Mag = Magnitude();

  if ( Mag != 0 ) {
    X /= Mag;
    Y /= Mag;
    Z /= Mag;
  }
}

void JVector3D::ToRadians()
{
  if (abs(X) > 360.0)
    X = mod(X, 360.0);

  if (abs(Y) > 360.0)
    Y = mod(Y, 360.0);

  if (abs(Z) > 360.0)
    Z = mod(Z, 360.0);

  X *= MATH_PI / 180.0;
  Y *= MATH_PI / 180.0;
  Z *= MATH_PI / 180.0;
}


void JVector3D::Cross( const JVector3D& v ) {
  const double xTmp = (Y * v.Z) - (Z * v.Y);
  const double yTmp = (Z * v.X) - (X * v.Z);
  const double zTmp = (X * v.Y) - (Y * v.X);
  X = xTmp;
  Y = yTmp;
  Z = zTmp;
}

void JVector3D::HalfBetween( const JVector3D& v ) {
  X = 0.5 * (X + v.X);
  Y = 0.5 * (Y + v.Y);
  Z = 0.5 * (Z + v.Z);
}

JVector3D vecCross( const JVector3D& v1, const JVector3D& v2 ) {
  return JVector3D( (v1.Y * v2.Z) - (v1.Z * v2.Y),
                   (v1.Z * v2.X) - (v1.X * v2.Z),
                   (v1.X * v2.Y) - (v1.Y * v2.X)
  );
}

inline JVector3D& JVector3D::operator=( const JVector3D& v ) {
  X = v.X;
  Y = v.Y:
  Z = v.Z;
  return *this;
}

inline void JVector3D::AddScaled( const JVector3D& v, const double Scale ) {
  X += v.X * Scale; 
  Y += v.Y * Scale; 
  Z += v.Z * Scale; 
}

inline void JVector3D::Adjust( const double x, const double y, const double z )
{
  X += x;
  Y += y;
  Z += z;
}

inline double JVector3D::X() const {
  return X;
}

inline double JVector3D::X( const double x ) {
  X = x;
  return X;
}

inline double JVector3D::Y() const {
  return Y;
}

inline double JVector3D::Y( const double y ) {
  Y = y;
  return Y;
}
inline double JVector3D::Z() const {
  return Z;
}

inline double JVector3D::Z( const double z ) {
  Z = z;
  return Z;
}

inline double JVector3D::MagSum() const {
  return (X + Y + Z);
}

inline void JVector3D::Negate() {
  X *= -1;
  Y *= -1;
  Z *= -1;
}

inline void JVector3D::Set( const double x, const double y, const double z ) {
  X = x;
  Y = y;
  Z = z;
}

inline void JVector3D::Square() {
  X *= X;
  Y *= Y;
  Z *= Z;
}

inline JVector3D vecHalfBetween( const JVector3D& v1, const JVector3D& v2 ) {
  return JVector3D(  0.5 * (v1.X + v2.X),
                    0.5 * (v1.Y + v2.Y),
                    0.5 * (v1.Z + v2.Z)
  );
}

inline JVector3D vecMix( const JVector3D& v1, const JVector3D& v2 ) {
  return JVector3D(  v1.X * v2.Y, v1.X * v2.Z, v1.Y * v2.Z );
}

// ---------------------------------------------------------------------------
//  Typedef the vector to T3DPoint so that it can be more self documenting
//  when used as a point in a 3D floating point space.
// ---------------------------------------------------------------------------
typedef JVector3D   T3DPoint;

#endif

---