CAE_Post.hxx

//--------------------------------------------------------------------------
// 版权所有 2024 Siemens
//--------------------------------------------------------------------------
//  JA API 的 C++ 接口头文件
//--------------------------------------------------------------------------
//
//  源文件:
//     CAE_Post.ja
//
//  生成方式:
//     apiwrap
//
//  警告:
//    此文件为自动生成，请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/CAE_BaseIteration.hxx>
#include <NXOpen/CAE_BeamDisplayParameters.hxx>
#include <NXOpen/CAE_CaeGroupCollection.hxx>
#include <NXOpen/CAE_Hotspot.hxx>
#include <NXOpen/CAE_MeshTranslucencyBuilder.hxx>
#include <NXOpen/CAE_PostAnnotation.hxx>
#include <NXOpen/CAE_PostAnnotationBuilder.hxx>
#include <NXOpen/CAE_PostGraph.hxx>
#include <NXOpen/CAE_PostGroupBuilder.hxx>
#include <NXOpen/CAE_PostLegend.hxx>
#include <NXOpen/CAE_PostPointManager.hxx>
#include <NXOpen/CAE_PostSelectionEntity.hxx>
#include <NXOpen/CAE_PostShowhideBuilder.hxx>
#include <NXOpen/CAE_Result.hxx>
#include <NXOpen/CAE_ShowHideEntitiesBuilder.hxx>
#include <NXOpen/CAE_Xyplot_Plot.hxx>
#include <NXOpen/NXColor.hxx>
#include <NXOpen/TaggedObject.hxx>
#include <NXOpen/ugmath.hxx>
#include <NXOpen/libnxopencpp_cae_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 CAE
    {
        class Post;
    }
    class Session;
    namespace CAE
    {
        class BaseResultType;
    }
    namespace CAE
    {
        class BeamDisplayParameters;
    }
    namespace CAE
    {
        class ClippingParameters;
    }
    namespace CAE
    {
        class CrossSectionParameters;
    }
    namespace CAE
    {
        class DeformationParameters;
    }
    namespace CAE
    {
        class Hotspot;
    }
    namespace CAE
    {
        class HotspotRecipe;
    }
    namespace CAE
    {
        class Iteration;
    }
    namespace CAE
    {
        class MeshTranslucencyBuilder;
    }
    namespace CAE
    {
        class PostAnnotation;
    }
    namespace CAE
    {
        class PostAnnotationBuilder;
    }
namespace CAE
{
    class PostDisplayManager;
}
namespace CAE
{
    class PostGraph;
}
namespace CAE
{
    class PostGroupBuilder;
}
namespace CAE
{
    class PostLegend;
}
namespace CAE
{
    class PostMesh;
}
namespace CAE
{
    class PostPointManager;
}
namespace CAE
{
    class PostPreference;
}
namespace CAE
{
    class PostProcessingSession;
}
namespace CAE
{
    class PostSelectionEntity;
}
namespace CAE
{
    class PostShowhideBuilder;
}
namespace CAE
{
    class PostSmartSelectionManager;
}
namespace CAE
{
    namespace ResponseSimulation
    {
        class RSEvent;
    }
}
namespace CAE
{
    class Result;
}
namespace CAE
{
    class ResultParameters;
}
namespace CAE
{
    class ResultParametersWithNodalForceReport;
}
namespace CAE
{
    class ResultParametersWithProbe;
}
namespace CAE
{
    class ShowHideEntitiesBuilder;
}
namespace CAE
{
    class SimPart;
}
namespace CAE
{
    namespace Xyplot
    {
        class Plot;
    }
}
class NXColor;
class TaggedObject;
class Unit;
namespace CAE
{
    class PostImpl;
    class NXOPENCPP_CAEEXPORT  Post
    {
        public: enum DisplayColorSchemeType
        {
            DisplayColorSchemeTypeFringe ,
            DisplayColorSchemeTypeMid ,
            DisplayColorSchemeTypePid ,
            DisplayColorSchemeTypeMesh
        };

        public: enum Style
        {
            StyleSmoothContours ,
            StyleBandedContours ,
            StyleElements ,
            StyleIsoLines ,
            StyleIsoSurfaces ,
            StyleCubes ,
            StyleSpheres ,
            StyleArrows ,
            StyleTensors ,
            StyleStreamlines
        };

        public: enum PlotStyle
        {
            PlotStyleContours ,
            PlotStyleIsoLines ,
            PlotStyleIsoSurfaces ,
            PlotStyleCubes ,
            PlotStyleSpheres ,
            PlotStyleArrows ,
            PlotStyleTensors ,
            PlotStyleStreamlines
        };

        public: enum ColorbarStyle
        {
            ColorbarStyleSmooth ,
            ColorbarStyleBanded
        };

        public: enum BandStyle
        {
            BandStyleDefault ,
            BandStyleLine ,
            BandStyleValInline
        };

        public: enum ShowHeader
        {
            ShowHeaderNone ,
            ShowHeaderAutomatic ,
            ShowHeaderCustomized ,
            ShowHeaderCompact
        };

        public: enum Legend
        {
            LegendDetailed ,
            LegendColorbarOnly ,
            LegendHeaderOnly
        };

        public: enum Threshold
        {
            ThresholdResult ,
            ThresholdDisplayed ,
            ThresholdSpecified ,
            ThresholdViewportResult ,
            ThresholdViewportDisplayed
        };

        public: enum Spacing
        {
            SpacingEquallySpaced ,
            SpacingRoundOff ,
            SpacingLevelIncrement
        };

            public: enum Spectrum
            {
                SpectrumStructural ,
                SpectrumThermal ,
                SpectrumGrayScale ,
                SpectrumStopLight
            };

            public: enum Scale
            {
                ScaleAutomatic ,
                ScaleLinear ,
                ScaleLogarithmic
            };

            public: enum Format
            {
                FormatAuto ,
                FormatFixedPoint ,
                FormatScientific
            };

            public: enum Position
            {
                PositionLeft ,
                PositionRight ,
                PositionNone
            };

            public: enum EdgeStyle
            {
                EdgeStyleExternal ,
                EdgeStyleFeature ,
                EdgeStyleWireframe ,
                EdgeStyleNone ,
                EdgeStylePolygonedge
            };

            public: enum FaceStyle
            {
                FaceStyleOpaque ,
                FaceStyleTranslucent ,
                FaceStyleNone
            };

            public: enum FaceFillStyle
            {
                FaceFillStyleFill ,
                FaceFillStyleNoFill
            };

            public: enum MarkRenderStyle
            {
                MarkRenderStyleLine ,
                MarkRenderStyleSolid
            };

            public: enum MarkTensorStyle
            {
                MarkTensorStyleBoxAndArrows ,
                MarkTensorStyleOnlyArrows ,
                MarkTensorStyleOnlyBox ,
                MarkTensorStyleOnlyLine
            };

            public: enum MarkComponentCombinationType
            {
                MarkComponentCombinationTypeNormal,
                MarkComponentCombinationTypePrincipal,
                MarkComponentCombinationTypeShear,
                MarkComponentCombinationTypeForce,
                MarkComponentCombinationTypeMoment,
                MarkComponentCombinationTypePrincipal2D
            };

            public: enum MarkColor
            {
                MarkColorResultValue ,
                MarkColorSpecified ,
                MarkColorTextcolor
            };

            public: enum MarkSize
            {
                MarkSizeResultValue ,
                MarkSizeSpecified
            };

            public: enum MarkMaximumSize
            {
                MarkMaximumSizePercentageOfModel ,
                MarkMaximumSizeSpecifiedLength
            };

            public: enum BeamContourScaleMethod
            {
                BeamContourScaleMethodPercentModel ,
                BeamContourScaleMethodAbsolute
            };

            public: enum MarkResultantCompCombinationType
            {
                MarkResultantCompCombinationTypeNone ,
                MarkResultantCompCombinationTypeXy ,
                MarkResultantCompCombinationTypeYz ,
                MarkResultantCompCombinationTypeZx
            };

            public: enum MarkLocation
            {
                MarkLocationNodes ,
                MarkLocationElements
            };

            public: enum MarkHide
            {
                MarkHideResultPercent ,
                MarkHideAbsoluteResultPercent ,
                MarkHideResultValue
            };

            public: enum Target
            {
                TargetFreeFacees ,
                TargetVolume ,
                TargetCuttingPlane ,
                TargetAxisSymmetry3D
            };

            public: enum Marker
            {
                MarkerMinimumAndMaximum ,
                MarkerMinimumOnly ,
                MarkerMaximumOnly
            };

            public: enum AnimationType
            {
                AnimationTypeResult ,
                AnimationTypeIterations ,
                AnimationTypeStreamline
            };

            public: enum AnimationStyle
            {
                AnimationStyleLinear ,
                AnimationStyleModal ,
                AnimationStyleForwardwave ,
                AnimationStyleBackwardwave
            };

            public: enum AnimationIterationTypes
            {
                AnimationIterationTypesValue ,
                AnimationIterationTypesNone
            };

public: enum AnimationControl
            {
                AnimationControlBack ,
                AnimationControlNext ,
                AnimationControlPlay ,
                AnimationControlPause ,
                AnimationControlStop ,
                AnimationControlSetFrame ,
                AnimationControlFullCycle ,
                AnimationControlDelay ,
                AnimationControlStreamline
            };

            public: enum ClipSide
            {
                ClipSidePositive ,
                ClipSideNegative ,
                ClipSideBoth
            };

            public: enum ClipPlane
            {
                ClipPlaneX ,
                ClipPlaneY ,
                ClipPlaneZ
            };

            public: enum ValueSharingCriterion
            {
                ValueSharingCriterionAverage ,
                ValueSharingCriterionMinimum ,
                ValueSharingCriterionMaximum
            };

            public: enum NodeValueSharingCriterion
            {
                NodeValueSharingCriterionAverage ,
                NodeValueSharingCriterionMinimum ,
                NodeValueSharingCriterionMaximum ,
                NodeValueSharingCriterionSum
            };

            public: enum NoDataTreatment
            {
                NoDataTreatmentIgnore ,
                NoDataTreatmentSpecifiedValue
            };

            public: enum Abcissa
            {
                AbcissaUneven ,
                AbcissaEven ,
                AbcissaSequenced
            };

            public: enum Export
            {
                ExportAscii ,
                ExportJt ,
                ExportVrml
            };

            public: enum GroupVisibility
            {
                GroupVisibilityShowOnly ,
                GroupVisibilityShow ,
                GroupVisibilityHide
            };

            public: enum StreamlineDirection
            {
                StreamlineDirectionUpstream ,
                StreamlineDirectionDownstream ,
                StreamlineDirectionBoth
            };

