PartSet_Tools.h

// Copyright (C) 2014-2025  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 PartSet_Tools_H
#define PartSet_Tools_H
 
#include "PartSet.h"
 
#include <gp_Pnt.hxx>
#include <gp_Ax3.hxx>
#include <Bnd_Box.hxx>
 
#include <QPoint>
#include <QList>
#include <QCursor>
 
#include <ModelAPI_CompositeFeature.h>
#include <ModelAPI_Object.h>
#include <ModelAPI_Attribute.h>
#include <ModelAPI_AttributeSelection.h>
 
#include <Events_Message.h>
 
#include <TopoDS_Shape.hxx>
 
#include <memory>
#include <string>
#include <array>
#include <utility>
 
class V3d_View;
class ModuleBase_IViewWindow;
class ModuleBase_ViewerPrs;
class ModuleBase_IWorkshop;
class GeomDataAPI_Point2D;
class GeomAPI_Shape;
class GeomAPI_Face;
class GeomAPI_Pln;
class GeomAPI_Pnt2d;
class GeomAPI_Pnt;
class GeomAPI_Edge;
class GeomAPI_Vertex;
class ModelAPI_Result;
 
class QMouseEvent;
 
class PARTSET_EXPORT PartSet_Tools
{
public:
  enum ConstraintVisibleState
  {
    Geometrical = 0, // all constrains excepting dimensional
    Dimensional,     // length, distance, radius and angle constraints
    Expressions,     // parameter text should be shown in dimensional constraint
    Any              // both, geometrical and dimensional, types of constraints
  };
 
 public:
  static int getAISDefaultWidth();
 
  static gp_Pnt convertClickToPoint(QPoint thePoint, Handle(V3d_View) theView);
 
  static void convertTo2D(const gp_Pnt& thePoint, FeaturePtr theSketch,
                          Handle(V3d_View) theView,
                          double& theX, double& theY);
 
  static std::shared_ptr<GeomAPI_Pnt2d> convertTo2D(FeaturePtr theSketch,
                                                    const std::shared_ptr<GeomAPI_Pnt>& thePnt);
 
