MathUtils.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
//  C++接口的头文件：JA API
//--------------------------------------------------------------------------
//
//  源文件:
//     MathUtils.ja
//
//  生成方式:
//     apiwrap
//
//  警告:
//    本文件由自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/TaggedObject.hxx>
#include <NXOpen/ugmath.hxx>
#include <NXOpen/libnxopencpp_exports.hxx>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace NXOpen
{
    class MathUtils;
    class Session;
    class MathUtilsImpl;
    class NXOPENCPPEXPORT  MathUtils
    {
        private: MathUtilsImpl * m_mathutils_impl;
        private: NXOpen::Session* m_owner;
        public: explicit MathUtils(NXOpen::Session *owner);
        public:
        tag_t Tag() const;
        public: ~MathUtils();
        public: NXOpen::Matrix3x3 Orthonormalize
        (
            const NXOpen::Matrix3x3 & original 
        );
        public: NXOpen::Vector3d Multiply
        (
            const NXOpen::Matrix3x3 & matrix ,
            const NXOpen::Vector3d & originalVector 
        );
        public: NXOpen::Point3d Multiply
        (
            const NXOpen::Matrix3x3 & matrix ,
            const NXOpen::Point3d & originalPoint 
        );
        public: bool Point3IsEqual
        (
            const NXOpen::Point3d & point ,
            const NXOpen::Point3d & originalPoint 
        );
        public: bool Point3IsEqualUserTolerance
        (
            const NXOpen::Point3d & point ,
            const NXOpen::Point3d & originalPoint ,
            double tolerance 
        );
        public: bool Point3NotEqual
        (
            const NXOpen::Point3d & point ,
            const NXOpen::Point3d & originalPoint 
        );
        public: bool Vector3IsEqual
        (
            const NXOpen::Vector3d & vector ,
            const NXOpen::Vector3d & originalVector 
        );
        public: bool Vector3IsEqualUserTolerance
        (
            const NXOpen::Vector3d & vector ,
            const NXOpen::Vector3d & originalVector ,
            double tolerance 
        );
        public: bool Vector3NotEqual
        (
            const NXOpen::Vector3d & vector ,
            const NXOpen::Vector3d & originalVector 
        );
        public: bool Point2IsEqual
        (
            const NXOpen::Point2d & point ,
            const NXOpen::Point2d & originalPoint 
        );
        public: NXOpen::Point3d AddPoint3ToVector3
        (
            const NXOpen::Point3d & originalPoint ,
            const NXOpen::Vector3d & vector 
        );
        public: NXOpen::Vector3d SubtractPoint3FromPoint3
        (
            const NXOpen::Point3d & firstPoint ,
            const NXOpen::Point3d & secondPoint 
        );
        public: NXOpen::Point3d SubtractVector3FromPoint3
        (
            const NXOpen::Point3d & originalPoint ,
            const NXOpen::Vector3d & vector 
        );
        public: NXOpen::Point3d MultiplyPoint3ByDouble
        (
            const NXOpen::Point3d & originalPoint ,
            double scale 
        );
        public: NXOpen::Point3d DividePoint3ByDouble
        (
            const NXOpen::Point3d & originalPoint ,
            double scale 
        );
        public: NXOpen::Point3d MultiplyPoint3ByMatrix3
        (
            const NXOpen::Point3d & originalPoint ,
            const NXOpen::Matrix3x3 & matrix 
        );
        public: double DistanceBetweenPoint3
        (
            const NXOpen::Point3d & originalPoint ,
            const NXOpen::Point3d & referencePoint 
        );
        public: NXOpen::Vector3d ConvertPoint3ToVector3
        (
            const NXOpen::Point3d & point 
        );
        public: NXOpen::Point2d ConvertPoint3ToPoint2
        (
            const NXOpen::Point3d & point 
        );
        public: void ConvertPoint3ToArray
        (
            const NXOpen::Point3d & point ,
            std::vector<double> & array 
        );
        public: NXOpen::Point3d InitPoint3WithDoubles
        (
            double value1 ,
            double value2 ,
            double value3 
        );
        public: NXOpen::Point3d InitPoint3WithArray
        (
            const std::vector<double> & array 
        );
        public: double ReturnPoint3Coordinate
        (
            const NXOpen::Point3d & point ,
            int i 
        );
        public: double Point3AndVector3DotProduct
        (
            const NXOpen::Point3d & point ,
            const NXOpen::Vector3d & vector 
        );
        public: NXOpen::Vector3d InitVector3WithDoubles
        (
            double value1 ,
            double value2 ,
            double value3 
        );
        public: NXOpen::Vector3d InitVector3WithArray
        (
            const std::vector<double> & array 
        );
        public: double ReturnVector3Coordinate
        (
            const NXOpen::Vector3d & vector ,
            int i 
        );
        public: NXOpen::Vector3d AddVector3ToVector3
        (
            const NXOpen::Vector3d & vector1 ,
            const NXOpen::Vector3d & vector2 
        );
        public: NXOpen::Vector3d SubtractVector3FromVector3
        (
            const NXOpen::Vector3d & vector1 ,
            const NXOpen::Vector3d & vector2 
        );
        public: NXOpen::Vector3d MultiplyVector3ByDouble
        (
            const NXOpen::Vector3d & originalVector ,
            double scale 
        );
        public: NXOpen::Vector3d DivideVector3ByDouble
        (
            const NXOpen::Vector3d & originalVector ,
            double scale 
        );
        public: NXOpen::Vector3d NegateVector3
        (
            const NXOpen::Vector3d & originalVector 
        );
        public: NXOpen::Vector3d Vector3CrossProduct
        (
            const NXOpen::Vector3d & vector1 ,
            const NXOpen::Vector3d & vector2 
        );
        public: double MagnitudeOfVector3
        (
            const NXOpen::Vector3d & vector 
        );
        public: NXOpen::Vector3d ParallelVector3
        (
            const NXOpen::Vector3d & vector ,
            double tolerance 
        );
        public: NXOpen::Point3d ConvertVector3ToPoint3
        (
            const NXOpen::Vector3d & vector 
        );
        public: NXOpen::Vector2d ConvertVector3ToVector2
        (
            const NXOpen::Vector3d & vector 
        );
        public: bool Vector2IsEqual
        (
            const NXOpen::Vector2d & vector ,
            const NXOpen::Vector2d & originalVector 
        );
        public: void ConvertVector3ToArray
        (
            const NXOpen::Vector3d & vector ,
            std::vector<double> & array 
        );
        public: double Vector3FindAngleWithOrientation
        (
            const NXOpen::Vector3d & vector1 ,
            const NXOpen::Vector3d & vector2 ,
            const NXOpen::Vector3d & orientationVector 
        );
        public: double Vector3FindAngle
        (
            const NXOpen::Vector3d & vector1 ,
            const NXOpen::Vector3d & vector2 
        );
        public: double Vector3DotProduct
        (
            const NXOpen::Vector3d & vector1 ,
            const NXOpen::Vector3d & vector2 
        );
        public: bool Vector3IsParallel
        (
            const NXOpen::Vector3d & vector1 ,
            const NXOpen::Vector3d & vector2 ,
            double tolerance 
        );
        public: bool Vector3IsPerpendicular
        (
            const NXOpen::Vector3d & vector1 ,
            const NXOpen::Vector3d & vector2 ,
            double tolerance 
        );
        public: NXOpen::Vector3d Vector3MakePerpendicular
        (
            const NXOpen::Vector3d & vector 
        );
        public: bool Point2IsEqualUserTolerance
        (
            const NXOpen::Point2d & point ,
            const NXOpen::Point2d & originalPoint ,
            double tolerance 
        );
        public: bool Point2NotEqual
        (
            const NXOpen::Point2d & point ,
            const NXOpen::Point2d & originalPoint 
        );
        public: NXOpen::Point2d InitPoint2
        (
            double value1 ,
            double value2 
        );
        public: NXOpen::Point2d InitPoint2WithArray
        (
            const std::vector<double> & array 
        );
        public: double ReturnPoint2Coordinate
        (
            const NXOpen::Point2d & point ,
            int i 
        );
        public: NXOpen::Vector2d SubtractPoint2FromPoint2
        (
            const NXOpen::Point2d & firstPoint ,
            const NXOpen::Point2d & secondPoint 
        );
        public: bool Vector2IsEqualUserTolerance
        (
            const NXOpen::Vector2d & vector ,
            const NXOpen::Vector2d & originalVector ,
            double tolerance 
        );
        public: NXOpen::Point2d AddPoint2ToVector2
        (
            const NXOpen::Point2d & originalPoint ,
            const NXOpen::Vector2d & vector 
        );
        public: NXOpen::Point2d SubtractVector2FromPoint2
        (
            const NXOpen::Point2d & originalPoint ,
            const NXOpen::Vector2d & vector 
        );
        public: NXOpen::Point2d MultiplyPoint2ByDouble
        (
            const NXOpen::Point2d & originalPoint ,
            double scale 
        );
        public: NXOpen::Point2d DividePoint2ByDouble
        (
            const NXOpen::Point2d & originalPoint ,
            double scale 
        );
        public: double DistanceBetweenPoint2
        (
            const NXOpen::Point2d & originalPoint ,
            const NXOpen::Point2d & referencePoint 
        );
        public: NXOpen::Vector2d ConvertPoint2ToVector2
        (
            const NXOpen::Point2d & point 
        );
        public: NXOpen::Point3d ConvertPoint2ToPoint3
        (
            const NXOpen::Point2d & point 
        );
        public: void ConvertPoint2ToArray
        (
            const NXOpen::Point2d & point ,
            std::vector<double> & array 
        );
        public: NXOpen::Vector2d InitVector2
        (
            double value1 ,
            double value2 
        );
        public: NXOpen::Vector2d InitVector2WithArray
        (
            const std::vector<double> & array 
        );
        public: double ReturnVector2Coordinate
        (
            const NXOpen::Vector2d & vector ,
            int i 
        );
        public: NXOpen::Vector2d AddVector2ToVector2
        (
            const NXOpen::Vector2d & vector1 ,
            const NXOpen::Vector2d & vector2 
        );
        public: NXOpen::Vector2d SubtractVector2FromVector2
        (
            const NXOpen::Vector2d & vector1 ,
            const NXOpen::Vector2d & vector2 
        );
        public: NXOpen::Vector2d MultiplyVector2ByDouble
        (
            const NXOpen::Vector2d & originalVector ,
            double scale 
        );
        public: NXOpen::Vector2d DivideVector2ByDouble
        (
            const NXOpen::Vector2d & originalVector ,
            double scale 
        );
        public: NXOpen::Vector2d NegateVector2
        (
            const NXOpen::Vector2d & originalVector 
        );
        public: double Vector2DotProduct
        (
            const NXOpen::Vector2d & vector1 ,
            const NXOpen::Vector2d & vector2 
        );
        public: double Vector2CrossProduct
        (
            const NXOpen::Vector2d & vector1 ,
            const NXOpen::Vector2d & vector2 
        );
        public: double MagnitudeOfVector2
        (
            const NXOpen::Vector2d & vector 
        );
        public: bool Vector2NotEqual
        (
            const NXOpen::Vector2d & vector ,
            const NXOpen::Vector2d & originalVector 
        );
        public: NXOpen::Vector2d ParallelVector2
        (
            const NXOpen::Vector2d & vector ,
            double tolerance 
        );
        public: NXOpen::Point2d ConvertVector2ToPoint2
        (
            const NXOpen::Vector2d & vector 
        );
        public: NXOpen::Vector3d ConvertVector2ToVector3
        (
            const NXOpen::Vector2d & vector 
        );
        public: void ConvertVector2ToArray
        (
            const NXOpen::Vector2d & vector ,
            std::vector<double> & array 
        );
        public: double Vector2FindAngle
        (
            const NXOpen::Vector2d & vector1 ,
            const NXOpen::Vector2d & vector2 
        );
        public: bool Vector2IsParallel
        (
            const NXOpen::Vector2d & vector1 ,
            const NXOpen::Vector2d & vector2 ,
            double tolerance 
        );
        public: bool Vector2IsPerpendicular
        (
            const NXOpen::Vector2d & vector1 ,
            const NXOpen::Vector2d & vector2 ,
            double tolerance 
        );
        public: NXOpen::Vector2d Vector2MakePerpendicular
        (
            const NXOpen::Vector2d & vector 
        );
        public: int Vector2AskComponents
        (
            const NXOpen::Vector2d & componentVector1 ,
            const NXOpen::Vector2d & componentVector2 ,
            const NXOpen::Vector2d & componentVector3 ,
            double tolerance ,
            double scalar1 ,
            double scalar2 
        );
        public: NXOpen::Vector2d RotateVector2
        (
            const NXOpen::Vector2d & vector ,
            double angle 
        );
        public: NXOpen::Point4d InitPoint4
        (
            double value1 ,
            double value2 ,
            double value3 ,
            double weight 
        );
        public: NXOpen::Point4d InitPoint4WithArray
        (
            const std::vector<double> & array 
        );
        public: NXOpen::Point4d InitPoint4WithCoordinates
        (
            double value1 ,
            double value2 ,
            double value3 ,
            double weight 
        );
        public: double ReturnPoint4Coordinate
        (
            const NXOpen::Point4d & point ,
            int i 
        );
        public: bool Point4IsEqual
        (
            const NXOpen::Point4d & point ,
            const NXOpen::Point4d & originalPoint 
        );
        public: bool Point4IsEqualUserTolerance
        (
            const NXOpen::Point4d & point ,
            const NXOpen::Point4d & originalPoint ,
            double tolerance 
        );
        public: bool Point4NotEqual
        (
            const NXOpen::Point4d & point ,
            const NXOpen::Point4d & originalPoint 
        );
        public: NXOpen::Point3d ConvertPoint4ToPoint3
        (
            const NXOpen::Point4d & point 
        );
        public: void ConvertPoint4ToArray
        (
            const NXOpen::Point4d & point ,
            std::vector<double> & array 
        );
        public: bool Matrix3IsEqual
        (
            const NXOpen::Matrix3x3 & matrix ,
            const NXOpen::Matrix3x3 & originalMatrix 
        );
        public: bool Matrix3IsEqualUserTolerance
        (
            const NXOpen::Matrix3x3 & matrix ,
            const NXOpen::Matrix3x3 & originalMatrix ,
            double tolerance 
        );
        public: bool Matrix3NotEqual
        (
            const NXOpen::Matrix3x3 & matrix ,
            const NXOpen::Matrix3x3 & originalMatrix 
        );
        public: NXOpen::Matrix3x3 InitMatrix3
        (
            const NXOpen::Vector3d & vectorX ,
            const NXOpen::Vector3d & vectorY ,
            const NXOpen::Vector3d & vectorZ 
        );
        public: NXOpen::Matrix3x3 InitMatrix3WithArray
        (
            const std::vector<double> & array 
        );
        public: NXOpen::Matrix3x3 InitRotationMatrix3
        (
            double angle ,
            const NXOpen::Vector3d & vector 
        );
        public: NXOpen::Matrix3x3 InitMatrix3RollPitchYaw
        (
            double roll ,
            double pitch ,
            double yaw 
        );
        public: NXOpen::Matrix3x3 InitMatrix3WithVector
        (
            const NXOpen::Vector3d & vector 
        );
        public: NXOpen::Matrix3x3 InitMatrix3WithXYVectors
        (
            const NXOpen::Vector3d & vectorX ,
            const NXOpen::Vector3d & vectorY 
        );
        public: NXOpen::Vector3d ReturnDirectionVector
        (
            const NXString & direction ,
            const NXOpen::Matrix3x3 & matrix 
        );
        NXOpen::Vector3d ReturnDirectionVector
        (
            const char * direction ,
            const NXOpen::Matrix3x3 & matrix 
        );
        public: NXOpen::Matrix3x3 MultiplyMatrix3AndMatrix3
        (
            const NXOpen::Matrix3x3 & matrix1 ,
            const NXOpen::Matrix3x3 & matrix2 
        );
        public: void AskRollPitchYaw
        (
            const NXOpen::Matrix3x3 & matrix ,
            std::vector<double> & array 
        );
        public: NXOpen::Matrix3x3 TransposeMatrix3
        (
            const NXOpen::Matrix3x3 & matrix 
        );
        public: void ConvertMatrix3ToArray
        (
            const NXOpen::Matrix3x3 & matrix ,
            std::vector<double> & array 
        );
        public: double DeterminantOfMatrix3
        (
            const NXOpen::Matrix3x3 & matrix 
        );
        public: bool Matrix3IsOrthoNormal
        (
            const NXOpen::Matrix3x3 & matrix 
        );
    }; //lint !e1712 default constructor not defined for class
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#ifdef __GNUC__
#ifndef NX_NO_GCC_DEPRECATION_WARNINGS
#pragma GCC diagnostic warning "-Wdeprecated-declarations"
#endif
#endif
#undef EXPORTLIBRARY