ModelAPI_Tools.h

// Copyright (C) 2014-2026  CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef ModelAPI_Tools_HeaderFile
#define ModelAPI_Tools_HeaderFile
 
#include "ModelAPI.h"
#include <ModelAPI_AttributeSelectionList.h>
 
class ModelAPI_CompositeFeature;
class ModelAPI_Document;
class ModelAPI_Feature;
class ModelAPI_Result;
class ModelAPI_ResultParameter;
class ModelAPI_ResultBody;
 
class GeomAlgoAPI_MakeShape;
class GeomAPI_Shape;
class GeomAPI_ShapeHierarchy;
 
#include <memory>
#include <vector>
#include <map>
#include <set>
#include <list>
 
namespace ModelAPI_Tools {
MODELAPI_EXPORT std::shared_ptr<GeomAPI_Shape> shape(
                                   const std::shared_ptr<ModelAPI_Result>& theResult);
 
MODELAPI_EXPORT std::string getFeatureError(const std::shared_ptr<ModelAPI_Feature>& theFeature);
 
struct ResultBaseAlgo {
  std::shared_ptr<ModelAPI_ResultBody> resultBody;
  std::shared_ptr<GeomAPI_Shape> baseShape;
  std::shared_ptr<GeomAlgoAPI_MakeShape> makeShape;
};
 
MODELAPI_EXPORT void loadModifiedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
  const std::list<std::shared_ptr<GeomAPI_Shape>>& theBaseShapes,
  const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
  const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
  const std::shared_ptr<GeomAPI_Shape> theResultShape,
  const std::string& theNamePrefix = "");
 
MODELAPI_EXPORT void loadModifiedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
  const std::shared_ptr<GeomAPI_Shape>& theBaseShape,
  const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
  const std::string theName);
MODELAPI_EXPORT void loadDeletedShapes(std::shared_ptr<ModelAPI_ResultBody> theResultBody,
  const std::shared_ptr<GeomAPI_Shape> theBaseShape,
  const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
  const std::shared_ptr<GeomAlgoAPI_MakeShape>& theMakeShape,
  const std::shared_ptr<GeomAPI_Shape> theResultShapesCompound);
 
MODELAPI_EXPORT void loadDeletedShapes(std::vector<ResultBaseAlgo>& theResultBaseAlgoList,
  const std::list<std::shared_ptr<GeomAPI_Shape>>& theTools,
  const std::shared_ptr<GeomAPI_Shape> theResultShapesCompound);
 
MODELAPI_EXPORT bool findVariable(const std::shared_ptr<ModelAPI_Document>& theDocument,
                                  std::shared_ptr<ModelAPI_Feature> theSearcher,
                                  const std::wstring& theName, double& outValue,
                                  std::shared_ptr<ModelAPI_ResultParameter>& theParam);
 
MODELAPI_EXPORT bool findVariable(std::shared_ptr<ModelAPI_Feature> theSearcher,
  const std::wstring& theName,
  double& outValue, std::shared_ptr<ModelAPI_ResultParameter>& theParam,
  const std::shared_ptr<ModelAPI_Document>& theDocument = std::shared_ptr<ModelAPI_Document>());
 
MODELAPI_EXPORT std::shared_ptr<ModelAPI_Result> findPartResult(
                                              const std::shared_ptr<ModelAPI_Document>& theMain,
                                              const std::shared_ptr<ModelAPI_Document>& theSub);
 
MODELAPI_EXPORT std::shared_ptr<ModelAPI_Feature> findPartFeature(
                                           const std::shared_ptr<ModelAPI_Document>& theMain,
                                           const std::shared_ptr<ModelAPI_Document>& theSub);
 
MODELAPI_EXPORT std::shared_ptr<ModelAPI_CompositeFeature> compositeOwner(
                                        const std::shared_ptr<ModelAPI_Feature>& theFeature);
 
MODELAPI_EXPORT std::shared_ptr<ModelAPI_ResultBody>
  bodyOwner(const std::shared_ptr<ModelAPI_Result>& theSub, const bool theRoot = false);
 
/*
* Returns the result - main parent of this result.
* \param theSubBody the sub-element of composit result
* \returns Root resultBody
*/
MODELAPI_EXPORT std::shared_ptr<ModelAPI_ResultBody> mainBody(const std::shared_ptr<ModelAPI_ResultBody> theSubBody);
 
MODELAPI_EXPORT int bodyIndex(const std::shared_ptr<ModelAPI_Result>& theSub);
 
MODELAPI_EXPORT bool hasSubResults(const std::shared_ptr<ModelAPI_Result>& theResult);
 
MODELAPI_EXPORT void allSubs(const std::shared_ptr<ModelAPI_ResultBody>& theResult,
                             std::list<std::shared_ptr<ModelAPI_Result> >& theResults,
                             const bool theLowerOnly = false);
 
MODELAPI_EXPORT void allResults(const std::shared_ptr<ModelAPI_Feature>& theFeature,
                                std::list<std::shared_ptr<ModelAPI_Result> >& theResults);
 
MODELAPI_EXPORT bool allDocumentsActivated(std::wstring& theNotActivatedNames);
 
MODELAPI_EXPORT bool removeFeaturesAndReferences(
                       const std::set<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
                                                 const bool theFlushRedisplay = false,
                                                 const bool theUseComposite = false,
                                                 const bool theUseRecursion = true);
 
MODELAPI_EXPORT bool removeFeatures(
                            const std::set<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
                            const bool theFlushRedisplay);
 
