Mechatronics_InverseKinematicsBuilder.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// C++接口到JA API的头文件
//--------------------------------------------------------------------------
//
// 源文件:
//     Mechatronics_InverseKinematicsBuilder.ja
//
// 生成器:
//     apiwrap
//
// 警告:
//    本文件自动生成 - 请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/Expression.hxx>
#include <NXOpen/Mechatronics_EulerConvention.hxx>
#include <NXOpen/Mechatronics_FrameBuilder.hxx>
#include <NXOpen/Builder.hxx>
#include <NXOpen/ObjectList.hxx>
#include <NXOpen/SelectObject.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 InverseKinematicsBuilder;
    }
    class Builder;
    class CoordinateSystem;
    class Expression;
    namespace Mechatronics
    {
        class FrameBuilderList;
    }
    namespace Mechatronics
    {
        class SelectRigidBody;
    }
    namespace Mechatronics
    {
        class Tracer;
    }
    class Point;
    namespace Mechatronics
    {
        class _InverseKinematicsBuilderBuilder;
        class InverseKinematicsBuilderImpl;
        class NXOPENCPP_MECHATRONICSEXPORT  InverseKinematicsBuilder : public NXOpen::Builder
        {
            public: enum Types
            {
                TypesOnline,
                TypesOffline
            };

            public: enum BodyTypes
            {
                BodyTypesOneBody,
                BodyTypesTwoBodies
            };

            public: enum ReferenceTypes
            {
                ReferenceTypesWcs,
                ReferenceTypesSelectedCsys
            };

            public: enum AlignTypes
            {
                AlignTypesAll,
                AlignTypesZ,
                AlignTypesY,
                AlignTypesX,
                AlignTypesNone
            };

            public: enum SolverResult
            {
                SolverResultSuccess,
                SolverResultApproximate,
                SolverResultLimits,
                SolverResultReachError,
                SolverResultTimeout,
                SolverResultCollidingTarget,
                SolverResultCollidingStart,
                SolverResultLimitError,
                SolverResultTargetEqualsStart,
                SolverResultUnknown
            };
            private: InverseKinematicsBuilderImpl * m_inversekinematicsbuilder_impl;
            private: friend class  _InverseKinematicsBuilderBuilder;
            protected: InverseKinematicsBuilder();
public: ~InverseKinematicsBuilder();
            public: NXOpen::Mechatronics::InverseKinematicsBuilder::Types Type
            (
            );
            public: void SetType
            (
                NXOpen::Mechatronics::InverseKinematicsBuilder::Types type 
            );
            public: NXOpen::Mechatronics::InverseKinematicsBuilder::BodyTypes BodyType
            (
            );
            public: void SetBodyType
            (
                NXOpen::Mechatronics::InverseKinematicsBuilder::BodyTypes type 
            );
            public: NXOpen::Mechatronics::SelectRigidBody * RigidBody
            (
            );
            public: NXOpen::Point * StartPoint
            (
            );
            public: void SetStartPoint
            (
                NXOpen::Point * startPoint 
            );
            public: void SetStartOrientation
            (
                const NXOpen::Matrix3x3 & startOrit 
            );
            public: NXOpen::Matrix3x3 GetStartOrientation
            (
            );
            public: NXOpen::Mechatronics::InverseKinematicsBuilder::ReferenceTypes ReferenceType
            (
            );
            public: void SetReferenceType
            (
                NXOpen::Mechatronics::InverseKinematicsBuilder::ReferenceTypes referenceType 
            );
            public: NXOpen::CoordinateSystem * ReferenceOrientation
            (
            );
            public: void SetReferenceOrientation
            (
                NXOpen::CoordinateSystem * orientation 
            );
            public: NXOpen::Mechatronics::SelectRigidBody * FirstRigidBody
            (
            );
            public: NXOpen::Mechatronics::SelectRigidBody * SecondRigidBody
            (
            );
            public: NXOpen::Point * FirstPoint
            (
            );
            public: void SetFirstPoint
            (
                NXOpen::Point * firstPoint 
            );
            public: NXOpen::Point * SecondPoint
            (
            );
            public: void SetSecondPoint
            (
                NXOpen::Point * secondPoint 
            );
            public: void SetFirstPointOrientation
            (
                const NXOpen::Matrix3x3 & startOrit 
            );
            public: NXOpen::Matrix3x3 GetFirstPointOrientation
            (
            );
            public: void SetSecondPointOrientation
            (
                const NXOpen::Matrix3x3 & startOrit 
            );
            public: NXOpen::Matrix3x3 GetSecondPointOrientation
            (
            );
            public: NXOpen::Mechatronics::InverseKinematicsBuilder::AlignTypes AlignType
            (
            );
            public: void SetAlignType
            (
                NXOpen::Mechatronics::InverseKinematicsBuilder::AlignTypes alignType 
            );
            public: NXOpen::Expression * PointTolerance
            (
            );
            public: NXOpen::Expression * VectorTolerance
            (
            );
            public: void SetSecondTracer
            (
                NXOpen::Mechatronics::Tracer * secondTracer 
            );
            public: NXOpen::Mechatronics::FrameBuilderList * FrameList
            (
            );
            public: NXString Name
            (
            );
            public: void SetName
            (
                const NXString & name 
            );
            void SetName
            (
                const char * name 
            );
            public: bool AvoidCollision
            (
            );
            public: void SetAvoidCollision
            (
                bool avoidCollision 
            );
            public: bool GenerateTracer
            (
            );
            public: void SetGenerateTracer
            (
                bool bTracer 
            );
            public: NXOpen::Mechatronics::InverseKinematicsBuilder::SolverResult GetResult
            (
            );
            public: NXOpen::CoordinateSystem * GetErrorPose
            (
            );
            public: NXOpen::Mechatronics::Convention EulerAngleConvention
            (
            );
            public: void SetEulerAngleConvention
            (
                NXOpen::Mechatronics::Convention type 
            );
            public: void SetTracer
            (
                NXOpen::Mechatronics::Tracer * tracer 
            );
            public: bool GetIsAutosolve
            (
            );
            public: void SetIsAutosolve
            (
                bool autoSolve 
            );
            public: void ExportPoses
            (
                const NXString & fileName ,
                bool inDesign 
            );
            void ExportPoses
            (
                const char * fileName ,
                bool inDesign 
            );
            public: bool GeneratePoseCSYS
            (
            );
            public: void SetGeneratePoseCSYS
            (
                bool generatePoseCSYS 
            );
            public: void CreateAllPosesCsys
            (
                std::vector<NXOpen::CoordinateSystem *> & posesCSYS 
            );
            public: bool GenerateAllOperations
            (
            );
            public: void SetGenerateAllOperations
            (
                bool generateAllOperations 
            );
            public: void SetPosesName
            (
                const std::vector<NXString> & posesName 
            );
            public: void SetPosesMotionType
            (
                const std::vector<NXOpen::Mechatronics::FrameBuilder::MotionTypes> & posesMotionType 
            );
            public: void SetPosesSolution
            (
                const std::vector<int> & posesSolution 
            );
            public: void SetPosesPoint
            (
                const std::vector<NXOpen::Point *> & posesPoint 
            );
            public: void UpdateIk
            (
            );
            public: void UpdateIkStatus
            (
            );
            public: bool UseSixAxes
            (
            );
            public: void SetUseSixAxes
            (
                bool useSixAxes 
            );
            public: bool UseBlending
            (
            );
            public: void SetUseBlending
            (
                bool useBlending 
            );
            public: NXString GetRobotName
            (
            );
            public: void SetRobotName
            (
                const NXString & robotName 
            );
            void SetRobotName
            (
                const char * robotName 
            );
            public: void SetPosesFlybyRank
            (
                const std::vector<int> & posesFlybyRank 
            );
            public: void SetPosesSpeedData
            (
                const std::vector<NXString> & posesSpeedData 
            );
        };
    }
}
#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