X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPartSet%2FPartSet_Tools.h;h=b76e1dd4449892fedd0047668f439fcacda3d8c0;hb=b73fb7468bea81901dbeed8e229d742f788ec282;hp=7b81b3f10015e3c7e444d50cd9ed490759c5647a;hpb=d727f40573f7a71044fea24b6af43b419ac19e51;p=modules%2Fshaper.git diff --git a/src/PartSet/PartSet_Tools.h b/src/PartSet/PartSet_Tools.h old mode 100644 new mode 100755 index 7b81b3f10..b76e1dd44 --- a/src/PartSet/PartSet_Tools.h +++ b/src/PartSet/PartSet_Tools.h @@ -1,6 +1,22 @@ -// File: PartSet_Tools.h -// Created: 28 Apr 2014 -// Author: Natalia ERMOLAEVA +// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// +// 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 @@ -10,85 +26,92 @@ #include #include +#include -#include +#include +#include +#include +#include -#include +#include -#include +#include -class Handle_V3d_View; -class XGUI_ViewerPrs; +#include + +class V3d_View; +class ModuleBase_IViewWindow; +class ModuleBase_ViewerPrs; +class ModuleBase_IWorkshop; class GeomDataAPI_Point2D; +class GeomAPI_Shape; class GeomAPI_Pln; class GeomAPI_Pnt2d; class GeomAPI_Pnt; -class PartSet_FeaturePrs; +class GeomAPI_Edge; +class GeomAPI_Vertex; +class ModelAPI_Result; + +class QMouseEvent; /*! - \class PartSet_Tools + * \class PartSet_Tools + * \ingroup Modules * \brief The operation for the sketch feature creation -*/ + */ class PARTSET_EXPORT PartSet_Tools { public: + /// \enum ConstraintVisibleState types of constraints which visible state can be + /// changed in the sketch widget + enum ConstraintVisibleState + { + Geometrical = 0, // all constrains excepting dimensional + Dimensional, // lenght, distance, radius and angle constraints + Expressions, // parameter text should be shown in dimensional constraint + Any // both, geometrical and dimensional, types of constraints + }; + + public: + /// Returns default value of AIS presentation + /// \return integer value + static int getAISDefaultWidth(); + /// Converts the 2D screen point to the 3D point on the view according to the point of view /// \param thePoint a screen point /// \param theView a 3D view - static gp_Pnt convertClickToPoint(QPoint thePoint, Handle_V3d_View theView); + static gp_Pnt convertClickToPoint(QPoint thePoint, Handle(V3d_View) theView); /// \brief Converts the 3D point to the projected coodinates on the sketch plane. /// \param thePoint the 3D point in the viewer /// \param theSketch the sketch feature + /// \param theView a view 3d object /// \param theX the X coordinate /// \param theY the Y coordinate static void convertTo2D(const gp_Pnt& thePoint, FeaturePtr theSketch, - Handle(V3d_View) theView, double& theX, double& theY); + Handle(V3d_View) theView, + double& theX, double& theY); + + /// \brief Converts the 3D point to the projected coodinates on the sketch plane. + /// \param theSketch the sketch feature + /// \param thePnt the 3D point in the viewer + /// \returns the converted point object + static std::shared_ptr convertTo2D(FeaturePtr theSketch, + const std::shared_ptr& thePnt); /// \brief Converts the 2D projected coodinates on the sketch plane to the 3D point. /// \param theX the X coordinate /// \param theY the Y coordinate /// \param theSketch the sketch feature - /// \param thePoint the 3D point in the viewer - static void convertTo3D(const double theX, const double theY, FeaturePtr theSketch, - gp_Pnt& thePoint); - - /// Creates the feature presentation - /// \param theKind a feature kind - /// \param theSketch the sketch of the feature - /// \param theFeature the feature - static boost::shared_ptr createFeaturePrs(const std::string& theKind, - FeaturePtr theSketch, - FeaturePtr theFeature = FeaturePtr()); - - /// Returns a feature that is under the mouse point - /// \param thePoint a screen point - /// \param theView a 3D view - /// \param theSketch the sketch feature - /// \param theFeatures the list of selected presentations - static FeaturePtr nearestFeature(QPoint thePoint, Handle_V3d_View theView, FeaturePtr theSketch, - const std::list& theFeatures); - - /// \brief Move the feature. - /// \param theFeature the source feature - /// \param theDeltaX the delta for X coordinate is moved - /// \param theDeltaY the delta for Y coordinate is moved - static void moveFeature(FeaturePtr theFeature, double theDeltaX, double theDeltaY); + static std::shared_ptr convertTo3D(const double theX, const double theY, + FeaturePtr theSketch); /// Returns pointer to the root document. - static boost::shared_ptr document(); - - /// \brief Save the point to the feature. If the attribute is 2D geometry point, it is filled. - /// \param theFeature the feature - /// \param theX the horizontal coordinate - /// \param theY the vertical coordinate - /// \param theAttribute the feature attribute - static void setFeaturePoint(FeaturePtr theFeature, double theX, double theY, - const std::string& theAttribute); + static std::shared_ptr document(); /// \brief Save the double to the feature. If the attribute is double, it is filled. /// \param theFeature the feature - /// \param theValue the horizontal coordinate + /// \param theX the horizontal coordinate /// \param theAttribute the feature attribute static void setFeatureValue(FeaturePtr theFeature, double theX, const std::string& theAttribute); @@ -97,8 +120,7 @@ public: /// \param theAttribute the feature attribute /// \param isValid an output parameter whether the value is valid /// \returns the feature value - static double featureValue(FeaturePtr theFeature, const std::string& theAttribute, - bool& isValid); + static double featureValue(FeaturePtr theFeature, const std::string& theAttribute, bool& isValid); /// Find a feature in the attribute of the given feature. If the kind is not empty, /// the return feature should be this type. Otherwise it is null @@ -107,44 +129,169 @@ public: /// \param theKind an output feature kind /// \return the feature static FeaturePtr feature(FeaturePtr theFeature, const std::string& theAttribute, - const std::string& theKind); + const std::string& theKind); /// Creates a constraint on two points + /// \param theSketch a sketch feature /// \param thePoint1 the first point - /// \param thePoint1 the second point - static void createConstraint(FeaturePtr theSketch, - boost::shared_ptr thePoint1, - boost::shared_ptr thePoint2); - - /// Find a point in the line with given coordinates - /// \param theFeature the line feature - /// \param theX the horizontal point coordinate - /// \param theY the vertical point coordinate - static boost::shared_ptr findPoint(FeaturePtr theFeature, double theX, - double theY); + /// \param thePoint2 the second point + static void createConstraint(CompositeFeaturePtr theSketch, + std::shared_ptr thePoint1, + std::shared_ptr thePoint2); /// Create a sketch plane instance /// \param theSketch a sketch feature /// \return API object of geom plane - static boost::shared_ptr sketchPlane(FeaturePtr theSketch); + static std::shared_ptr sketchPlane(CompositeFeaturePtr theSketch); /// Create a point 3D on a basis of point 2D and sketch feature /// \param thePoint2D a point on a sketch /// \param theSketch a sketch feature /// \return API object of point 3D - static boost::shared_ptr point3D(boost::shared_ptr thePoint2D, - FeaturePtr theSketch); - /// Check whether there is a constraint with the feature kind given - /// \param theKind a feature kind - /// \return the boolean value - static bool isConstraintFeature(const std::string& theKind); - -private: - /// Return the distance between the feature and the point - /// \param theFeature feature object - /// \param theX the horizontal coordinate of the point - /// \param theX the vertical coordinate of the point - static double distanceToPoint(FeaturePtr theFeature, double theX, double theY); + static std::shared_ptr point3D(std::shared_ptr thePoint2D, + CompositeFeaturePtr theSketch); + + /// Finds a line (arc or circle) by given edge + /// \param theShape an edge + /// \param theObject a selected result object + /// \param theSketch a sketch feature + /// \return result of found feature or NULL + static std::shared_ptr findFixedObjectByExternal( + const TopoDS_Shape& theShape, + const ObjectPtr& theObject, + CompositeFeaturePtr theSketch); + + /// Creates a line (arc or circle) by given edge + /// Created line will have fixed constraint + /// \param theShape an edge + /// \param theObject a selected result object + /// \param theSketch a sketch feature + /// \param theTemporary the created external object is temporary, execute is not performed for it + /// \param theCreatedFeature a new projection feature + /// \return result of created feature + static std::shared_ptr createFixedObjectByExternal( + const std::shared_ptr& theShape, + const ObjectPtr& theObject, + CompositeFeaturePtr theSketch, + const bool theTemporary, + FeaturePtr& theCreatedFeature); + + /// Checks whether the list of selected presentations contains the given one + /// \param theSelected a list of presentations + /// \param thePrs a presentation to be found + /// \return - result of check, true if the list contains the prs + static bool isContainPresentation(const QList>& theSelected, + const std::shared_ptr& thePrs); + + /** + * Find attribute of object which corresponds to the given shape + * \param theObj - an object + * \param theShape - a Shape + * \param theSketch - a Sketch to get a plane of converting to 2d + */ + static AttributePtr findAttributeBy2dPoint(ObjectPtr theObj, const TopoDS_Shape theShape, + FeaturePtr theSketch); + + /** + * Finds an attribute value in attribute reference attribute value + * \param theAttribute - an attribure reference filled with an attribute + * \param theWorkshop a reference to workshop + * \return a geometry shape + */ + static std::shared_ptr findShapeBy2DPoint(const AttributePtr& theAttribute, + ModuleBase_IWorkshop* theWorkshop); + + /** + * Returns point of coincidence feature + * \param theFeature the coincidence feature + * \param theAttribute the attribute name + */ + static std::shared_ptr getPoint(std::shared_ptr& theFeature, + const std::string& theAttribute); + + /** + * Convertes parameters into a geom point + * \theEvent a Qt event to find mouse position + * \param theWindow view window to define eye of view + * \param theSketch to convert 3D point coordinates into coorditates of the sketch plane + */ + static std::shared_ptr getPnt2d(QMouseEvent* theEvent, + ModuleBase_IViewWindow* theWindow, + const FeaturePtr& theSketch); + + /** + * Gets all references to the feature, take coincidence constraint features, get point 2d attributes + * and compare the point value to be equal with the given. Returns the first feature, which has + * equal points. + * \param theFeature the coincidence feature + * \param thePoint a 2d point + * \return the coincidence feature or null + */ + static FeaturePtr findFirstCoincidence(const FeaturePtr& theFeature, + std::shared_ptr thePoint); + + /** + * Returns list of features connected in a councedence feature point + * \param theStartCoin the coincidence feature + * \param theList a list which collects lines features + * \param theCoincidencies a list of coincidence features + * \param theAttr the attribute name + */ + static void findCoincidences(FeaturePtr theStartCoin, QList& theList, + QList& theCoincidencies, + std::string theAttr, QList& 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 indentifier 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& aRefsList = theFeature->data()->refsToMe(); + std::set::const_iterator anIt; + for (anIt = aRefsList.cbegin(); anIt != aRefsList.cend(); ++anIt) { + FeaturePtr aRefFeature = std::dynamic_pointer_cast((*anIt)->owner()); + if (aRefFeature && aRefFeature->getKind() == theFeatureId) + return aRefFeature; + } + return FeaturePtr(); + } + + /** + * Returns point of a coincedence + * \param theStartCoin the coincedence feature + */ + static std::shared_ptr getCoincedencePoint(FeaturePtr theStartCoin); + + /// Sends redisplay event for all sub-features of the composite. Flush it. + static void sendSubFeaturesEvent(const CompositeFeaturePtr& theComposite, + const Events_ID theId); + + /** + * Returns true if the object is a sketch entity, where auxiliary attribute has true value + * \param theObject a result or feature + * \return boolean result + */ + static bool isAuxiliarySketchEntity(const ObjectPtr& theObject); + + /** + * Returns true if the object is a sketch entity produced by projection or intersection feature + * and if it should not be included into the sketch result + */ + static bool isIncludeIntoSketchResult(const ObjectPtr& theObject); + + static ResultPtr createFixedByExternalCenter(const ObjectPtr& theObject, + const std::shared_ptr& theEdge, + ModelAPI_AttributeSelection::CenterType theType, + const CompositeFeaturePtr& theSketch, + bool theTemporary, + FeaturePtr& theCreatedFeature); + }; #endif