  static std::shared_ptr<GeomAPI_Pnt> convertTo3D(const double theX, const double theY,
                                                  FeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_Document> document();
 
  static void setFeatureValue(FeaturePtr theFeature, double theX, const std::string& theAttribute);
 
  static double featureValue(FeaturePtr theFeature, const std::string& theAttribute, bool& isValid);
 
  static FeaturePtr feature(FeaturePtr theFeature, const std::string& theAttribute,
                            const std::string& theKind);
 
  static void createConstraint(CompositeFeaturePtr theSketch,
                               std::shared_ptr<GeomDataAPI_Point2D> thePoint1,
                               std::shared_ptr<GeomDataAPI_Point2D> thePoint2);
 
  static std::shared_ptr<GeomAPI_Pln> sketchPlane(CompositeFeaturePtr theSketch);
 
  static void nullifySketchPlane(CompositeFeaturePtr theSketch);
 
  static std::pair<bool, gp_Ax3> getWorldCSAt(const GeomAPI_Face& theFace, double U, double V);
 
  static std::pair<bool, gp_Pnt> getWorldPointByUV(const GeomAPI_Face& theFace, double U, double V);
 
  static std::pair<bool, Bnd_Box> getBBoxAtCS(const GeomAPI_Shape& theShape, const gp_Ax3 theCS);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneDefaultSize(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeBoolean> sketchPlaneAxesEnabled(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeBoolean> sketchPlaneSubstrateEnabled(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeString> sketchPlaneGridType(CompositeFeaturePtr theSketch);
 
  class SketchPlaneGridType {
  public:
    typedef enum {
      No,
      Rectangular,
      Circular
    } Enum;
 
    static std::string toString(Enum iType);
    static Enum fromString(const std::string& iTypeString);
 
  private:
    static const std::array<std::string, 3> STRINGS;
  };
 
  static void setSketchPlaneGridType(CompositeFeaturePtr theSketch, SketchPlaneGridType::Enum theType);
  static SketchPlaneGridType::Enum getSketchPlaneGridType(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneRectangularGridStepX(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneRectangularGridStepY(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneRectangularGridOffsetAngle(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneRectangularGridOffsetX(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneRectangularGridOffsetY(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneCircularGridStepR(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeInteger> sketchPlaneCircularGridNumOfAngSegments(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneCircularGridOffsetAngle(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneCircularGridOffsetX(CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_AttributeDouble> sketchPlaneCircularGridOffsetY(CompositeFeaturePtr theSketch);
 
 
  static std::shared_ptr<GeomAPI_Pnt> point3D(std::shared_ptr<GeomAPI_Pnt2d> thePoint2D,
                                                CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_Result> findFixedObjectByExternal(
                                             const TopoDS_Shape& theShape,
                                             const ObjectPtr& theObject,
                                             CompositeFeaturePtr theSketch);
 
  static std::shared_ptr<ModelAPI_Result> createFixedObjectByExternal(
                                               const std::shared_ptr<GeomAPI_Shape>& theShape,
                                               const ObjectPtr& theObject,
                                               CompositeFeaturePtr theSketch,
                                               const bool theTemporary,
                                               FeaturePtr& theCreatedFeature);
 
  static bool isContainPresentation(const QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theSelected,
                                    const std::shared_ptr<ModuleBase_ViewerPrs>& thePrs);
 
  static std::pair<AttributePtr, int> findAttributeBy2dPoint(ObjectPtr theObj,
                                                             const TopoDS_Shape theShape,
                                                             FeaturePtr theSketch);
 
  static std::shared_ptr<GeomAPI_Shape> findShapeBy2DPoint(const AttributePtr& theAttribute,
                                         ModuleBase_IWorkshop* theWorkshop);
 
  static std::shared_ptr<GeomAPI_Pnt2d> getPoint(std::shared_ptr<ModelAPI_Feature>& theFeature,
                                                 const std::string& theAttribute);
 
  static std::shared_ptr<GeomAPI_Pnt2d> getPnt2d(QMouseEvent* theEvent,
                                                 ModuleBase_IViewWindow* theWindow,
                                                 const FeaturePtr& theSketch);
 
  static std::shared_ptr<GeomAPI_Pnt2d> getPnt2d(const Handle(V3d_View)& theView,
                                                 const TopoDS_Shape& theShape,
                                                 const FeaturePtr& theSketch);
 
  static FeaturePtr findFirstCoincidence(const FeaturePtr& theFeature,
                                         std::shared_ptr<GeomAPI_Pnt2d> thePoint);
 
  static void findCoincidences(FeaturePtr theStartCoin, QList<FeaturePtr>& theList,
                               QList<FeaturePtr>& theCoincidencies,
                               std::string theAttr, QList<bool>& theIsAttributes);
 
  /*
  * Finds and returns feature reerenced to the paramenter feature with the given name if found
  * \param theFeature a source feature where refsToMe is obtained
  * \param theFeatureId an identifier of the searched feature
  */
  static FeaturePtr findRefsToMeFeature(FeaturePtr theFeature, const std::string& theFeatureId)
  {
    if (!theFeature.get())
      return FeaturePtr();
 
    // find first projected feature and edit it
    const std::set<AttributePtr>& aRefsList = theFeature->data()->refsToMe();
    std::set<AttributePtr>::const_iterator anIt;
    for (anIt = aRefsList.cbegin(); anIt != aRefsList.cend(); ++anIt) {
      FeaturePtr aRefFeature = std::dynamic_pointer_cast<ModelAPI_Feature>((*anIt)->owner());
      if (aRefFeature && aRefFeature->getKind() == theFeatureId)
        return aRefFeature;
    }
    return FeaturePtr();
  }
 
  static std::shared_ptr<GeomAPI_Pnt2d> getCoincedencePoint(FeaturePtr theStartCoin);
 
  static void sendSubFeaturesEvent(const CompositeFeaturePtr& theComposite,
                                   const Events_ID theId);
 
  static bool isAuxiliarySketchEntity(const ObjectPtr& theObject);
 
  static bool isIncludeIntoSketchResult(const ObjectPtr& theObject);
 
  static ResultPtr createFixedByExternalCenter(const ObjectPtr& theObject,
                                               const std::shared_ptr<GeomAPI_Edge>& theEdge,
                                               ModelAPI_AttributeSelection::CenterType theType,
                                               const CompositeFeaturePtr& theSketch,
                                               bool theTemporary,
                                               FeaturePtr& theCreatedFeature);
 
 
  static void getFirstAndLastIndexInFolder(const ObjectPtr& theFolder,
    int& theFirst, int& theLast);
 
 
  static void getDefaultColor(ObjectPtr theObject, const bool isEmptyColorValid,
    std::vector<int>& theColor);
 
  static double getDefaultDeflection(const ObjectPtr& theObject);
 
 
  static double getDefaultTransparency();
 
  static QCursor getOperationCursor();
};
 
#endif