Search  

---

C:/temp/src/j2k/Beta/3D/Vector3D.cpp

Go to the documentation of this file.

// Implementation: Vector 3D class 

#ifndef __J2K__Vector3D_CPP__
#define __J2K__Vector3D_CPP__

#include <j2k/Fred/3d/Vector3D.hpp>

#include <math.h>

// Assignment
inline const Vector3DH& Vector3DH::operator=( const Vector3DH& v ) {
  a = v.a;
  b = v.b;
  return *this;
}

// Angle vertical theta du vecteur ( par rapport au plans xoy ).
inline realtype Vector3DH::angle_ver() {
  realtype n = norme();
  if ( n == 0 ) return 0;
  return (realtype)asin( compoz() / n );
}

// cos et sin de l'angle vertical theta du vecteur.
void Vector3DH::cos_sinangle_ver ( realtype& cos_Theta, realtype& sin_Theta )
{
 realtype n   = norme(),
          dx  = compox(),
          dy  = compoy(),
          nxy = (realtype) sqrt( dy*dy + dx*dx );

  if ( n == 0 ) {
    cos_Theta = sin_Theta = 0;

  } else {
   cos_Theta = nxy / n;
   sin_Theta = compoz() / n;

  }
}

// cos de l'angle vertical theta du vecteur.
realtype Vector3DH::cosangle_ver() {
  realtype n   = norme(),
           dx  = compox(),
           dy  = compoy(),
           nxy = (realtype)sqrt( dy*dy + dx*dx );

  return ( (n == 0) ? 0 : (nxy / n) );
}

// sin de l'angle vertical theta du vecteur.
inline realtype Vector3DH::sinangle_ver() {
  realtype n = norme();
  return ( (n == 0) ? 0 : (compoz() / n) );
}

// Angle horizontal du vecteur ( sur le plans xoy à partir de l'axe ox dans
// le sens trigonometrique pour un repère direct ).
realtype Vector3DH::angle_hor() {
  return (realtype)atan2( compoy(), compox() );
}

// cos et sin de l'angle horizontal phi du vecteur.
// Nb - le cas particulier où la vecteur est vertical rend la projection sur
//      le plans XOY égale à un point.  Dans ce cas,  il n'y à pas de calcul
//      d'angle possible. On suppose donc phi=0;

void Vector3DH::cos_sinangle_hor( realtype& cos_Phi, realtype& sin_Phi )
{
  realtype n   = norme(),
           dx  = compox(),
           dy  = compoy(),
           nxy = (realtype)sqrt( dy*dy + dx*dx );

  if ( n == 0 ) {
    cos_Phi = sin_Phi = 0;
    return;
  }

  if ( nxy == 0 ) {
    cos_Phi = 1;
    sin_Phi = 0;
    return;
  }

  cos_Phi = dx / nxy;
  sin_Phi = dy / nxy;
}

// cos de l'angle horizontal phi du vecteur.
realtype Vector3DH::cosangle_hor() {
  realtype n   = norme(),
           dx  = compox(),
           dy  = compoy(),
           nxy = (realtype)sqrt( dy*dy + dx*dx );

  if ( n == 0 ) return 0;

  if ( nxy == 0 ) return 1;

  return dx / nxy;
}

// sin de l'angle horizontal phi du vecteur.
realtype Vector3DH::sinangle_hor() {
  realtype n   = norme(),
           dx  = compox(),
           dy  = compoy(),
           nxy = (realtype)sqrt( dy*dy + dx*dx );

  if ( n == 0  ||  nxy == 0 ) return 0;

  return dy / nxy;
}

//Norme du vecteur.
realtype Vector3DH::norme() {
  realtype dx = compox(),
           dy = compoy(),
           dz = compoz();

  return (realtype) sqrt( dx*dx + dy*dy + dz*dz );
}

// Composante X du vecteur.
inline realtype Vector3DH::compox() {
  return ( b.x - a.x );
}

// Composante Y du vecteur.
inline realtype Vector3DH::compoy() {
  return ( b.y - a.y );
}

// Composante Z du vecteur.
inline realtype Vector3DH::compoz() {
  return ( b.z - a.z );
}

// normalisation du vecteur.
void Vector3DH::normalisation() {
  realtype n  = norme(),
           dx = compox() / n,
           dy = compoy() / n,
           dz = compoz() / n;

  b.x = a.x + dx;
  b.y = a.y + dy;
  b.z = a.z + dz;
}

// produit scalaire du vecteur par un autre vecteur.
realtype Vector3DH::produit_scalaire( const Vector3DH& v ) {
  realtype tmp = compox() * v.compox() +
                 compoy() * v.compoy() +
                 compoz() * v.compoz();
  return tmp;
}

// produit vectoriel du vecteur par un autre vecteur.
// Application à l'obtention du vecteur normal 1.
void Vector3DH::vecteur_normal( const Vector3DH& v, Sommet3DH& result ) {
  realtype adx = compox(),
           ady = compoy(),
           adz = compoz(),
           bdx = v.compox(),
           bdy = v.compoy(),
           bdz = v.compoz();

  result.x = ady * bdz - adz* bdy;
  result.y = adz * bdx - adx* bdz;
  result.z = adx * bdy - ady* bdx;
}

// produit vectoriel du vecteur par un autre vecteur.
// Application à l'obtention du vecteur normal 2.
inline void Vector3DH::vecteur_normal( const Vector3DH& v, Vector3DH& result )
{
  result.a = a;
  vecteur_normal(v, result.b);
}

istream& operator>>( istream& in, const Vector3DH& v ) {
  return in  >> (Sommet3D&)v.a >> (Sommet3D&)v.b;
}

ostream& operator<<( ostream& out, const Vector3DH& v ) {
  return out << (Sommet3D&)v.a << (Sommet3D&)v.b;
}

#endif

---