SketchPlugin_Sketch.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 SketchPlugin_Sketch_H_
#define SketchPlugin_Sketch_H_
 
#include "SketchPlugin.h"
#include <SketchPlugin_Feature.h>
#include <GeomAPI_Pnt.h>
#include <GeomAPI_Pln.h>
#include <GeomAPI_IPresentable.h>
#include <GeomAPI_ICustomPrs.h>
 
#include <GeomAPI_Ax3.h>
#include <GeomAPI_XYZ.h>
#include <GeomDataAPI_Point.h>
#include <GeomDataAPI_Dir.h>
#include <list>
 
#ifdef SET_PLANES_COLOR_IN_PREFERENCES
  #define YZ_PLANE_COLOR "225,0,0"
  #define XZ_PLANE_COLOR "0,225,0"
  #define XY_PLANE_COLOR "0,0,225"
#endif
 
class SketchPlugin_Sketch : public ModelAPI_CompositeFeature//, public GeomAPI_ICustomPrs
{
 public:
  inline static const std::string& ID()
  {
    static const std::string MY_SKETCH_ID("Sketch");
    return MY_SKETCH_ID;
  }
  inline static const std::string& ORIGIN_ID()
  {
    static const std::string MY_ORIGIN_ID("Origin");
    return MY_ORIGIN_ID;
  }
  inline static const std::string& DIRX_ID()
  {
    static const std::string MY_DIRX_ID("DirX");
    return MY_DIRX_ID;
  }
  inline static const std::string& NORM_ID()
  {
    static const std::string MY_NORM_ID("Norm");
    return MY_NORM_ID;
  }
 
  inline static const std::string& DEFAULT_SIZE_ID()
  {
    static const std::string MY_DEFAULT_SIZE_ID_ID("DefaultSize");
    return MY_DEFAULT_SIZE_ID_ID;
  }
 
  inline static const std::string& AXES_ENABLED_ID()
  {
    static const std::string MY_AXES_ENABLED_ID("AxesEnabled");
    return MY_AXES_ENABLED_ID;
  }
 
  inline static const std::string& SUBSTRATE_ENABLED_ID()
  {
    static const std::string MY_SUBSTRATE_ENABLED_ID("SubstrateEnabled");
    return MY_SUBSTRATE_ENABLED_ID;
  }
 
  inline static const std::string& CONSTRUCTION_GRID_TYPE_ID()
  {
    static const std::string MY_CONSTRUCTION_GRID_TYPE_ID("GridType");
    return MY_CONSTRUCTION_GRID_TYPE_ID;
  }
 
  inline static const std::string& RECTANGULAR_CONSTRUCTION_GRID_STEP_X_ID()
  {
    static const std::string MY_RECTANGULAR_CONSTRUCTION_GRID_STEP_X_ID("RectangularGridStepX");
    return MY_RECTANGULAR_CONSTRUCTION_GRID_STEP_X_ID;
  }
  inline static const std::string& RECTANGULAR_CONSTRUCTION_GRID_STEP_Y_ID()
  {
    static const std::string MY_RECTANGULAR_CONSTRUCTION_GRID_STEP_Y_ID("RectangularGridStepY");
    return MY_RECTANGULAR_CONSTRUCTION_GRID_STEP_Y_ID;
  }
  inline static const std::string& RECTANGULAR_CONSTRUCTION_GRID_OFFSET_ANGLE_ID()
  {
    static const std::string MY_RECTANGULAR_CONSTRUCTION_GRID_OFFSET_ANGLE_ID("RectangularGridOffsetAngle");
    return MY_RECTANGULAR_CONSTRUCTION_GRID_OFFSET_ANGLE_ID;
  }
  inline static const std::string& RECTANGULAR_CONSTRUCTION_GRID_OFFSET_X_ID()
  {
    static const std::string MY_RECTANGULAR_CONSTRUCTION_GRID_OFFSET_X_ID("RectangularGridOffsetX");
    return MY_RECTANGULAR_CONSTRUCTION_GRID_OFFSET_X_ID;
  }
  inline static const std::string& RECTANGULAR_CONSTRUCTION_GRID_OFFSET_Y_ID()
  {
    static const std::string MY_RECTANGULAR_CONSTRUCTION_GRID_OFFSET_Y_ID("RectangularGridOffsetY");
    return MY_RECTANGULAR_CONSTRUCTION_GRID_OFFSET_Y_ID;
  }
 
