CAM_Operation.hxx

//--------------------------------------------------------------------------
// 版权所有 2024 Siemens
//--------------------------------------------------------------------------
//  JA API 的 C++ 接口头文件
//--------------------------------------------------------------------------
//
//  源文件:
//     CAM_Operation.ja
//
//  生成者:
//     apiwrap
//
//  警告:
//     此文件为自动生成，请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/CAM_CAMSetup.hxx>
#include <NXOpen/CAM_CutRegionsData.hxx>
#include <NXOpen/CAM_GougeCheckResults.hxx>
#include <NXOpen/CAM_Move.hxx>
#include <NXOpen/CAM_PreviewOperation.hxx>
#include <NXOpen/CAM_CAMObject.hxx>
#include <NXOpen/ugmath.hxx>
#include <NXOpen/libnxopencpp_cam_exports.hxx>
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
namespace NXOpen
{
    namespace CAM
    {
        class Operation;
    }
    namespace CAM
    {
        class CAMFeature;
    }
    namespace CAM
    {
        class CAMObject;
    }
    namespace CAM
    {
        class CutRegionsData;
    }
    namespace CAM
    {
        namespace FBM
        {
            class Feature;
        }
    }
    namespace CAM
    {
        class GougeCheckResults;
    }
    namespace CAM
    {
        class Move;
    }
    namespace CAM
    {
        class MoveCollection;
    }
    namespace CAM
    {
        class NCGroup;
    }
    namespace CAM
    {
        class PreviewOperation;
    }
    namespace CAM
    {
        class ToolPathEditorBuilder;
    }
    class NXObject;
    namespace CAM
    {
        class _OperationBuilder;
        class OperationImpl;
        class NXOPENCPP_CAMEXPORT  Operation : public NXOpen::CAM::CAMObject
        {
            public: enum GenerateIpwStatus
            {
                GenerateIpwStatusPass ,
                GenerateIpwStatusNoSetup ,
                GenerateIpwStatusNoBlank ,
                GenerateIpwStatusHasRefpart ,
                GenerateIpwStatusNoPath
            };
            private: OperationImpl * m_operation_impl;
            private: friend class  _OperationBuilder;
            protected: Operation();
public: ~Operation();
            public: void AppendMove
            (
                NXOpen::CAM::Move * move 
            );
            public: void InsertMove
            (
                NXOpen::CAM::Move * insertAfter  ,
                NXOpen::CAM::Move * move 
            );
            public: std::vector<NXString> GetUserDefinedMoveTypes
            (
            );
            public: NXOpen::CAM::ToolPathEditorBuilder * CreateToolPathEditorBuilder
            (
            );
            public: double GetToolpathTime
            (
            );
            public: void SetToolpathTime
            (
                double time 
            );
            public: double GetToolpathLength
            (
            );
            public: void SetToolpathLength
            (
                double length 
            );
            public: double GetToolpathCuttingTime
            (
            );
            public: void SetToolpathCuttingTime
            (
                double time 
            );
            public: double GetToolpathCuttingLength
            (
            );
            public: void SetToolpathCuttingLength
            (
                double length 
            );
            public: NXOpen::CAM::NCGroup * GetParent
            (
                NXOpen::CAM::CAMSetup::View branch 
            );
            public: void UnlinkInstance
            (
            );

            public: void GenerateIpw
            (
                bool checkCollisions  ,
                bool useHolder 
            );

            public: NXOpen::NXObject * GetInputIpw
            (
            );
            public: NXOpen::CAM::FBM::Feature * InsertFeature
            (
                NXOpen::CAM::CAMFeature * tagMachiningFeature 
            );
            public: void RemoveFeature
            (
                NXOpen::CAM::CAMFeature * tagFeature 
            );
            public: NXString GetInProcessFeatureType
            (
            );
            public: void SetInProcessFeatureType
            (
                const NXString & type 
            );
            void SetInProcessFeatureType
            (
                const char * type 
            );
            public: void SetMachiningArea
            (
                const NXString & type 
            );
            void SetMachiningArea
            (
                const char * type 
            );
            public: bool GougeCheckStatus
            (
            );

            public: NXOpen::CAM::GougeCheckResults * PerformGougeCheck
            (
                NXOpen::CAM::GougeCheckResults::Option gougeOption 
            );

            public: NXOpen::CAM::GougeCheckResults * GougeCheckResults
            (
            );

            public: void ResetGougeChecking
            (
            );

            public: void PerformSpikeCheck
            (
            );

            public: NXOpen::CAM::CutRegionsData * CutRegionsData
            (
            );

            public: bool HasOtherInstances
            (
            );
            public: std::vector<NXOpen::CAM::Operation *> GetOtherInstances
            (
            );
            public: bool IsFirstOfDivide
            (
            );
            public: bool IsDivided
            (
            );
            public: std::vector<NXOpen::CAM::Operation *> GetDividedOperations
            (
            );
            public: NXOpen::CAM::Operation * GetFirstOfDivide
            (
            );

            public: bool IsAdditive
            (
            );

            public: bool ComparePath
            (
                double positionTolerance ,
                double angleTolerance 
            );

            public: bool ComparePath
            (
                double positionTolerance ,
                double angleTolerance ,
                bool exactCompare ,
                bool realCompare ,
                bool tubeCompare 
            );

            public: bool ComparePath
            (
                double positionTolerance ,
                double angleTolerance ,
                bool exactCompare ,
                bool realCompare ,
                bool tubeCompare ,
                bool realCompareDetailed ,
                int stopAfterNDiffs ,
                int* realCPosDiff ,
                int* realCOrientDiff 
            );

            public: bool IsMirror
            (
            );
            public: bool IsMaintainCutDirection
            (
            );
            public: bool IsMaintainCutAngle
            (
            );
            public: bool GetTransformationMatrix
            (
                NXOpen::Matrix3x3* rotationMatrix ,
                NXOpen::Vector3d* translation ,
                double* scale 
            );

            public: bool CanGenerateIpw
            (
                NXOpen::CAM::Operation::GenerateIpwStatus* status 
            );

            public: NXOpen::CAM::PreviewOperation * GetPreview
            (
            );

            public: double GetRemovedVolume
            (
            );
            public: void ClearRemovedVolume
            (
            );
            public: double GetMaterialRemovalRate
            (
            );
            public: void ClearMaterialRemovalRate
            (
            );

            public: NXOpen::CAM::NCGroup * ParentProgramOrder
            (
            );

            public: NXOpen::CAM::NCGroup * ParentMachineMethod
            (
            );

            public: NXOpen::CAM::NCGroup * ParentGeometry
            (
            );

            public: NXOpen::CAM::NCGroup * ParentMachineTool
            (
            );

            public: NXOpen::CAM::Operation * GetSourceOfMirrorOperation
            (
            );
            public: NXOpen::CAM::MoveCollection *CAMMoveCollection();
        };
    }
}
#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