            public: enum IntegrationScheme
            {
                IntegrationSchemeEuler ,
                IntegrationSchemeRk2 ,
                IntegrationSchemeRk4
            };

            public: enum StreamlineStyle
            {
                StreamlineStyleLine ,
                StreamlineStyleRibbon ,
                StreamlineStyleTube ,
                StreamlineStyleBubble
            };

            public: enum StreamlineColor
            {
                StreamlineColorResultValue ,
                StreamlineColorSpecified ,
                StreamlineColorTextcolor
            };

            public: enum StreamlineSize
            {
                StreamlineSizePercentageOfModel ,
                StreamlineSizeSpecifiedLength
            };

            public: enum StreamlineLineWeight
            {
                StreamlineLineWeightThin ,
                StreamlineLineWeightNormal ,
                StreamlineLineWeightThick
            };

            public: enum StreamlineSynchronization
            {
                StreamlineSynchronizationUpstream ,
                StreamlineSynchronizationDownstream ,
                StreamlineSynchronizationSeedPoint
            };

            public: enum LimitDisplay
            {
                LimitDisplayNone ,
                LimitDisplayShaded ,
                LimitDisplayTranslucent ,
                LimitDisplayClipped
            };

            public: enum AxisymetricAxis
            {
                AxisymetricAxisNone  = -1,
                AxisymetricAxisX ,
                AxisymetricAxisY ,
                AxisymetricAxisZ
            };

            public:
            struct Colorbar
            {
                public:  NXOpen::CAE::Post::Spectrum Spectrum;
                public:  bool InvertSpectrum;
                public:  NXOpen::CAE::Post::Scale Scale;
                public:  bool AutomaticLevel;
                public:  int NumberOfLevels;
                public:  NXOpen::CAE::Post::Threshold Threshold;
                public:  double ThresholdMinimum;
                public:  double ThresholdMaximum;
                public:  bool ShowOverflowAbove;
                public:  bool ShowOverflowBelow;
                public:  NXColor* OverflowAboveColor;
                public:  NXColor* OverflowBelowColor;
                public:  NXOpen::CAE::Post::Position Position;
                public:  NXOpen::CAE::Post::LimitDisplay Overflow;
                public:  NXOpen::CAE::Post::LimitDisplay Underflow;
                public:  NXOpen::CAE::Post::Spacing Spacing;
                public:  double IncrementPerLevel;
public: Colorbar() :
                    Spectrum((NXOpen::CAE::Post::Spectrum)0),
                    InvertSpectrum(),
                    Scale((NXOpen::CAE::Post::Scale)0),
                    AutomaticLevel(),
                    NumberOfLevels(),
                    Threshold((NXOpen::CAE::Post::Threshold)0),
                    ThresholdMinimum(),
                    ThresholdMaximum(),
                    ShowOverflowAbove(),
                    ShowOverflowBelow(),
                    OverflowAboveColor(),
                    OverflowBelowColor(),
                    Position((NXOpen::CAE::Post::Position)0),
                    Overflow((NXOpen::CAE::Post::LimitDisplay)0),
                    Underflow((NXOpen::CAE::Post::LimitDisplay)0),
                    Spacing((NXOpen::CAE::Post::Spacing)0),
                    IncrementPerLevel()
                {
                }
                public: Colorbar(NXOpen::CAE::Post::Spectrum spectrumInitial  ,
                        bool invertSpectrumInitial  ,
                        NXOpen::CAE::Post::Scale scaleInitial  ,
                        bool automaticLevelInitial  ,
                        int numberOfLevelsInitial  ,
                        NXOpen::CAE::Post::Threshold thresholdInitial  ,
                        double thresholdMinimumInitial  ,
                        double thresholdMaximumInitial  ,
                        bool showOverflowAboveInitial  ,
                        bool showOverflowBelowInitial  ,
                        NXColor* overflowAboveColorInitial  ,
                        NXColor* overflowBelowColorInitial  ,
                        NXOpen::CAE::Post::Position positionInitial  ,
                        NXOpen::CAE::Post::LimitDisplay overflowInitial  ,
                        NXOpen::CAE::Post::LimitDisplay underflowInitial  ,
                        NXOpen::CAE::Post::Spacing spacingInitial  ,
                        double incrementPerLevelInitial  ) :
                    Spectrum(spectrumInitial),
                    InvertSpectrum(invertSpectrumInitial),
                    Scale(scaleInitial),
                    AutomaticLevel(automaticLevelInitial),
                    NumberOfLevels(numberOfLevelsInitial),
                    Threshold(thresholdInitial),
                    ThresholdMinimum(thresholdMinimumInitial),
                    ThresholdMaximum(thresholdMaximumInitial),
                    ShowOverflowAbove(showOverflowAboveInitial),
                    ShowOverflowBelow(showOverflowBelowInitial),
                    OverflowAboveColor(overflowAboveColorInitial),
                    OverflowBelowColor(overflowBelowColorInitial),
                    Position(positionInitial),
                    Overflow(overflowInitial),
                    Underflow(underflowInitial),
                    Spacing(spacingInitial),
                    IncrementPerLevel(incrementPerLevelInitial)
                {
                }
            };

            public:
            struct Headerlines
            {
                public:  bool Show;
                public:  NXString Line;
                public: Headerlines() :
                    Show(),
                    Line()
                {
                }
                public: Headerlines(bool showInitial  ,
                        const NXString &lineInitial  ) :
                    Show(showInitial),
                    Line(lineInitial)
                {
                }
            };

            public:
            struct EdgeFace
            {
                public:  NXOpen::CAE::Post::EdgeStyle EdgeStyle;
                public:  NXColor* EdgeColor;
                public:  NXOpen::CAE::Post::FaceStyle FaceStyle;
                public:  NXColor* FaceColor;
                public: EdgeFace() :
                    EdgeStyle((NXOpen::CAE::Post::EdgeStyle)0),
                    EdgeColor(),
                    FaceStyle((NXOpen::CAE::Post::FaceStyle)0),
                    FaceColor()
                {
                }
                public: EdgeFace(NXOpen::CAE::Post::EdgeStyle edgeStyleInitial  ,
                        NXColor* edgeColorInitial  ,
                        NXOpen::CAE::Post::FaceStyle faceStyleInitial  ,
                        NXColor* faceColorInitial  ) :
                    EdgeStyle(edgeStyleInitial),
                    EdgeColor(edgeColorInitial),
                    FaceStyle(faceStyleInitial),
                    FaceColor(faceColorInitial)
{
                }
            };

            public:
            struct PrimaryEdgeFace
            {
                public:  NXOpen::CAE::Post::EdgeStyle EdgeStyle;
                public:  NXColor* EdgeColor;
                public:  NXOpen::CAE::Post::FaceFillStyle FaceStyle;
                public:  NXColor* FaceColor;
                public: PrimaryEdgeFace() :
                    EdgeStyle((NXOpen::CAE::Post::EdgeStyle)0),
                    EdgeColor(),
                    FaceStyle((NXOpen::CAE::Post::FaceFillStyle)0),
                    FaceColor()
                {
                }
                public: PrimaryEdgeFace(NXOpen::CAE::Post::EdgeStyle edgeStyleInitial  ,
                        NXColor* edgeColorInitial  ,
                        NXOpen::CAE::Post::FaceFillStyle faceStyleInitial  ,
                        NXColor* faceColorInitial  ) :
                    EdgeStyle(edgeStyleInitial),
                    EdgeColor(edgeColorInitial),
                    FaceStyle(faceStyleInitial),
                    FaceColor(faceColorInitial)
                {
                }
            };

