/****************************************************************************

   Copyright (C) 2002-2008 Gilles Debunne. All rights reserved.

   This file is part of the QGLViewer library version 2.3.6.

   http://www.libqglviewer.com - contact@libqglviewer.com

   This file may be used under the terms of the GNU General Public License
   versions 2.0 or 3.0 as published by the Free Software Foundation and
   appearing in the LICENSE file included in the packaging of this file.
   In addition, as a special exception, Gilles Debunne gives you certain
   additional rights, described in the file GPL_EXCEPTION in this package.

   libQGLViewer uses dual licensing. Commercial/proprietary software must
   purchase a libQGLViewer Commercial License.

   This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
   WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 *****************************************************************************/

#include "domUtils.h"
#include "vec.h"
#include "math.h"

// Most of the methods are declared inline in vec.h

using namespace qglviewer;
using namespace std;

#ifdef _MSC_VER
#  include <float.h>
#  define isfinite _finite
#endif

/*! Projects the Vec on the axis of direction \p direction that passes through the origin.

   \p direction does not need to be normalized (but must be non null). */
void Vec::projectOnAxis(const Vec& direction)
{
#ifndef QT_NO_DEBUG
  if(direction.squaredNorm() < 1.0E-10)
    qWarning("Vec::projectOnAxis: axis direction is not normalized (norm=%f).", direction.norm());
#endif

  *this = (((*this) * direction) / direction.squaredNorm()) * direction;
}

/*! Projects the Vec on the plane whose normal is \p normal that passes through the origin.

   \p normal does not need to be normalized (but must be non null). */
void Vec::projectOnPlane(const Vec& normal)
{
#ifndef QT_NO_DEBUG
  if(normal.squaredNorm() < 1.0E-10)
    qWarning("Vec::projectOnPlane: plane normal is not normalized (norm=%f).", normal.norm());
#endif

  *this -= (((*this) * normal) / normal.squaredNorm()) * normal;
}

/*! Returns a Vec orthogonal to the Vec. Its norm() depends on the Vec, but is zero only for a
   null Vec. Note that the function that associates an orthogonalVec() to a Vec is not continous. */
Vec Vec::orthogonalVec() const
{
  // Find smallest component. Keep equal case for null values.
  if((fabs(y) >= 0.9 * fabs(x)) && (fabs(z) >= 0.9 * fabs(x)))
    return Vec(0.0, -z, y);
  else if((fabs(x) >= 0.9 * fabs(y)) && (fabs(z) >= 0.9 * fabs(y)))
    return Vec(-z, 0.0, x);
  else
    return Vec(-y, x, 0.0);
}

/*! Constructs a Vec from a \c QDomElement representing an XML code of the form
   \code< anyTagName x=".." y=".." z=".." />\endcode

   If one of these attributes is missing or is not a number, a warning is displayed and the associated
   value is set to 0.0.

   See also domElement() and initFromDOMElement(). */
Vec::Vec(const QDomElement& element)
{
  QStringList attribute;
  attribute << "x"
            << "y"
            << "z";
#if QT_VERSION >= 0x040000
  for(int i = 0; i < attribute.size(); ++i) {
#else
  for(unsigned int i = 0; i < attribute.count(); ++i) {
#endif
#ifdef QGLVIEWER_UNION_NOT_SUPPORTED
    this->operator[](i) = DomUtils::floatFromDom(element, attribute[i], 0.0);
    if(!isfinite(this->operator[](i)))
      this->operator[](i) = 0;
#else
    v_[i] = DomUtils::floatFromDom(element, attribute[i], 0.0);
    if(!isfinite(v_[i]))
      v_[i] = 0;
#endif
  }
}

/*! Returns an XML \c QDomElement that represents the Vec.

   \p name is the name of the QDomElement tag. \p doc is the \c QDomDocument factory used to create
   QDomElement.

   When output to a file, the resulting QDomElement will look like:
   \code
   <name x=".." y=".." z=".." />
   \endcode

   Use initFromDOMElement() to restore the Vec state from the resulting \c QDomElement. See also the
   Vec(const QDomElement&) constructor.

   Here is complete example that creates a QDomDocument and saves it into a file:
   \code
   Vec sunPos;
   QDomDocument document("myDocument");
   QDomElement sunElement = document.createElement("Sun");
   document.appendChild(sunElement);
   sunElement.setAttribute("brightness", sunBrightness());
   sunElement.appendChild(sunPos.domElement("sunPosition", document));
   // Other additions to the document hierarchy...

   // Save doc document
   QFile f("myFile.xml");
   if (f.open(IO_WriteOnly))
   {
   QTextStream out(&f);
   document.save(out, 2);
   f.close();
   }
   \endcode

   See also Quaternion::domElement(), Frame::domElement(), Camera::domElement()... */
QDomElement Vec::domElement(const QString& name, QDomDocument& document) const
{
  QDomElement de = document.createElement(name);
  de.setAttribute("x", QString::number(x));
  de.setAttribute("y", QString::number(y));
  de.setAttribute("z", QString::number(z));
  return de;
}

/*! Restores the Vec state from a \c QDomElement created by domElement().

   The \c QDomElement should contain \c x, \c y and \c z attributes. If one of these attributes is
   missing or is not a number, a warning is displayed and the associated value is set to 0.0.

   To restore the Vec state from an xml file, use:
   \code
   // Load DOM from file
   QDomDocument doc;
   QFile f("myFile.xml");
   if (f.open(IO_ReadOnly))
   {
   doc.setContent(&f);
   f.close();
   }
   // Parse the DOM tree and initialize
   QDomElement main=doc.documentElement();
   myVec.initFromDOMElement(main);
   \endcode

   See also the Vec(const QDomElement&) constructor. */
void Vec::initFromDOMElement(const QDomElement& element)
{
  const Vec v(element);
  *this = v;
}

ostream& operator<<(ostream& o, const Vec& v) {
  return o << v.x << '\t' << v.y << '\t' << v.z;
}
