Mechatronics_CamProfileBuilder.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// C++接口头文件，用于JA API
//--------------------------------------------------------------------------
//
// 源文件:
//     Mechatronics_CamProfileBuilder.ja
//
// 生成工具:
//     apiwrap
//
// 警告:
//    此文件为自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/Expression.hxx>
#include <NXOpen/Builder.hxx>
#include <NXOpen/ugmath.hxx>
#include <NXOpen/libnxopencpp_mechatronics_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 Mechatronics
    {
        class CamProfileBuilder;
    }
    class Builder;
    class Expression;
    namespace Mechatronics
    {
        class CamProfile;
    }
    class NXObject;
    namespace Mechatronics
    {
        class _CamProfileBuilderBuilder;
        class CamProfileBuilderImpl;
        class NXOPENCPP_MECHATRONICSEXPORT CamProfileBuilder : public NXOpen::Builder
        {
            public: enum MasterValueUnit
            {
                MasterValueUnitLinear,
                MasterValueUnitRotary,
                MasterValueUnitTime
            };

            public: enum ProfileCyclicType
            {
                ProfileCyclicTypeRelativeCyclic,
                ProfileCyclicTypeCyclic,
                ProfileCyclicTypeNonCyclic
            };

            public: enum SlaveValueUnit
            {
                SlaveValueUnitLinearPosition,
                SlaveValueUnitRotaryPosition,
                SlaveValueUnitLinearSpeed,
                SlaveValueUnitRotarySpeed
            };

            public: enum ProfileInterpolationType
            {
                ProfileInterpolationTypeCubicSpline ,
                ProfileInterpolationTypeLinear ,
                ProfileInterpolationTypeBezierSpline
            };

            public:
            struct Element
            {
                public: int Id;
                public: NXString SegmentName;
                public: int SegmentType;
                public: int CurveType;
                public: double Slope;
                public: double Curvature;
                public: double MasterMin;
                public: double MasterMax;
                public: double SlaveMin;
                public: double SlaveMax;
                public: double Xn1;
                public: double Xn2;
                public: double A0;
                public: double A1;
                public: double A2;
                public: double A3;
                public: double A4;
                public: double A5;
                public: double A6;
                public: double Amplitude;
                public: double AngularFrequency;
                public: double Phase;
                public: bool SlopeEqualPrev;
                public: bool SlopeEqualNext;
                public: bool CurveEqualPrev;
                public: bool CurveEqualNext;
                public: double Slope2;
                public: double Jerk;
                public: int FormulaType;
                public: double LambdaValue;
                public: int OptimizeType;
                public: double YnMin;
                public: double YnMax;
                public: Element() :
                    Id(),
                    SegmentName(),
                    SegmentType(),
                    CurveType(),
                    Slope(),
                    Curvature(),
                    MasterMin(),
                    MasterMax(),
                    SlaveMin(),
                    SlaveMax(),
                    Xn1(),
                    Xn2(),
                    A0(),
                    A1(),
                    A2(),
                    A3(),
                    A4(),
                    A5(),
                    A6(),
                    Amplitude(),
                    AngularFrequency(),
                    Phase(),
                    SlopeEqualPrev(),
                    SlopeEqualNext(),
                    CurveEqualPrev(),
                    CurveEqualNext(),
                    Slope2(),
                    Jerk(),
                    FormulaType(),
                    LambdaValue(),
                    OptimizeType(),
                    YnMin(),
                    YnMax()
{
                }
                public: Element(int idInitial ,
                        const NXString &segmentNameInitial ,
                        int segmentTypeInitial ,
                        int curveTypeInitial ,
                        double slopeInitial ,
                        double curvatureInitial ,
                        double masterMinInitial ,
                        double masterMaxInitial ,
                        double slaveMinInitial ,
                        double slaveMaxInitial ,
                        double xn1Initial ,
                        double xn2Initial ,
                        double a0Initial ,
                        double a1Initial ,
                        double a2Initial ,
                        double a3Initial ,
                        double a4Initial ,
                        double a5Initial ,
                        double a6Initial ,
                        double amplitudeInitial ,
                        double angularFrequencyInitial ,
                        double phaseInitial ,
                        bool slopeEqualPrevInitial ,
                        bool slopeEqualNextInitial ,
                        bool curveEqualPrevInitial ,
                        bool curveEqualNextInitial ,
                        double slope2Initial ,
                        double jerkInitial ,
                        int formulaTypeInitial ,
                        double lambdaValueInitial ,
                        int optimizeTypeInitial ,
                        double ynMinInitial ,
                        double ynMaxInitial ) :
                    Id(idInitial),
                    SegmentName(segmentNameInitial),
                    SegmentType(segmentTypeInitial),
                    CurveType(curveTypeInitial),
                    Slope(slopeInitial),
                    Curvature(curvatureInitial),
                    MasterMin(masterMinInitial),
                    MasterMax(masterMaxInitial),
                    SlaveMin(slaveMinInitial),
                    SlaveMax(slaveMaxInitial),
                    Xn1(xn1Initial),
                    Xn2(xn2Initial),
                    A0(a0Initial),
                    A1(a1Initial),
                    A2(a2Initial),
                    A3(a3Initial),
                    A4(a4Initial),
                    A5(a5Initial),
                    A6(a6Initial),
                    Amplitude(amplitudeInitial),
                    AngularFrequency(angularFrequencyInitial),
                    Phase(phaseInitial),
                    SlopeEqualPrev(slopeEqualPrevInitial),
                    SlopeEqualNext(slopeEqualNextInitial),
                    CurveEqualPrev(curveEqualPrevInitial),
                    CurveEqualNext(curveEqualNextInitial),
                    Slope2(slope2Initial),
                    Jerk(jerkInitial),
                    FormulaType(formulaTypeInitial),
                    LambdaValue(lambdaValueInitial),
                    OptimizeType(optimizeTypeInitial),
                    YnMin(ynMinInitial),
                    YnMax(ynMaxInitial)
                {
                }
            };
            private: CamProfileBuilderImpl * m_camprofilebuilder_impl;
            private: friend class  _CamProfileBuilderBuilder;
            protected: CamProfileBuilder();
            public: ~CamProfileBuilder();
            public: NXString Name
            (
            );
            public: void SetName
            (
                const NXString & name 
            );
            void SetName
            (
                const char * name 
            );
            public: NXOpen::Expression * MasterMinimum
            (
            );
            public: NXOpen::Expression * MasterMaximum
            (
            );
            public: NXOpen::Mechatronics::CamProfileBuilder::MasterValueUnit MasterUnit
            (
            );
            public: void SetMasterUnit
            (
                NXOpen::Mechatronics::CamProfileBuilder::MasterValueUnit masterUnit 
            );
            public: NXOpen::Expression * SlaveMinimum
            (
            );
            public: NXOpen::Expression * SlaveMaximum
            (
            );
            public: NXOpen::Mechatronics::CamProfileBuilder::SlaveValueUnit SlaveUnit
            (
            );
            public: void SetSlaveUnit
            (
                NXOpen::Mechatronics::CamProfileBuilder::SlaveValueUnit slaveUnit 
            );
            public: NXOpen::Mechatronics::CamProfileBuilder::ProfileCyclicType CyclicType
            (
            );
            public: void SetCyclicType
            (
                NXOpen::Mechatronics::CamProfileBuilder::ProfileCyclicType cyclicType 
            );
            public: NXOpen::Mechatronics::CamProfileBuilder::ProfileInterpolationType InterpolationType
            (
            );
            public: void SetInterpolationType
            (
                NXOpen::Mechatronics::CamProfileBuilder::ProfileInterpolationType interpolationType 
            );
            public: bool CheckingG2Continuity
            (
            );
            public: void SetCheckingG2Continuity
            (
                bool checking 
            );
            public: int FindElementIndex
            (
                const NXOpen::Mechatronics::CamProfileBuilder::Element & element 
            );
            public: void AddElement
            (
                NXOpen::NXObject * part  ,
                const NXOpen::Mechatronics::CamProfileBuilder::Element & element 
            );
            public: void AddElement
            (
                NXOpen::NXObject * part  ,
                const NXOpen::Mechatronics::CamProfileBuilder::Element & element  ,
                const std::vector<NXOpen::Point2d> & interPoints 
            );
            public: void EditElement
            (
                int index ,
                NXOpen::NXObject * part  ,
                const NXOpen::Mechatronics::CamProfileBuilder::Element & element 
            );
            public: void RemoveElementByIndex
            (
                int index 
            );
            public: void ClearElements
            (
            );
            public: void SetSegmentTable
            (
                NXOpen::Mechatronics::CamProfile * segmentTableObject 
            );
            public: NXOpen::Mechatronics::CamProfileBuilder::Element AskElementByIndex
            (
                int index 
            );
            public: int AskElementsLength
            (
            );
            public: void SwitchSegmentTable
            (
                NXOpen::Mechatronics::CamProfile * segmentTableObject 
            );
        };
    }
}
#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