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

Warning, file /include/opencascade/XSAlgo_ShapeProcessor.hxx was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 // Copyright (c) 2000-2014 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 _XSAlgo_ShapeProcessor_HeaderFile
 #define _XSAlgo_ShapeProcessor_HeaderFile
 
 #include <DE_ShapeFixParameters.hxx>
 #include <ShapeProcess.hxx>
 #include <TopAbs_ShapeEnum.hxx>
 #include <TopTools_DataMapOfShapeShape.hxx>
 #include <TopoDS_Edge.hxx>
 #include <TopoDS_Face.hxx>
 
 class ShapeProcess_ShapeContext;
 class ShapeExtend_MsgRegistrator;
 class Transfer_TransientProcess;
 class Transfer_FinderProcess;
 class Transfer_Binder;
 
 //! Shape Processing module.
 //! Allows to define and apply general Shape Processing as a customizable sequence of operators.
 class XSAlgo_ShapeProcessor
 {
 public:
   using ParameterMap   = NCollection_DataMap<TCollection_AsciiString, TCollection_AsciiString>;
   using ProcessingData = std::pair<ParameterMap, ShapeProcess::OperationsFlags>;
   // Flags defining operations to be performed on shapes. Since there is no std::optional in C++11,
   // we use a pair. The first element is the flags, the second element is a boolean value that
   // indicates whether the flags were set.
   using ProcessingFlags = std::pair<ShapeProcess::OperationsFlags, bool>;
 
 public:
   //! Constructor.
   //! @param theParameters Pre-filled parameter map to be used in the processing.
   //! @param theShapeFixParameters Shape healing parameters to be used in the processing.
   //!        If @p theParameters has some shape healing values, they will override the
   //!        corresponding values from @p theShapeFixParameters.
   Standard_EXPORT XSAlgo_ShapeProcessor(const ParameterMap&          theParameters,
                                         const DE_ShapeFixParameters& theShapeFixParameters = {});
 
   //! Constructor.
   //! @param theParameters Parameters to be used in the processing.
   Standard_EXPORT XSAlgo_ShapeProcessor(const DE_ShapeFixParameters& theParameters);
 
   //! Process the shape by applying the specified operations.
   //! @param theShape Shape to process.
   //! @param theOperations Operations to be performed.
   //! @param theProgress Progress indicator.
   //! @return Processed shape. May be the same as the input shape if no modifications were made.
   Standard_EXPORT TopoDS_Shape ProcessShape(const TopoDS_Shape&                  theShape,
                                             const ShapeProcess::OperationsFlags& theOperations,
                                             const Message_ProgressRange&         theProgress);
 
   //! Get the context of the last processing.
   //! Only valid after the ProcessShape() method was called.
   //! @return Shape context.
   Handle(ShapeProcess_ShapeContext) GetContext() { return myContext; }
 
   //! Merge the results of the shape processing with the transfer process.
   //! @param theTransientProcess Transfer process to merge with.
   //! @param theFirstTPItemIndex Index of the first item in the transfer process to merge with.
   Standard_EXPORT void MergeTransferInfo(
     const Handle(Transfer_TransientProcess)& theTransientProcess,
     const Standard_Integer                   theFirstTPItemIndex) const;
 
   //! Merge the results of the shape processing with the finder process.
   //! @param theFinderProcess Finder process to merge with.
   Standard_EXPORT void MergeTransferInfo(
     const Handle(Transfer_FinderProcess)& theFinderProcess) const;
 
   //! Check quality of pcurve of the edge on the given face, and correct it if necessary.
   //! @param theEdge Edge to check.
   //! @param theFace Face on which the edge is located.
   //! @param thePrecision Precision to use for checking.
   //! @param theIsSeam Flag indicating whether the edge is a seam edge.
   //! @return True if the pcurve was corrected, false if it was dropped.
   Standard_EXPORT static Standard_Boolean CheckPCurve(const TopoDS_Edge&     theEdge,
                                                       const TopoDS_Face&     theFace,
                                                       const Standard_Real    thePrecision,
                                                       const Standard_Boolean theIsSeam);
 
   //! Reads the parameter map from and operation flags from the file specified in static interface.
   //! @param theFileResourceName Name of the parameter in interface static that contains the name
   //!        of the file. For example, parameter "read.iges.resource.name" may contain string
   //!        "IGES".
   //! @param theScopeResourceName Name of the parameter in interface static that contains the name
   //!        of the scope. For example, parameter "read.iges.sequence" may contain string
   //!        "FromIGES".
   //! @return Read parameter map.
   Standard_EXPORT static ProcessingData ReadProcessingData(
     const TCollection_AsciiString& theFileResourceName,
     const TCollection_AsciiString& theScopeResourceName);
 
   //! Fill the parameter map with the values from the specified parameters.
   //! @param theParameters Parameters to be used in the processing.
   //! @param theIsForce Flag indicating whether parameter should be replaced if it already exists in
   //! the map.
   //! @param theMap Map to fill.
   Standard_EXPORT static void FillParameterMap(const DE_ShapeFixParameters& theParameters,
                                                const bool                   theIsReplace,
                                                ParameterMap&                theMap);
 
   //! Sets parameters for shape processing.
   //! Parameters from @p theParameters are copied to the output map.
   //! Parameters from @p theAdditionalParameters are copied to the output map
   //! if they are not present in @p theParameters.
   //! @param theParameters the parameters for shape processing.
   //! @param theAdditionalParameters the additional parameters for shape processing.
   //! @param theTargetParameterMap Map to set the parameters in.
   Standard_EXPORT static void SetShapeFixParameters(const DE_ShapeFixParameters& theParameters,
                                                     const ParameterMap& theAdditionalParameters,
                                                     ParameterMap&       theTargetParameterMap);
 
   //! Set the parameter in the map.
   //! @param theKey Key of the parameter.
   //! @param theValue Value of the parameter.
   //! @param theIsReplace Flag indicating whether parameter should be replaced if it already exists
   //! in the map.
   //! @param theMap Map to set the parameter in.
   Standard_EXPORT static void SetParameter(const char*                          theKey,
                                            const DE_ShapeFixParameters::FixMode theValue,
                                            const bool                           theIsReplace,
                                            XSAlgo_ShapeProcessor::ParameterMap& theMap);
 
   //! Set the parameter in the map.
   //! @param theKey Key of the parameter.
   //! @param theValue Value of the parameter.
   //! @param theIsReplace Flag indicating whether parameter should be replaced if it already exists
   //! in the map.
   //! @param theMap Map to set the parameter in.
   Standard_EXPORT static void SetParameter(const char*   theKey,
                                            const double  theValue,
                                            const bool    theIsReplace,
                                            ParameterMap& theMap);
 
   //! Set the parameter in the map.
   //! @param theKey Key of the parameter.
   //! @param theValue Value of the parameter.
   //! @param theIsReplace Flag indicating whether parameter should be replaced if it already exists
   //! in the map.
   //! @param theMap Map to set the parameter in.
   Standard_EXPORT static void SetParameter(const char*                    theKey,
                                            const TCollection_AsciiString& theValue,
                                            const bool                     theIsReplace,
                                            ParameterMap&                  theMap);
 
   //! The function is designed to set the length unit for the application before performing a
   //! transfer operation. It ensures that the length unit is correctly configured based on the
   //! value associated with the key "xstep.cascade.unit".
   Standard_EXPORT static void PrepareForTransfer();
 
   //! Merge the results of the shape processing with the finder process.
   //! @param theTransientProcess Transfer process to merge with.
   //! @param theModifiedShapesMap Map of modified shapes.
   //! @param theFirstTPItemIndex Index of the first item in the transfer process to merge with.
   //! @param theMessages Messages to add.
   Standard_EXPORT static void MergeShapeTransferInfo(
     const Handle(Transfer_TransientProcess)& theFinderProcess,
     const TopTools_DataMapOfShapeShape&      theModifiedShapesMap,
     const Standard_Integer                   theFirstTPItemIndex,
     Handle(ShapeExtend_MsgRegistrator)       theMessages);
 
   //! Merge the results of the shape processing with the transfer process.
   //! @param theTransientProcess Transfer process to merge with.
   //! @param theModifiedShapesMap Map of modified shapes.
   //! @param theFirstTPItemIndex Index of the first item in the transfer process to merge with.
   //! @param theMessages Messages to add.
   Standard_EXPORT static void MergeShapeTransferInfo(
     const Handle(Transfer_FinderProcess)& theTransientProcess,
     const TopTools_DataMapOfShapeShape&   theModifiedShapesMap,
     Handle(ShapeExtend_MsgRegistrator)    theMessages);
 
 private:
   //! Initialize the context with the specified shape.
   //! @param theShape Shape to process.
   void initializeContext(const TopoDS_Shape& theShape);
 
   //! Add messages from the specified shape to the transfer binder.
   //! @param theMessages Container with messages.
   //! @param theShape Shape to get messages from.
   //! @param theBinder Transfer binder to add messages to.
   static void addMessages(const Handle(ShapeExtend_MsgRegistrator)& theMessages,
                           const TopoDS_Shape&                       theShape,
                           Handle(Transfer_Binder)&                  theBinder);
 
   //! Create a new edge with the same geometry as the source edge.
   //! @param theSourceEdge Source edge.
   //! @return New edge with the same geometry.
   static TopoDS_Edge MakeEdgeOnCurve(const TopoDS_Edge& aSourceEdge);
 
 private:
   ParameterMap                      myParameters; //!< Parameters to be used in the processing.
   Handle(ShapeProcess_ShapeContext) myContext;    //!< Shape context.
 };
 
 #endif // _XSAlgo_ShapeProcessor_HeaderFile

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