vlnormal.h

Go to the documentation of this file.

// $Id: vlnormal.h,v 1.4 2002/12/24 19:02:05 sarang Exp $
//
// OpenVL - A Library for working with volumetric datasets.
//          http://openvl.sf.net
//
// Copyright (C) 2000-2002  Sarang Lakare <sarang#users.sf.net>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Library General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library 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
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA.
//
// Please report all bugs and problems to openvl-devel@lists.sf.net or
// at the OpenVL website.
//

#ifndef _vlNormal_h
#define _vlNormal_h

#include <iostream>
#include <math.h>

#include "vlvector.h"

template <class T>
class vlNormal : public vlVector<T>
{
public:
  vlNormal<T>(T const & x = 0, T const & y = 0, T const & z = 0);

  vlNormal<T>(vlTriple<T> const & triple);

  ~vlNormal<T>();

  T x() const { return m_x; }

  T y() const { return m_y; }

  T z() const { return m_z; }

  template <class S>
  void x(const S & value) { m_x = value; normalize(); }

  template <class S>
  void y(const S & value) { m_y = value; normalize(); }

  template <class S>
  void z(const S & value) { m_z = value; normalize(); }

  vlNormal<T> operator - () const;

  vlNormal<T> operator + (vlTriple<T> const & other) const;

  vlNormal<T> operator + (T const & value) const;

  vlNormal<T> operator - (vlTriple<T> const & other) const;

  vlNormal<T> operator - (T const & value) const;

  vlNormal<T> & operator += (vlTriple<T> const & other);

  vlNormal<T> & operator -= (vlTriple<T> const & other);

  void operator *= (T const & value);
  //vlNormal<T> operator *= (T const & value);

  void operator /= (T const & value);
  //vlNormal<T> operator /= (T const & value);

  vlNormal<T> operator * (T const & value) const;

  vlNormal<T> operator / (T const & value) const;

  vlNormal<T> cross(vlVector<T> const & other) const;

  void clamp(T const & min, T const & max);

  void scale(vlVector<T> const & other);
};

// include the inline definitions

template <class T>
vlNormal<T>::vlNormal(T const & x, T const & y, T const & z)
  : vlVector<T>(x, y, z)
{
  // normalize the input
  normalize();
}

template <class T>
vlNormal<T>::vlNormal(vlTriple<T> const & triple)
  : vlVector<T>(triple)
{
  // normalize the input
  normalize();
}

template <class T>
vlNormal<T>::~vlNormal()
{

}

template <class T>
inline vlNormal<T> vlNormal<T>::operator - () const {
  return vlNormal<T>(-m_x, -m_y, -m_z);
}


template <class T>
inline vlNormal<T> vlNormal<T>::operator + (vlTriple<T> const & other) const {
  return vlNormal<T>(m_x+other.m_x, m_y+other.m_y, m_z+other.m_z);
}


template <class T>
inline vlNormal<T> vlNormal<T>::operator + (T const & value) const {
    return vlNormal<T>(m_x+value, m_y+value, m_z+value);
}


template <class T>
inline vlNormal<T> vlNormal<T>::operator - (vlTriple<T> const & other) const {
    return vlNormal<T>(m_x-other.m_x, m_y-other.m_y, m_z-other.m_z);
}


template <class T>
inline vlNormal<T> vlNormal<T>::operator - (T const & value) const {
    return vlNormal<T>(m_x-value, m_y-value, m_z-value);
}
       

template <class T>
inline vlNormal<T> & vlNormal<T>::operator += (vlTriple<T> const & other) {
    m_x+=other.m_x; m_y+=other.m_y; m_z+=other.m_z;
    normalize();
    return *this;
}


template <class T>
inline vlNormal<T> & vlNormal<T>::operator -= (vlTriple<T> const & other) {
    m_x-=other.m_x; m_y-=other.m_y; m_z-=other.m_z;
    normalize();
    return *this;
}


template <class T>
inline void vlNormal<T>::operator *= (T const & value) {
  m_x*=value;
  m_y*=value;
  m_z*=value;
  normalize();
  //return *this;
}


template <class T>
inline void vlNormal<T>::operator /= (T const & value) {
  float factor = (value == static_cast<T>(0)) ? 1.0 : (1.0f/value);
  m_x = static_cast<T>(m_x*factor);
  m_y = static_cast<T>(m_y*factor);
  m_z = static_cast<T>(m_z*factor);
  normalize();
  //return *this;
}


template <>
inline void vlNormal<float>::operator /= (float const & value) {
  float factor = (value == 0.0f) ? 1.0f : 1.0f/value;
  m_x *= factor;
  m_y *= factor;
  m_z *= factor;
  normalize();
}


template <>
inline void vlNormal<double>::operator /= (double const & value) {
  double factor = (value == 0.0f) ? 1.0f : 1.0f/value;
  m_x *= factor;
  m_y *= factor;
  m_z *= factor;
  normalize();
}


template <class T>
inline vlNormal<T> vlNormal<T>::operator * (T const & value) const {
  return vlNormal(m_x*value, m_y*value, m_z*value);
}


template <class T>
inline vlNormal<T> vlNormal<T>::operator / (T const & value) const {
  T factor =
  (constValue == static_cast<T>(0)) ? static_cast<T>(1) : ((static_cast<T>(1))/value);

  return vlNormal(m_x*factor, m_y*factor, m_z*factor);
}


template <class T>
inline vlNormal<T> vlNormal<T>::cross(vlVector<T> const & other) const
{
  return vlNormal<T>((m_y*other.m_z - m_z*other.m_y),
                          (m_z*other.m_x - m_x*other.m_z),
                          (m_x*other.m_y - m_y*other.m_x));
}


template <class T>
inline void vlNormal<T>::clamp(T const & min, T const & max)
{
  // what does clamping mean for a normal?
}


template <class T>
inline void vlNormal<T>::scale(vlVector<T> const & other)
{
  // normal cannot be scaled.. so do nothing
}


typedef vlNormal<float> vlNormal3f;

typedef vlNormal<double> vlNormal3d;

#endif // _vlNormal_h

---