            public:
            struct Mark
            {
                public:  bool ShowArrowXComponent;
                public:  bool ShowArrowYComponent;
                public:  bool ShowArrowZComponent;
                public:  bool ShowArrowMagnitude;
                public:  NXOpen::CAE::Post::MarkRenderStyle MarkRenderStyle;
                public:  NXOpen::CAE::Post::MarkTensorStyle MarkTensorStyle;
                public:  NXOpen::CAE::Post::MarkColor MarkColor;
                public:  NXColor* SpecifiedColor;
                public:  NXOpen::CAE::Post::MarkSize MarkSize;
                public:  NXOpen::CAE::Post::MarkMaximumSize MarkMaximumSize;
                public:  double ModelPrecentValue;
                public:  double SpecifiedLengthValue;
                public:  NXOpen::CAE::Post::MarkLocation MarkLocation;
                public:  bool HideMarksBelow;
                public:  NXOpen::CAE::Post::MarkHide BelowMarkHideType;
                public:  double BelowResultPercent;
                public:  double BelowResultValue;
                public:  bool DisplayNumericalValueWithArrow;
                public:  bool DoubleSided;
                public:  NXOpen::CAE::Post::MarkComponentCombinationType MarkComponentCombinationType;
                public:  bool ShowTensorComponent1;
                public:  bool ShowTensorComponent2;
                public:  bool ShowTensorComponent3;
                public: bool ShowTensorComponent4;
                public: bool ShowTensorComponent5;
                public:  bool DisplayComponentLabelWithArrow;
                public: bool ShowArrowResultant;
                public: NXOpen::CAE::Post::MarkResultantCompCombinationType MarkResultantCompCombinationType;
                public: Mark() :
                    ShowArrowXComponent(),
                    ShowArrowYComponent(),
                    ShowArrowZComponent(),
                    ShowArrowMagnitude(),
                    MarkRenderStyle((NXOpen::CAE::Post::MarkRenderStyle)0),
                    MarkTensorStyle((NXOpen::CAE::Post::MarkTensorStyle)0),
                    MarkColor((NXOpen::CAE::Post::MarkColor)0),
                    SpecifiedColor(),
                    MarkSize((NXOpen::CAE::Post::MarkSize)0),
                    MarkMaximumSize((NXOpen::CAE::Post::MarkMaximumSize)0),
                    ModelPrecentValue(),
                    SpecifiedLengthValue(),
                    MarkLocation((NXOpen::CAE::Post::MarkLocation)0),
                    HideMarksBelow(),
                    BelowMarkHideType((NXOpen::CAE::Post::MarkHide)0),
                    BelowResultPercent(),
                    BelowResultValue(),
                    DisplayNumericalValueWithArrow(),
                    DoubleSided(),
                    MarkComponentCombinationType((NXOpen::CAE::Post::MarkComponentCombinationType)0),
                    ShowTensorComponent1(),
                    ShowTensorComponent2(),
                    ShowTensorComponent3(),
                    ShowTensorComponent4(),
                    ShowTensorComponent5(),
                    DisplayComponentLabelWithArrow(),
                    ShowArrowResultant(),
                    MarkResultantCompCombinationType((NXOpen::CAE::Post::MarkResultantCompCombinationType)0)
                {
                }
                public: Mark(bool showArrowXComponentInitial  ,
                        bool showArrowYComponentInitial  ,
                        bool showArrowZComponentInitial  ,
                        bool showArrowMagnitudeInitial  ,
                        NXOpen::CAE::Post::MarkRenderStyle markRenderStyleInitial  ,
                        NXOpen::CAE::Post::MarkTensorStyle markTensorStyleInitial  ,
                        NXOpen::CAE::Post::MarkColor markColorInitial  ,
                        NXColor* specifiedColorInitial  ,
                        NXOpen::CAE::Post::MarkSize markSizeInitial  ,
                        NXOpen::CAE::Post::MarkMaximumSize markMaximumSizeInitial  ,
                        double modelPrecentValueInitial  ,
                        double specifiedLengthValueInitial  ,
                        NXOpen::CAE::Post::MarkLocation markLocationInitial  ,
                        bool hideMarksBelowInitial  ,
                        NXOpen::CAE::Post::MarkHide belowMarkHideTypeInitial  ,
                        double belowResultPercentInitial  ,
                        double belowResultValueInitial  ,
                        bool displayNumericalValueWithArrowInitial  ,
                        bool doubleSidedInitial  ,
                        NXOpen::CAE::Post::MarkComponentCombinationType markComponentCombinationTypeInitial  ,
                        bool showTensorComponent1Initial  ,
                        bool showTensorComponent2Initial  ,
                        bool showTensorComponent3Initial  ,
                        bool showTensorComponent4Initial ,
                        bool showTensorComponent5Initial ,
                        bool displayComponentLabelWithArrowInitial  ,
                        bool showArrowResultantInitial ,
                        NXOpen::CAE::Post::MarkResultantCompCombinationType markResultantCompCombinationTypeInitial ) :
                    ShowArrowXComponent(showArrowXComponentInitial),
                    ShowArrowYComponent(showArrowYComponentInitial),
                    ShowArrowZComponent(showArrowZComponentInitial),
                    ShowArrowMagnitude(showArrowMagnitudeInitial),
                    MarkRenderStyle(markRenderStyleInitial),
                    MarkTensorStyle(markTensorStyleInitial),
                    MarkColor(markColorInitial),
                    SpecifiedColor(specifiedColorInitial),
                    MarkSize(markSizeInitial),
                    MarkMaximumSize(markMaximumSizeInitial),
                    ModelPrecentValue(modelPrecentValueInitial),
                    SpecifiedLengthValue(specifiedLengthValueInitial),
                    MarkLocation(markLocationInitial),
                    HideMarksBelow(hideMarksBelowInitial),
                    BelowMarkHideType(belowMarkHideTypeInitial),
                    BelowResultPercent(belowResultPercentInitial),
                    BelowResultValue(belowResultValueInitial),
                    DisplayNumericalValueWithArrow(displayNumericalValueWithArrowInitial),
                    DoubleSided(doubleSidedInitial),
                    MarkComponentCombinationType(markComponentCombinationTypeInitial),
                    ShowTensorComponent1(showTensorComponent1Initial),
                    ShowTensorComponent2(showTensorComponent2Initial),
                    ShowTensorComponent3(showTensorComponent3Initial),
                    ShowTensorComponent4(showTensorComponent4Initial),
                    ShowTensorComponent5(showTensorComponent5Initial),
                    DisplayComponentLabelWithArrow(displayComponentLabelWithArrowInitial),
                    ShowArrowResultant(showArrowResultantInitial),
                    MarkResultantCompCombinationType(markResultantCompCombinationTypeInitial)
{
                }
            };

            public:
            struct StreamlineData
            {
                public:  NXOpen::CAE::Post::ValueSharingCriterion ValueShareingCriterion;
                public:  NXOpen::CAE::Post::NoDataTreatment NoDataTreatment;
                public:  double NoDataValue;
                public: StreamlineData() :
                    ValueShareingCriterion((NXOpen::CAE::Post::ValueSharingCriterion)0),
                    NoDataTreatment((NXOpen::CAE::Post::NoDataTreatment)0),
                    NoDataValue()
                {
                }
                public: StreamlineData(NXOpen::CAE::Post::ValueSharingCriterion valueShareingCriterionInitial  ,
                        NXOpen::CAE::Post::NoDataTreatment noDataTreatmentInitial  ,
                        double noDataValueInitial  ) :
                    ValueShareingCriterion(valueShareingCriterionInitial),
                    NoDataTreatment(noDataTreatmentInitial),
                    NoDataValue(noDataValueInitial)
                {
                }
            };

            public:
            struct Streamline
            {
                public:  NXOpen::CAE::Post::StreamlineData DataParams;
                public:  NXOpen::CAE::Post::StreamlineStyle StreamStyle;
                public:  NXOpen::CAE::Post::StreamlineColor StreamColor;
                public:  NXColor* SpecifiedColor;
                public:  NXOpen::CAE::Post::StreamlineSize StreamSize;
                public:  double ModelPrecentValue;
                public:  double SpecifiedLengthValue;
                public:  NXOpen::CAE::Post::StreamlineLineWeight Lineweight;
                public:  NXOpen::CAE::Post::StreamlineSynchronization StreamSync;
                public:  double BubbleTimestep;
                public: Streamline() :
                    DataParams(),
                    StreamStyle((NXOpen::CAE::Post::StreamlineStyle)0),
                    StreamColor((NXOpen::CAE::Post::StreamlineColor)0),
                    SpecifiedColor(),
                    StreamSize((NXOpen::CAE::Post::StreamlineSize)0),
                    ModelPrecentValue(),
                    SpecifiedLengthValue(),
                    Lineweight((NXOpen::CAE::Post::StreamlineLineWeight)0),
                    StreamSync((NXOpen::CAE::Post::StreamlineSynchronization)0),
                    BubbleTimestep()
                {
                }
                public: Streamline(const NXOpen::CAE::Post::StreamlineData &dataParamsInitial  ,
                        NXOpen::CAE::Post::StreamlineStyle streamStyleInitial  ,
                        NXOpen::CAE::Post::StreamlineColor streamColorInitial  ,
                        NXColor* specifiedColorInitial  ,
                        NXOpen::CAE::Post::StreamlineSize streamSizeInitial  ,
                        double modelPrecentValueInitial  ,
                        double specifiedLengthValueInitial  ,
                        NXOpen::CAE::Post::StreamlineLineWeight lineweightInitial  ,
                        NXOpen::CAE::Post::StreamlineSynchronization streamSyncInitial  ,
                        double bubbleTimestepInitial  ) :
                    DataParams(dataParamsInitial),
                    StreamStyle(streamStyleInitial),
                    StreamColor(streamColorInitial),
                    SpecifiedColor(specifiedColorInitial),
                    StreamSize(streamSizeInitial),
                    ModelPrecentValue(modelPrecentValueInitial),
                    SpecifiedLengthValue(specifiedLengthValueInitial),
                    Lineweight(lineweightInitial),
                    StreamSync(streamSyncInitial),
                    BubbleTimestep(bubbleTimestepInitial)
                {
                }
            };

            public:
            struct AnimationStreamline
            {
                public:  bool ShowGuides;
                public:  NXOpen::CAE::Post::StreamlineSynchronization StreamSync;
                public: double ActiveRegionStartFactor;
                public: double ActiveRegionEndFactor;
                public:  int NumberOfIncrements;
                public:  bool ContinuousPulse;
                public:  int NumberOfTimePeriods;
                public: double FramesPerPulse;
                public: double PulseDutycycle;
                public: AnimationStreamline() :
                    ShowGuides(),
                    StreamSync((NXOpen::CAE::Post::StreamlineSynchronization)0),
                    ActiveRegionStartFactor(),
                    ActiveRegionEndFactor(),
                    NumberOfIncrements(),
                    ContinuousPulse(),
                    NumberOfTimePeriods(),
                    FramesPerPulse(),
                    PulseDutycycle()
{
                }
                public: AnimationStreamline(bool showGuidesInitial  ,
                        NXOpen::CAE::Post::StreamlineSynchronization streamSyncInitial  ,
                        double activeRegionStartFactorInitial ,
                        double activeRegionEndFactorInitial ,
                        int numberOfIncrementsInitial  ,
                        bool continuousPulseInitial  ,
                        int numberOfTimePeriodsInitial  ,
                        double framesPerPulseInitial ,
                        double pulseDutycycleInitial ) :
                    ShowGuides(showGuidesInitial),
                    StreamSync(streamSyncInitial),
                    ActiveRegionStartFactor(activeRegionStartFactorInitial),
                    ActiveRegionEndFactor(activeRegionEndFactorInitial),
                    NumberOfIncrements(numberOfIncrementsInitial),
                    ContinuousPulse(continuousPulseInitial),
                    NumberOfTimePeriods(numberOfTimePeriodsInitial),
                    FramesPerPulse(framesPerPulseInitial),
                    PulseDutycycle(pulseDutycycleInitial)
                {
                }
            };

            public:
            struct Animation
            {
                public:  NXOpen::CAE::Post::AnimationType AnimationType;
                public:  NXOpen::CAE::Post::AnimationStyle AnimationStyle;
                public:  int NumberOfFrames;
                public:  int StartLoadcase;
                public:  int StartIteration;
                public:  int EndLoadcase;
                public:  int EndIteration;
                public:  int IterationIncrement;
                public:  bool FullCycle;
                public: int Delay;
                public:  NXOpen::CAE::Post::AnimationStreamline AnimationStreamline;
                public:  NXOpen::CAE::Post::AnimationIterationTypes IterationType;
                public:  NXOpen::CAE::BaseIteration::IterationValueType IterValueType;
                public: bool Color;
                public: bool Deformation;
                public: bool SaveFramesInMemory;
                public: Animation() :
                    AnimationType((NXOpen::CAE::Post::AnimationType)0),
                    AnimationStyle((NXOpen::CAE::Post::AnimationStyle)0),
                    NumberOfFrames(),
                    StartLoadcase(),
                    StartIteration(),
                    EndLoadcase(),
                    EndIteration(),
                    IterationIncrement(),
                    FullCycle(),
                    Delay(),
                    AnimationStreamline(),
                    IterationType((NXOpen::CAE::Post::AnimationIterationTypes)0),
                    IterValueType((NXOpen::CAE::BaseIteration::IterationValueType)0),
                    Color(),
                    Deformation(),
                    SaveFramesInMemory()
                {
                }
                public: Animation(NXOpen::CAE::Post::AnimationType animationTypeInitial  ,
                        NXOpen::CAE::Post::AnimationStyle animationStyleInitial  ,
                        int numberOfFramesInitial  ,
                        int startLoadcaseInitial  ,
                        int startIterationInitial  ,
                        int endLoadcaseInitial  ,
                        int endIterationInitial  ,
                        int iterationIncrementInitial  ,
                        bool fullCycleInitial  ,
                        int delayInitial ,
                        const NXOpen::CAE::Post::AnimationStreamline &animationStreamlineInitial  ,
                        NXOpen::CAE::Post::AnimationIterationTypes iterationTypeInitial  ,
                        NXOpen::CAE::BaseIteration::IterationValueType iterValueTypeInitial  ,
                        bool colorInitial ,
                        bool deformationInitial ,
                        bool saveFramesInMemoryInitial ) :
                    AnimationType(animationTypeInitial),
                    AnimationStyle(animationStyleInitial),
                    NumberOfFrames(numberOfFramesInitial),
                    StartLoadcase(startLoadcaseInitial),
                    StartIteration(startIterationInitial),
                    EndLoadcase(endLoadcaseInitial),
                    EndIteration(endIterationInitial),
                    IterationIncrement(iterationIncrementInitial),
                    FullCycle(fullCycleInitial),
                    Delay(delayInitial),
                    AnimationStreamline(animationStreamlineInitial),
                    IterationType(iterationTypeInitial),
                    IterValueType(iterValueTypeInitial),
                    Color(colorInitial),
                    Deformation(deformationInitial),
                    SaveFramesInMemory(saveFramesInMemoryInitial)
                {
                }
            };

