XYZ.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

#include <Geom/GeomEnums.h>
#include <Geom/geom_defines.h>

#include <vector>

namespace Geom
{
class Mat;
class XYZ;
}  // namespace Geom

typedef std::vector<Geom::XYZ> COORDS;

namespace Geom
{

class GEOM_EXPORT XYZ
{
public:
    //                                                       //
    // --------------------- BEGIN API --------------------- //
    //                                                       //
    // ATTENTION: DO NOT CHANGE ANY SIGNATURES IN THE API !  //
    //                                                       //

    // Methods PUBLIC
    //
    XYZ();
    XYZ(const double X, const double Y, const double Z);
    void setCoord(const double X, const double Y, const double Z);

    void setCoord(const int Index, const double Xi);
    void setX(const double X);
    void setY(const double Y);
    void setZ(const double Z);

    double coord(const int Index) const;

    void coord(double& X, double& Y, double& Z) const;
    double x() const;
    double y() const;
    double z() const;
    double modulus() const;
    double squareModulus() const;


    bool isEqual(const XYZ& Other, const double Tolerance) const;

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


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


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


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


    double crossMagnitude(const XYZ& Right) const;

    double crossSquareMagnitude(const XYZ& Right) const;
    void crossCross(const XYZ& Coord1, const XYZ& Coord2);
    XYZ crossCrossed(const XYZ& Coord1, const XYZ& Coord2) const;
    void divide(const double Scalar);
    void operator/=(const double Scalar) { divide(Scalar); }

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

    double dot(const XYZ& Other) const;
    double operator*(const XYZ& Other) const { return dot(Other); }

    double dotCross(const XYZ& Coord1, const XYZ& Coord2) const;

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


    void multiply(const XYZ& Other);
    void operator*=(const XYZ& Other) { multiply(Other); }

    void multiply(const Geom::Mat& Matrix);
    void operator*=(const Geom::Mat& Matrix) { multiply(Matrix); }

    // HPK TODO
    /*void multiply(const Geom::Mat& Matrix) ;
    void operator *=(const Geom::Mat& Matrix)
    {
    multiply(Matrix);
    }
    */


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



    XYZ multiplied(const XYZ& Other) const;

    XYZ multiplied(const Geom::Mat& Matrix) const;
    XYZ operator*(const Geom::Mat& Matrix) const { return multiplied(Matrix); }


    void normalize();

    XYZ normalized() const;

    void reverse();

    XYZ reversed() const;

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


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


    void setLinearForm(const double A1, const XYZ& XYZ1, const double A2, const XYZ& XYZ2, const double A3, const XYZ& XYZ3, const XYZ& XYZ4);

    void setLinearForm(const double A1, const XYZ& XYZ1, const double A2, const XYZ& XYZ2, const double A3, const XYZ& XYZ3);

    void setLinearForm(const double A1, const XYZ& XYZ1, const double A2, const XYZ& XYZ2, const XYZ& XYZ3);

    void setLinearForm(const double A1, const XYZ& XYZ1, const double A2, const XYZ& XYZ2);

    void setLinearForm(const double A1, const XYZ& XYZ1, const XYZ& XYZ2);

    void setLinearForm(const XYZ& Left, const XYZ& Right);

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

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

    bool operator<(const XYZ& rhs) const;


private:
    double _x;
    double _y;
    double _z;
};


typedef std::vector<XYZ> XYZ_Array;
}  // namespace Geom

inline Geom::XYZ operator*(const Geom::Mat& Matrix, const Geom::XYZ& Coord1)
{
    return Coord1.multiplied(Matrix);
}

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