EIC code displayed by LXR master/​include/​opencascade/​RWMesh_CafReader.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-15 09:16:53

 // Author: Kirill Gavrilov
 // Copyright (c) 2016-2019 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _RWMesh_CafReader_HeaderFile
 #define _RWMesh_CafReader_HeaderFile
 
 #include <Message_ProgressRange.hxx>
 #include <OSD_OpenFile.hxx>
 #include <RWMesh_CoordinateSystemConverter.hxx>
 #include <RWMesh_NodeAttributes.hxx>
 #include <TCollection_AsciiString.hxx>
 #include <NCollection_IndexedDataMap.hxx>
 #include <TDF_Label.hxx>
 #include <TopoDS_Shape.hxx>
 #include <NCollection_Sequence.hxx>
 
 class TDocStd_Document;
 class XCAFDoc_ShapeTool;
 class XCAFDoc_ColorTool;
 class XCAFDoc_VisMaterialTool;
 
 //! Extended status bits.
 enum RWMesh_CafReaderStatusEx
 {
   RWMesh_CafReaderStatusEx_NONE = 0, //!< empty status
   RWMesh_CafReaderStatusEx_Partial =
     0x01, //!< partial read (due to unexpected EOF, syntax error, memory limit)
 };
 
 //! The general interface for importing mesh data into XDE document.
 //!
 //! The tool implements auxiliary structures for creating an XDE document in two steps:
 //! 1) Creating TopoDS_Shape hierarchy (myRootShapes)
 //!    and Shape attributes (myAttribMap) separately within performMesh().
 //!    Attributes include names and styles.
 //! 2) Filling XDE document from these auxiliary structures.
 //!    Named elements are expanded within document structure, while Compounds having no named
 //!    children will remain collapsed. In addition, unnamed nodes can be filled with generated names
 //!    like "Face", "Compound" via generateNames() method, and the very root unnamed node can be
 //!    filled from file name like "MyModel.obj".
 class RWMesh_CafReader : public Standard_Transient
 {
   DEFINE_STANDARD_RTTIEXT(RWMesh_CafReader, Standard_Transient)
 public:
   //! Structure holding tools for filling the document.
   struct CafDocumentTools
   {
     occ::handle<XCAFDoc_ShapeTool>                                        ShapeTool;
     occ::handle<XCAFDoc_ColorTool>                                        ColorTool;
     occ::handle<XCAFDoc_VisMaterialTool>                                  VisMaterialTool;
     NCollection_DataMap<TopoDS_Shape, TDF_Label, TopTools_ShapeMapHasher> ComponentMap;
     NCollection_DataMap<TopoDS_Shape, TDF_Label, TopTools_ShapeMapHasher> OriginalShapeMap;
   };
 
 public:
   //! Empty constructor.
   Standard_EXPORT RWMesh_CafReader();
 
   //! Destructor.
   Standard_EXPORT ~RWMesh_CafReader() override;
 
   //! Return target document.
   const occ::handle<TDocStd_Document>& Document() const { return myXdeDoc; }
 
   //! Set target document.
   //! Set system length unit according to the units of the document
   Standard_EXPORT void SetDocument(const occ::handle<TDocStd_Document>& theDoc);
 
   //! Return prefix for generating root labels names.
   const TCollection_AsciiString& RootPrefix() const { return myRootPrefix; }
 
   //! Set prefix for generating root labels names
   void SetRootPrefix(const TCollection_AsciiString& theRootPrefix) { myRootPrefix = theRootPrefix; }
 
   //! Flag indicating if partially read file content should be put into the XDE document, TRUE by
   //! default.
   //!
   //! Partial read means unexpected end of file, critical parsing syntax errors in the middle of
   //! file, or reached memory limit indicated by performMesh() returning FALSE. Partial read allows
   //! importing a model even in case of formal reading failure, so that it will be up to user to
   //! decide if processed data has any value.
   //!
   //! In case of partial read (performMesh() returns FALSE, but there are some data that could be
   //! put into document), Perform() will return TRUE and result flag will have failure bit set.
   //! @sa MemoryLimitMiB(), ExtraStatus().
   bool ToFillIncompleteDocument() const { return myToFillIncomplete; }
 
   //! Set flag allowing partially read file content to be put into the XDE document.
   void SetFillIncompleteDocument(bool theToFillIncomplete)
   {
     myToFillIncomplete = theToFillIncomplete;
   }
 
   //! Return memory usage limit in MiB, -1 by default which means no limit.
   int MemoryLimitMiB() const { return myMemoryLimitMiB; }
 
   //! Set memory usage limit in MiB; can be ignored by reader implementation!
   void SetMemoryLimitMiB(int theLimitMiB) { myMemoryLimitMiB = theLimitMiB; }
 
 public:
   //! Return coordinate system converter.
   const RWMesh_CoordinateSystemConverter& CoordinateSystemConverter() const
   {
     return myCoordSysConverter;
   }
 
   //! Set coordinate system converter.
   void SetCoordinateSystemConverter(const RWMesh_CoordinateSystemConverter& theConverter)
   {
     myCoordSysConverter = theConverter;
   }
 
   //! Return the length unit to convert into while reading the file, defined as scale factor for m
   //! (meters); -1.0 by default, which means that NO conversion will be applied.
   double SystemLengthUnit() const { return myCoordSysConverter.OutputLengthUnit(); }
 
   //! Set system length units to convert into while reading the file, defined as scale factor for m
   //! (meters).
   void SetSystemLengthUnit(double theUnits) { myCoordSysConverter.SetOutputLengthUnit(theUnits); }
 
   //! Return TRUE if system coordinate system has been defined; FALSE by default.
   bool HasSystemCoordinateSystem() const { return myCoordSysConverter.HasOutputCoordinateSystem(); }
 
   //! Return system coordinate system; UNDEFINED by default, which means that no conversion will be
   //! done.
   const gp_Ax3& SystemCoordinateSystem() const
   {
     return myCoordSysConverter.OutputCoordinateSystem();
   }
 
   //! Set system origin coordinate system to perform conversion into during read.
   void SetSystemCoordinateSystem(const gp_Ax3& theCS)
   {
     myCoordSysConverter.SetOutputCoordinateSystem(theCS);
   }
 
   //! Set system origin coordinate system to perform conversion into during read.
   void SetSystemCoordinateSystem(RWMesh_CoordinateSystem theCS)
   {
     myCoordSysConverter.SetOutputCoordinateSystem(theCS);
   }
 
   //! Return the length unit to convert from while reading the file, defined as scale factor for m
   //! (meters). Can be undefined (-1.0) if file format is unitless.
   double FileLengthUnit() const { return myCoordSysConverter.InputLengthUnit(); }
 
   //! Set (override) file length units to convert from while reading the file, defined as scale
   //! factor for m (meters).
   void SetFileLengthUnit(double theUnits) { myCoordSysConverter.SetInputLengthUnit(theUnits); }
 
   //! Return TRUE if file origin coordinate system has been defined.
   bool HasFileCoordinateSystem() const { return myCoordSysConverter.HasInputCoordinateSystem(); }
 
   //! Return file origin coordinate system; can be UNDEFINED, which means no conversion will be
   //! done.
   const gp_Ax3& FileCoordinateSystem() const { return myCoordSysConverter.InputCoordinateSystem(); }
 
   //! Set (override) file origin coordinate system to perform conversion during read.
   void SetFileCoordinateSystem(const gp_Ax3& theCS)
   {
     myCoordSysConverter.SetInputCoordinateSystem(theCS);
   }
 
   //! Set (override) file origin coordinate system to perform conversion during read.
   void SetFileCoordinateSystem(RWMesh_CoordinateSystem theCS)
   {
     myCoordSysConverter.SetInputCoordinateSystem(theCS);
   }
 
 public:
   //! Open stream and pass it to Perform method.
   //! The Document instance should be set beforehand.
   bool Perform(const TCollection_AsciiString& theFile, const Message_ProgressRange& theProgress)
   {
     std::ifstream aStream;
     OSD_OpenStream(aStream, theFile, std::ios_base::in | std::ios_base::binary);
     return Perform(aStream, theProgress, theFile);
   }
 
   //! Read the data from specified file.
   bool Perform(std::istream&                  theStream,
                const Message_ProgressRange&   theProgress,
                const TCollection_AsciiString& theFile = "")
   {
     return perform(theStream, theFile, theProgress, false);
   }
 
   //! Return extended status flags.
   //! @sa RWMesh_CafReaderStatusEx enumeration.
   int ExtraStatus() const { return myExtraStatus; }
 
 public:
   //! Return result as a single shape.
   Standard_EXPORT TopoDS_Shape SingleShape() const;
 
   //! Return the list of complementary files - external references (textures, data, etc.).
   const NCollection_IndexedMap<TCollection_AsciiString>& ExternalFiles() const
   {
     return myExternalFiles;
   }
 
   //! Return metadata map.
   const NCollection_IndexedDataMap<TCollection_AsciiString, TCollection_AsciiString>& Metadata()
     const
   {
     return myMetadata;
   }
 
   //! Open stream and pass it to ProbeHeader method.
   bool ProbeHeader(const TCollection_AsciiString& theFile,
                    const Message_ProgressRange&   theProgress = Message_ProgressRange())
   {
     std::ifstream aStream;
     OSD_OpenStream(aStream, theFile, std::ios_base::in | std::ios_base::binary);
     return ProbeHeader(aStream, theFile, theProgress);
   }
 
   //! Read the header data from specified file without reading entire model.
   //! The main purpose is collecting metadata and external references - for copying model into a new
   //! location, for example. Can be NOT implemented (unsupported by format / reader).
   bool ProbeHeader(std::istream&                  theStream,
                    const TCollection_AsciiString& theFile     = "",
                    const Message_ProgressRange&   theProgress = Message_ProgressRange())
   {
     return perform(theStream, theFile, theProgress, true);
   }
 
 protected:
   //! Open stream and pass it to Perform method.
   //! @param theFile    file to read
   //! @param optional   progress indicator
   //! @param theToProbe flag indicating that mesh data should be skipped and only basing information
   //! to be read
   Standard_EXPORT virtual bool perform(const TCollection_AsciiString& theFile,
                                        const Message_ProgressRange&   theProgress,
                                        const bool                     theToProbe);
 
   //! Read the data from specified file.
   //! Default implementation calls performMesh() and fills XDE document from collected shapes.
   //! @param theStream  input stream
   //! @param theFile    path of additional files
   //! @param optional   progress indicator
   //! @param theToProbe flag indicating that mesh data should be skipped and only basing information
   //! to be read
   Standard_EXPORT virtual bool perform(std::istream&                  theStream,
                                        const TCollection_AsciiString& theFile,
                                        const Message_ProgressRange&   theProgress,
                                        const bool                     theToProbe);
 
   //! Read the mesh from specified file
   Standard_EXPORT virtual bool performMesh(const TCollection_AsciiString& theFile,
                                            const Message_ProgressRange&   theProgress,
                                            const bool                     theToProbe)
   {
     std::ifstream aStream;
     OSD_OpenStream(aStream, theFile, std::ios_base::in | std::ios_base::binary);
     return performMesh(aStream, theFile, theProgress, theToProbe);
   }
 
   //! Read the mesh from specified file - interface to be implemented by sub-classes.
   Standard_EXPORT virtual bool performMesh(std::istream&                  theStream,
                                            const TCollection_AsciiString& theFile,
                                            const Message_ProgressRange&   theProgress,
                                            const bool                     theToProbe) = 0;
 
   //! @name tools for filling XDE document
 protected:
   //! Fill document with new root shapes.
   Standard_EXPORT virtual void fillDocument();
 
   //! Append new shape into the document (recursively).
   Standard_EXPORT bool addShapeIntoDoc(CafDocumentTools&              theTools,
                                        const TopoDS_Shape&            theShape,
                                        const TDF_Label&               theLabel,
                                        const TCollection_AsciiString& theParentName);
 
   //! Append new sub-shape into the document (recursively).
   Standard_EXPORT bool addSubShapeIntoDoc(CafDocumentTools&   theTools,
                                           const TopoDS_Shape& theShape,
                                           const TDF_Label&    theParentLabel);
 
   //! Put name attribute onto the label.
   Standard_EXPORT void setShapeName(const TDF_Label&               theLabel,
                                     const TopAbs_ShapeEnum         theShapeType,
                                     const TCollection_AsciiString& theName,
                                     const TDF_Label&               theParentLabel,
                                     const TCollection_AsciiString& theParentName);
 
   //! Put color and material attributes onto the label.
   Standard_EXPORT void setShapeStyle(const CafDocumentTools& theTools,
                                      const TDF_Label&        theLabel,
                                      const XCAFPrs_Style&    theStyle);
 
   //! Put name data (metadata) attribute onto the label.
   Standard_EXPORT void setShapeNamedData(const CafDocumentTools&                theTools,
                                          const TDF_Label&                       theLabel,
                                          const occ::handle<TDataStd_NamedData>& theNameData);
 
   //! Generate names for root labels starting from specified index.
   Standard_EXPORT void generateNames(const TCollection_AsciiString& theFile,
                                      const int                      theRootLower,
                                      const bool                     theWithSubLabels);
 
   //! Return shape type as string.
   //! @sa TopAbs::ShapeTypeToString()
   static TCollection_AsciiString shapeTypeToString(TopAbs_ShapeEnum theType)
   {
     TCollection_AsciiString aString = TopAbs::ShapeTypeToString(theType);
     aString.Capitalize();
     return aString;
   }
 
 protected:
   occ::handle<TDocStd_Document> myXdeDoc; //!< target document
 
   NCollection_IndexedDataMap<TCollection_AsciiString, TCollection_AsciiString>
     myMetadata; //!< metadata map
   NCollection_IndexedMap<TCollection_AsciiString>
     // clang-format off
                             myExternalFiles;     //!< the list of complementary files - external references (textures, data, etc.)
   TCollection_AsciiString   myRootPrefix;        //!< root folder for generating root labels names
   NCollection_Sequence<TopoDS_Shape>  myRootShapes;        //!< sequence of result root shapes
   NCollection_DataMap<TopoDS_Shape, RWMesh_NodeAttributes, TopTools_ShapeMapHasher>   myAttribMap;         //!< map of per-shape attributes
 
   RWMesh_CoordinateSystemConverter
                             myCoordSysConverter; //!< coordinate system converter
   bool          myToFillDoc;         //!< fill document from shape sequence
   bool          myToFillIncomplete;  //!< fill the document with partially retrieved data even if reader has failed with error
   // clang-format on
   int myMemoryLimitMiB; //!< memory usage limit
   int myExtraStatus;    //!< extra status bitmask
 };
 
 #endif // _RWMesh_CafReader_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team