            public:
            struct AnimationParameters
            {
                public:  NXOpen::CAE::Post::AnimationType AnimationType;
                public:  NXOpen::CAE::Post::AnimationStyle AnimationStyle;
                public:  int NumberOfFrames;
                public: NXOpen::CAE::Iteration * AnimStartIteration;
                public: NXOpen::CAE::Iteration * AnimEndIteration;
                public:  int IterationIncrement;
                public:  bool FullCycle;
                public: int Delay;
                public:  NXOpen::CAE::Post::AnimationStreamline AnimationStreamline;
                public:  NXOpen::CAE::Post::AnimationIterationTypes IterationType;
                public:  NXOpen::CAE::BaseIteration::IterationValueType IterValueType;
                public: bool Color;
                public: bool Deformation;
                public: bool SaveFramesInMemory;
                public: double StartPhaseAngle;
                public:  double EndPhaseAngle;
                public: AnimationParameters() :
                    AnimationType((NXOpen::CAE::Post::AnimationType)0),
                    AnimationStyle((NXOpen::CAE::Post::AnimationStyle)0),
                    NumberOfFrames(),
                    AnimStartIteration(),
                    AnimEndIteration(),
                    IterationIncrement(),
                    FullCycle(),
                    Delay(),
                    AnimationStreamline(),
                    IterationType((NXOpen::CAE::Post::AnimationIterationTypes)0),
                    IterValueType((NXOpen::CAE::BaseIteration::IterationValueType)0),
                    Color(),
                    Deformation(),
                    SaveFramesInMemory(),
                    StartPhaseAngle(),
                    EndPhaseAngle()
{
                }
                public: AnimationParameters(NXOpen::CAE::Post::AnimationType animationTypeInitial  ,
                        NXOpen::CAE::Post::AnimationStyle animationStyleInitial  ,
                        int numberOfFramesInitial  ,
                        NXOpen::CAE::Iteration * animStartIterationInitial ,
                        NXOpen::CAE::Iteration * animEndIterationInitial  ,
                        int iterationIncrementInitial  ,
                        bool fullCycleInitial  ,
                        int delayInitial ,
                        const NXOpen::CAE::Post::AnimationStreamline &animationStreamlineInitial  ,
                        NXOpen::CAE::Post::AnimationIterationTypes iterationTypeInitial  ,
                        NXOpen::CAE::BaseIteration::IterationValueType iterValueTypeInitial  ,
                        bool colorInitial ,
                        bool deformationInitial ,
                        bool saveFramesInMemoryInitial ,
                        double startPhaseAngleInitial ,
                        double endPhaseAngleInitial  ) :
                    AnimationType(animationTypeInitial),
                    AnimationStyle(animationStyleInitial),
                    NumberOfFrames(numberOfFramesInitial),
                    AnimStartIteration(animStartIterationInitial),
                    AnimEndIteration(animEndIterationInitial),
                    IterationIncrement(iterationIncrementInitial),
                    FullCycle(fullCycleInitial),
                    Delay(delayInitial),
                    AnimationStreamline(animationStreamlineInitial),
                    IterationType(iterationTypeInitial),
                    IterValueType(iterValueTypeInitial),
                    Color(colorInitial),
                    Deformation(deformationInitial),
                    SaveFramesInMemory(saveFramesInMemoryInitial),
                    StartPhaseAngle(startPhaseAngleInitial),
                    EndPhaseAngle(endPhaseAngleInitial)
                {
                }
            };

            public:
            struct Clipping
            {
                public:  bool ShowOutline;
                public:  bool ShowClippedGhost;
                public:  double ClipValue;
                public:  NXOpen::CAE::Post::ClipSide Side;
                public:  NXOpen::CAE::Post::ClipPlane Plane;
                public: NXOpen::CAE::Result::CoordinateSystem PlaneCoordinateSystem;
                public: Clipping() :
                    ShowOutline(),
                    ShowClippedGhost(),
                    ClipValue(),
                    Side((NXOpen::CAE::Post::ClipSide)0),
                    Plane((NXOpen::CAE::Post::ClipPlane)0),
                    PlaneCoordinateSystem((NXOpen::CAE::Result::CoordinateSystem)0)
                {
                }
                public: Clipping(bool showOutlineInitial  ,
                        bool showClippedGhostInitial  ,
                        double clipValueInitial  ,
                        NXOpen::CAE::Post::ClipSide sideInitial  ,
                        NXOpen::CAE::Post::ClipPlane planeInitial  ,
                        NXOpen::CAE::Result::CoordinateSystem planeCoordinateSystemInitial ) :
                    ShowOutline(showOutlineInitial),
                    ShowClippedGhost(showClippedGhostInitial),
                    ClipValue(clipValueInitial),
                    Side(sideInitial),
                    Plane(planeInitial),
                    PlaneCoordinateSystem(planeCoordinateSystemInitial)
                {
                }
            };

            public:
            struct Axisymmetric
            {
                public:  int NumberOfSection;
                public:  double RevolveAngle;
                public:  NXOpen::CAE::Post::AxisymetricAxis AxisymAxis;
                public: Axisymmetric() :
                    NumberOfSection(),
                    RevolveAngle(),
                    AxisymAxis((NXOpen::CAE::Post::AxisymetricAxis)0)
                {
                }
                public: Axisymmetric(int numberOfSectionInitial  ,
                        double revolveAngleInitial  ,
                        NXOpen::CAE::Post::AxisymetricAxis axisymAxisInitial  ) :
                    NumberOfSection(numberOfSectionInitial),
                    RevolveAngle(revolveAngleInitial),
                    AxisymAxis(axisymAxisInitial)
                {
                }
            };

            public:
            struct AnnotationBox
            {
                public:  NXColor* LineColor;
                public:  NXColor* AreaColor;
                public:  bool ShowBorder;
                public:  bool FillArea;
                public:  bool AreaTranslucency;
                public: AnnotationBox() :
                    LineColor(),
                    AreaColor(),
                    ShowBorder(),
                    FillArea(),
                    AreaTranslucency()
{
                }
                public: AnnotationBox(NXColor* lineColorInitial  ,
                        NXColor* areaColorInitial  ,
                        bool showBorderInitial  ,
                        bool fillAreaInitial  ,
                        bool areaTranslucencyInitial  ) :
                    LineColor(lineColorInitial),
                    AreaColor(areaColorInitial),
                    ShowBorder(showBorderInitial),
                    FillArea(fillAreaInitial),
                    AreaTranslucency(areaTranslucencyInitial)
                {
                }
            };

            public:
            struct Text
            {
                public:  int Font;
                public:  int Size;
                public:  NXColor* Color;
                public:  int Bold;
                public: Text() :
                    Font(),
                    Size(),
                    Color(),
                    Bold()
                {
                }
                public: Text(int fontInitial  ,
                        int sizeInitial  ,
                        NXColor* colorInitial  ,
                        int boldInitial  ) :
                    Font(fontInitial),
                    Size(sizeInitial),
                    Color(colorInitial),
                    Bold(boldInitial)
                {
                }
            };

            public:
            struct StreamlineExtraction
            {
                public:  NXOpen::CAE::Post::StreamlineDirection Direction;
                public:  double MaximumTimeElapsed;
                public:  int MaxIntegrationSteps;
                public:  bool LimitStepSize;
                public:  double MaximumStepSize;
                public: NXOpen::CAE::Post::IntegrationScheme IntegrationScheme;
                public:  bool DisjointRestart;
                public: StreamlineExtraction() :
                    Direction((NXOpen::CAE::Post::StreamlineDirection)0),
                    MaximumTimeElapsed(),
                    MaxIntegrationSteps(),
                    LimitStepSize(),
                    MaximumStepSize(),
                    IntegrationScheme((NXOpen::CAE::Post::IntegrationScheme)0),
                    DisjointRestart()
                {
                }
                public: StreamlineExtraction(NXOpen::CAE::Post::StreamlineDirection directionInitial  ,
                        double maximumTimeElapsedInitial  ,
                        int maxIntegrationStepsInitial  ,
                        bool limitStepSizeInitial  ,
                        double maximumStepSizeInitial  ,
                        NXOpen::CAE::Post::IntegrationScheme integrationSchemeInitial ,
                        bool disjointRestartInitial  ) :
                    Direction(directionInitial),
                    MaximumTimeElapsed(maximumTimeElapsedInitial),
                    MaxIntegrationSteps(maxIntegrationStepsInitial),
                    LimitStepSize(limitStepSizeInitial),
                    MaximumStepSize(maximumStepSizeInitial),
                    IntegrationScheme(integrationSchemeInitial),
                    DisjointRestart(disjointRestartInitial)
                {
                }
            };

            public:
            struct StreamlineSeed
            {
                public:  NXOpen::CAE::Post::StreamlineExtraction Extraction;
                public:  NXOpen::Point3d Coordinates;
                public: int ElementId;
                public: StreamlineSeed() :
                    Extraction(),
                    Coordinates(),
                    ElementId()
                {
                }
                public: StreamlineSeed(const NXOpen::CAE::Post::StreamlineExtraction &extractionInitial  ,
                        const NXOpen::Point3d &coordinatesInitial  ,
                        int elementIdInitial ) :
                    Extraction(extractionInitial),
                    Coordinates(coordinatesInitial),
                    ElementId(elementIdInitial)
{
                }
            };

