Measurement.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// C++接口的JA API头文件
//--------------------------------------------------------------------------
//
// 源文件:
//     Measurement.ja
//
// 生成工具:
//     apiwrap
//
// 警告:
//    此文件为自动生成，请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/GeometryTypes.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 Measurement;
    class Session;
    class Curve;
    class Direction;
    class DisplayableObject;
    class Edge;
    class Face;
    class IBody;
    class ICurve;
    class IReferenceAxis;
    class ISurface;
    class NXObject;
    class Point;
    namespace Routing
    {
        class ISegment;
    }
    class ScCollector;
    class Unit;
    class MeasurementImpl;
    class NXOPENCPPEXPORT  Measurement
    {
        public: enum DeviationReportType
        {
            DeviationReportTypeNoDeviation,
            DeviationReportTypeAllDeviation,
            DeviationReportTypeMaximumDistance,
            DeviationReportTypeMinimumDistance,
            DeviationReportTypeMaximumAngle,
            DeviationReportTypeMinimumAngle
        };

        public: enum AlternateAngle
        {
            AlternateAngleInner,
            AlternateAngleOuter,
            AlternateAngleSupplimental
        };

        public: enum AlternateDistance
        {
            AlternateDistanceMinimum,
            AlternateDistanceMaximum,
            AlternateDistanceMaximumCenterToEdge,
            AlternateDistanceMaximumEdgeToCenter,
            AlternateDistanceCenterToCenter,
            AlternateDistanceThickness,
            AlternateDistanceMinimumPerpendicular,
            AlternateDistanceMaximumPerpendicular,
            AlternateDistanceMinimumDistanceArcExtension,
            AlternateDistanceMinimumPerpendicularArcExtension
        };

        public: enum AlternateFace
        {
            AlternateFaceRadius,
            AlternateFaceDiameter
        };

        public: enum AlternateExtremeArea
        {
            AlternateExtremeAreaInscribed,
            AlternateExtremeAreaCircumscribed
        };

        public: enum QuickMeasureType
        {
            QuickMeasureTypeDistance ,
            QuickMeasureTypeCurve ,
            QuickMeasureTypeFace ,
            QuickMeasureTypeProjectedDistance ,
            QuickMeasureTypeAngleThreePoints ,
            QuickMeasureTypeCombinedFace ,
            QuickMeasureTypeCombinedLength ,
            QuickMeasureTypeCombinedBody ,
            QuickMeasureTypeAngle ,
            QuickMeasureTypeBody ,
            QuickMeasureTypePoint ,
            QuickMeasureTypeArcLengthTwoPoints ,
            QuickMeasureTypeEulerAngle ,
            QuickMeasureTypeBoundingBox ,
            QuickMeasureTypeSurfaceCenterLine ,
            QuickMeasureTypePolarAngle ,
            QuickMeasureTypePolarArea ,
            QuickMeasureTypePolarRadius ,
            QuickMeasureTypeExtremePoint ,
            QuickMeasureTypeLast
        };

        public: enum QuickMeasureValueType
        {
            QuickMeasureValueTypeLength,
            QuickMeasureValueTypeDistance,
            QuickMeasureValueTypeArea,
            QuickMeasureValueTypeVolume,
            QuickMeasureValueTypeMass,
            QuickMeasureValueTypeInnerAngle,
            QuickMeasureValueTypeOuterAngle,
            QuickMeasureValueTypeRadius,
            QuickMeasureValueTypeDiameter,
            QuickMeasureValueTypeUndefined
        };
        private: MeasurementImpl * m_measurement_impl;
        private: NXOpen::Session* m_owner;
        public: explicit Measurement(NXOpen::Session *owner);
        public:
        tag_t Tag() const;
        public: ~Measurement();
        public: void DisplayArcLength
        (
            const std::vector<NXOpen::DisplayableObject *> & selectedObjects 
        );
        public: double GetArcLength
        (
            const std::vector<NXOpen::DisplayableObject *> & selectedObjects 
        );
        public: void DisplayMinimumDistance
        (
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Point3d* closePoint1 ,
            NXOpen::Point3d* closePoint2 
        );
        public: void DisplayMinimumDistance
        (
            NXOpen::NXObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::NXObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 ,
            NXOpen::Point3d* closePoint1 ,
            NXOpen::Point3d* closePoint2 
        );
        public: void DisplayMinimumDistance
        (
            NXOpen::NXObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::NXObject * object2 ,
            NXOpen::Point3d* closePoint1 ,
            NXOpen::Point3d* closePoint2 
        );
        public: void DisplayMinimumDistance
        (
            NXOpen::NXObject * object1 ,
            NXOpen::NXObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 ,
            NXOpen::Point3d* closePoint1 ,
            NXOpen::Point3d* closePoint2 
        );
        public: double GetMinimumDistance
        (
            NXOpen::NXObject * object1 ,
            NXOpen::NXObject * object2 ,
            NXOpen::Point3d* closePoint1 ,
            NXOpen::Point3d* closePoint2 ,
            double* accuracy 
        );
        public: double GetMinimumDistance
        (
            NXOpen::NXObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::NXObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 ,
            NXOpen::Point3d* closePoint1 ,
            NXOpen::Point3d* closePoint2 ,
            double* accuracy 
        );
        public: double GetMinimumDistance
        (
            NXOpen::NXObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::NXObject * object2 ,
            NXOpen::Point3d* closePoint1 ,
            NXOpen::Point3d* closePoint2 ,
            double* accuracy 
        );
        public: double GetMinimumDistance
        (
            NXOpen::NXObject * object1 ,
            NXOpen::NXObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 ,
            NXOpen::Point3d* closePoint1 ,
            NXOpen::Point3d* closePoint2 ,
            double* accuracy 
        );
        public: void DisplayAngle
        (
            NXOpen::NXObject * object1 ,
            const NXOpen::Point3d & position1 ,
            NXOpen::NXObject * object2 ,
            const NXOpen::Point3d & position2 
        );
        public: double GetAngle
        (
            NXOpen::NXObject * object1 ,
            const NXOpen::Point3d & position1 ,
            NXOpen::NXObject * object2 ,
            const NXOpen::Point3d & position2 
        );
        public: void DisplayDeviationChecking
        (
            NXOpen::ICurve * curve1 ,
            NXOpen::ICurve * curve2 ,
            int numOfCheckPoints ,
            double distanceTolerance ,
            double angularTolerance ,
            NXOpen::Measurement::DeviationReportType reportType 
        );
        public: void DisplayDeviationChecking
        (
            NXOpen::Curve * curve1 ,
            NXOpen::Face * face2 ,
            int numOfCheckPoints ,
            double distanceTolerance ,
            double angularTolerance ,
            NXOpen::Measurement::DeviationReportType reportType 
        );
        public: void DisplayDeviationChecking
        (
            NXOpen::Face * face1 ,
            NXOpen::Edge * edge1 ,
            NXOpen::Face * face2 ,
            int numOfCheckPoints ,
            double distanceTolerance ,
            double angularTolerance ,
            NXOpen::Measurement::DeviationReportType reportType 
        );
        public: void DisplayDeviationChecking
        (
            NXOpen::Face * face1 ,
            NXOpen::Face * face2 ,
            int numOfCheckPointsU ,
            int numOfCheckPointsV ,
            double distanceTolerance ,
            double angularTolerance ,
            NXOpen::Measurement::DeviationReportType reportType 
        );
        public: void DisplayDeviationChecking
        (
            NXOpen::Face * face1 ,
            NXOpen::Edge * edge1 ,
            NXOpen::Face * face2 ,
            NXOpen::Edge * edge2 ,
            int numOfCheckPoints ,
            double distanceTolerance ,
            double angularTolerance ,
            NXOpen::Measurement::DeviationReportType reportType 
        );
        public: void DisplayArcLengthBetweenPoints
        (
            NXOpen::Point * point1 ,
            NXOpen::Point * point2 
        );
        public: void GetArcLengthBetweenPoints
        (
            NXOpen::Point * point1 ,
            NXOpen::Point * point2 ,
            double* length ,
            std::vector<NXOpen::Curve *> & curves 
        );
        public: void DisplayRoutingPathLength
        (
            const std::vector<NXOpen::Routing::ISegment *> & selectedObjects ,
            std::vector<NXOpen::Routing::ISegment *> & usedObjects 
        );
        public: double GetRoutingPathLength
        (
            const std::vector<NXOpen::NXObject *> & selectedObjects ,
            std::vector<NXOpen::NXObject *> & usedObjects ,
            std::vector<double> & individualLengths 
        );
        public: double GetMinimumOrthogonalDistance
        (
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Point3d* closestOrthogonalPoint 
        );
        public: void GetAngleQualifier
        (
            NXOpen::DisplayableObject * proto  ,
            bool requireExact ,
            const std::vector<double> & seed  ,
            bool flip 
        );
        public: double GetAngle
        (
            NXOpen::Measurement::AlternateAngle alternateSolution ,
            bool requireExact ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Point3d* pt1 ,
            NXOpen::Point3d* pt2 ,
            NXOpen::Point3d* pt3 ,
            bool* isApproximate 
        );
        public: double GetDistance
        (
            NXOpen::Measurement::AlternateDistance alternateSolution ,
            bool requireExact ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::Point3d* pt1 ,
            NXOpen::Point3d* pt2 ,
            bool* isApproximate 
        );
        public: void GetFaceProperties
        (
            const std::vector<NXOpen::ISurface *> & faces ,
            double accuracy ,
            NXOpen::Measurement::AlternateFace alternateSolution ,
            bool requireExact ,
            double* area ,
            double* perimeter ,
            double* radiusDiameter ,
            NXOpen::Point3d* cog ,
            double* minRadiusOfCurvature ,
            double* areaErrorEstimate ,
            NXOpen::Point3d* anchorPoint ,
            bool* isApproximate 
        );
        public: void GetBodyProperties
        (
            const std::vector<NXOpen::IBody *> & bodys ,
            double accuracy ,
            bool useWCS ,
            std::vector<double> & massProps ,
            double* weight ,
            NXOpen::Point3d* centroid ,
            std::vector<double> & centroidUnit ,
            double* density ,
            std::vector<double> & axis 
        );
        public: void GetProjectedDistanceProperties
        (
            const std::vector<NXOpen::NXObject *> & selList1 ,
            const std::vector<NXOpen::NXObject *> & selList2 ,
            NXOpen::NXObject * vectorTag ,
            NXOpen::NXObject * targetUnit ,
            bool requireExact ,
            int alternateSolution ,
            double* distance ,
            std::vector<NXOpen::Point3d> & points ,
            bool* isApproximate 
        );
        public: void GetEulerAnglesProperties
        (
            NXOpen::NXObject * csys1Tag ,
            NXOpen::NXObject * csys2Tag ,
            int alternateSolution ,
            NXOpen::NXObject * targetUnit ,
            double* theta1 ,
            double* theta2 ,
            double* theta3 
        );
        public: void GetArcAndCurveProperties
        (
            const std::vector<NXOpen::NXObject *> & selList ,
            NXOpen::NXObject * targetUnit ,
            bool requireExact ,
            bool* isApproximate ,
            double* arcLength ,
            double* radius ,
            double* diameter ,
            double* minRadiusOfCurvature ,
            NXOpen::Point3d* startPoint ,
            NXOpen::Point3d* endPoint ,
            NXOpen::Point3d* arcCenter 
        );
        public: void GetPolarAngleProperties
        (
            NXOpen::ScCollector * collector ,
            NXOpen::Point * center ,
            NXOpen::IReferenceAxis * vector ,
            bool minAngle ,
            NXOpen::NXObject * targetUnit ,
            double* angle ,
            NXOpen::Point3d* p1 ,
            NXOpen::Point3d* p2 ,
            NXOpen::Point3d* p3 ,
            NXOpen::Point3d* axis 
        );
        public: double GetPolarAreaProperties
        (
            NXOpen::ScCollector * collector ,
            NXOpen::NXObject * targetUnit ,
            NXOpen::Point3d* p1 ,
            NXOpen::Point3d* p2 ,
            NXOpen::Point3d* axis 
        );
        public: void GetPolarRadiusProperties
        (
            NXOpen::ScCollector * collector ,
            NXOpen::Point * center ,
            bool minDist ,
            NXOpen::NXObject * targetUnit ,
            double* radius ,
            NXOpen::Point3d* p1 ,
            NXOpen::Point3d* p2 ,
            std::vector<double> & axis 
        );
        public: NXOpen::Point3d GetExtremePointProperties
        (
            NXOpen::ScCollector * collector ,
            const std::vector<NXOpen::Direction *> & vectors 
        );
        public: void GetPointProperties
        (
            NXOpen::Point * point ,
            NXOpen::NXObject * csys ,
            std::vector<NXOpen::Point3d> & coords 
        );
        public: double GetCenterlineProperties
        (
            const std::vector<NXOpen::NXObject *> & selList ,
            NXOpen::NXObject * targetUnit ,
            std::vector<NXOpen::NXObject *> & pvUGCurves ,
            NXOpen::Point3d* startPoint ,
            NXOpen::Point3d* endPoint 
        );
        public: void GetBoundingBoxProperties
        (
            const std::vector<NXOpen::NXObject *> & selList ,
            int nAltSolution ,
            const NXOpen::Point3d & ptAnchor ,
            bool allowCache  ,
            std::vector<NXOpen::Point3d> & boxPoints ,
            std::vector<NXOpen::Point3d> & dir ,
            std::vector<double> & edgeLength ,
            NXOpen::Point3d* ptOrigin ,
            NXOpen::Point3d* ptExtreme ,
            double* pdVolume 
        );
        public: void GetSectionInertia
        (
            const std::vector<NXOpen::NXObject *> & curves ,
            const std::vector<NXOpen::Unit *> & sectionUnits ,
            bool solidFlag ,
            double hollowThickness ,
            bool useWCS ,
            NXOpen::Point3d* centerGravity ,
            double* maxPrinMOI ,
            double* minPrinMOI ,
            NXOpen::Vector3d* prinBAxis ,
            NXOpen::Vector3d* prinCAxis ,
            double* sectionLength ,
            double* sectionArea ,
            NXOpen::Point2d* rectangleLengths 
        );
        public: void GetCircle3pts
        (
            const NXOpen::Point3d & point1 ,
            const NXOpen::Point3d & point2 ,
            const NXOpen::Point3d & point3 ,
            NXOpen::NXObject * lengthUnit ,
            NXOpen::NXObject * pointUnit ,
            double* radius ,
            double* diameter ,
            NXOpen::Point3d* centroid ,
            NXOpen::Vector3d* axis 
        );
        public: void GetExtremeArea
        (
            const std::vector<NXOpen::NXObject *> & selList ,
            NXOpen::Measurement::AlternateExtremeArea altSolution ,
            NXOpen::NXObject * unit ,
            double* radius ,
            NXOpen::Point3d* centroid ,
            NXOpen::Point3d* pointOnCircle ,
            NXOpen::Vector3d* axis 
        );
    }; //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