  inline static const std::string& CIRCULAR_CONSTRUCTION_GRID_STEP_R_ID()
  {
    static const std::string MY_CIRCULAR_CONSTRUCTION_GRID_STEP_R_ID("CircularGridStepR");
    return MY_CIRCULAR_CONSTRUCTION_GRID_STEP_R_ID;
  }
  inline static const std::string& CIRCULAR_CONSTRUCTION_GRID_NUM_OF_ANG_SEGMENTS_ID()
  {
    static const std::string MY_CIRCULAR_CONSTRUCTION_GRID_NUM_OF_ANG_SEGMENTS_ID("CircularGridNumOfAnularSegments");
    return MY_CIRCULAR_CONSTRUCTION_GRID_NUM_OF_ANG_SEGMENTS_ID;
  }
  inline static const std::string& CIRCULAR_CONSTRUCTION_GRID_OFFSET_ANGLE_ID()
  {
    static const std::string MY_CIRCULAR_CONSTRUCTION_GRID_OFFSET_ANGLE_ID("CircularGridOffsetAngle");
    return MY_CIRCULAR_CONSTRUCTION_GRID_OFFSET_ANGLE_ID;
  }
  inline static const std::string& CIRCULAR_CONSTRUCTION_GRID_OFFSET_X_ID()
  {
    static const std::string MY_CIRCULAR_CONSTRUCTION_GRID_OFFSET_X_ID("CircularGridOffsetX");
    return MY_CIRCULAR_CONSTRUCTION_GRID_OFFSET_X_ID;
  }
  inline static const std::string& CIRCULAR_CONSTRUCTION_GRID_OFFSET_Y_ID()
  {
    static const std::string MY_CIRCULAR_CONSTRUCTION_GRID_OFFSET_Y_ID("CircularGridOffsetY");
    return MY_CIRCULAR_CONSTRUCTION_GRID_OFFSET_Y_ID;
  }
 
  inline static const std::string& FEATURES_ID()
  {
    static const std::string MY_FEATURES_ID("Features");
    return MY_FEATURES_ID;
  }
  inline static const std::string& SOLVER_ERROR()
  {
    static const std::string MY_SOLVER_ERROR("SolverError");
    return MY_SOLVER_ERROR;
  }
 
  inline static const std::string& SOLVER_DOF()
  {
    static const std::string MY_SOLVER_DOF("SolverDOF");
    return MY_SOLVER_DOF;
  }
 
  inline static const std::string& ACTION_REMOVE_EXTERNAL()
  {
    static const std::string MY_ACTION_REMOVE_EXTERNAL("RemoveExternalLinks");
    return MY_ACTION_REMOVE_EXTERNAL;
  }
 
  SKETCHPLUGIN_EXPORT virtual const std::string& getKind()
  {
    static std::string MY_KIND = SketchPlugin_Sketch::ID();
    return MY_KIND;
  }
 
  SKETCHPLUGIN_EXPORT virtual void execute();
 
  SKETCHPLUGIN_EXPORT virtual void initAttributes();
 
