Facet_FacetedBodyCollection.hxx

//--------------------------------------------------------------------------
// Copyright 2024 Siemens
//--------------------------------------------------------------------------
// JA API的C++接口头文件
//--------------------------------------------------------------------------
//
// 源文件:
//     Facet_FacetedBodyCollection.ja
//
// 生成工具:
//     apiwrap
//
// 警告:
//    此文件为自动生成，请勿手动编辑
//
#pragma once
#include <NXOpen/NXDeprecation.hxx>
#include <iterator>
#include <vector>
#include <NXOpen/NXString.hxx>
#include <NXOpen/Callback.hxx>
#include <NXOpen/BasePart.hxx>
#include <NXOpen/Facet_BestFitAlignBuilder.hxx>
#include <NXOpen/Facet_BridgeFacetBodyBuilder.hxx>
#include <NXOpen/Facet_CurvatureBuilder.hxx>
#include <NXOpen/Facet_DecimateFacetBodyBuilder.hxx>
#include <NXOpen/Facet_ExtrudeFacetBodyBuilder.hxx>
#include <NXOpen/Facet_ExtrudeProfileBuilder.hxx>
#include <NXOpen/Facet_FeatureExtractionBuilder.hxx>
#include <NXOpen/Facet_FillHoleBuilder.hxx>
#include <NXOpen/Facet_MergeFacetBodyBuilder.hxx>
#include <NXOpen/Facet_MultiPatchAlignmentBuilder.hxx>
#include <NXOpen/Facet_STLImportBuilder.hxx>
#include <NXOpen/Facet_SewFacetBodyBuilder.hxx>
#include <NXOpen/Facet_SnipFacetBodyBuilder.hxx>
#include <NXOpen/Facet_SubdivideFacetBodyBuilder.hxx>
#include <NXOpen/TaggedObjectCollection.hxx>
#include <NXOpen/TaggedObject.hxx>
#include <NXOpen/ugmath.hxx>
#include <NXOpen/libnxopencpp_facet_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 Facet
    {
        class FacetedBodyCollection;
    }
    class Part;
    namespace Facet
    {
        class FacetedBody;
    }
    class Body;
    class Face;
    namespace Facet
    {
        class BestFitAlignBuilder;
    }
    namespace Facet
    {
        class BridgeFacetBodyBuilder;
    }
    namespace Facet
    {
        class CurvatureBuilder;
    }
    namespace Facet
    {
        class DecimateFacetBodyBuilder;
    }
    namespace Facet
    {
        class ExtrudeFacetBodyBuilder;
    }
    namespace Facet
    {
        class ExtrudeProfileBuilder;
    }
    namespace Facet
    {
        class FacetModelingCollection;
    }
    namespace Facet
    {
        class FeatureExtractionBuilder;
    }
    namespace Facet
    {
        class FillHoleBuilder;
    }
    namespace Facet
    {
        class MergeFacetBodyBuilder;
    }