            public:
            struct GraphParameters
            {
                public: bool UseDeformedConfiguration;
                public:  bool IncludeIntersections;
                public:  NXOpen::CAE::Post::NodeValueSharingCriterion ValueShareingCriterion;
                public:  NXOpen::CAE::Post::NoDataTreatment NoDataTreatment;
                public:  double NoDataValue;
                public:  NXOpen::CAE::Post::Abcissa Abcissa;
                public: GraphParameters() :
                    UseDeformedConfiguration(),
                    IncludeIntersections(),
                    ValueShareingCriterion((NXOpen::CAE::Post::NodeValueSharingCriterion)0),
                    NoDataTreatment((NXOpen::CAE::Post::NoDataTreatment)0),
                    NoDataValue(),
                    Abcissa((NXOpen::CAE::Post::Abcissa)0)
                {
                }
                public: GraphParameters(bool useDeformedConfigurationInitial ,
                        bool includeIntersectionsInitial  ,
                        NXOpen::CAE::Post::NodeValueSharingCriterion valueShareingCriterionInitial  ,
                        NXOpen::CAE::Post::NoDataTreatment noDataTreatmentInitial  ,
                        double noDataValueInitial  ,
                        NXOpen::CAE::Post::Abcissa abcissaInitial  ) :
                    UseDeformedConfiguration(useDeformedConfigurationInitial),
                    IncludeIntersections(includeIntersectionsInitial),
                    ValueShareingCriterion(valueShareingCriterionInitial),
                    NoDataTreatment(noDataTreatmentInitial),
                    NoDataValue(noDataValueInitial),
                    Abcissa(abcissaInitial)
                {
                }
            };

            public:
            struct GraphIds
            {
                public:  int GraphFileId;
                public:  int GraphSetId;
                public: GraphIds() :
                    GraphFileId(),
                    GraphSetId()
                {
                }
                public: GraphIds(int graphFileIdInitial  ,
                        int graphSetIdInitial  ) :
                    GraphFileId(graphFileIdInitial),
                    GraphSetId(graphSetIdInitial)
                {
                }
            };

            public:
            struct ASCIIDiffTolerances
            {
                public: double Coorderr;
                public: double Dataerr;
                public: double Rgbtol;
                public: double Coordtol;
                public: double Datatol;
                public: double Zerotol;
                public: ASCIIDiffTolerances() :
                    Coorderr(),
                    Dataerr(),
                    Rgbtol(),
                    Coordtol(),
                    Datatol(),
                    Zerotol()
                {
                }
                public: ASCIIDiffTolerances(double coorderrInitial ,
                        double dataerrInitial ,
                        double rgbtolInitial ,
                        double coordtolInitial ,
                        double datatolInitial ,
                        double zerotolInitial ) :
                    Coorderr(coorderrInitial),
                    Dataerr(dataerrInitial),
                    Rgbtol(rgbtolInitial),
                    Coordtol(coordtolInitial),
                    Datatol(datatolInitial),
                    Zerotol(zerotolInitial)
                {
                }
            };

            public: enum MassSizeOption
            {
                MassSizeOptionPercentageOfModel ,
                MassSizeOptionSpecifiedLength
            };

            public:
            struct Mass
            {
                public:  NXOpen::CAE::Post::MassSizeOption MassSizeOption;
                public:  double ModelPrecentValue;
                public:  double SpecifiedLengthValue;
                public: Mass() :
                    MassSizeOption((NXOpen::CAE::Post::MassSizeOption)0),
                    ModelPrecentValue(),
                    SpecifiedLengthValue()
{
                }
                public: Mass(NXOpen::CAE::Post::MassSizeOption massSizeOptionInitial  ,
                        double modelPrecentValueInitial  ,
                        double specifiedLengthValueInitial  ) :
                    MassSizeOption(massSizeOptionInitial),
                    ModelPrecentValue(modelPrecentValueInitial),
                    SpecifiedLengthValue(specifiedLengthValueInitial)
                {
                }
            };

            public: enum SpringSizeOption
            {
                SpringSizeOptionPercentageOfModel ,
                SpringSizeOptionSpecifiedLength
            };

            public:
            struct Spring
            {
                public:  NXOpen::CAE::Post::SpringSizeOption SpringSizeOption;
                public:  double ModelPrecentValue;
                public:  double SpecifiedLengthValue;
                public: Spring() :
                    SpringSizeOption((NXOpen::CAE::Post::SpringSizeOption)0),
                    ModelPrecentValue(),
                    SpecifiedLengthValue()
                {
                }
                public: Spring(NXOpen::CAE::Post::SpringSizeOption springSizeOptionInitial  ,
                        double modelPrecentValueInitial  ,
                        double specifiedLengthValueInitial  ) :
                    SpringSizeOption(springSizeOptionInitial),
                    ModelPrecentValue(modelPrecentValueInitial),
                    SpecifiedLengthValue(specifiedLengthValueInitial)
                {
                }
            };