MODELAPI_EXPORT void findAllReferences(
  const std::set<std::shared_ptr<ModelAPI_Feature> >& theFeatures,
  std::map<std::shared_ptr<ModelAPI_Feature>,
  std::set<std::shared_ptr<ModelAPI_Feature> > >& theReferences,
  const bool theUseComposite = true,
  const bool theUseRecursion = true);
 
MODELAPI_EXPORT void findRefsToFeatures(
  const std::set<std::shared_ptr<ModelAPI_Feature> >& aFeatures,
  const std::map<std::shared_ptr<ModelAPI_Feature>,
                 std::set<std::shared_ptr<ModelAPI_Feature> > >& aReferences,
  std::set<std::shared_ptr<ModelAPI_Feature> >& aFeaturesRefsTo);
 
MODELAPI_EXPORT void getConcealedResults(const std::shared_ptr<ModelAPI_Feature>& theFeature,
                                   std::list<std::shared_ptr<ModelAPI_Result> >& theResults);
 
MODELAPI_EXPORT std::pair<std::wstring, bool> getDefaultName(
  const std::shared_ptr<ModelAPI_Result>& theResult,
  const bool theInherited = true,
  const bool theRecursive = false);
 
MODELAPI_EXPORT std::set<std::shared_ptr<ModelAPI_Feature> >
    getParents(const std::shared_ptr<ModelAPI_Feature>& theFeature);
 
MODELAPI_EXPORT void fillShapeHierarchy(
    const std::shared_ptr<GeomAPI_Shape>& theShape,
    const std::shared_ptr<ModelAPI_Result>& theContext,
    GeomAPI_ShapeHierarchy& theHierarchy);
 
MODELAPI_EXPORT void removeResults(const std::list<std::shared_ptr<ModelAPI_Result> >& theResults);
 
MODELAPI_EXPORT double getDeflection(const std::shared_ptr<ModelAPI_Result>& theResult);
 
MODELAPI_EXPORT void setDeflection(std::shared_ptr<ModelAPI_Result> theResult,
  const double theDeflection);
 
MODELAPI_EXPORT void getColor(const std::shared_ptr<ModelAPI_Result>& theResult,
  std::vector<int>& theColor);
 
MODELAPI_EXPORT void getColor(const std::shared_ptr<ModelAPI_Result> theResult,
  const std::shared_ptr<GeomAPI_Shape> theShape,
  std::vector<int>& theColor);
 
MODELAPI_EXPORT void getColoredSubShapes(const std::shared_ptr<ModelAPI_Result> theResult,
  std::map<std::shared_ptr<GeomAPI_Shape>, std::vector<int>>& theColoredShapes,
  bool theGetSubResults = false);
 
MODELAPI_EXPORT void removeSubShapeColors(const std::shared_ptr<ModelAPI_Result> theResult);
 
MODELAPI_EXPORT void setColor(std::shared_ptr<ModelAPI_Result> theResult,
  const std::vector<int>& theColor);
 
MODELAPI_EXPORT void setColor(std::shared_ptr<ModelAPI_Result> theResult,
  std::shared_ptr<GeomAPI_Shape> theShape,
  const std::vector<int>& theColor);
 
MODELAPI_EXPORT void getIsoLines(const std::shared_ptr<ModelAPI_Result>& theResult,
  bool& isVisible, std::vector<int>& theNbLines);
 
MODELAPI_EXPORT void setIsoLines(std::shared_ptr<ModelAPI_Result> theResult,
  const std::vector<int>& theIso);
 
MODELAPI_EXPORT void showIsoLines(std::shared_ptr<ModelAPI_Result> theResult, bool theShow);
 
MODELAPI_EXPORT bool isShownIsoLines(std::shared_ptr<ModelAPI_Result> theResult);
 
MODELAPI_EXPORT void showEdgesDirection(std::shared_ptr<ModelAPI_Result> theResult, bool theShow);
 
MODELAPI_EXPORT bool isShowEdgesDirection(std::shared_ptr<ModelAPI_Result> theResult);
 
MODELAPI_EXPORT void bringToFront(std::shared_ptr<ModelAPI_Result> theResult, bool theFlag);
 
MODELAPI_EXPORT bool isBringToFront(std::shared_ptr<ModelAPI_Result> theResult);
 
MODELAPI_EXPORT double getTransparency(const std::shared_ptr<ModelAPI_Result>& theResult);
 
MODELAPI_EXPORT void setTransparency(std::shared_ptr<ModelAPI_Result> theResult,
  double theTransparency);
 
 
MODELAPI_EXPORT void copyVisualizationAttrs(std::shared_ptr<ModelAPI_Result> theSource,
                                            std::shared_ptr<ModelAPI_Result> theDest);
 
MODELAPI_EXPORT void copyImageAttribute(std::shared_ptr<ModelAPI_Result> theSource,
                                        std::shared_ptr<ModelAPI_Result> theDest);
 
MODELAPI_EXPORT std::list<std::shared_ptr<ModelAPI_Feature> > referencedFeatures(
  std::shared_ptr<ModelAPI_Result> theTarget, const std::string& theFeatureKind,
  const bool theSortResults);
 
MODELAPI_EXPORT bool isInResults(AttributeSelectionListPtr theSelection,
                                 const std::list<ResultPtr>& theResults,
                                 std::set<ResultPtr>& theCashedResults);
 
MODELAPI_EXPORT void findRandomColor(std::vector<int>& theValues, bool theReset = false);
 
MODELAPI_EXPORT std::wstring validateMovement(
  const FeaturePtr& theAfter, const std::list<FeaturePtr> theMoved);
 
}
 
#endif