namespace Facet
    {
        class MultiPatchAlignmentBuilder;
    }
    namespace Facet
    {
        class STLImportBuilder;
    }
    namespace Facet
    {
        class SewFacetBodyBuilder;
    }
    namespace Facet
    {
        class SmoothFacetBodyBuilder;
    }
    namespace Facet
    {
        class SnipFacetBodyBuilder;
    }
    namespace Facet
    {
        class SubdivideFacetBodyBuilder;
    }
    namespace Facet
    {
        struct FacetingParameters
        {
            public: int MaximumFacetEdges;
            public: bool SpecifySurfaceTolerance;
            public: double SurfaceDistanceTolerance;
            public: double SurfaceAngularTolerance;
            public: bool SpecifyCurveTolerance;
            public: double CurveDistanceTolerance;
            public: double CurveAngularTolerance;
            public: double CurveMaximumLength;
            public: bool SpecifyConvexFacets;
            public: bool SpecifyMaximumFacetSize;
            public: double MaximumFacetSize;
            public: bool SpecifyParameters;
            public: int NumberStorageType;
            public: bool SpecifyViewDirection;
            public: NXOpen::Vector3d SilhouetteViewDirection;
            public: double SilhouetteChordTolerance;
            public: bool StoreFaceTag;
            public: bool WithLODS;
            public: FacetingParameters() :
                MaximumFacetEdges(),
                SpecifySurfaceTolerance(),
                SurfaceDistanceTolerance(),
                SurfaceAngularTolerance(),
                SpecifyCurveTolerance(),
                CurveDistanceTolerance(),
                CurveAngularTolerance(),
                CurveMaximumLength(),
                SpecifyConvexFacets(),
                SpecifyMaximumFacetSize(),
                MaximumFacetSize(),
                SpecifyParameters(),
                NumberStorageType(),
                SpecifyViewDirection(),
                SilhouetteViewDirection(),
                SilhouetteChordTolerance(),
                StoreFaceTag(),
                WithLODS()
{
            }
            public: FacetingParameters(int maximumFacetEdgesInitial ,
                    bool specifySurfaceToleranceInitial ,
                    double surfaceDistanceToleranceInitial ,
                    double surfaceAngularToleranceInitial ,
                    bool specifyCurveToleranceInitial ,
                    double curveDistanceToleranceInitial ,
                    double curveAngularToleranceInitial ,
                    double curveMaximumLengthInitial ,
                    bool specifyConvexFacetsInitial ,
                    bool specifyMaximumFacetSizeInitial ,
                    double maximumFacetSizeInitial ,
                    bool specifyParametersInitial ,
                    int numberStorageTypeInitial ,
                    bool specifyViewDirectionInitial ,
                    const NXOpen::Vector3d &silhouetteViewDirectionInitial ,
                    double silhouetteChordToleranceInitial ,
                    bool storeFaceTagInitial ,
                    bool withLODSInitial ) :
                MaximumFacetEdges(maximumFacetEdgesInitial),
                SpecifySurfaceTolerance(specifySurfaceToleranceInitial),
                SurfaceDistanceTolerance(surfaceDistanceToleranceInitial),
                SurfaceAngularTolerance(surfaceAngularToleranceInitial),
                SpecifyCurveTolerance(specifyCurveToleranceInitial),
                CurveDistanceTolerance(curveDistanceToleranceInitial),
                CurveAngularTolerance(curveAngularToleranceInitial),
                CurveMaximumLength(curveMaximumLengthInitial),
                SpecifyConvexFacets(specifyConvexFacetsInitial),
                SpecifyMaximumFacetSize(specifyMaximumFacetSizeInitial),
                MaximumFacetSize(maximumFacetSizeInitial),
                SpecifyParameters(specifyParametersInitial),
                NumberStorageType(numberStorageTypeInitial),
                SpecifyViewDirection(specifyViewDirectionInitial),
                SilhouetteViewDirection(silhouetteViewDirectionInitial),
                SilhouetteChordTolerance(silhouetteChordToleranceInitial),
                StoreFaceTag(storeFaceTagInitial),
                WithLODS(withLODSInitial)
{
            }
        };
    }
    namespace Facet
    {
        class FacetedBodyCollectionImpl;
        class NXOPENCPP_FACETEXPORT  FacetedBodyCollection : public NXOpen::TaggedObjectCollection
        {
            public: enum Type
            {
                TypeNx,
                TypeJt
            };
            private: FacetedBodyCollectionImpl * m_facetedbodycollection_impl;
            private: NXOpen::Part* m_owner;
            public: explicit FacetedBodyCollection(NXOpen::Part *owner);
            public:
            tag_t Tag() const;
            public: ~FacetedBodyCollection();
            //lint -sem(NXOpen::Facet::FacetedBodyCollection::iterator::copy,initializer)
            class iterator : public std::iterator<std::forward_iterator_tag, NXOpen::Facet::FacetedBody *>
            {
            public:
                iterator() : m_context(nullptr), m_current(NULL_TAG)
                {
                    // coverity[uninit_member]
                } //lint !e1401 m_state is not initialized

                explicit iterator(NXOpen::Facet::FacetedBodyCollection *context) : m_context(context), m_current(NULL_TAG)
                {
                    // coverity[uninit_member]
                }//lint !e1401 m_state is not initialized

                iterator(const iterator &other): m_context(nullptr), m_current(NULL_TAG)
                {
                    copy(other);
                }

                iterator &operator =(const iterator &other)
                {
                    if (&other != this)
                        copy(other);
                    return *this;
                }

                bool operator ==(const iterator &other) const
                {
                    return m_current == other.m_current && m_context == other.m_context;
                }

                bool operator !=(const iterator &other) const
                {
                    return !operator == (other);
                }

                NXOPENCPP_FACETEXPORT  value_type operator * () const;
                iterator & operator ++()
                {
                    next();
                    return *this;
                }

                iterator operator ++(int)
                {
                    iterator tmp(*this);
                    ++*this;
                    return tmp;
                }
            private:
                void copy(const iterator &other)
                {
                    m_context = other.m_context;
                    m_current = other.m_current;
                    for (int i = 0; i < sizeof(m_state)/sizeof(m_state[0]); i++)
                         m_state[i] = other.m_state[i];
                }
                NXOPENCPP_FACETEXPORT  void next();
                NXOpen::Facet::FacetedBodyCollection *m_context;
                tag_t m_current;
                unsigned int m_state[8];
            };

            iterator begin();
            iterator end()
{
                return iterator(this);
            }

            public: NXOpen::Facet::FacetedBody * FindObject
            (
                const NXString & journalIdentifier 
            );
            NXOpen::Facet::FacetedBody * FindObject
            (
                const char * journalIdentifier 
            );
            public: NXOpen::Facet::CurvatureBuilder * CreateFacetCurvatureBuilder
            (
            );
            public: NXOpen::Facet::FeatureExtractionBuilder * CreateFacetFeatureExtractionBuilder
            (
            );
            public: void Convert
            (
                NXOpen::Facet::FacetedBody * fromBody ,
                NXOpen::Facet::FacetedBodyCollection::Type toFacetType 
            );
            public: NXOpen::Facet::FacetedBody * Copy
            (
                NXOpen::Facet::FacetedBody * fromBody ,
                NXOpen::Part * toPart ,
                NXOpen::Facet::FacetedBodyCollection::Type toFacetType 
            );
            public: std::vector<NXOpen::Facet::FacetedBody *> GetAssociatedFacetedBodies
            (
                NXOpen::Body * solidBody ,
                int* numberOfUnloadedFacetedBodies 
            );
            public: void DeleteTemporaryFacesAndEdges
            (
            );
            public: NXOpen::Facet::BestFitAlignBuilder * CreateBestFitAlignBuilder
            (
            );
            public: NXOpen::Facet::FillHoleBuilder * CreateFillHoleBuilder
            (
            );
            public: NXOpen::Facet::STLImportBuilder * CreateSTLImportBuilder
            (
            );
            public: NXOpen::Facet::DecimateFacetBodyBuilder * CreateDecimateFacetBodyBuilder
            (
            );
            public: NXOpen::Facet::MultiPatchAlignmentBuilder * CreateMultiPatchAlignmentBuilder
            (
            );
            public: NXOpen::Facet::SubdivideFacetBodyBuilder * CreateSubdivideFacetBodyBuilder
            (
            );
            public: NXOpen::Facet::SmoothFacetBodyBuilder * CreateSmoothFacetBodyBuilder
            (
            );
            public: NXOpen::Facet::SnipFacetBodyBuilder * CreateSnipFacetBodyBuilder
            (
            );
            public: void CreateFacetBody
            (
                const std::vector<NXOpen::Body *> & solidBodies  ,
                std::vector<NXOpen::Facet::FacetedBody *> & facetBodies  ,
                std::vector<int> & errorTable 
            );
            public: void CreateFacetBodyFromFaces
            (
                const std::vector<NXOpen::Face *> & solidFaces  ,
                std::vector<NXOpen::Facet::FacetedBody *> & facetBodies  ,
                std::vector<int> & errorTable 
            );
            public: NXOpen::Facet::ExtrudeFacetBodyBuilder * CreateExtrudeFacetBodyBuilder
            (
            );
            public: NXOpen::Facet::ExtrudeProfileBuilder * CreateExtrudeProfileBuilder
            (
            );
            public: NX_DEPRECATED("Deprecated in NX2206.0.0.  This functionality is no longer supported.") NXOpen::Facet::MergeFacetBodyBuilder * CreateMergeFacetBodyBuilder
            (
            );
            public: NXOpen::Facet::BridgeFacetBodyBuilder * CreateBridgeFacetBodyBuilder
            (
            );
            public: NXOpen::Facet::SewFacetBodyBuilder * CreateSewFacetBodyBuilder
            (
            );
            public: NXOpen::Facet::FacetModelingCollection *FacetModelingCollection();
        }; //lint !e1712 default constructor not defined for class
    }
}
#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