Vec.h

Go to the documentation of this file.

//
// Copyright(C) 2013-2016  OpenCascade [www.opencascade.org]
//
// This library 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 2.1 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street,
// Fifth Floor, Boston, MA  02110 - 1301  USA
//

#pragma once

#pragma warning(push)
#pragma warning(disable : 4251)

#include <Geom/XYZ.h>
#include <QString>

namespace Geom
{
class Ax1;
class Ax2;
class Trsf;
class Dir;
class Pnt;
class Vec;

}  // namespace Geom

namespace Geom
{
class LX_GEOM_EXPORT Vec
{
public:
    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //

    // Methods PUBLIC
    //
    Vec();
    Vec(const Geom::Dir& V);
    Vec(const Geom::XYZ& Coord);
    Vec(const double Xv, const double Yv, const double Zv);

    Vec(const Geom::Pnt& P1, const Geom::Pnt& P2);

    Vec(const Vec& rhs);

    void setCoord(const int Index, const double Xi);
    void setCoord(const double Xv, const double Yv, const double Zv);
    void setX(const double X);
    void setY(const double Y);
    void setZ(const double Z);
    void setXYZ(const Geom::XYZ& Coord);

    double coord(const int Index) const;
    void coord(double& Xv, double& Yv, double& Zv) const;
    double x() const;
    double y() const;
    double z() const;
    const Geom::XYZ& xyz() const;

    float fx() const;
    float fy() const;
    float fz() const;


    bool isEqual(const Vec& Other, const double LinearTolerance, const double AngularTolerance) const;

    bool isNormal(const Vec& Other, const double AngularTolerance) const;

    bool isOpposite(const Vec& Other, const double AngularTolerance) const;

    bool isParallel(const Vec& Other, const double AngularTolerance) const;

    double angle(const Vec& Other) const;
    double angleWithRef(const Vec& Other, const Vec& VRef) const;
    double magnitude() const;
    double squareMagnitude() const;

    void add(const Vec& Other);
    void operator+=(const Vec& Other) { add(Other); }

    Vec added(const Vec& Other) const;
    Vec operator+(const Vec& Other) const { return added(Other); }


    void subtract(const Vec& Right);
    void operator-=(const Vec& Right) { subtract(Right); }

    Vec subtracted(const Vec& Right) const;
    Vec operator-(const Vec& Right) const { return subtracted(Right); }


    void multiply(const double Scalar);
    void operator*=(const double Scalar) { multiply(Scalar); }

    Vec multiplied(const double Scalar) const;
    Vec operator*(const double Scalar) const { return multiplied(Scalar); }


    void divide(const double Scalar);
    void operator/=(const double Scalar) { divide(Scalar); }

    Vec divided(const double Scalar) const;
    Vec operator/(const double Scalar) const { return divided(Scalar); }


    void cross(const Vec& Right);
    void operator^=(const Vec& Right) { cross(Right); }

    Vec crossed(const Vec& Right) const;
    Vec operator^(const Vec& Right) const { return crossed(Right); }


    double crossMagnitude(const Vec& Right) const;

    double crossSquareMagnitude(const Vec& Right) const;

    void crossCross(const Vec& V1, const Vec& V2);
    Vec crossCrossed(const Vec& V1, const Vec& V2) const;
    double dot(const Vec& Other) const;
    double operator*(const Vec& Other) const { return dot(Other); }

    double dotCross(const Vec& V1, const Vec& V2) const;

    void normalize();
    Vec normalized() const;

    void reverse();
    Vec reversed() const;
    Vec operator-() const { return reversed(); }
    Vec operator &  (const Vec& rcVct) const;


    void setLinearForm(const double A1, const Vec& V1, const double A2, const Vec& V2, const double A3, const Vec& V3, const Vec& V4);

    void setLinearForm(const double A1, const Vec& V1, const double A2, const Vec& V2, const double A3, const Vec& V3);

    void setLinearForm(const double A1, const Vec& V1, const double A2, const Vec& V2, const Vec& V3);

    void setLinearForm(const double A1, const Vec& V1, const double A2, const Vec& V2);

    void setLinearForm(const double A1, const Vec& V1, const Vec& V2);

    void setLinearForm(const Vec& V1, const Vec& V2);


    void mirror(const Vec& V);


    Vec mirrored(const Vec& V) const;


    void mirror(const Geom::Ax1& A1);


    Vec mirrored(const Geom::Ax1& A1) const;


    void mirror(const Geom::Ax2& A2);


    Vec mirrored(const Geom::Ax2& A2) const;

    void rotate(const Geom::Ax1& A1, const double Ang);

    Vec rotated(const Geom::Ax1& A1, const double Ang) const;

    void scale(const double S);
    Vec scaled(const double S) const;


    void transform(const Geom::Trsf& T);
    Vec transformed(const Geom::Trsf& T) const;

    Geom::Vec& projectToLine(const Geom::Vec& rclPoint, const Geom::Vec& rclLine);

    Geom::Vec perpendicular(const Geom::Vec& rclBase, const Geom::Vec& rclDir) const;

    double distanceToPlane(const Geom::Vec& rclBase, const Geom::Vec& rclNorm) const;
    double distanceToLine(const Geom::Vec& rclBase, const Geom::Vec& rclDirect) const;
    Geom::Vec distanceToLineSegment(const Geom::Vec& rclP1, const Geom::Vec& rclP2) const;

    //                                                       //
    // ---------------------- END API ---------------------- //
    //                                                       //

    double& operator[](int i);

private:
    Geom::XYZ _coord;
};

// global functions

inline double distance(const Geom::Vec& v1, const Geom::Vec& v2)
{
    double x = v1.x() - v2.x(), y = v1.y() - v2.y(), z = v1.z() - v2.z();
    return static_cast<double>(sqrt((x * x) + (y * y) + (z * z)));
}

inline double distanceP2(const Geom::Vec& v1, const Geom::Vec& v2)
{
    double x = v1.x() - v2.x(), y = v1.y() - v2.y(), z = v1.z() - v2.z();
    return x * x + y * y + z * z;
}

LX_GEOM_EXPORT QString to_string(const Vec& vec);
}  // namespace Geom

inline Geom::Vec operator*(const double Scalar, const Geom::Vec& V)
{
    return V.multiplied(Scalar);
}



#pragma warning(pop)