MeasureManager.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
//  C++接口的头文件，用于JA API
//--------------------------------------------------------------------------
//
//  源文件:
//     MeasureManager.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 MeasureManager;
    class BasePart;
    namespace Annotations
    {
        class Annotation;
    }
    class CartesianCoordinateSystem;
    class Direction;
    class DisplayableObject;
    class IBody;
    class IParameterizedSurface;
    class IReferenceAxis;
    class Measure;
    class MeasureAngle;
    class MeasureAngleBuilder;
    class MeasureBodies;
    class MeasureBodyBuilder;
    class MeasureDistance;
    class MeasureDistanceBuilder;
    class MeasureElement;
    class MeasureExtremePoint;
    class MeasureFaceBuilder;
    class MeasureFaces;
    class MeasureLength;
    class MeasureMaster;
    class MeasureMasterBuilder;
    class MeasurePoint;
    class MeasurePolarAngle;
    class MeasurePolarArea;
    class MeasurePolarRadius;
    class MeasurePrefsBuilder;
    class MeasureRectangularExtreme;
    class NXObject;
    class Point;
    namespace Routing
    {
        class RoutingMeasureDistanceBuilder;
    }
    class ScCollector;
    class Scalar;
    class Unit;
    class MeasureManagerImpl;
    class NXOPENCPPEXPORT  MeasureManager
    {
        public: enum EndpointType
        {
            EndpointTypeNone,
            EndpointTypeStartPoint ,
            EndpointTypeEndPoint
        };

        public: enum MeasureType
        {
            MeasureTypeMinimum ,
            MeasureTypeMaximum
        };

        public: enum ProjectionType
        {
            ProjectionTypeMinimum ,
            ProjectionTypeMinClearance ,
            ProjectionTypeMaxClearance ,
            ProjectionTypeMaximum
        };

        public: enum RadialMeasureType
        {
            RadialMeasureTypeRadius ,
            RadialMeasureTypeDiameter
        };

        public: enum ExtremeType
        {
            ExtremeTypeRectangular ,
            ExtremeTypePolarRadius ,
            ExtremeTypePolarAngle ,
            ExtremeTypePolarArea ,
            ExtremeTypeExtremePoint
        };

        public: enum SectionType
        {
            SectionTypeSolid ,
            SectionTypeHollow
        };

        public: enum DistanceDeltaValue
        {
            DistanceDeltaValueX ,
            DistanceDeltaValueY ,
            DistanceDeltaValueZ
        };

        public: enum ExtremeAreaType
        {
            ExtremeAreaTypeInscribedRadius ,
            ExtremeAreaTypeInscribedDiameter ,
            ExtremeAreaTypeCircumscribedRadius ,
            ExtremeAreaTypeCircumscribedDiameter
        };
        private: MeasureManagerImpl * m_measuremanager_impl;
        private: NXOpen::BasePart* m_owner;
        public: explicit MeasureManager(NXOpen::BasePart *owner);
        public:
        tag_t Tag() const;
        public: ~MeasureManager();
        public: NXOpen::MeasurePoint * NewPoint
        (
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys ,
            bool createExpressions 
        );
        public: void EditPoint
        (
            NXOpen::Measure * feature ,
            NXOpen::Point * object1 ,
            NXOpen::CartesianCoordinateSystem * object2 
        );
        public: NXOpen::MeasurePoint * InitializePoint
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            bool createGeometry ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::DisplayableObject * object1 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::RadialMeasureType mType 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::NXObject * object1 ,
            NXOpen::NXObject * object2 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            bool createGeometry ,
            NXOpen::NXObject * object1 ,
            NXOpen::NXObject * object2 
        );
        public: NXOpen::MeasureDistance * NewScDistance
        (
            NXOpen::Unit * units ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 
        );
        public: NXOpen::MeasureDistance * NewScDistance
        (
            NXOpen::Unit * units ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            bool createGeometry ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::DisplayableObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::DisplayableObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            bool createGeometry ,
            NXOpen::DisplayableObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::DisplayableObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction ,
            NXOpen::MeasureManager::ProjectionType projType 
        );
        public: NXOpen::MeasureDistance * NewDistance
        (
            NXOpen::Unit * units ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction ,
            NXOpen::MeasureManager::ProjectionType projType ,
            bool createGeometry 
        );
        public: NXOpen::MeasureDistance * NewScDistance
        (
            NXOpen::Unit * units ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            NXOpen::Direction * direction ,
            NXOpen::MeasureManager::ProjectionType projType 
        );
        public: NXOpen::MeasureDistance * NewScDistance
        (
            NXOpen::Unit * units ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            NXOpen::Direction * direction ,
            NXOpen::MeasureManager::ProjectionType projType ,
            bool createGeometry 
        );
        public: void EditDistance
        (
            NXOpen::Measure * feature ,
            NXOpen::NXObject * object1 ,
            NXOpen::NXObject * object2 
        );
        public: void EditScDistance
        (
            NXOpen::Measure * feature ,
            NXOpen::ScCollector * object1 ,
            NXOpen::ScCollector * object2 ,
            NXOpen::MeasureManager::MeasureType measurementType 
        );
        public: void EditDistance
        (
            NXOpen::Measure * feature ,
            NXOpen::DisplayableObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::DisplayableObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 
        );
        public: void EditDistance
        (
            NXOpen::Measure * feature ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction 
        );
        public: void EditDistance
        (
            NXOpen::Measure * feature ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction ,
            NXOpen::MeasureManager::ProjectionType projType 
        );
        public: void EditDistance
        (
            NXOpen::Measure * feature ,
            NXOpen::DisplayableObject * object1 
        );
        public: void EditDistance
        (
            const NXString & name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 
        );
        void EditDistance
        (
            const char * name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 
        );
        public: void EditDistance
        (
            const NXString & name ,
            NXOpen::DisplayableObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::DisplayableObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 
        );
        void EditDistance
        (
            const char * name ,
            NXOpen::DisplayableObject * object1 ,
            const NXOpen::Point3d & startPointForObject1 ,
            NXOpen::DisplayableObject * object2 ,
            const NXOpen::Point3d & startPointForObject2 
        );
        public: void EditDistance
        (
            const NXString & name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction 
        );
        void EditDistance
        (
            const char * name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction 
        );
        public: void EditDistance
        (
            const NXString & name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction ,
            NXOpen::MeasureManager::ProjectionType projType 
        );
        void EditDistance
        (
            const char * name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::Direction * direction ,
            NXOpen::MeasureManager::ProjectionType projType 
        );
        public: void EditDistance
        (
            const NXString & name ,
            NXOpen::DisplayableObject * object1 
        );
        void EditDistance
        (
            const char * name ,
            NXOpen::DisplayableObject * object1 
        );
        public: NXOpen::MeasureDistance * InitializeDistance
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureLength * NewLength
        (
            NXOpen::Unit * units ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureLength * NewLength
        (
            NXOpen::Unit * units ,
            const std::vector<NXOpen::DisplayableObject *> & objects 
        );
        public: void EditLength
        (
            NXOpen::Measure * feature ,
            NXOpen::ScCollector * objects 
        );
        public: void EditLength
        (
            NXOpen::Measure * feature ,
            const std::vector<NXOpen::DisplayableObject *> & objects 
        );
        public: void EditLength
        (
            const NXString & name ,
            NXOpen::ScCollector * objects 
        );
        void EditLength
        (
            const char * name ,
            NXOpen::ScCollector * objects 
        );
        public: void EditLength
        (
            const NXString & name ,
            const std::vector<NXOpen::DisplayableObject *> & objects 
        );
        void EditLength
        (
            const char * name ,
            const std::vector<NXOpen::DisplayableObject *> & objects 
        );
        public: NXOpen::MeasureLength * InitializeLength
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureAngle * NewAngle
        (
            NXOpen::Unit * units ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            bool minorAngle 
        );
        public: NXOpen::MeasureAngle * NewAngle
        (
            NXOpen::Unit * units ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            bool minorAngle ,
            bool trueAngle 
        );
        public: NXOpen::MeasureAngle * NewAngle
        (
            NXOpen::Unit * units ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 ,
            bool minorAngle 
        );
        public: NXOpen::MeasureAngle * NewAngle
        (
            NXOpen::Unit * units ,
            bool createGeometry ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 ,
            bool minorAngle 
        );
        public: void EditAngle
        (
            NXOpen::Measure * feature ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            bool minorAngle 
        );
        public: void EditAngle
        (
            NXOpen::Measure * feature ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            bool minorAngle ,
            bool trueAngle 
        );
        public: void EditAngle
        (
            NXOpen::Measure * feature ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 ,
            bool minorAngle 
        );
        public: void EditAngle
        (
            const NXString & name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            bool minorAngle 
        );
        void EditAngle
        (
            const char * name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            bool minorAngle 
        );
        public: void EditAngle
        (
            const NXString & name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            bool minorAngle ,
            bool trueAngle 
        );
        void EditAngle
        (
            const char * name ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            bool minorAngle ,
            bool trueAngle 
        );
        public: void EditAngle
        (
            const NXString & name ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 ,
            bool minorAngle 
        );
        void EditAngle
        (
            const char * name ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 ,
            bool minorAngle 
        );
        public: NXOpen::MeasureAngle * InitializeAngle
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureFaces * NewFaceProperties
        (
            NXOpen::Unit * areaUnit ,
            NXOpen::Unit * lengthUnit ,
            double accuracy ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureFaces * NewFaceProperties
        (
            NXOpen::Unit * areaUnit ,
            NXOpen::Unit * lengthUnit ,
            double accuracy ,
            const std::vector<NXOpen::IParameterizedSurface *> & objects 
        );
        public: void EditFaceProperties
        (
            NXOpen::Measure * feature ,
            NXOpen::ScCollector * objects 
        );
        public: void EditFaceProperties
        (
            NXOpen::Measure * feature ,
            const std::vector<NXOpen::IParameterizedSurface *> & objects 
        );
        public: void EditFaceProperties
        (
            const NXString & name ,
            NXOpen::ScCollector * objects 
        );
        void EditFaceProperties
        (
            const char * name ,
            NXOpen::ScCollector * objects 
        );
        public: void EditFaceProperties
        (
            const NXString & name ,
            const std::vector<NXOpen::IParameterizedSurface *> & objects 
        );
        void EditFaceProperties
        (
            const char * name ,
            const std::vector<NXOpen::IParameterizedSurface *> & objects 
        );
        public: NXOpen::MeasureFaces * InitializeFaceProperties
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureBodies * NewMassProperties
        (
            const std::vector<NXOpen::Unit *> & massUnits ,
            double accuracy ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureBodies * NewMassProperties
        (
            const std::vector<NXOpen::Unit *> & massUnits ,
            double accuracy ,
            bool createGeometry ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureBodies * NewMassProperties
        (
            const std::vector<NXOpen::Unit *> & massUnits ,
            double accuracy ,
            const std::vector<NXOpen::IBody *> & objects 
        );
        public: NXOpen::MeasureBodies * NewMassProperties
        (
            const std::vector<NXOpen::Unit *> & massUnits ,
            const std::vector<double> & tolerances ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureBodies * NewMassProperties
        (
            const std::vector<NXOpen::Unit *> & massUnits ,
            const std::vector<double> & tolerances ,
            bool createGeometry ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureBodies * NewMassProperties
        (
            const std::vector<NXOpen::Unit *> & massUnits ,
            const std::vector<double> & tolerances ,
            const std::vector<NXOpen::IBody *> & objects 
        );
        public: void EditMassProperties
        (
            NXOpen::Measure * feature ,
            NXOpen::ScCollector * objects 
        );
        public: void EditMassProperties
        (
            NXOpen::Measure * feature ,
            const std::vector<NXOpen::IBody *> & objects 
        );
        public: void EditMassProperties
        (
            const NXString & name ,
            NXOpen::ScCollector * objects 
        );
        void EditMassProperties
        (
            const char * name ,
            NXOpen::ScCollector * objects 
        );
        public: void EditMassProperties
        (
            const NXString & name ,
            const std::vector<NXOpen::IBody *> & objects 
        );
        void EditMassProperties
        (
            const char * name ,
            const std::vector<NXOpen::IBody *> & objects 
        );
        public: NXOpen::MeasureBodies * InitializeMassProperties
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureDistanceBuilder * CreateMeasureDistanceBuilder
        (
            NXOpen::NXObject * feature 
        );
        public: NXOpen::MeasureAngleBuilder * CreateMeasureAngleBuilder
        (
            NXOpen::NXObject * feature 
        );
        public: NXOpen::MeasureFaceBuilder * CreateMeasureFaceBuilder
        (
            NXOpen::NXObject * feature 
        );
        public: NXOpen::MeasureBodyBuilder * CreateMeasureBodyBuilder
        (
            NXOpen::NXObject * feature 
        );
        public: NXOpen::MeasureLength * NewPointsOnCurvesLength
        (
            NXOpen::Unit * units ,
            const std::vector<NXOpen::Point *> & objects 
        );
        public: NXOpen::Routing::RoutingMeasureDistanceBuilder * CreateRoutingMeasureDistanceBuilder
        (
            NXOpen::NXObject * feature 
        );
        public: NXOpen::MeasureLength * NewRoutingPathLength
        (
            NXOpen::Unit * units ,
            const std::vector<NXOpen::NXObject *> & objects 
        );
        public: NXOpen::Routing::RoutingMeasureDistanceBuilder * CreateRoutingMeasureDistanceBuilder
        (
            NXOpen::NXObject * feature  ,
            NXOpen::MeasureDistanceBuilder * measureDistanceBuilder 
        );
        public: NXOpen::MeasurePolarRadius * NewPolarRadius
        (
            NXOpen::Unit * units ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            NXOpen::Point * point  ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasurePolarRadius * NewPolarRadius
        (
            NXOpen::Unit * units ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            NXOpen::Point * point  ,
            NXOpen::ScCollector * objects ,
            bool createGeometry 
        );
        public: void EditPolarRadius
        (
            NXOpen::Measure * feature ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            NXOpen::Point * point  ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasurePolarRadius * InitializePolarRadius
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasurePolarAngle * NewPolarAngle
        (
            NXOpen::Unit * units ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            NXOpen::Point * point ,
            NXOpen::Direction * vector ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasurePolarAngle * NewPolarAngle
        (
            NXOpen::Unit * units ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            NXOpen::Point * point ,
            NXOpen::Direction * vector ,
            NXOpen::ScCollector * objects ,
            bool createGeometry 
        );
        public: void EditPolarAngle
        (
            NXOpen::Measure * feature ,
            NXOpen::MeasureManager::MeasureType minMaxFlag ,
            NXOpen::Point * point  ,
            NXOpen::Direction * vector ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasurePolarAngle * InitializePolarAngle
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasurePolarArea * NewPolarArea
        (
            NXOpen::Unit * units ,
            NXOpen::ScCollector * objects ,
            bool createExpressions 
        );
        public: NXOpen::MeasurePolarArea * NewPolarArea
        (
            NXOpen::Unit * units ,
            NXOpen::ScCollector * objects ,
            bool createExpressions ,
            bool createGeometry 
        );
        public: void EditPolarArea
        (
            NXOpen::Measure * feature ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasurePolarArea * InitializePolarArea
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureExtremePoint * ExtremePoint
        (
            NXOpen::Unit * units ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 ,
            NXOpen::ScCollector * objects ,
            bool createExpressions 
        );
        public: NXOpen::MeasureExtremePoint * ExtremePoint
        (
            NXOpen::Unit * units ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 ,
            NXOpen::ScCollector * objects ,
            bool createExpressions ,
            bool createGeometry 
        );
        public: void EditExtremePoint
        (
            NXOpen::Measure * feature ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureExtremePoint * InitializeExtremePoint
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureRectangularExtreme * NewRectangularExtreme
        (
            NXOpen::Unit * units ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 ,
            NXOpen::ScCollector * objects ,
            bool createExpressions 
        );
        public: NXOpen::MeasureRectangularExtreme * NewRectangularExtreme
        (
            NXOpen::Unit * units ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 ,
            NXOpen::ScCollector * objects ,
            bool createExpressions ,
            bool createGeometry 
        );
        public: void EditRectangularExtreme
        (
            NXOpen::Measure * feature ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureRectangularExtreme * InitializeRectangularExtreme
        (
            NXOpen::Measure * feature 
        );
        public: NXOpen::MeasureMasterBuilder * CreateMeasureMasterBuilder
        (
            NXOpen::NXObject * feature 
        );
        public: NXOpen::MeasureMaster * MasterMeasurement
        (
        );
        public: void ShowMeasureAnnotation
        (
            NXOpen::MeasureMaster * feature 
        );
        public: NXOpen::MeasureElement * DistanceElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 
        );
        public: NXOpen::MeasureElement * DistanceElementWithUnits
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 
        );
        public: NXOpen::Scalar * EmbeddedDistance
        (
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXString* name 
        );

        public: NXOpen::Scalar * EmbeddedDistanceDelta
        (
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::MeasureManager::DistanceDeltaValue deltaValue ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXString* name 
        );

        public: void EditDistanceElement
        (
            NXOpen::MeasureElement * data ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 
        );
        public: void EditDistanceElementWithUnits
        (
            NXOpen::MeasureElement * data ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 
        );
        public: void EditEmbeddedDistance
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 
        );

        public: void EditEmbeddedDistanceDelta
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::MeasureManager::DistanceDeltaValue deltaValue ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 
        );

        public: NXOpen::NXObject * EmbeddedPoint
        (
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys ,
            NXString* name 
        );
        public: NXOpen::NXObject * EmbeddedPointWithUnit
        (
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys ,
            NXOpen::Unit * unit ,
            NXString* name 
        );
        public: NXOpen::MeasureElement * FacePropertiesElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            const std::vector<NXOpen::Unit *> & faceUnits ,
            int alternateSolution ,
            bool requireExact ,
            double accuracy ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::NXObject * EmbeddedFaceProperties
        (
            int outputField ,
            const std::vector<NXOpen::Unit *> & faceUnits ,
            int alternateSolution ,
            bool requireExact ,
            double accuracy ,
            NXOpen::ScCollector * objects ,
            NXString* name 
        );
        public: void EditFacePropertiesElement
        (
            NXOpen::MeasureElement * data ,
            const std::vector<NXOpen::Unit *> & faceUnits ,
            int alternateSolution ,
            bool requireExact ,
            double accuracy ,
            NXOpen::ScCollector * objects 
        );
        public: void EditEmbeddedFaceProperties
        (
            NXOpen::NXObject * measurement ,
            int outputField ,
            const std::vector<NXOpen::Unit *> & faceUnits ,
            int alternateSolution ,
            bool requireExact ,
            double accuracy ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureElement * CurvePropertiesElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * curves ,
            const std::vector<NXOpen::DisplayableObject *> & extraObjects 
        );
        public: NXOpen::Scalar * EmbeddedCurveProperties
        (
            int outputField ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * curves ,
            NXString* name 
        );
        public: void EditCurvePropertiesElement
        (
            NXOpen::MeasureElement * data ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            const std::vector<NXOpen::DisplayableObject *> & extraObjects 
        );
        public: void EditEmbeddedCurveProperties
        (
            NXOpen::Scalar * measurement ,
            int outputField ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * curves 
        );
        public: NXOpen::MeasureElement * AngleElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 
        );
        public: NXOpen::Scalar * EmbeddedAngle
        (
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 ,
            NXString* name 
        );
        public: void EditAngleElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 
        );
        public: void EditEmbeddedAngle
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::DisplayableObject * object1 ,
            NXOpen::MeasureManager::EndpointType qualifier1 ,
            NXOpen::DisplayableObject * object2 ,
            NXOpen::MeasureManager::EndpointType qualifier2 
        );
        public: NXOpen::MeasureElement * Angle3ptElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 
        );
        public: NXOpen::Scalar * EmbeddedAngle3pt
        (
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 ,
            NXString* name 
        );
        public: void EditAngle3ptElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 
        );
        public: void EditEmbeddedAngle3pt
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::Point * basePoint ,
            NXOpen::Point * endPoint1 ,
            NXOpen::Point * endPoint2 
        );
        public: NXOpen::MeasureElement * ProjectedDistanceElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::IReferenceAxis * direction 
        );
        public: NXOpen::MeasureElement * ProjectedDistanceElementWithUnits
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::IReferenceAxis * direction 
        );
        public: NXOpen::Scalar * EmbeddedProjectedDistance
        (
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::IReferenceAxis * direction ,
            NXString* name 
        );

        public: NXOpen::Scalar * EmbeddedProjectedDistanceDelta
        (
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::MeasureManager::DistanceDeltaValue deltaValue ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::IReferenceAxis * direction ,
            NXString* name 
        );

        public: void EditProjectedDistanceElement
        (
            NXOpen::MeasureElement * data ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::IReferenceAxis * direction 
        );
        public: void EditProjectedDistanceElementWithUnits
        (
            NXOpen::MeasureElement * data ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::IReferenceAxis * direction 
        );
        public: void EditEmbeddedProjectedDistance
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::IReferenceAxis * direction 
        );

        public: void EditEmbeddedProjectedDistanceDelta
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * lengthUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::MeasureManager::DistanceDeltaValue deltaValue ,
            NXOpen::ScCollector * collection1 ,
            NXOpen::ScCollector * collection2 ,
            const std::vector<NXOpen::DisplayableObject *> & objects1 ,
            const std::vector<NXOpen::DisplayableObject *> & objects2 ,
            NXOpen::IReferenceAxis * direction 
        );

        public: NXOpen::MeasureElement * BodyElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            const std::vector<NXOpen::Unit *> & massUnits ,
            double accuracy ,
            NXOpen::ScCollector * objects 
        );
        public: void EditBodyElement
        (
            NXOpen::MeasureElement * data ,
            const std::vector<NXOpen::Unit *> & massUnits ,
            double accuracy ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureElement * PointElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys 
        );
        public: NXOpen::MeasureElement * PointElementWithUnit
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys ,
            NXOpen::Unit * unit 
        );
        public: void EditPointElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys 
        );
        public: void EditPointElementWithUnit
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys ,
            NXOpen::Unit * unit 
        );
        public: void EditEmbeddedPoint
        (
            NXOpen::NXObject * measurement ,
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys 
        );
        public: void EditEmbeddedPointWithUnit
        (
            NXOpen::NXObject * measurement ,
            NXOpen::Point * point ,
            NXOpen::CartesianCoordinateSystem * csys ,
            NXOpen::Unit * unit 
        );
        public: NXOpen::MeasureElement * EulerAnglesElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            NXOpen::CartesianCoordinateSystem * csys1 ,
            NXOpen::CartesianCoordinateSystem * csys2 
        );
        public: void EditEulerAnglesElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            NXOpen::CartesianCoordinateSystem * csys1 ,
            NXOpen::CartesianCoordinateSystem * csys2 
        );
        public: void CleanupAssociativeGeometry
        (
        );
        public: NXOpen::Annotations::Annotation * CreateDimensionAnnotation
        (
            const NXOpen::Point3d & startPoint ,
            const NXOpen::Point3d & endPoint ,
            const NXString & annotationText 
        );
        NXOpen::Annotations::Annotation * CreateDimensionAnnotation
        (
            const NXOpen::Point3d & startPoint ,
            const NXOpen::Point3d & endPoint ,
            const char * annotationText 
        );
        public: NXOpen::Annotations::Annotation * CreateDimensionAnnotationOnPosition
        (
            const NXOpen::Point3d & startPoint ,
            const NXOpen::Point3d & endPoint ,
            const NXOpen::Point3d & position ,
            const NXString & annotationText 
        );
        NXOpen::Annotations::Annotation * CreateDimensionAnnotationOnPosition
        (
            const NXOpen::Point3d & startPoint ,
            const NXOpen::Point3d & endPoint ,
            const NXOpen::Point3d & position ,
            const char * annotationText 
        );
        public: NXOpen::Annotations::Annotation * CreateNoteAnnotation
        (
            const NXOpen::Point3d & anchorPoint ,
            const std::vector<NXString> & annotationText 
        );
        public: NXOpen::Annotations::Annotation * CreateNoteAnnotationOnPosition
        (
            const NXOpen::Point3d & anchorPoint ,
            const NXOpen::Point3d & position ,
            const std::vector<NXString> & annotationText 
        );
        public: NXOpen::Annotations::Annotation * CreateAngleAnnotation
        (
            const NXOpen::Point3d & basePoint ,
            const NXOpen::Point3d & endPoint1 ,
            const NXOpen::Point3d & endPoint2 ,
            int alternateSolution ,
            const NXString & annotationText 
        );
        NXOpen::Annotations::Annotation * CreateAngleAnnotation
        (
            const NXOpen::Point3d & basePoint ,
            const NXOpen::Point3d & endPoint1 ,
            const NXOpen::Point3d & endPoint2 ,
            int alternateSolution ,
            const char * annotationText 
        );
        public: NXOpen::Annotations::Annotation * CreateAngleAnnotationOnPosition
        (
            const NXOpen::Point3d & basePoint ,
            const NXOpen::Point3d & endPoint1 ,
            const NXOpen::Point3d & endPoint2 ,
            const NXOpen::Point3d & position ,
            int alternateSolution ,
            const NXString & annotationText 
        );
        NXOpen::Annotations::Annotation * CreateAngleAnnotationOnPosition
        (
            const NXOpen::Point3d & basePoint ,
            const NXOpen::Point3d & endPoint1 ,
            const NXOpen::Point3d & endPoint2 ,
            const NXOpen::Point3d & position ,
            int alternateSolution ,
            const char * annotationText 
        );
        public: NXOpen::MeasureElement * CenterlinePropertiesElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            const std::vector<NXOpen::Unit *> & centerlineUnits ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::NXObject * EmbeddedCenterlineProperties
        (
            int outputField ,
            const std::vector<NXOpen::Unit *> & centerlineUnits ,
            NXOpen::ScCollector * objects ,
            NXString* name 
        );
        public: void EditCenterlinePropertiesElement
        (
            NXOpen::MeasureElement * data ,
            const std::vector<NXOpen::Unit *> & centerlineUnits ,
            NXOpen::ScCollector * objects 
        );
        public: void EditEmbeddedCenterlineProperties
        (
            NXOpen::NXObject * measurement ,
            int outputField ,
            const std::vector<NXOpen::Unit *> & centerlineUnits ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureElement * BboxPropertiesElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            const std::vector<NXOpen::Unit *> & centerlineUnits ,
            NXOpen::ScCollector * objects ,
            int altSolution 
        );
        public: NXOpen::NXObject * EmbeddedBboxProperties
        (
            int outputField ,
            const std::vector<NXOpen::Unit *> & centerlineUnits ,
            NXOpen::ScCollector * objects ,
            NXString* name ,
            int altSolution 
        );
        public: void EditBboxPropertiesElement
        (
            NXOpen::MeasureElement * data ,
            const std::vector<NXOpen::Unit *> & bboxUnits ,
            int altSolution  ,
            NXOpen::ScCollector * objects 
        );
        public: void EditEmbeddedBboxProperties
        (
            NXOpen::NXObject * measurement ,
            int outputField ,
            const std::vector<NXOpen::Unit *> & bboxUnits ,
            int altSolution  ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureElement * PolarAngleElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Point * originPoint ,
            NXOpen::IReferenceAxis * direction 
        );
        public: void EditPolarAngleElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Point * originPoint ,
            NXOpen::IReferenceAxis * direction 
        );
        public: NXOpen::Scalar * EmbeddedPolarAngle
        (
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Point * originPoint ,
            NXOpen::IReferenceAxis * direction 
        );
        public: void EditEmbeddedPolarAngle
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * angleUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Point * originTag ,
            NXOpen::IReferenceAxis * direction 
        );
        public: NXOpen::MeasureElement * PolarRadiusElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * radiusUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Point * originPoint 
        );
        public: void EditPolarRadiusElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * radiusUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Point * originPoint 
        );
        public: NXOpen::Scalar * EmbeddedPolarRadius
        (
            NXOpen::Unit * radiusUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Point * originPoint 
        );
        public: void EditEmbeddedPolarRadius
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * radiusUnit ,
            int alternateSolution ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Point * originTag 
        );
        public: NXOpen::MeasureElement * PolarAreaElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * radiusUnit ,
            bool requireExact ,
            NXOpen::ScCollector * objects 
        );
        public: void EditPolarAreaElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * radiusUnit ,
            bool requireExact ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::Scalar * EmbeddedPolarArea
        (
            NXOpen::Unit * areaUnit ,
            bool requireExact ,
            NXOpen::ScCollector * objects 
        );
        public: void EditEmbeddedPolarArea
        (
            NXOpen::Scalar * measurement ,
            NXOpen::Unit * areaUnit ,
            bool requireExact ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::MeasureElement * ExtremePointElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * units ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 
        );
        public: void EditExtremePointElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * unit ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 
        );
        public: NXOpen::NXObject * EmbeddedExtremePoint
        (
            NXOpen::Unit * units ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 
        );
        public: void EditEmbeddedExtremePoint
        (
            NXOpen::NXObject * measurement ,
            NXOpen::Unit * areaUnit ,
            bool requireExact ,
            NXOpen::ScCollector * objects ,
            NXOpen::Direction * vector1 ,
            NXOpen::Direction * vector2 ,
            NXOpen::Direction * vector3 
        );
        public: bool GetIsMeasureAnnotation
        (
            NXOpen::NXObject * annotation 
        );
        public: void SetPartTransientModification
        (
        );
        public: void ClearPartTransientModification
        (
        );
        public: void SetSelectionIntent
        (
            NXOpen::Scalar * measurement ,
            int selectionIntent1 ,
            int selectionIntent2 
        );
        public: void GetSelectionIntent
        (
            NXOpen::Scalar * measurement ,
            int* selectionIntent1 ,
            int* selectionIntent2 
        );
        public: NXOpen::MeasurePrefsBuilder * CreateMeasurePrefsBuilder
        (
        );
        public: NXOpen::MeasureElement * SectionInertiaElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            const std::vector<NXOpen::Unit *> & sectionUnits ,
            NXOpen::ScCollector * objects ,
            NXOpen::MeasureManager::SectionType sectionType ,
            double thickness 
        );
        public: void EditSectionInertiaElement
        (
            NXOpen::MeasureElement * data ,
            const std::vector<NXOpen::Unit *> & sectionUnits ,
            NXOpen::ScCollector * objects ,
            NXOpen::MeasureManager::SectionType sectionType ,
            double thickness 
        );
        public: NXOpen::MeasureElement * Circle3ptElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            int alternateSolution ,
            NXOpen::Point * point1 ,
            NXOpen::Point * point2 ,
            NXOpen::Point * point3 
        );
        public: NXOpen::NXObject * EmbeddedCircle3pt
        (
            int outputField ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            int alternateSolution ,
            NXOpen::Point * point1 ,
            NXOpen::Point * point2 ,
            NXOpen::Point * point3 ,
            NXString* name 
        );
        public: void EditCircle3ptElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            int alternateSolution ,
            NXOpen::Point * point1 ,
            NXOpen::Point * point2 ,
            NXOpen::Point * point3 
        );
        public: void EditEmbeddedCircle3pt
        (
            NXOpen::Scalar * measurement ,
            int outputField ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            int alternateSolution ,
            NXOpen::Point * point1 ,
            NXOpen::Point * point2 ,
            NXOpen::Point * point3 
        );
        public: NXOpen::MeasureElement * ExtremeAreaElement
        (
            NXOpen::MeasureMaster * masterMeasurement ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            NXOpen::MeasureManager::ExtremeAreaType alternateSolution ,
            NXOpen::ScCollector * objects 
        );
        public: NXOpen::NXObject * EmbeddedExtremeArea
        (
            int outputField ,
            NXOpen::Unit * unitTag ,
            NXOpen::MeasureManager::ExtremeAreaType alternateSolution ,
            NXOpen::ScCollector * objects ,
            NXString* name 
        );
        public: void EditExtremeAreaElement
        (
            NXOpen::MeasureElement * data  ,
            NXOpen::Unit * lengthUnit ,
            NXOpen::Unit * pointUnit ,
            NXOpen::MeasureManager::ExtremeAreaType alternateSolution ,
            NXOpen::ScCollector * objects 
        );
        public: void EditEmbeddedExtremeArea
        (
            NXOpen::Scalar * measurement ,
            int outputField ,
            NXOpen::Unit * unitTag ,
            NXOpen::MeasureManager::ExtremeAreaType alternateSolution ,
            NXOpen::ScCollector * objects 
        );
}; //lint !e1712 类未定义默认构造函数
}
#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