  std::shared_ptr<GeomAPI_Pnt> to3D(const double theX, const double theY) const
  {
    std::shared_ptr<GeomDataAPI_Point> aC = std::dynamic_pointer_cast<GeomDataAPI_Point>(
        data()->attribute(ORIGIN_ID()));
    std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
        data()->attribute(NORM_ID()));
    std::shared_ptr<GeomDataAPI_Dir> aX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
        data()->attribute(DIRX_ID()));
    std::shared_ptr<GeomAPI_Dir> aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir())));
 
    std::shared_ptr<GeomAPI_XYZ> aSum = aC->pnt()->xyz()->added(aX->dir()->xyz()->multiplied(theX))
        ->added(aY->xyz()->multiplied(theY));
 
    return std::shared_ptr<GeomAPI_Pnt>(new GeomAPI_Pnt(aSum));
  }
 
  std::shared_ptr<GeomAPI_Pnt2d> to2D(const std::shared_ptr<GeomAPI_Pnt>& thePnt) const
  {
    std::shared_ptr<GeomDataAPI_Point> aC = std::dynamic_pointer_cast<GeomDataAPI_Point>(
        data()->attribute(ORIGIN_ID()));
    std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
        data()->attribute(NORM_ID()));
    std::shared_ptr<GeomDataAPI_Dir> aX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
        data()->attribute(DIRX_ID()));
    std::shared_ptr<GeomAPI_Dir> aY(new GeomAPI_Dir(aNorm->dir()->cross(aX->dir())));
    return thePnt->to2D(aC->pnt(), aX->dir(), aY);
  }
 
  SKETCHPLUGIN_EXPORT virtual bool isInHistory()
  {
    return true;
  }
 
  SketchPlugin_Sketch();
 
  std::shared_ptr<GeomAPI_Pln> plane() const
  {
    std::shared_ptr<GeomDataAPI_Point> anOrigin = std::dynamic_pointer_cast<GeomDataAPI_Point>(
        data()->attribute(ORIGIN_ID()));
    std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
        data()->attribute(NORM_ID()));
 
    if (anOrigin.get() && aNorm.get() && anOrigin->isInitialized() && aNorm->isInitialized())
      return std::shared_ptr<GeomAPI_Pln>(new GeomAPI_Pln(anOrigin->pnt(), aNorm->dir()));
 
    return std::shared_ptr<GeomAPI_Pln>();
  }
 
  std::shared_ptr<GeomAPI_Ax3> coordinatePlane() const
  {
    DataPtr aData = data();
    std::shared_ptr<GeomDataAPI_Point> aC = std::dynamic_pointer_cast<GeomDataAPI_Point>(
      aData->attribute(ORIGIN_ID()));
    std::shared_ptr<GeomDataAPI_Dir> aX = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
      aData->attribute(DIRX_ID()));
    std::shared_ptr<GeomDataAPI_Dir> aNorm = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
      aData->attribute(NORM_ID()));
 
    if (!aNorm->isInitialized() || !aX->isInitialized() ||
        aNorm->dir()->cross(aX->dir())->squareModulus() < 1.e-14)
      return std::shared_ptr<GeomAPI_Ax3>();
 
    return std::shared_ptr<GeomAPI_Ax3>(new GeomAPI_Ax3(aC->pnt(), aX->dir(), aNorm->dir()));
  }
 
  bool isPlaneSet() const
  {
    std::shared_ptr<GeomDataAPI_Dir> aNormal = std::dynamic_pointer_cast<GeomDataAPI_Dir>(
        data()->attribute(NORM_ID()));
 
    return aNormal && !(aNormal->x() == 0 && aNormal->y() == 0 && aNormal->z() == 0);
  }
 
 
  SKETCHPLUGIN_EXPORT virtual std::shared_ptr<ModelAPI_Feature> addFeature(std::string theID);
 
  virtual void removeFeature(std::shared_ptr<ModelAPI_Feature> theFeature);
 
  SKETCHPLUGIN_EXPORT virtual int numberOfSubs(bool forTree = false) const;
 
  SKETCHPLUGIN_EXPORT virtual std::shared_ptr<ModelAPI_Feature>
    subFeature(const int theIndex, bool forTree = false);
 
  SKETCHPLUGIN_EXPORT virtual int subFeatureId(const int theIndex) const;
 
  SKETCHPLUGIN_EXPORT virtual bool isSub(ObjectPtr theObject) const;
 
  SKETCHPLUGIN_EXPORT virtual void attributeChanged(const std::string& theID);
 
  SKETCHPLUGIN_EXPORT virtual bool customAction(const std::string& theActionId);
 
  static void createPoint2DResult(ModelAPI_Feature* theFeature,
                                  SketchPlugin_Sketch* theSketch,
                                  const std::string& theAttributeID, const int theIndex);
 
  static void createLine2DResult(ModelAPI_Feature* theFeature,
                                 SketchPlugin_Sketch* theSketch,
                                 const std::string& theStartAttrID,
                                 const std::string& theEndAttrID,
                                 const int theIndex = 0);
 
  static FeaturePtr addUniqueNamedCopiedFeature(FeaturePtr theFeature,
                                                SketchPlugin_Sketch* theSketch,
                                                const bool theIsCopy = false);
 
  static std::shared_ptr<GeomAPI_Ax3> plane(SketchPlugin_Sketch* theSketch);
 
  //virtual bool customisePresentation(ResultPtr theResult, AISObjectPtr thePrs,
  //                                   std::shared_ptr<GeomAPI_ICustomPrs> theDefaultPrs)
  //{
  //  bool isCustomized = false;
  //  // apply the color of the result to the presentation
  //  if (theDefaultPrs.get())
  //    isCustomized = theDefaultPrs->customisePresentation(theResult, thePrs, theDefaultPrs);
  //  // set the sketch presentation bold
  //  isCustomized = thePrs->setWidth(2) || isCustomized;
 
  //  return isCustomized;
  //}
 
private:
  bool removeLinksToExternal();
 
  void updateCoordinateAxis(ObjectPtr theSub, std::shared_ptr<GeomAPI_Ax3> thePlane);
 
private:
  std::shared_ptr<GeomAPI_Ax3> myPlane;
};
 
#endif