            public:
            struct NodalForceReportDisplaySettings
            {
                public:  bool DisplayAtCentroid;
                public: NodalForceReportDisplaySettings() :
                    DisplayAtCentroid()
                {
                }
                public: NodalForceReportDisplaySettings(bool displayAtCentroidInitial  ) :
                    DisplayAtCentroid(displayAtCentroidInitial)
                {
                }
            };
            private: PostImpl * m_post_impl;
            private: NXOpen::Session* m_owner;
            public: explicit Post(NXOpen::Session *owner);
            public:
            tag_t Tag() const;
            public: ~Post();
            public: std::vector<int> GetPostviewIds
            (
            );
            public: int GetMainPostviewIdInActivePart
            (
            );
            public: void SetMainPostviewIdInActivePart
            (
                int postviewId 
            );
            public: int LoadImportedResult
            (
                const NXString & resultName  ,
                const NXString & fileName  ,
                const std::vector<NXOpen::Unit *> & units 
            );
            int LoadImportedResult
            (
                const char * resultName  ,
                const char * fileName  ,
                const std::vector<NXOpen::Unit *> & units 
            );
            public: int LoadRaEventResult
            (
                NXOpen::CAE::ResponseSimulation::RSEvent * raEvent 
            );
            public: void UnloadResultFile
            (
                const NXString & fileName 
            );
            void UnloadResultFile
            (
                const char * fileName 
            );
            public: void UnloadResult
            (
                int resultId 
            );
            public: void UpdateUserGroupsFromSimPart
            (
                NXOpen::CAE::SimPart * simpart 
            );
            public: int CreateNewPostview
            (
                int viewIndex ,
                int resultId  ,
                bool overlay  ,
                NXOpen::CAE::Post::DisplayColorSchemeType colorscheme 
            );
            public: NX_DEPRECATED("自 NX7.5.1 起弃用。请改用 NXOpen::CAE::Post::CreatePostviewForResult。") int CreatePostviewForResult
            (
                int viewIndex ,
                int resultId  ,
                bool overlay  ,
                const NXOpen::CAE::Result::ResultParameters & result 
            );
            public: int CreateNewPostviewForResult
            (
                int viewIndex ,
                int resultId  ,
                bool overlay  ,
                const NXOpen::CAE::Result::ResultParameters & result  ,
                NXOpen::CAE::Post::DisplayColorSchemeType colorscheme 
            );
            public: int CreateCrossSectionViewForResult
            (
                int viewIndex ,
                int resultId  ,
                NXOpen::CAE::CrossSectionParameters * result 
            );
            public: void DeleteViewport
            (
                int viewIndex 
            );
            public: void PostviewRename
            (
                int postviewId  ,
                const NXString & newName 
            );
            void PostviewRename
            (
                int postviewId  ,
                const char * newName 
            );
            public: void PostviewDelete
            (
                int postviewId 
            );
            public: void PostviewSetCurrentInOverlay
            (
                int postviewId 
            );
            public: NX_DEPRECATED("Deprecated in NX11.0.0.  Use NXOpen::CAE::Post::PostviewAnimationPlay instead.") void PostviewAnimationPlay
            (
                int postviewId  ,
                const NXOpen::CAE::Post::Animation & animation 
            );
            public: void PostviewAnimationControl
            (
                int postviewId  ,
                NXOpen::CAE::Post::AnimationControl control  ,
                int frame ,
                bool fullCycle ,
                int delay 
            );
            public: void PostviewAnimationControlStreamline
            (
                int postviewId  ,
                const NXOpen::CAE::Post::AnimationStreamline & control 
            );
            public: void PostviewAnimationVectorDisplaySizeControl
            (
                int postviewId  ,
                bool vectorDisplaySizeControl 
            );
            public: void PostviewMarkerOnOff
            (
                int postviewId  ,
                bool showMarker 
            );
            public: void PostviewApplyTemplate
            (
                int postviewId  ,
                int templateId 
            );
            public: void PostviewApplyTemplateFile
            (
                int postviewId  ,
                const NXString & xmlFileName 
            );
            void PostviewApplyTemplateFile
            (
                int postviewId  ,
                const char * xmlFileName 
            );
            public: void PostviewApplyShowAll
            (
                int postviewId 
            );
            public: void PostviewApplyGroupContainerVisibility
            (
                int postviewId  ,
                NXOpen::CAE::Result::GroupContainer container  ,
                bool visibility 
            );
            public: void PostviewApplySEVisibility
            (
                int postviewId  ,
                int superelementId  ,
                bool visibility 
            );
            public: void PostviewApplySERepresentation
            (
                int postviewId  ,
                int superelementId  ,
                NXOpen::CAE::Result::SuperElementRep representation 
            );
            public: void PostviewApplySERepresentation
            (
                int postviewId  ,
                const std::vector<int> & superelementIds  ,
                NXOpen::CAE::Result::SuperElementRep representation 
            );
            public: void PostviewApplyAllSEVis
            (
                int pvid  ,
                bool visibility 
            );
            public: void PostviewAskSERepresentations
            (
                int postviewId  ,
                int superelementId  ,
                std::vector<NXOpen::CAE::Result::SuperElementRep> & representation 
            );
            public: void PostviewApplyGroupContainerVisibility
            (
                int postviewId  ,
                NXOpen::CAE::Result * result  ,
                NXOpen::CAE::Result::GroupContainer container  ,
                bool visibility 
            );
            public: void PostviewApplyGroupContainerVisibility
            (
                int postviewId  ,
                const std::vector<NXOpen::CAE::Result::GroupContainer> & container  ,
                bool visibility 
            );
            public: void PostviewApplyGroupContainerVisibility
            (
                int postviewId  ,
                NXOpen::CAE::Result * result  ,
                const std::vector<NXOpen::CAE::Result::GroupContainer> & container  ,
                bool visibility 
            );
            public: void PostviewApplyGroupVisibility
            (
                int postviewId  ,
                NXOpen::CAE::Result::GroupContainer container  ,
                int group ,
                bool visibility 
            );
            public: void PostviewApplyGroupVisibility
            (
                int postviewId  ,
                int resultId  ,
                NXOpen::CAE::Result::GroupContainer container  ,
                int group ,
                bool visibility 
            );
            public: void PostviewApplyGroupVisibility
            (
                int postviewId  ,
                const std::vector<NXOpen::CAE::Result::GroupContainer> & container  ,
                const std::vector<int> & group  ,
                bool visibility 
            );
            public: void PostviewApplyGroupVisibility
            (
                int postviewId  ,
                int resultId  ,
                const std::vector<NXOpen::CAE::Result::GroupContainer> & container  ,
                const std::vector<int> & group  ,
                bool visibility 
            );
            public: void PostviewApplyCsysContainerVisibility
            (
                int postviewId  ,
                bool visibility 
            );
            public: void PostviewApplyCsysVisibility
            (
                int postviewId  ,
                int id ,
                bool visibility 
            );
            public: void PostviewApplyUserGroupVisibility
            (
                int postviewId  ,
                const std::vector<int> & usergroupIds  ,
                NXOpen::CAE::Post::GroupVisibility visibility 
            );
            public: void PostviewApplyUserGroupVisibility
            (
                int postviewId  ,
                NXOpen::CAE::Result * result  ,
                const std::vector<int> & usergroupIds  ,
                NXOpen::CAE::Post::GroupVisibility visibility 
            );
            public: void PostviewApplyUserGroupVisibility
            (
                int postviewId  ,
                const std::vector<NXOpen::CAE::Result *> & results  ,
                const std::vector<int> & usergroupIds  ,
                NXOpen::CAE::Post::GroupVisibility visibility 
            );
            public: void PostviewGetUserGroupGids
            (
                int postviewId  ,
                const std::vector<NXString> & usergroupNames  ,
                std::vector<int> & usergroupsGids 
            );
            public: NX_DEPRECATED("Deprecated in NX1847.0.0.  Use NXOpen::CAE::Post::PostviewSetStyle instead.") void PostviewSetStyle
            (
                int postviewId  ,
                int showStyle  ,
                NXOpen::CAE::Post::Style style 
            );
            public: void NodalForceReportSetDisplayAtCentroid
            (
                int postviewId  ,
                bool displayAtCentroid 
            );
            public: bool NodalForceReportGetDisplayAtCentroid
            (
                int postviewId 
            );
            public: void PostviewSetStyle
            (
                int postviewId  ,
                int showStyle  ,
                NXOpen::CAE::Post::PlotStyle style 
            );
            public: void PostviewSetColorbarStyle
            (
                int postviewId  ,
                NXOpen::CAE::Post::ColorbarStyle colorbarStyle 
            );
            public: void PostViewSetColorScheme
            (
                int postviewId  ,
                NXOpen::CAE::Post::DisplayColorSchemeType colorScheme 
            );
            public: void PostviewSetTarget
            (
                int postviewId  ,
                NXOpen::CAE::Post::Target target 
            );
            public: NX_DEPRECATED("Deprecated in NX7.5.1.  Use NXOpen::CAE::Post::PostviewSetResult instead.") void PostviewSetResult
            (
                int postviewId  ,
                const NXOpen::CAE::Result::ResultParameters & result 
            );
            public: void PostviewSetBandStyle
            (
                int postviewId  ,
                NXOpen::CAE::Post::BandStyle bandstyle 
            );
            public: void CrossSectionViewSetResult
            (
                int postviewId  ,
                NXOpen::CAE::CrossSectionParameters * result 
            );
            public: NX_DEPRECATED("Deprecated in NX7.5.1.  Use NXOpen::CAE::Post::PostviewSetDeformation instead.") void PostviewSetDeformation
            (
                int postviewId  ,
                const NXOpen::CAE::Result::DeformationParameters & deformation 
            );
            public: NX_DEPRECATED("Deprecated in NX7.5.1.  Use NXOpen::CAE::Post::PostviewSetStreamlineVelocity instead.") void PostviewSetStreamlineVelocity
            (
                int postviewId  ,
                const NXOpen::CAE::Result::VelocityParameters & velocity 
            );
            public: void PostviewSetStreamlineSeedSet
            (
                int postviewId  ,
                int seedsetId 
            );
            public: void PostviewSetMark
            (
                int postviewId  ,
                const NXOpen::CAE::Post::Mark & mark 
            );
            public: void PostviewSetStreamline
            (
                int postviewId  ,
                const NXOpen::CAE::Post::Streamline & streamline 
            );
            public: void PostviewSetDeformed
            (
                int postviewId  ,
                bool deformed 
            );
            public: void PostviewSetUndeformed
            (
                int postviewId  ,
                bool undeformed 
            );
            public: void PostviewSetColorDisplayDeformationSynchronization
            (
                int postviewId  ,
                bool synchronization 
            );
            public: void PostviewSetDeformedUndeformedSynchronization
            (
                int postviewId  ,
                bool showDeformedPrimaryDisplay  ,
                bool showUndeformedModel  ,
                bool synchronizeLoadCaseAndIteration 
            );
            public: void PostviewSetColorbar
            (
                int postviewId  ,
                const NXOpen::CAE::Post::Colorbar & colorbar 
            );
            public: NX_DEPRECATED("Deprecated in NX1847.0.0.  Use NXOpen::CAE::Post::PostviewSetColorbar and NXOpen::CAE::Post::PostviewSetColorbar instead.") void PostviewSetColorbar
            (
                int postviewId ,
                const NXOpen::CAE::Post::Colorbar & colorbar ,
                bool customOverwrite  ,
                const std::vector<double> & rangeValue ,
                const std::vector<NXOpen::NXColor::Rgb> & rangeColors 
            );
            public: void PostviewSetColorbar
            (
                int postviewId ,
                const NXOpen::CAE::Post::Colorbar & colorbar ,
                bool customOverwriteValue  ,
                bool customOverwriteColor  ,
                const std::vector<double> & rangeValue ,
                const std::vector<NXOpen::NXColor::Rgb> & rangeColors 
            );
            public: NXOpen::CAE::Post::Colorbar PostviewGetColorbar
            (
                int postviewId  ,
                int* customOverwrite 
            );
            public: NXOpen::CAE::Post::Colorbar PostviewGetColorbarWithCustomOptions
            (
                int postviewId  ,
                bool* customOverwriteValue  ,
                bool* customOverwriteColor 
            );
            public: void PostviewSetShowHeader
            (
                int postviewId  ,
                NXOpen::CAE::Post::ShowHeader showHeader 
            );
            public: void PostviewSetHeaderlines
            (
                int postviewId  ,
                const std::vector<NXOpen::CAE::Post::Headerlines> & headerlines 
            );
            public: NXOpen::CAE::Post::ShowHeader PostviewGetShowHeader
            (
                int postviewId 
            );
            public: NX_DEPRECATED("Deprecated in NX8.5.0.  Use NXOpen::CAE::Post::PostviewSetShowHeader and NXOpen::CAE::Post::PostviewSetColorbar instead.") void PostviewSetLegend
            (
                int postviewId  ,
                bool showLegend  ,
                NXOpen::CAE::Post::Legend legend 
            );
            public: NX_DEPRECATED("Deprecated in NX12.0.0.  Use NXOpen::CAE::Post::PostviewSetEdgeFace instead.") void PostviewSetEdgeFace
            (
                int postviewId  ,
                const NXOpen::CAE::Post::EdgeFace & primaryEdgeface  ,
                const NXOpen::CAE::Post::EdgeFace & undeformedEdgeface 
            );
            public: NX_DEPRECATED("Deprecated in NX12.0.0.  Use NXOpen::CAE::Post::PostviewSetEdgeFace instead.") void PostviewSetEdgeFace
            (
                int postviewId  ,
                const NXOpen::CAE::Post::EdgeFace & edgeface 
            );
            public: void CrossSectionViewSetLockRotation
            (
                int postviewId  ,
                bool lockRotation 
            );
            public: void PostviewSetText
            (
                int postviewId  ,
                const NXOpen::CAE::Post::Text & text 
            );
            public: NXOpen::CAE::Post::Text PostviewGetText
            (
                int postviewId 
            );
            public: void PostviewSetFormat
            (
                int postviewId  ,
                NXOpen::CAE::Post::Format format  ,
                int numdecimal 
            );
            public: void PostviewGetFormat
            (
                int postviewId  ,
                NXOpen::CAE::Post::Format* format  ,
                int* numdecimal 
            );
            public: NX_DEPRECATED("Deprecated in NX12.0.0.  Set NXOpen::CAE::PostPreference Position set through post preferences instead.") void PostviewSetPosition
            (
                int postviewId  ,
                NXOpen::CAE::Post::Position position 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Set NXOpen::CAE::PostAnnotation show hide instead.") void PostviewSetMarker
            (
                int postviewId  ,
                bool showMarker  ,
                NXOpen::CAE::Post::Marker marker 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  Set NXOpen::CAE::PostAnnotation Display Attribute directly instead.") void PostviewSetAnnotationBox
            (
                int postviewId  ,
                const NXOpen::CAE::Post::AnnotationBox & annotationBox 
            );
            public: void PostviewSetFontSize
            (
                int postviewId  ,
                bool autoFontSize  ,
                double fontScale 
            );
            public: void PostviewGetFontSize
            (
                int postviewId  ,
                int* autoFontSize  ,
                double* fontScale 
            );
            public: void PostviewSetAxisymmetric
            (
                int postviewId  ,
                const NXOpen::CAE::Post::Axisymmetric & axisymmetric 
            );
            public: NX_DEPRECATED("Deprecated in NX7.5.1.  Use NXOpen::CAE::Post::PostviewSetClipping instead.") void PostviewSetClipping
            (
                int postviewId  ,
                const NXOpen::CAE::Post::Clipping & clipping 
            );
            public: void PostviewSetLighting
            (
                int postviewId  ,
                bool lighted 
            );
            public: void PostviewSetCompression
            (
                int postviewId  ,
                bool compress ,
                double featureangle ,
                double banddifference 
            );
            public: void PostviewSetClipping
            (
                int postviewId  ,
                NXOpen::CAE::ClippingParameters * clipping 
            );
            public: void PostviewSetGroupContainerVisibility
            (
                int postviewId  ,
                NXOpen::CAE::Result::GroupContainer container  ,
                bool visibility 
            );
            public: void PostviewSetGroupVisibility
            (
                int postviewId  ,
                NXOpen::CAE::Result::GroupContainer container  ,
                int group ,
                bool visibility 
            );
            public: void PostviewUpdate
            (
                int postviewId 
            );
            public: NX_DEPRECATED("Deprecated in NX1926.0.0.  use NXOpen::CAE::Post::PostviewCaptureAllViewportsToGif for multiple animations.") void PostviewCaptureAnimatedGif
            (
                int postviewId  ,
                const NXString & fileName  ,
                bool includeOverlayedPostviews  ,
                bool whiteBackground 
            );
            void PostviewCaptureAnimatedGif
            (
                int postviewId  ,
                const char * fileName  ,
                bool includeOverlayedPostviews  ,
                bool whiteBackground 
            );
            public: void PostviewExportDisplay
            (
                int postviewId  ,
                const NXString & fileName  ,
                NXOpen::CAE::Post::Export format  ,
                bool ignoreClipping  ,
                bool ignoreVisibility 
            );
            void PostviewExportDisplay
            (
                int postviewId  ,
                const char * fileName  ,
                NXOpen::CAE::Post::Export format  ,
                bool ignoreClipping  ,
                bool ignoreVisibility 
            );
            public: int PostviewSaveTemplate
            (
                int postviewId 
            );
            public: void PostviewExportTemplate
            (
                int postviewId  ,
                const NXString & xmlFileName 
            );
            void PostviewExportTemplate
            (
                int postviewId  ,
                const char * xmlFileName 
            );
            public: void PostviewSetCriticalPlyIdDisplay
            (
                int postviewId ,
                bool displayCriticalPlies 
            );
            public: void PostviewSetCriticalLayerIdDisplay
            (
                int postviewId ,
                bool displayCriticalLayers 
            );
            public: void PostviewSetCriticalLoadIdDisplay
            (
                int postviewId ,
                bool displayCriticalLoads 
            );
            public: int CreateUserGroupFromEntityLabels
            (
                int postviewId  ,
                NXOpen::CAE::CaeGroupCollection::EntityType entityType  ,
                const std::vector<int> & labels 
            );
            public: int CreateUserGroupFromEntityLabels
            (
                int postviewId  ,
                NXOpen::CAE::Result * result  ,
                NXOpen::CAE::CaeGroupCollection::EntityType entityType  ,
                const std::vector<int> & labels 
            );
            public: NX_DEPRECATED("Deprecated in NX11.0.0.  use NXOpen::CAE::Post::UserGroupRename with resulttag.") void UserGroupRename
            (
                int usergroupId  ,
                const NXString & newName 
            );
            void UserGroupRename
            (
                int usergroupId  ,
                const char * newName 
            );
            public: NX_DEPRECATED("Deprecated in NX11.0.0.  use NXOpen::CAE::Post::UserGroupDelete with resulttag.") void UserGroupDelete
            (
                int usergroupId 
            );
            public: int CreateStreamlineSeedSet
            (
                int postviewId  ,
                const NXString & name  ,
                const std::vector<NXOpen::CAE::Post::StreamlineSeed> & seeds 
            );
            int CreateStreamlineSeedSet
            (
                int postviewId  ,
                const char * name  ,
                const std::vector<NXOpen::CAE::Post::StreamlineSeed> & seeds 
            );
            public: void StreamlineSeedSetDelete
            (
                int seedsetId 
            );
            public: NX_DEPRECATED("Deprecated in NX11.0.0.  use NXOpen::CAE::ResultManager::CreateQueryCurvePost with nodes, elements or free points.") int CreatePathFromNodeIds
            (
                int postviewId  ,
                const NXString & name  ,
                const std::vector<int> & nodeIds 
            );
            int CreatePathFromNodeIds
            (
                int postviewId  ,
                const char * name  ,
                const std::vector<int> & nodeIds 
            );
            public: NX_DEPRECATED("自NX11.0.0起已弃用。请使用NXOpen::CAE::ResultManager::CreateQueryCurvePost配合节点、单元或自由点。") int CreatePathFromElemIds
            (
                int postviewId  ,
                const NXString & name  ,
                const std::vector<int> & elemIds 
            );
            int CreatePathFromElemIds
            (
                int postviewId  ,
                const char * name  ,
                const std::vector<int> & elemIds 
            );
            public: NX_DEPRECATED("自NX11.0.0起已弃用。请使用NXOpen::CAE::ResultManager::CreateQueryCurvePost配合节点、单元或自由点。") int CreatePathFromPoints
            (
                int postviewId  ,
                const NXString & name  ,
                const std::vector<double> & points  ,
                int numberOfInsertPointsPerSegment 
            );
            int CreatePathFromPoints
            (
                int postviewId  ,
                const char * name  ,
                const std::vector<double> & points  ,
                int numberOfInsertPointsPerSegment 
            );
            public: NX_DEPRECATED("自NX11.0.0起已弃用。请使用NXOpen::CAE::ResultManager::DeleteQueryCurve来删除查询曲线") void PathDelete
            (
                int pathId 
            );
            public: NXOpen::CAE::Post::GraphIds CreateSpatialGraph
            (
                int postviewId  ,
                const NXString & name  ,
                const NXOpen::CAE::Post::GraphParameters & graph  ,
                int pathId 
            );
            NXOpen::CAE::Post::GraphIds CreateSpatialGraph
            (
                int postviewId  ,
                const char * name  ,
                const NXOpen::CAE::Post::GraphParameters & graph  ,
                int pathId 
            );
            public: NXOpen::CAE::Post::GraphIds CreateHistoryGraph
            (
                int postviewId  ,
                const NXString & name  ,
                const NXOpen::CAE::Post::GraphParameters & graph  ,
                int startIteration  ,
                int endIteration  ,
                int iterationIncrement  ,
                int nodeLabel  ,
                const std::vector<double> & point 
            );
            NXOpen::CAE::Post::GraphIds CreateHistoryGraph
            (
                int postviewId  ,
                const char * name  ,
                const NXOpen::CAE::Post::GraphParameters & graph  ,
                int startIteration  ,
                int endIteration  ,
                int iterationIncrement  ,
                int nodeLabel  ,
                const std::vector<double> & point 
            );
            public: void PlotGraph
            (
                int viewIndex  ,
                const NXOpen::CAE::Post::GraphIds & graphIds  ,
                bool overlay 
            );
            public: void GraphDelete
            (
                const NXOpen::CAE::Post::GraphIds & graphIds 
            );
            public: void TemplateDelete
            (
                int templateId 
            );
            public: void TemplateRename
            (
                int templateId  ,
                const NXString & newName 
            );
            void TemplateRename
            (
                int templateId  ,
                const char * newName 
            );
            public: int TemplateSearch
            (
                const NXString & name 
            );
            int TemplateSearch
            (
                const char * name 
            );
            public: void TemplateSetAsDefault
            (
                int templateId 
            );
            public: void DeleteAllTemplates
            (
            );
            public: NXString LoadTemplate
            (
                const NXString & filename  ,
                const NXString & name  ,
                int* templateId 
            );
            NXString LoadTemplate
            (
                const char * filename  ,
                const char * name  ,
                int* templateId 
            );
            public: void ReloadTemplates
            (
            );
            public: void SetFactoryDefaultTemplate
            (
            );
            public: NXString CompareDisplayFiles
            (
                const NXString & benchmarkFileName  ,
                const NXString & testFileName  ,
                const NXOpen::CAE::Post::ASCIIDiffTolerances & tolerances 
            );
            NXString CompareDisplayFiles
            (
                const char * benchmarkFileName  ,
                const char * testFileName  ,
                const NXOpen::CAE::Post::ASCIIDiffTolerances & tolerances 
            );

            public: NXString CompareDisplayFilesSmart
            (
                const NXString & benchmarkFileName  ,
                const NXString & testFileName  ,
                const NXOpen::CAE::Post::ASCIIDiffTolerances & tolerances 
            );
            NXString CompareDisplayFilesSmart
            (
                const char * benchmarkFileName  ,
                const char * testFileName  ,
                const NXOpen::CAE::Post::ASCIIDiffTolerances & tolerances 
            );

            public: int CreatePostview
            (
                int viewIndex ,
                NXOpen::CAE::Result * result  ,
                bool overlay 
            );
            public: int CreateNewPostview
            (
                int viewIndex ,
                NXOpen::CAE::Result * result  ,
                bool overlay  ,
                NXOpen::CAE::Post::DisplayColorSchemeType colorscheme 
            );
            public: int CreatePostviewForResult
            (
                int viewIndex ,
                NXOpen::CAE::Result * result  ,
                bool overlay  ,
                NXOpen::CAE::ResultParameters * resultParamter 
            );
            public: int CreateNewPostviewForResult
            (
                int viewIndex ,
                NXOpen::CAE::Result * result  ,
                bool overlay  ,
                NXOpen::CAE::ResultParameters * resultParamter  ,
                NXOpen::CAE::Post::DisplayColorSchemeType colorscheme 
            );
            public: void GetResultForPostview
            (
                int postviewId ,
                NXOpen::CAE::Result ** result ,
                NXOpen::CAE::ResultParameters ** resultParamter 
            );
            public: void CreatePostviewsForResultAndSE
            (
                int viewIndex ,
                NXOpen::CAE::Result * result  ,
                NXOpen::CAE::ResultParameters * resultParamter  ,
                std::vector<int> & postviewIds 
            );
            public: void PostviewSetResult
            (
                int postviewId  ,
                NXOpen::CAE::ResultParameters * resultParamter 
            );
            public: void PostviewSetDeformation
            (
                int postviewId  ,
                NXOpen::CAE::DeformationParameters * deformation 
            );
            public: void PostviewSetStreamlineVelocity
            (
                int postviewId  ,
                NXOpen::CAE::BaseResultType * velocity 
            );
            public: NX_DEPRECATED("Deprecated in NX11.0.0.  Use NXOpen::CAE::PostAnnotationBuilder instead.") NXOpen::CAE::PostAnnotation * CreateAnnotation
            (
                int postviewId  ,
                const NXString & name ,
                int num ,
                bool max ,
                const std::vector<NXString> & usertext 
            );
            NXOpen::CAE::PostAnnotation * CreateAnnotation
            (
                int postviewId  ,
                const char * name ,
                int num ,
                bool max ,
                const std::vector<NXString> & usertext 
            );
            public: NX_DEPRECATED("Deprecated in NX9.0.0.  use NXOpen::CAE::Post::CreateAnnotation with extra face parameter.") NXOpen::CAE::PostAnnotation * CreateAnnotation
            (
                int postviewId  ,
                const NXString & name ,
                const std::vector<int> & entities ,
                const std::vector<int> & subEntities ,
                const std::vector<NXString> & usertext 
            );
            NXOpen::CAE::PostAnnotation * CreateAnnotation
            (
                int postviewId  ,
                const char * name ,
                const std::vector<int> & entities ,
                const std::vector<int> & subEntities ,
                const std::vector<NXString> & usertext 
            );
            public: NX_DEPRECATED("Deprecated in NX11.0.0.  Use NXOpen::CAE::PostAnnotationBuilder instead.") NXOpen::CAE::PostAnnotation * CreateAnnotation
            (
                int postviewId  ,
                const NXString & name ,
                const std::vector<int> & elements ,
                const std::vector<int> & nodes ,
                const std::vector<int> & elmedgeface ,
                const std::vector<NXString> & usertext 
            );
            NXOpen::CAE::PostAnnotation * CreateAnnotation
            (
                int postviewId  ,
                const char * name ,
                const std::vector<int> & elements ,
                const std::vector<int> & nodes ,
                const std::vector<int> & elmedgeface ,
                const std::vector<NXString> & usertext 
            );
            public: NX_DEPRECATED("Deprecated in NX11.0.0.  Use NXOpen::CAE::PostAnnotationBuilder instead.") NXOpen::CAE::PostAnnotation * CreateAnnotation
            (
                int postviewId  ,
                const NXString & name ,
                double xcoord ,
                double ycoord ,
                const std::vector<NXString> & usertext 
            );
            NXOpen::CAE::PostAnnotation * CreateAnnotation
            (
                int postviewId  ,
                const char * name ,
                double xcoord ,
                double ycoord ,
                const std::vector<NXString> & usertext 
            );
            public: void GetAnnotations
            (
                int postviewId  ,
                std::vector<NXOpen::CAE::PostAnnotation *> & annotation 
            );
            public: NXOpen::CAE::Xyplot::Plot * Plotgraphs
            (
                int windowIndex ,
                int viewIndex ,
                const std::vector<NXOpen::CAE::PostGraph *> & graphs ,
                bool overlay 
            );
            public: void Deletegraphs
            (
                const std::vector<NXOpen::CAE::PostGraph *> & graphs 
            );
            public: int CreatePostview
            (
                int viewIndex ,
                NXOpen::CAE::ResultParametersWithProbe * probeparams  ,
                bool overlay 
            );
            public: void PostviewSetResultWithProbe
            (
                int postviewId  ,
                NXOpen::CAE::ResultParametersWithProbe * probeparams 
            );
            public: int PostviewCreateClone
            (
                int postviewId  ,
                int viewIndex 
            );
            public: void PostviewAnimationPlay
            (
                int postviewId  ,
                const NXOpen::CAE::Post::AnimationParameters & animation 
            );
            public: void UserGroupRename
            (
                NXOpen::CAE::Result * result  ,
                int usergroupId  ,
                const NXString & newName 
            );
            void UserGroupRename
            (
                NXOpen::CAE::Result * result  ,
                int usergroupId  ,
                const char * newName 
            );
            public: void UserGroupDelete
            (
                NXOpen::CAE::Result * result  ,
                int usergroupId 
            );
            public: NX_DEPRECATED("Deprecated in NX2206.0.0.  Use NXOpen::CAE::PostAnnotationBuilder instead.") NXOpen::CAE::PostAnnotationBuilder * CreateAnnotationBuilder
            (
                int pvid 
            );
            public: NXOpen::CAE::PostAnnotationBuilder * CreatePostAnnotationBuilder
            (
                int pvid  ,
                NXOpen::CAE::PostAnnotation * annotation 
            );
            public: std::vector<int> GetElemsVisibility
            (
                int pvid  ,
                bool* includeOrExculdes 
            );
            public: void GetClipLocations
            (
                int pvid  ,
                std::vector<NXOpen::CAE::PostSelectionEntity *> & cutinfos 
            );
            public: NXOpen::CAE::PostShowhideBuilder * CreatePostShowhideBuilder
            (
                int pvid 
            );
            public: void PostviewSetMeshTransparency
            (
                int pvid  ,
                const std::vector<NXOpen::CAE::PostMesh *> & meshes  ,
                bool isTransparent 
            );
            public: void PostviewSetGlobalTranslucency
            (
                int pvid  ,
                bool isTranslucent 
            );
            public: NX_DEPRECATED("Deprecated in NX1953.0.0.  use NXOpen::CAE::Post::JA_SPP_CreatePostviewFromNodalForceReportParameters instead.") int CreatePostview
            (
                int viewIndex ,
                NXOpen::CAE::ResultParametersWithNodalForceReport * nodalforcereportparams 
            );
            public: void PostviewSetResultWithNodalForceReport
            (
                int postviewId  ,
                NXOpen::CAE::ResultParametersWithNodalForceReport * nodalforcereportparams 
            );
            public: void PostviewSetEdgeFace
            (
                int postviewId  ,
                const NXOpen::CAE::Post::PrimaryEdgeFace & primaryEdgeface  ,
                const NXOpen::CAE::Post::EdgeFace & undeformedEdgeface 
            );
            public: void PostviewSetEdgeFace
            (
                int postviewId  ,
                const NXOpen::CAE::Post::PrimaryEdgeFace & primaryEdgeface 
            );
            public: double PostviewCalculateDistanceBetweenEntities
            (
                int pvid  ,
                NXOpen::CAE::PostSelectionEntity * postSel1 ,
                bool defstate1 ,
                NXOpen::CAE::PostSelectionEntity * postSel2 ,
                bool defstate2 
            );
            public: NXOpen::CAE::PostLegend * PostviewGetLegend
            (
                int postviewId 
            );
            public: void PostviewSetLegend
            (
                int postviewId  ,
                NXOpen::CAE::PostLegend * legend 
            );
            public: void PostviewSetMass
            (
                int postviewId  ,
                const NXOpen::CAE::Post::Mass & mass 
            );
public: NX_DEPRECATED("Deprecated in NX1953.0.0.  Instead use NXOpen::CAE::Post::PostviewSetBeamDisplay with Style as LineAndDiagram.") void PostviewShowBeamContour
(
    int posviewId  ,
    bool showBeamContour 
);
public: NX_DEPRECATED("Deprecated in NX1953.0.0.  Instead use NXOpen::CAE::Post::PostviewSetBeamDisplay with Style as LineAndDiagram.") void PostviewSetBeamContourScaleMethod
(
    int posviewId  ,
    NXOpen::CAE::Post::BeamContourScaleMethod method 
);
public: NX_DEPRECATED("Deprecated in NX1953.0.0.  Instead use NXOpen::CAE::Post::PostviewSetBeamDisplay with Style as LineAndDiagram.") void PostviewSetBeamContourScaleFactor
(
    int posviewId  ,
    double factor 
);
public: std::vector<NXOpen::TaggedObject *> PostviewAskHotspotRecipes
(
    int posviewId 
);
public: void PostviewAskHotspotsOfRecipe
(
    int posviewId  ,
    NXOpen::CAE::HotspotRecipe * recipe  ,
    std::vector<NXOpen::CAE::Hotspot *> & listhotspot 
);
public: void PostviewSetSpring
(
    int postviewId  ,
    const NXOpen::CAE::Post::Spring & spring 
);
public: void PostviewSetDrawForLegendBox
(
    int postviewId  ,
    bool draw 
);
public: bool PostviewAskDrawForLegendBox
(
    int postviewId 
);
public: void PostviewSetFillForLegendBox
(
    int postviewId  ,
    bool fill 
);
public: bool PostviewAskFillForLegendBox
(
    int postviewId 
);
public: void PostviewSetFillColorForLegendBox
(
    int postviewId  ,
    int fillColor 
);
            public: int PostviewAskFillColorForLegendBox
            (
                int postviewId 
            );
            public: void PostviewSetFillTranslucentForLegendBox
            (
                int postviewId  ,
                bool translucent 
            );
            public: bool PostviewAskFillTranslucentForLegendBox
            (
                int postviewId 
            );
            public: void PostviewCaptureAllViewportsToGif
            (
                const NXString & fileName  ,
                bool includeOverlayedPostviews  ,
                bool whiteBackground 
            );
            void PostviewCaptureAllViewportsToGif
            (
                const char * fileName  ,
                bool includeOverlayedPostviews  ,
                bool whiteBackground 
            );
            public: int CreatePostviewFromNodalForceReportParameters
            (
                int viewIndex ,
                NXOpen::CAE::ResultParametersWithNodalForceReport * nodalforcereportparams  ,
                bool overlay 
            );
            public: NXOpen::CAE::BeamDisplayParameters * PostviewGetBeamDisplay
            (
                int postviewId 
            );
            public: void PostviewSetBeamDisplay
            (
                int postviewId  ,
                NXOpen::CAE::BeamDisplayParameters * param 
            );
            public: NXOpen::CAE::ResultParametersWithNodalForceReport * AskResultParametersWithNodalForceReport
            (
                int pvid 
            );
            public: void SetResultParametersWithNodalForceReport
            (
                int pvid  ,
                NXOpen::CAE::ResultParametersWithNodalForceReport * resultParameter 
            );
            public: void PostviewInvertDisplay
            (
                int pvid 
            );

            public: void ExportDisplayInAscii
            (
                int postviewId  ,
                const NXString & fileName  ,
                bool ignoreClipping  ,
                bool ignoreVisibility  ,
                bool useDirectModelDisplay 
            );
            void ExportDisplayInAscii
            (
                int postviewId  ,
                const char * fileName  ,
                bool ignoreClipping  ,
                bool ignoreVisibility  ,
                bool useDirectModelDisplay 
            );

            public: void UpdateAllAnnotations
            (
                int pvid 
            );
            public: NXOpen::CAE::PostGroupBuilder * CreatePostGroupBuilder
            (
                int postViewId 
            );
            public: NXOpen::CAE::ShowHideEntitiesBuilder * CreateShowHideEntitiesBuilder
            (
                int postViewId 
            );
            public: void HidePostMeshes
            (
                const std::vector<int> & postviewIds  ,
                const std::vector<NXOpen::CAE::PostMesh *> & meshes 
            );
            public: std::vector<int> GetApplicablePostviewIds
            (
                int basePostviewId 
            );
            public: NXOpen::CAE::MeshTranslucencyBuilder * CreateMeshTranslucencyBuilder
            (
                int postviewId 
            );
            public: NXOpen::CAE::PostPointManager * AskPostPointManager
            (
            );
            public: NXOpen::CAE::PostPreference *Preference();
            public: NXOpen::CAE::PostProcessingSession *PostProcessingSession();

            public: NXOpen::CAE::PostDisplayManager *DisplayManager();

            public: NXOpen::CAE::PostSmartSelectionManager *SmartSelectionManager();
        }; //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