From: vsv Date: Wed, 15 Jun 2022 14:48:49 +0000 (+0300) Subject: bos #29469: Advanced geometry features: Detect type of shape X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=abb694b1f7e7a2ca90871fff37b4810220823d3e;p=modules%2Fgeom.git bos #29469: Advanced geometry features: Detect type of shape --- diff --git a/idl/GEOM_Gen.idl b/idl/GEOM_Gen.idl index d0fa16858..729b80759 100644 --- a/idl/GEOM_Gen.idl +++ b/idl/GEOM_Gen.idl @@ -4936,6 +4936,48 @@ module GEOM in boolean isRelative, in double angularDeflection); }; + // # GEOM_ICanonicalRecognition: + /*! + * \brief Interface for canonical recognition operations. + */ + interface GEOM_ICanonicalRecognition : GEOM_IOperations + { + /*! + * check if the shape is planar + */ + boolean isPlane(in GEOM_Object shape, in double tolerance, inout ListOfDouble normal, inout ListOfDouble origin); + + /*! + * check if shape is spherical + */ + boolean isSphere(in GEOM_Object shape, in double tolerance, inout ListOfDouble origin, inout double radius); + + /*! + * check if shape is conical + */ + boolean isCone(in GEOM_Object shape, in double tolerance, inout ListOfDouble axis, inout ListOfDouble apex, inout double halfAngle); + + /*! + * check if shape is cylinder + */ + boolean isCylinder(in GEOM_Object shape, in double tolerance, inout ListOfDouble axis, inout ListOfDouble origin, inout double radius); + + /*! + * check if edge / wire is line + */ + boolean isLine(in GEOM_Object edge, in double tolerance, inout ListOfDouble direction, inout ListOfDouble origin); + + /*! + * check if edge / wire is circle + */ + boolean isCircle(in GEOM_Object edge, in double tolerance, inout ListOfDouble normal, inout ListOfDouble origin, inout double radius); + + /*! + * check if edge / wire is ellipse + */ + boolean isEllipse(in GEOM_Object edge, in double tolerance, inout ListOfDouble normal, inout ListOfDouble dirX, inout ListOfDouble origin, inout double majorRadius, inout double minorRadius); + }; + // # GEOM_Gen: /*! * \brief Interface to access other GEOM interfaces. @@ -5049,20 +5091,21 @@ module GEOM // # Methods to access interfaces for objects creation and transformation - GEOM_IBasicOperations GetIBasicOperations () raises (SALOME::SALOME_Exception); - GEOM_ITransformOperations GetITransformOperations() raises (SALOME::SALOME_Exception); - GEOM_I3DPrimOperations GetI3DPrimOperations () raises (SALOME::SALOME_Exception); - GEOM_IShapesOperations GetIShapesOperations () raises (SALOME::SALOME_Exception); - GEOM_IBooleanOperations GetIBooleanOperations () raises (SALOME::SALOME_Exception); - GEOM_ICurvesOperations GetICurvesOperations () raises (SALOME::SALOME_Exception); - GEOM_ILocalOperations GetILocalOperations () raises (SALOME::SALOME_Exception); - GEOM_IHealingOperations GetIHealingOperations () raises (SALOME::SALOME_Exception); - GEOM_IInsertOperations GetIInsertOperations () raises (SALOME::SALOME_Exception); - GEOM_IMeasureOperations GetIMeasureOperations () raises (SALOME::SALOME_Exception); - GEOM_IBlocksOperations GetIBlocksOperations () raises (SALOME::SALOME_Exception); - GEOM_IGroupOperations GetIGroupOperations () raises (SALOME::SALOME_Exception); - GEOM_IFieldOperations GetIFieldOperations () raises (SALOME::SALOME_Exception); - GEOM_ITestOperations GetITestOperations () raises (SALOME::SALOME_Exception); + GEOM_IBasicOperations GetIBasicOperations () raises (SALOME::SALOME_Exception); + GEOM_ITransformOperations GetITransformOperations () raises (SALOME::SALOME_Exception); + GEOM_I3DPrimOperations GetI3DPrimOperations () raises (SALOME::SALOME_Exception); + GEOM_IShapesOperations GetIShapesOperations () raises (SALOME::SALOME_Exception); + GEOM_IBooleanOperations GetIBooleanOperations () raises (SALOME::SALOME_Exception); + GEOM_ICurvesOperations GetICurvesOperations () raises (SALOME::SALOME_Exception); + GEOM_ILocalOperations GetILocalOperations () raises (SALOME::SALOME_Exception); + GEOM_IHealingOperations GetIHealingOperations () raises (SALOME::SALOME_Exception); + GEOM_IInsertOperations GetIInsertOperations () raises (SALOME::SALOME_Exception); + GEOM_IMeasureOperations GetIMeasureOperations () raises (SALOME::SALOME_Exception); + GEOM_IBlocksOperations GetIBlocksOperations () raises (SALOME::SALOME_Exception); + GEOM_IGroupOperations GetIGroupOperations () raises (SALOME::SALOME_Exception); + GEOM_IFieldOperations GetIFieldOperations () raises (SALOME::SALOME_Exception); + GEOM_ITestOperations GetITestOperations () raises (SALOME::SALOME_Exception); + GEOM_ICanonicalRecognition GetICanonicalRecognition() raises (SALOME::SALOME_Exception); GEOM_IOperations GetPluginOperations (in string theLibName) raises (SALOME::SALOME_Exception); diff --git a/src/GEOMImpl/CMakeLists.txt b/src/GEOMImpl/CMakeLists.txt index 43faf7ab8..98e47cea3 100644 --- a/src/GEOMImpl/CMakeLists.txt +++ b/src/GEOMImpl/CMakeLists.txt @@ -182,6 +182,7 @@ SET(GEOMImpl_HEADERS GEOMImpl_PatchFaceDriver.hxx GEOMImpl_Types.hxx GEOM_GEOMImpl.hxx + GEOMImpl_ICanonicalRecognition.hxx ) # --- sources --- @@ -257,6 +258,7 @@ SET(GEOMImpl_SOURCES GEOMImpl_GlueDriver.cxx GEOMImpl_PatchFaceDriver.cxx GEOMImpl_FieldDriver.cxx + GEOMImpl_ICanonicalRecognition.cxx ) # --- rules --- diff --git a/src/GEOMImpl/GEOMImpl_Gen.cxx b/src/GEOMImpl/GEOMImpl_Gen.cxx index 867f7b9eb..74aceaf12 100644 --- a/src/GEOMImpl/GEOMImpl_Gen.cxx +++ b/src/GEOMImpl/GEOMImpl_Gen.cxx @@ -185,6 +185,7 @@ GEOMImpl_Gen::GEOMImpl_Gen() _GroupOperations = new GEOMImpl_IGroupOperations( this ); _FieldOperations = new GEOMImpl_IFieldOperations( this ); _TestOperations = new GEOMImpl_ITestOperations( this ); + _CanonicalRecognition = new GEOMImpl_ICanonicalRecognition( this ); } //============================================================================= @@ -210,6 +211,7 @@ GEOMImpl_Gen::~GEOMImpl_Gen() delete _MeasureOperations; delete _GroupOperations; delete _FieldOperations; + delete _CanonicalRecognition; } //============================================================================= @@ -351,3 +353,13 @@ GEOMImpl_ITestOperations* GEOMImpl_Gen::GetITestOperations() { return _TestOperations; } + +//============================================================================= +/*! + * GetICanonicalRecognition + */ +//============================================================================= +GEOMImpl_ICanonicalRecognition* GEOMImpl_Gen::GetICanonicalRecognition() +{ + return _CanonicalRecognition; +} diff --git a/src/GEOMImpl/GEOMImpl_Gen.hxx b/src/GEOMImpl/GEOMImpl_Gen.hxx index dcd430f19..86237a72e 100644 --- a/src/GEOMImpl/GEOMImpl_Gen.hxx +++ b/src/GEOMImpl/GEOMImpl_Gen.hxx @@ -41,6 +41,7 @@ #include "GEOMImpl_IGroupOperations.hxx" #include "GEOMImpl_IFieldOperations.hxx" #include "GEOMImpl_ITestOperations.hxx" +#include "GEOMImpl_ICanonicalRecognition.hxx" #include "GEOM_Engine.hxx" class GEOMIMPL_EXPORT GEOMImpl_Gen : public GEOM_Engine @@ -77,22 +78,25 @@ class GEOMIMPL_EXPORT GEOMImpl_Gen : public GEOM_Engine GEOMImpl_ITestOperations* GetITestOperations(); + GEOMImpl_ICanonicalRecognition* GetICanonicalRecognition(); + private: - GEOMImpl_IBasicOperations* _BasicOperations; - GEOMImpl_ITransformOperations* _TransformOperations; - GEOMImpl_I3DPrimOperations* _3DPrimOperations; - GEOMImpl_IShapesOperations* _ShapesOperations; - GEOMImpl_IBlocksOperations* _BlocksOperations; - GEOMImpl_IBooleanOperations* _BooleanOperations; - GEOMImpl_IHealingOperations* _HealingOperations; - GEOMImpl_ICurvesOperations* _CurvesOperations; - GEOMImpl_ILocalOperations* _LocalOperations; - GEOMImpl_IInsertOperations* _InsertOperations; - GEOMImpl_IMeasureOperations* _MeasureOperations; - GEOMImpl_IGroupOperations* _GroupOperations; - GEOMImpl_IFieldOperations* _FieldOperations; - GEOMImpl_ITestOperations* _TestOperations; + GEOMImpl_IBasicOperations* _BasicOperations; + GEOMImpl_ITransformOperations* _TransformOperations; + GEOMImpl_I3DPrimOperations* _3DPrimOperations; + GEOMImpl_IShapesOperations* _ShapesOperations; + GEOMImpl_IBlocksOperations* _BlocksOperations; + GEOMImpl_IBooleanOperations* _BooleanOperations; + GEOMImpl_IHealingOperations* _HealingOperations; + GEOMImpl_ICurvesOperations* _CurvesOperations; + GEOMImpl_ILocalOperations* _LocalOperations; + GEOMImpl_IInsertOperations* _InsertOperations; + GEOMImpl_IMeasureOperations* _MeasureOperations; + GEOMImpl_IGroupOperations* _GroupOperations; + GEOMImpl_IFieldOperations* _FieldOperations; + GEOMImpl_ITestOperations* _TestOperations; + GEOMImpl_ICanonicalRecognition* _CanonicalRecognition; }; #endif diff --git a/src/GEOMImpl/GEOMImpl_ICanonicalRecognition.cxx b/src/GEOMImpl/GEOMImpl_ICanonicalRecognition.cxx new file mode 100644 index 000000000..82c844673 --- /dev/null +++ b/src/GEOMImpl/GEOMImpl_ICanonicalRecognition.cxx @@ -0,0 +1,222 @@ +// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// 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 +// + +#include "GEOMImpl_ICanonicalRecognition.hxx" + +#include "GEOM_Function.hxx" +#include "GEOM_Object.hxx" +#include "GEOM_PythonDump.hxx" + +#include +#include +#include + +#include + + +//============================================================================= +/*! + * constructor: + */ +//============================================================================= +GEOMImpl_ICanonicalRecognition::GEOMImpl_ICanonicalRecognition (GEOM_Engine* theEngine) +: GEOM_IOperations(theEngine) +{ + MESSAGE("GEOMImpl_ICanonicalRecognition::GEOMImpl_ICanonicalRecognition"); +} + +//============================================================================= +/*! + * destructor + */ +//============================================================================= +GEOMImpl_ICanonicalRecognition::~GEOMImpl_ICanonicalRecognition() +{ + MESSAGE("GEOMImpl_ICanonicalRecognition::~GEOMImpl_ICanonicalRecognition"); +} + +//============================================================================= +/*! + * \brief Check if the shape is planar + */ + //============================================================================= +bool GEOMImpl_ICanonicalRecognition::isPlane(const Handle(GEOM_Object)& theShape, double theTolerance, gp_Pln& thePln) +{ + SetErrorCode(KO); + if (theShape.IsNull()) { + SetErrorCode("Error: NULL shape"); + return false; + } + TopoDS_Shape aShape = theShape->GetValue(); + if (aShape.IsNull()) + { + return false; + } + + ShapeAnalysis_CanonicalRecognition aRecognition(aShape); + SetErrorCode(OK); + return aRecognition.IsPlane(theTolerance, thePln); +} + +//============================================================================= +/*! + * \brief Check if shape is spherical + */ + //============================================================================= +bool GEOMImpl_ICanonicalRecognition::isSphere(const Handle(GEOM_Object)& theShape, double theTolerance, + gp_Sphere& theSphere) +{ + SetErrorCode(KO); + if (theShape.IsNull()) { + SetErrorCode("Error: NULL shape"); + return false; + } + TopoDS_Shape aShape = theShape->GetValue(); + if (aShape.IsNull()) + { + return false; + } + + ShapeAnalysis_CanonicalRecognition aRecognition(aShape); + SetErrorCode(OK); + return aRecognition.IsSphere(theTolerance, theSphere); +} + +//============================================================================= +/*! + * \brief Check if shape is conical + */ + //============================================================================= +bool GEOMImpl_ICanonicalRecognition::isCone(const Handle(GEOM_Object)& theShape, double theTolerance, + gp_Cone& theCone) +{ + SetErrorCode(KO); + if (theShape.IsNull()) { + SetErrorCode("Error: NULL shape"); + return false; + } + TopoDS_Shape aShape = theShape->GetValue(); + if (aShape.IsNull()) + { + return false; + } + + ShapeAnalysis_CanonicalRecognition aRecognition(aShape); + SetErrorCode(OK); + return aRecognition.IsCone(theTolerance, theCone); +} + +//============================================================================= +/*! + * \brief Check if shape is cylinder + */ + //============================================================================= +bool GEOMImpl_ICanonicalRecognition::isCylinder(const Handle(GEOM_Object)& theShape, double theTolerance, + gp_Cylinder& theCylinder) +{ + SetErrorCode(KO); + if (theShape.IsNull()) { + SetErrorCode("Error: NULL shape"); + return false; + } + TopoDS_Shape aShape = theShape->GetValue(); + if (aShape.IsNull()) + { + return false; + } + + ShapeAnalysis_CanonicalRecognition aRecognition(aShape); + SetErrorCode(OK); + return aRecognition.IsCylinder(theTolerance, theCylinder); +} + +//============================================================================= +/*! + * \brief Check if edge / wire is line + */ + //============================================================================= +bool GEOMImpl_ICanonicalRecognition::isLine(const Handle(GEOM_Object)& theEdge, double theTolerance, + gp_Lin& theLine) +{ + SetErrorCode(KO); + if (theEdge.IsNull()) { + SetErrorCode("Error: NULL edge"); + return false; + } + TopoDS_Shape aShape = theEdge->GetValue(); + if (aShape.IsNull()) + { + return false; + } + + ShapeAnalysis_CanonicalRecognition aRecognition(aShape); + SetErrorCode(OK); + return aRecognition.IsLine(theTolerance, theLine); +} + +//============================================================================= +/*! + * \brief Check if edge / wire is circle + */ + //============================================================================= +bool GEOMImpl_ICanonicalRecognition::isCircle(const Handle(GEOM_Object)& theEdge, double theTolerance, + gp_Circ& theCircle) +{ + SetErrorCode(KO); + if (theEdge.IsNull()) { + SetErrorCode("Error: NULL edge"); + return false; + } + TopoDS_Shape aShape = theEdge->GetValue(); + if (aShape.IsNull()) + { + return false; + } + + ShapeAnalysis_CanonicalRecognition aRecognition(aShape); + SetErrorCode(OK); + return aRecognition.IsCircle(theTolerance, theCircle); +} + +//============================================================================= +/*! + * \brief Check if edge / wire is ellipse + */ + //============================================================================= +bool GEOMImpl_ICanonicalRecognition::isEllipse(const Handle(GEOM_Object)& theEdge, double theTolerance, + gp_Elips& theElips) +{ + SetErrorCode(KO); + if (theEdge.IsNull()) { + SetErrorCode("Error: NULL edge"); + return false; + } + TopoDS_Shape aShape = theEdge->GetValue(); + if (aShape.IsNull()) + { + return false; + } + + ShapeAnalysis_CanonicalRecognition aRecognition(aShape); + SetErrorCode(OK); + return aRecognition.IsEllipse(theTolerance, theElips); +} diff --git a/src/GEOMImpl/GEOMImpl_ICanonicalRecognition.hxx b/src/GEOMImpl/GEOMImpl_ICanonicalRecognition.hxx new file mode 100644 index 000000000..b4d482dcf --- /dev/null +++ b/src/GEOMImpl/GEOMImpl_ICanonicalRecognition.hxx @@ -0,0 +1,86 @@ +// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// 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 _GEOMImpl_ICanonicalRecognition_HXX_ +#define _GEOMImpl_ICanonicalRecognition_HXX_ + +#include "GEOM_IOperations.hxx" + +#include + +#include +#include + +#include + +class GEOM_Object; + +class GEOMImpl_ICanonicalRecognition : public GEOM_IOperations { + public: + Standard_EXPORT GEOMImpl_ICanonicalRecognition(GEOM_Engine* theEngine); + Standard_EXPORT ~GEOMImpl_ICanonicalRecognition(); + + /*! + * \brief Check if the shape is planar + */ + Standard_EXPORT bool isPlane(const Handle(GEOM_Object)& theShape, double theTolerance, + gp_Pln& thePln); + + /*! + * \brief Check if shape is spherical + */ + Standard_EXPORT bool isSphere(const Handle(GEOM_Object)& theShape, double theTolerance, + gp_Sphere& theSphere); + + /*! + * \brief Check if shape is conical + */ + Standard_EXPORT bool isCone(const Handle(GEOM_Object)& theShape, double theTolerance, + gp_Cone& theCone); + + /*! + * \brief Check if shape is cylinder + */ + Standard_EXPORT bool isCylinder(const Handle(GEOM_Object)& theShape, double theTolerance, + gp_Cylinder& theCylinder); + + /*! + * \brief Check if edge / wire is line + */ + Standard_EXPORT bool isLine(const Handle(GEOM_Object)& theEdge, double theTolerance, + gp_Lin& theLine); + + /*! + * \brief Check if edge / wire is circle + */ + Standard_EXPORT bool isCircle(const Handle(GEOM_Object)& theEdge, double theTolerance, + gp_Circ& theCircle); + + /*! + * \brief Check if edge / wire is ellipse + */ + Standard_EXPORT bool isEllipse(const Handle(GEOM_Object)& theEdge, double theTolerance, + gp_Elips& theElips); + +}; + +#endif diff --git a/src/GEOM_I/CMakeLists.txt b/src/GEOM_I/CMakeLists.txt index 32ca28479..7aec8371b 100644 --- a/src/GEOM_I/CMakeLists.txt +++ b/src/GEOM_I/CMakeLists.txt @@ -78,6 +78,7 @@ SET(GEOMEngine_HEADERS GEOM_IMeasureOperations_i.hh GEOM_IGroupOperations_i.hh GEOM_ITestOperations_i.hh + GEOM_ICanonicalRecognition_i.hh GEOM_Gen_i.hh GEOM_Gen_Session_i.hh GEOM_Gen_No_Session_i.hh @@ -105,6 +106,7 @@ SET(GEOMEngine_SOURCES GEOM_IGroupOperations_i.cc GEOM_IFieldOperations_i.cc GEOM_ITestOperations_i.cc + GEOM_ICanonicalRecognition_i.cc GEOM_Gen_i.cc GEOM_Gen_Session_i.cc GEOM_Gen_No_Session_i.cc diff --git a/src/GEOM_I/GEOM_Gen_i.cc b/src/GEOM_I/GEOM_Gen_i.cc index c4a5599bb..00e58ed8a 100644 --- a/src/GEOM_I/GEOM_Gen_i.cc +++ b/src/GEOM_I/GEOM_Gen_i.cc @@ -2485,6 +2485,25 @@ GEOM::GEOM_ITestOperations_ptr GEOM_Gen_i::GetITestOperations() return operations._retn(); } +//============================================================================ +// function : GetICanonicalRecognition +// purpose : +//============================================================================ +GEOM::GEOM_ICanonicalRecognition_ptr GEOM_Gen_i::GetICanonicalRecognition() +{ + Unexpect aCatch(SALOME_SalomeException); + MESSAGE("GEOM_Gen_i::GetICanonicalRecognition"); + + GEOM::GEOM_Gen_ptr engine = _this(); + + GEOM_ICanonicalRecognition_i* aServant = + new GEOM_ICanonicalRecognition_i(_poa, engine, _impl->GetICanonicalRecognition()); + + // activate the CORBA servant + GEOM::GEOM_ICanonicalRecognition_var operations = aServant->_this(); + return operations._retn(); +} + //============================================================================ // function : GetPluginOperations // purpose : diff --git a/src/GEOM_I/GEOM_Gen_i.hh b/src/GEOM_I/GEOM_Gen_i.hh index cfe4b62ab..a956ed911 100644 --- a/src/GEOM_I/GEOM_Gen_i.hh +++ b/src/GEOM_I/GEOM_Gen_i.hh @@ -52,6 +52,7 @@ #include "GEOM_IGroupOperations_i.hh" #include "GEOM_IFieldOperations_i.hh" #include "GEOM_ITestOperations_i.hh" +#include "GEOM_ICanonicalRecognition_i.hh" #include "GEOMUtils.hxx" #include @@ -259,6 +260,8 @@ class GEOM_I_EXPORT GEOM_Gen_i : public POA_GEOM::GEOM_Gen, public Engines_Compo virtual GEOM::GEOM_ITestOperations_ptr GetITestOperations() ; + virtual GEOM::GEOM_ICanonicalRecognition_ptr GetICanonicalRecognition(); + //Returns a pointer to corresponding plugin operations interface virtual GEOM::GEOM_IOperations_ptr GetPluginOperations (const char* theLibName) ; diff --git a/src/GEOM_I/GEOM_ICanonicalRecognition_i.cc b/src/GEOM_I/GEOM_ICanonicalRecognition_i.cc new file mode 100644 index 000000000..bb2eba2dc --- /dev/null +++ b/src/GEOM_I/GEOM_ICanonicalRecognition_i.cc @@ -0,0 +1,319 @@ +// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// 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 +// + +#include "GEOM_ICanonicalRecognition_i.hh" + +#include "utilities.h" +#include "OpUtil.hxx" +#include "Utils_ExceptHandlers.hxx" + +#include "GEOM_Engine.hxx" +#include "GEOM_Object.hxx" +#include "GEOM_Field.hxx" + +#include "gp_Pln.hxx" +#include "gp_Sphere.hxx" +#include "gp_Cone.hxx" +#include "gp_Cylinder.hxx" +#include "gp_Circ.hxx" +#include "gp_Elips.hxx" + +//============================================================================= +/* + * constructor: + */ +//============================================================================= +GEOM_ICanonicalRecognition_i::GEOM_ICanonicalRecognition_i (PortableServer::POA_ptr thePOA, + GEOM::GEOM_Gen_ptr theEngine, + ::GEOMImpl_ICanonicalRecognition* theImpl) + :GEOM_IOperations_i(thePOA, theEngine, theImpl) +{ + MESSAGE("GEOM_ICanonicalRecognition_i::GEOM_ICanonicalRecognition_i"); +} + +//============================================================================= +/* + * destructor + */ +//============================================================================= +GEOM_ICanonicalRecognition_i::~GEOM_ICanonicalRecognition_i() +{ + MESSAGE("GEOM_ICanonicalRecognition_i::~GEOM_ICanonicalRecognition_i"); +} + +//============================================================================= +/* + * \brief Check if the shape is planar + */ + //============================================================================= +CORBA::Boolean GEOM_ICanonicalRecognition_i::isPlane(GEOM::GEOM_Object_ptr theShape, CORBA::Double theTolerance, + GEOM::ListOfDouble& theNormal, GEOM::ListOfDouble& theOrigin) +{ + Handle(::GEOM_Object) go = GetObjectImpl(theShape); + + bool aIsValidNormal = theNormal.length() == 3; + bool aIsValidOrigin = theOrigin.length() == 3; + gp_Pln aPln; + if (aIsValidNormal && aIsValidOrigin) { + aPln = gp_Pln(gp_Pnt(theOrigin[0], theOrigin[1], theOrigin[2]), + gp_Dir(theNormal[0], theNormal[1], theNormal[2])); + } + bool aResult = GetOperation()->isPlane(go, theTolerance, aPln); + if (aResult && aIsValidNormal && aIsValidOrigin) + { + gp_Pnt aOrig = aPln.Location(); + theOrigin[0] = aOrig.X(); + theOrigin[1] = aOrig.Y(); + theOrigin[2] = aOrig.Z(); + + gp_Dir aNorm = aPln.Axis().Direction(); + theNormal[0] = aNorm.X(); + theNormal[1] = aNorm.Y(); + theNormal[2] = aNorm.Z(); + } + return aResult; +} + +//============================================================================= +/* + * \brief Check if shape is spherical + */ + //============================================================================= +CORBA::Boolean GEOM_ICanonicalRecognition_i::isSphere(GEOM::GEOM_Object_ptr theShape, CORBA::Double theTolerance, + GEOM::ListOfDouble& theOrigin, CORBA::Double& theRadius) +{ + Handle(::GEOM_Object) go = GetObjectImpl(theShape); + + bool aIsValidOrigin = theOrigin.length() == 3; + bool aIsValidRadius = theRadius > 0; + gp_Sphere aSphere; + if (aIsValidOrigin && aIsValidRadius) + { + aSphere.SetLocation(gp_Pnt(theOrigin[0], theOrigin[1], theOrigin[2])); + aSphere.SetRadius(theRadius); + } + bool aResult = GetOperation()->isSphere(go, theTolerance, aSphere); + if (aResult && aIsValidOrigin && aIsValidRadius) + { + gp_Pnt aLoc = aSphere.Location(); + theOrigin[0] = aLoc.X(); + theOrigin[1] = aLoc.Y(); + theOrigin[2] = aLoc.Z(); + theRadius = aSphere.Radius(); + } + return aResult; +} + +//============================================================================= +/* + * \brief Check if shape is conical + */ + //============================================================================= +CORBA::Boolean GEOM_ICanonicalRecognition_i::isCone(GEOM::GEOM_Object_ptr theShape, CORBA::Double theTolerance, + GEOM::ListOfDouble& theAxis, GEOM::ListOfDouble& theApex, CORBA::Double& theHalfAngle) +{ + Handle(::GEOM_Object) go = GetObjectImpl(theShape); + + bool aIsValidAxis = theAxis.length() == 3; + bool aIsValidApex = theApex.length() == 3; + bool aIsValidAngle = theHalfAngle > 0; + gp_Cone aCone; + if (aIsValidAxis && aIsValidApex && aIsValidAngle) + { + gp_Pnt aLoc(theApex[0], theApex[1], theApex[2]); + aCone.SetLocation(aLoc); + aCone.SetAxis(gp_Ax1(aLoc, gp_Dir(theAxis[0], theAxis[1], theAxis[2]))); + } + bool aResult = GetOperation()->isCone(go, theTolerance, aCone); + if (aResult && aIsValidAxis && aIsValidApex && aIsValidAngle) + { + gp_Dir aDir = aCone.Axis().Direction(); + theAxis[0] = aDir.X(); + theAxis[1] = aDir.Y(); + theAxis[2] = aDir.Z(); + + gp_Pnt aApex = aCone.Apex(); + theApex[0] = aApex.X(); + theApex[1] = aApex.Y(); + theApex[2] = aApex.Z(); + + theHalfAngle = aCone.SemiAngle(); + } + return aResult; +} + +//============================================================================= +/*! + * \brief Check if shape is cylinder + */ + //============================================================================= +CORBA::Boolean GEOM_ICanonicalRecognition_i::isCylinder(GEOM::GEOM_Object_ptr theShape, CORBA::Double theTolerance, + GEOM::ListOfDouble& theAxis, GEOM::ListOfDouble& theOrigin, CORBA::Double& theRadius) +{ + Handle(::GEOM_Object) go = GetObjectImpl(theShape); + + bool aIsValidAxis = theAxis.length() == 3; + bool aIsValidOrigin = theOrigin.length() == 3; + bool aIsValidRadius = theRadius > 0; + gp_Cylinder aCylinder; + if (aIsValidAxis && aIsValidOrigin && aIsValidRadius) + { + gp_Pnt aLoc(theOrigin[0], theOrigin[0], theOrigin[0]); + aCylinder.SetLocation(aLoc); + aCylinder.SetAxis(gp_Ax1(aLoc, gp_Dir(theAxis[0], theAxis[1], theAxis[2]))); + aCylinder.SetRadius(theRadius); + } + bool aResult = GetOperation()->isCylinder(go, theTolerance, aCylinder); + if (aResult && aIsValidAxis && aIsValidOrigin && aIsValidRadius) + { + gp_Dir aDir = aCylinder.Axis().Direction(); + theAxis[0] = aDir.X(); + theAxis[1] = aDir.Y(); + theAxis[2] = aDir.Z(); + + gp_Pnt aLoc = aCylinder.Location(); + theOrigin[0] = aLoc.X(); + theOrigin[1] = aLoc.Y(); + theOrigin[2] = aLoc.Z(); + + theRadius = aCylinder.Radius(); + } + return aResult; +} + +//============================================================================= +/*! + * \brief Check if edge / wire is line + */ + //============================================================================= +CORBA::Boolean GEOM_ICanonicalRecognition_i::isLine(GEOM::GEOM_Object_ptr theEdge, CORBA::Double theTolerance, + GEOM::ListOfDouble& theDir, GEOM::ListOfDouble& theOrigin) +{ + Handle(::GEOM_Object) go = GetObjectImpl(theEdge); + + bool aIsValidDir = theDir.length() == 3; + bool aIsValidOrigin = theOrigin.length() == 3; + gp_Lin aLine; + if (aIsValidDir && aIsValidOrigin) + { + aLine.SetLocation(gp_Pnt(theOrigin[0], theOrigin[1], theOrigin[2])); + aLine.SetDirection(gp_Dir(theDir[0], theDir[1], theDir[2])); + } + bool aResult = GetOperation()->isLine(go, theTolerance, aLine); + if (aResult && aIsValidDir && aIsValidOrigin) + { + gp_Pnt aLoc = aLine.Location(); + theOrigin[0] = aLoc.X(); + theOrigin[1] = aLoc.Y(); + theOrigin[2] = aLoc.Z(); + + gp_Dir aDir = aLine.Direction(); + theDir[0] = aDir.X(); + theDir[1] = aDir.Y(); + theDir[2] = aDir.Z(); + } + return aResult; +} + +//============================================================================= +/*! + * \brief Check if edge / wire is circle + */ + //============================================================================= +CORBA::Boolean GEOM_ICanonicalRecognition_i::isCircle(GEOM::GEOM_Object_ptr theEdge, CORBA::Double theTolerance, + GEOM::ListOfDouble& theNormal, GEOM::ListOfDouble& theOrigin, CORBA::Double& theRadius) +{ + Handle(::GEOM_Object) go = GetObjectImpl(theEdge); + bool aIsValidNormal = theNormal.length() == 3; + bool aIsValidOrigin = theOrigin.length() == 3; + bool aIsValidRadius = theRadius > 0; + gp_Circ aCircle; + if (aIsValidNormal && aIsValidOrigin && aIsValidRadius) + { + aCircle.SetAxis(gp_Ax1(gp_Pnt(theOrigin[0], theOrigin[1], theOrigin[2]), + gp_Dir(theNormal[0], theNormal[1], theNormal[2]))); + aCircle.SetRadius(theRadius); + } + bool aResult = GetOperation()->isCircle(go, theTolerance, aCircle); + if (aResult && aIsValidNormal && aIsValidOrigin && aIsValidRadius) + { + gp_Pnt aLoc = aCircle.Location(); + theOrigin[0] = aLoc.X(); + theOrigin[1] = aLoc.Y(); + theOrigin[2] = aLoc.Z(); + + gp_Dir aDir = aCircle.Axis().Direction(); + theNormal[0] = aDir.X(); + theNormal[1] = aDir.Y(); + theNormal[2] = aDir.Z(); + theRadius = aCircle.Radius(); + } + return aResult; +} + +//============================================================================= +/*! + * \brief Check if edge / wire is ellipse + */ + //============================================================================= +CORBA::Boolean GEOM_ICanonicalRecognition_i::isEllipse(GEOM::GEOM_Object_ptr theEdge, CORBA::Double theTolerance, + GEOM::ListOfDouble& theNormal, GEOM::ListOfDouble& theDirX, GEOM::ListOfDouble& theOrigin, + CORBA::Double& theMajorRadius, CORBA::Double& theMinorRadius) +{ + Handle(::GEOM_Object) go = GetObjectImpl(theEdge); + bool aIsValidNormal = theNormal.length() == 3; + bool aIsValidOrigin = theOrigin.length() == 3; + bool aIsValidDirX = theDirX.length() == 3; + bool aIsValidRad1 = (theMajorRadius > 0) && (theMajorRadius > theMinorRadius); + bool aIsValidRad2 = (theMinorRadius > 0) && (theMajorRadius > theMinorRadius); + + gp_Elips aElips; + if (aIsValidNormal && aIsValidOrigin && aIsValidDirX && aIsValidRad1 && aIsValidRad2) + { + gp_Ax2 aAx2(gp_Pnt(theOrigin[0], theOrigin[1], theOrigin[2]), + gp_Dir(theNormal[0], theNormal[1], theNormal[2]), + gp_Dir(theDirX[0], theDirX[1], theDirX[2])); + aElips = gp_Elips(aAx2, theMajorRadius, theMinorRadius); + } + bool aResult = GetOperation()->isEllipse(go, theTolerance, aElips); + if (aResult && aIsValidNormal && aIsValidOrigin && aIsValidDirX && aIsValidRad1 && aIsValidRad2) + { + gp_Pnt aLoc = aElips.Position().Location(); + theOrigin[0] = aLoc.X(); + theOrigin[1] = aLoc.Y(); + theOrigin[2] = aLoc.Z(); + + gp_Dir aNorm = aElips.Position().Direction(); + theNormal[0] = aNorm.X(); + theNormal[1] = aNorm.Y(); + theNormal[2] = aNorm.Z(); + + gp_Dir aDirX = aElips.Position().XDirection(); + theDirX[0] = aDirX.X(); + theDirX[1] = aDirX.Y(); + theDirX[2] = aDirX.Z(); + + theMajorRadius = aElips.MajorRadius(); + theMinorRadius = aElips.MinorRadius(); + } + return aResult; +} diff --git a/src/GEOM_I/GEOM_ICanonicalRecognition_i.hh b/src/GEOM_I/GEOM_ICanonicalRecognition_i.hh new file mode 100644 index 000000000..a237f7d18 --- /dev/null +++ b/src/GEOM_I/GEOM_ICanonicalRecognition_i.hh @@ -0,0 +1,96 @@ +// Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE +// +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// 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 _GEOM_ICanonicalRecognition_i_HeaderFile +#define _GEOM_ICanonicalRecognition_i_HeaderFile + +#include "GEOMImpl_Gen.hxx" + +#include + +#include CORBA_SERVER_HEADER(GEOM_Gen) +#include "GEOM_IOperations_i.hh" +#include "GEOM_Object_i.hh" + +#include "GEOMImpl_ICanonicalRecognition.hxx" + +class GEOM_I_EXPORT GEOM_ICanonicalRecognition_i : + public virtual POA_GEOM::GEOM_ICanonicalRecognition, + public virtual GEOM_IOperations_i +{ + public: + GEOM_ICanonicalRecognition_i (PortableServer::POA_ptr thePOA, GEOM::GEOM_Gen_ptr theEngine, + ::GEOMImpl_ICanonicalRecognition* theImpl); + ~GEOM_ICanonicalRecognition_i(); + + /*! + * \brief Check if the shape is planar + */ + CORBA::Boolean isPlane(GEOM::GEOM_Object_ptr theShape, CORBA::Double theTolerance, + GEOM::ListOfDouble& theNormal, GEOM::ListOfDouble& theOrigin); + + /*! + * \brief Check if shape is spherical + */ + CORBA::Boolean isSphere(GEOM::GEOM_Object_ptr theShape, CORBA::Double theTolerance, + GEOM::ListOfDouble& theOrigin, CORBA::Double& theRadius); + + /*! + * \brief Check if shape is conical + */ + CORBA::Boolean isCone(GEOM::GEOM_Object_ptr theShape, CORBA::Double theTolerance, + GEOM::ListOfDouble& theAxis, GEOM::ListOfDouble& theApex, + CORBA::Double& theHalfAngle); + + /*! + * \brief Check if shape is cylinder + */ + CORBA::Boolean isCylinder(GEOM::GEOM_Object_ptr theShape, CORBA::Double theTolerance, + GEOM::ListOfDouble& theAxis, GEOM::ListOfDouble& theOrigin, + CORBA::Double& theRadius); + + /*! + * \brief Check if edge / wire is line + */ + CORBA::Boolean isLine(GEOM::GEOM_Object_ptr theEdge, CORBA::Double theTolerance, + GEOM::ListOfDouble& theDir, GEOM::ListOfDouble& theOrigin); + + /*! + * \brief Check if edge / wire is circle + */ + CORBA::Boolean isCircle(GEOM::GEOM_Object_ptr theEdge, CORBA::Double theTolerance, + GEOM::ListOfDouble& theNormal, GEOM::ListOfDouble& theOrigin, + CORBA::Double& theRadius); + + /*! + * \brief Check if edge / wire is ellipse + */ + CORBA::Boolean isEllipse(GEOM::GEOM_Object_ptr theEdge, CORBA::Double theTolerance, + GEOM::ListOfDouble& theNormal, GEOM::ListOfDouble& theDirX, + GEOM::ListOfDouble& theOrigin, + CORBA::Double& theMajorRadius, CORBA::Double& theMinorRadius); + + ::GEOMImpl_ICanonicalRecognition* GetOperation() + { return (::GEOMImpl_ICanonicalRecognition*)GetImpl(); } +}; + +#endif diff --git a/src/GEOM_SWIG/CMakeLists.txt b/src/GEOM_SWIG/CMakeLists.txt index 963540446..39f3ac6af 100644 --- a/src/GEOM_SWIG/CMakeLists.txt +++ b/src/GEOM_SWIG/CMakeLists.txt @@ -71,6 +71,7 @@ SET(_other_SCRIPTS SET(_python_SCRIPTS geomBuilder.py gsketcher.py + canonicalrecognition.py ) # Advanced scripts diff --git a/src/GEOM_SWIG/GEOM_example8.py b/src/GEOM_SWIG/GEOM_example8.py new file mode 100644 index 000000000..925f070e3 --- /dev/null +++ b/src/GEOM_SWIG/GEOM_example8.py @@ -0,0 +1,11 @@ +import salome +salome.salome_init() +import GEOM +from salome.geom import geomBuilder + +geompy = geomBuilder.New() +aCircle = geompy.MakeCircleR(150.) +aCylinder = geompy.MakeCylinderRH(100.,200.) + +aCR = geompy.CanonicalRecognition() +aCR.isCylinder(aCylinder, 0.1) diff --git a/src/GEOM_SWIG/canonicalrecognition.py b/src/GEOM_SWIG/canonicalrecognition.py new file mode 100644 index 000000000..86a4dc508 --- /dev/null +++ b/src/GEOM_SWIG/canonicalrecognition.py @@ -0,0 +1,57 @@ +# -*- coding: iso-8859-1 -*- +# Copyright (C) 2007-2022 CEA/DEN, EDF R&D, OPEN CASCADE +# +# 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 +# +# File : GEOM_CanonicalRecognition.py +# Author : Vitaly SMETANNIKOV, Open CASCADE S.A.S. +# Module : GEOM_SWIG + + +class CanonicalRecognition: + "The class provides recognition of canonical shapes" + + def __init__(self, geompyD): + self.CR = geompyD.GetICanonicalRecognition() + + def isPlane(self, shape, tolerance, normal = [], origin = []): + "Check if shape is planar" + return self.CR.isPlane(shape, tolerance, normal, origin) + + def isSphere(self, shape, tolerance, origin = [], radius = 0.0): + "Check if shape is spherical" + return self.CR.isSphere(shape, tolerance, origin, radius) + + def isCone(self, shape, tolerance, axis = [], apex = [], halfAngle = 0.0): + "Check if shape is conical" + return self.CR.isCone(shape, tolerance, axis, apex, halfAngle) + + def isCylinder(self, shape, tolerance, axis = [], origin = [], radius = 0.0): + "Check if shape is cylinder" + return self.CR.isCylinder(shape, tolerance, axis, origin, radius) + + def isLine(self, edge, tolerance, direction = [], origin = []): + "Check if edge/wire is line" + return self.CR.isLine(edge, tolerance, direction, origin) + + def isCircle(self, edge, tolerance, normal = [], origin = [], radius = 0.0): + "Check if edge/wire is circle" + return self.CR.isCircle(edge, tolerance, normal, origin, radius) + + def isEllipse(self, edge, tolerance, normal = [], dirX = [], origin = [], majorRadius = 0.0, minorRadius = 0.0): + "Check if edge/wire is ellipse" + return self.CR.isEllipse(edge, tolerance, normal, dirX, origin, majorRadius, minorRadius) diff --git a/src/GEOM_SWIG/geomBuilder.py b/src/GEOM_SWIG/geomBuilder.py index 5ad918d86..2c56c09c6 100644 --- a/src/GEOM_SWIG/geomBuilder.py +++ b/src/GEOM_SWIG/geomBuilder.py @@ -260,6 +260,7 @@ import os import functools from salome.geom.gsketcher import Sketcher3D, Sketcher2D, Polyline2D +from salome.geom.canonicalrecognition import CanonicalRecognition # In case the omniORBpy EnumItem class does not fully support Python 3 # (for instance in version 4.2.1-2), the comparison ordering methods must be @@ -2786,6 +2787,21 @@ class geomBuilder(GEOM._objref_GEOM_Gen): pl = Polyline2D (self) return pl + ## Obtain a 2D polyline creation interface + # @return An instance of @ref gsketcher.Polyline2D "Polyline2D" interface + # + # @ref tui_3dsketcher_page "Example" + def CanonicalRecognition (self): + """ + Obtain a canonical recognition interface. + + Example of usage: + cr = geompy.CanonicalRecognition() + cr.isLine(aLine, tolerance) + """ + cr = CanonicalRecognition (self) + return cr + # end of l3_sketcher ## @}