MC_v3d.hpp

Go to the documentation of this file.

/*
**    Mesh Converter
**    Copyright (C) 2009 Damien Rohmer
**
**    This program is free software: you can redistribute it and/or modify
**    it under the terms of the GNU 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 General Public License for more details.
**
**    You should have received a copy of the GNU General Public License
**    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/



#ifndef MC_V3D_HPP
#define MC_V3D_HPP

#include <iostream>
#include <cmath>





namespace mesh_conv
{
    class MC_double_vector;
    class MC_v3d_vector;
    class MC_matrix;
    class MC_quaternion;
    class MC_segment;


class MC_v3d
{
public:

    //*********************************************//
    //*********************************************//
    // CONSTRUCTORS
    //*********************************************//
    //*********************************************//

    MC_v3d();
    MC_v3d(const double& x,const double& y,const double& z);
    MC_v3d(const MC_v3d& _v);
    MC_v3d(const double* _v);
    MC_v3d(const std::string& s);

    MC_v3d(const MC_matrix& M);

    MC_v3d(const MC_v3d_vector& vec);

    MC_v3d(const MC_double_vector& vec);

    ~MC_v3d();


    // ********************************************* //
    // ********************************************* //
    //  Math Operator
    // ********************************************* //
    // ********************************************* //

    void set_zero();


    //*********************************************//
    //*********************************************//
    // Equality
    //*********************************************//
    //*********************************************//

    MC_v3d& operator=(const MC_matrix& M);

    //*********************************************//
    //*********************************************//
    // Math Operator
    //*********************************************//
    //*********************************************//

    MC_v3d operator-() const;

    friend MC_v3d operator+(const MC_v3d& vec,const double& to_add);
    friend MC_v3d operator-(const MC_v3d& vec,const double& to_sub);
    friend MC_v3d operator*(const MC_v3d& vec,const double& to_mult);
    friend MC_v3d operator*(const double& to_mult,const MC_v3d& vec);
    friend MC_v3d operator/(const MC_v3d& vec,const double& to_subdiv);


    friend MC_v3d operator+(const MC_v3d& vec,const MC_v3d& to_add);
    friend MC_v3d operator-(const MC_v3d& vec,const MC_v3d& to_sub);


    MC_v3d& operator+=(const double& to_add);
    MC_v3d& operator-=(const double& to_sub);
    MC_v3d& operator*=(const double& to_mult);
    MC_v3d& operator/=(const double& to_subdiv);

    MC_v3d& operator+=(const MC_v3d& to_add);
    MC_v3d& operator-=(const MC_v3d& to_sub);

    MC_v3d& scale(const double& sx,const double& sy,const double& sz);
    MC_v3d& scale(const MC_v3d& scaling);
    MC_v3d& scale(const double& scaling);

    MC_v3d scaled(const MC_v3d& scaling) const;
    MC_v3d scaled(const double& scaling) const;


    MC_v3d mask(const double& sx,const double& sy,const double& sz) const;
    MC_v3d mask(const MC_v3d& scaling) const;
    MC_v3d scale(const double& scaling) const;

    double dot(const MC_v3d& vec) const;
    MC_v3d cross(const MC_v3d& vec) const;
    double norm() const;
    MC_v3d normalized() const;


    MC_v3d& operator*=(const MC_matrix& M);

    friend MC_v3d operator*(const MC_quaternion& q,const MC_v3d& vec);
    MC_v3d& operator*=(const MC_quaternion& q);


    friend bool operator==(const MC_v3d& a1,const MC_v3d& a2);
    friend bool operator!=(const MC_v3d& a1,const MC_v3d& a2);


    static double area(const MC_v3d& v0,const MC_v3d& v1);

    static double cotan(const MC_v3d& u0,const MC_v3d& u1);

    static double angle(const MC_v3d& u0,const MC_v3d& u1);

    MC_v3d project_on_plane(const MC_v3d& normal) const;

    MC_v3d project_on_line(const MC_v3d& dir) const;
    MC_v3d project_on_line(const MC_segment& seg) const;

    //*********************************************//
    //*********************************************//
    // Operator with gradient
    //*********************************************//
    //*********************************************//

    std::pair <MC_v3d,MC_v3d_vector> normalized_with_gradient() const;


    //*********************************************//
    //*********************************************//
    // GET
    //*********************************************//
    //*********************************************//

    const double& operator()(const int& k_dim) const;
    double& operator()(const int& k_dim);
    const double& operator[](const int& k_dim) const;
    double& operator[](const int& k_dim);

    const double* pointer() const;
    double* pointer_unprotected();

    //*********************************************//
    //*********************************************//
    // OUTPUT
    //*********************************************//
    //*********************************************//

    friend std::ostream& operator<<(std::ostream& stream,const MC_v3d& v);

    std::string to_string() const;

    friend bool operator>>(std::istream& stream,MC_v3d& v);

private:

    double v[3];
};


class MC_v3d_less
{
 public:
  bool operator ()(const MC_v3d& v0,const MC_v3d& v1) const
  {

    double epsilon=1e-5;
    if( std::fabs(v0[0]-v1[0])<epsilon && std::fabs(v0[1]-v1[1])<epsilon && std::fabs(v0[2]-v1[2])<epsilon )
      return false;


    if(v0[0]+epsilon<v1[0])
      return true;
    else if ( !(v1[0]+epsilon<v0[0]) && v0[1]+epsilon<v1[1] )
      return true;
    else if ( !(v1[0]+epsilon<v0[0]) && !(v1[1]+epsilon<v0[1]) && v0[2]+epsilon<v1[2] )
      return true;


    return false;
  }
};

}

#endif // MC_V3D_HPP