vertex.icc

Go to the documentation of this file.

/*
 * lib-gmapkernel : Un noyau de 3-G-cartes et des opérations.
 * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
 *               http://www.sic.sp2mi.univ-poitiers.fr/
 * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
 *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
 *
 * This file is part of lib-gmapkernel
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

//******************************************************************************
#include <cassert>
#include <cmath>
//******************************************************************************
INLINE
CVertex::CVertex()
{
  setXYZ(0,0,0);
}
//******************************************************************************
INLINE
CVertex::CVertex(TCoordinate Ax, TCoordinate Ay, TCoordinate Az)
{
  setXYZ(Ax,Ay,Az);
}
//******************************************************************************
INLINE
CVertex::CVertex(TCoordinate ATab[3])
{
  setXYZ(ATab[0],ATab[1],ATab[2]);
}
//******************************************************************************
INLINE
CVertex::CVertex(const CVertex& AVector)
{
  setXYZ(AVector.getX(), AVector.getY(), AVector.getZ());
}
//******************************************************************************
INLINE
TCoordinate CVertex::getX() const
{
  return FCoord[0];
}
//******************************************************************************
INLINE
TCoordinate CVertex::getY() const
{
  return FCoord[1];
}
//******************************************************************************
INLINE
TCoordinate CVertex::getZ() const
{
  return FCoord[2];
}
//******************************************************************************
INLINE
TCoordinate CVertex::getCoord(int ADim) const
{
  assert(0<=ADim && ADim<=2);
  return FCoord[ADim];
}
//******************************************************************************
INLINE
void CVertex::setX(TCoordinate ANewX)
{
  FCoord[0] = ANewX;
}
//******************************************************************************
INLINE
void CVertex::setY(TCoordinate ANewY)
{
  FCoord[1] = ANewY;
}
//******************************************************************************
INLINE
void CVertex::setZ(TCoordinate ANewZ)
{
  FCoord[2] = ANewZ;
}
//******************************************************************************
INLINE
void CVertex::setCoord(int ADim, TCoordinate ANewCoord)
{
  assert(0<=ADim && ADim<=2);
  FCoord[ADim] = ANewCoord;
}
//******************************************************************************
INLINE
void CVertex::setXYZ(TCoordinate ANewX, TCoordinate ANewY, TCoordinate ANewZ)
{
  setX(ANewX);
  setY(ANewY);
  setZ(ANewZ);
}
//******************************************************************************
INLINE
CVertex& CVertex::operator=(const CVertex& AVector)
{
  setXYZ(AVector.getX(), AVector.getY(), AVector.getZ());
  return *this;
}
//******************************************************************************
INLINE
bool CVertex::operator==(const CVertex& AVector) const
{
  return
    isZero(this->getX() - AVector.getX()) &&
    isZero(this->getY() - AVector.getY()) &&
    isZero(this->getZ() - AVector.getZ());
}
//******************************************************************************
INLINE
bool CVertex::operator!=(const CVertex& AVector) const
{
  return ! (*this == AVector);
}
//******************************************************************************
INLINE
CVertex& CVertex::operator+=(const CVertex& AVector)
{
  *this= *this + AVector;
  return *this;
}
//******************************************************************************
INLINE
CVertex& CVertex::operator-=(const CVertex& AVector)
{
  return *this= *this - AVector;
}
//******************************************************************************
INLINE
CVertex CVertex::operator*(TCoordinate ACoef) const
{
  return CVertex(getX()*ACoef, getY()*ACoef, getZ()*ACoef);
}
//******************************************************************************
INLINE
CVertex CVertex::operator/(TCoordinate ACoef) const
{
  assert(!isZero(ACoef));
  return CVertex(getX()/ACoef, getY()/ACoef, getZ()/ACoef);
}
//******************************************************************************
INLINE
CVertex& CVertex::operator*=(TCoordinate ACoef)
{
  return *this = *this * ACoef;
}
//******************************************************************************
INLINE
CVertex& CVertex::operator/=(TCoordinate ACoef)
{
  return *this = *this / ACoef;
}
//******************************************************************************
INLINE
CVertex CVertex::operator+(const CVertex& AVector) const
{
  return CVertex(getX() + AVector.getX(),
         getY() + AVector.getY(),
         getZ() + AVector.getZ());
}
//******************************************************************************
INLINE
CVertex CVertex::operator-(const CVertex& AVector) const
{
  return CVertex(getX() - AVector.getX(),
         getY() - AVector.getY(),
         getZ() - AVector.getZ());
}
//******************************************************************************
INLINE
CVertex CVertex::operator+() const
{
  return *this;
}
//******************************************************************************
INLINE
CVertex CVertex::operator-() const
{
  return CVertex(-getX(),-getY(),-getZ());
}
//******************************************************************************
INLINE
CVertex CVertex::operator*(const CVertex& AVector) const
{
  return CVertex(getY()*AVector.getZ() - AVector.getY()*getZ(),
         getZ()*AVector.getX() - AVector.getZ()*getX(),
         getX()*AVector.getY() - AVector.getX()*getY());
}
//******************************************************************************
INLINE
CVertex CVertex::multiply(const CVertex& AVector) const
{
  return CVertex(getX()*AVector.getX(),
         getY()*AVector.getY(),
         getZ()*AVector.getZ());
}
//******************************************************************************
INLINE
CVertex CVertex::divide(const CVertex& AVector) const
{
  assert(!isZero(AVector.getX()));
  assert(!isZero(AVector.getY()));
  assert(!isZero(AVector.getZ()));

  return CVertex(getX()/AVector.getX(),
         getY()/AVector.getY(),
         getZ()/AVector.getZ());
}
//******************************************************************************
INLINE
TCoordinate CVertex::dot(const CVertex& AVector) const
{
  return
    getX()*AVector.getX() +
    getY()*AVector.getY() +
    getZ()*AVector.getZ();
}
//******************************************************************************
INLINE
bool CVertex::isNull() const
{
  return
    isZero(getX()) &&
    isZero(getY()) &&
    isZero(getZ());
}
//******************************************************************************
INLINE
TCoordinate CVertex::norm() const
{
  return sqrt(sqrNorm());
}
//******************************************************************************
INLINE
TCoordinate CVertex::normalize()
{
  TCoordinate n = norm();
  if (! isNull()) *this /= n;
  return n;
}
//******************************************************************************
INLINE
CVertex CVertex::normalized() const
{
  CVertex result(*this);
  result.normalize();
  return result;
}
//******************************************************************************
INLINE
TCoordinate CVertex::sqrNorm() const
{
  return sqr(getX()) + sqr(getY()) + sqr(getZ());
}
//******************************************************************************
INLINE
CVertex operator*(TCoordinate ACoef, const CVertex& AVertex)
{
  return AVertex*ACoef;
}
//******************************************************************************
INLINE
std::ostream& operator<<(std::ostream& AStream, const CVertex& AVertex)
{
  AStream << "(";
  AStream << "x="; AStream << AVertex.getX() << "\t";
  // AStream.form("% .5f", AVertex.getX());
  AStream << ",";
  AStream << "y="; AStream << AVertex.getY() << "\t";
  // AStream.form("% .5f", AVertex.getY());
  AStream << ",";
  AStream << "z="; AStream << AVertex.getZ() << "\t";
  // AStream.form("% .5f", AVertex.getZ());
  AStream << ")";

  return AStream;
}
//******************************************************************************