bos #29469: Advanced geometry features: Detect type of shape

idl/GEOM_Gen.idl

@@ -4908,6 +4908,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.
@@ -5022,7 +5064,7 @@ 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_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);
@@ -5035,6 +5077,7 @@ module GEOM
     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);
 

src/GEOMImpl/CMakeLists.txt

@@ -180,6 +180,7 @@ SET(GEOMImpl_HEADERS
   GEOMImpl_GlueDriver.hxx
   GEOMImpl_Types.hxx
   GEOM_GEOMImpl.hxx
+  GEOMImpl_ICanonicalRecognition.hxx
   )
 # --- sources ---
 
@@ -254,6 +255,7 @@ SET(GEOMImpl_SOURCES
   GEOMImpl_FillingDriver.cxx
   GEOMImpl_GlueDriver.cxx
   GEOMImpl_FieldDriver.cxx
+  GEOMImpl_ICanonicalRecognition.cxx
   )
 
 # --- rules ---

src/GEOMImpl/GEOMImpl_Gen.cxx

@@ -183,6 +183,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 );
 }
 
 //=============================================================================
@@ -208,6 +209,7 @@ GEOMImpl_Gen::~GEOMImpl_Gen()
   delete _MeasureOperations;
   delete _GroupOperations;
   delete _FieldOperations;
+  delete _CanonicalRecognition;
 }
 
 //=============================================================================
@@ -349,3 +351,13 @@ GEOMImpl_ITestOperations* GEOMImpl_Gen::GetITestOperations()
 {
   return _TestOperations;
 }
+
+//=============================================================================
+/*!
+ * GetICanonicalRecognition
+ */
+//=============================================================================
+GEOMImpl_ICanonicalRecognition* GEOMImpl_Gen::GetICanonicalRecognition()
+{
+  return _CanonicalRecognition;
+}

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,6 +78,8 @@ class GEOMIMPL_EXPORT GEOMImpl_Gen : public GEOM_Engine
 
   GEOMImpl_ITestOperations* GetITestOperations();
 
+  GEOMImpl_ICanonicalRecognition* GetICanonicalRecognition();
+
  private:
 
   GEOMImpl_IBasicOperations*      _BasicOperations;
@@ -93,6 +96,7 @@ class GEOMIMPL_EXPORT GEOMImpl_Gen : public GEOM_Engine
   GEOMImpl_IGroupOperations*      _GroupOperations;
   GEOMImpl_IFieldOperations*      _FieldOperations;
   GEOMImpl_ITestOperations*       _TestOperations;
+  GEOMImpl_ICanonicalRecognition* _CanonicalRecognition;
 };
 
 #endif

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 <TDataStd_ListIteratorOfListOfExtendedString.hxx>
+#include <ShapeAnalysis_CanonicalRecognition.hxx>
+#include <gp_Pln.hxx>
+
+#include <utilities.h>
+
+
+//=============================================================================
+/*!
+ *   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);
+}

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 <GEOM_Field.hxx>
+
+#include <TColStd_HSequenceOfTransient.hxx>
+#include <TColStd_HArray1OfExtendedString.hxx>
+
+#include <vector>
+
+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

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

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  :

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 <TopTools_IndexedMapOfShape.hxx>
@@ -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)
     ;

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;
+}

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 <SALOMEconfig.h>
+
+#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

src/GEOM_SWIG/CMakeLists.txt

@@ -59,6 +59,7 @@ SET(_other_SCRIPTS
   GEOM_Nut.py
   GEOM_Sketcher.py
   GEOM_ObjectInfo.py
+  GEOM_TestCR.py
   PAL_MESH_019_020_geometry.py
   PAL_MESH_028_geometry.py
   PAL_MESH_030_geometry.py
@@ -71,6 +72,7 @@ SET(_other_SCRIPTS
 SET(_python_SCRIPTS
   geomBuilder.py
   gsketcher.py
+  canonicalrecognition.py
   )
 
 # Advanced scripts

src/GEOM_SWIG/GEOM_TestCR.py

@@ -0,0 +1,80 @@
+#  -*- coding: iso-8859-1 -*-
+# 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
+#
+
+import salome
+
+salome.salome_init()
+
+import GEOM
+from salome.geom import geomBuilder
+import math
+import SALOMEDS
+
+geompy = geomBuilder.New()
+
+def GetShapeType(theShape):
+    CR = geompy.CanonicalRecognition()
+    if CR.isPlane(theShape, 0.1)[0]:
+        return "Plane"
+    if CR.isSphere(theShape, 0.1)[0]:
+        return "Sphere"
+    if CR.isCone(theShape, 0.1)[0]:
+        return "Cone"
+    if CR.isCylinder(theShape, 0.1)[0]:
+        return "Cylinder"
+    if CR.isLine(theShape, 0.1)[0]:
+        return "Line"
+    if CR.isCircle(theShape, 0.1)[0]:
+        return "Circle"
+    if CR.isEllipse(theShape, 0.1)[0]:
+        return "Ellipse"
+    return "Not defined"
+
+O = geompy.MakeVertex(0, 0, 0)
+OX = geompy.MakeVectorDXDYDZ(1, 0, 0)
+OY = geompy.MakeVectorDXDYDZ(0, 1, 0)
+OZ = geompy.MakeVectorDXDYDZ(0, 0, 1)
+Cylinder_1 = geompy.MakeCylinderRH(100, 300)
+[Face_1,Face_2,Face_3] = geompy.ExtractShapes(Cylinder_1, geompy.ShapeType["FACE"], True)
+[Edge_1,Edge_2,Edge_3] = geompy.ExtractShapes(Cylinder_1, geompy.ShapeType["EDGE"], True)
+Sphere_1 = geompy.MakeSphereR(100)
+[Shell_1] = geompy.ExtractShapes(Sphere_1, geompy.ShapeType["SHELL"], True)
+Cone_1 = geompy.MakeConeR1R2H(100, 0, 300)
+[Shell_2] = geompy.ExtractShapes(Cone_1, geompy.ShapeType["SHELL"], True)
+[Face_4,Face_5] = geompy.ExtractShapes(Shell_2, geompy.ShapeType["FACE"], True)
+
+## Create ellips
+Cylinder_2 = geompy.MakeCylinderRH(100, 300)
+Plane_1 = geompy.MakePlaneLCS(None, 350, 1)
+Translation_1 = geompy.MakeTranslation(Plane_1, 0, 0, 150)
+Rotation_1 = geompy.MakeRotation(Translation_1, OX, 20*math.pi/180.0)
+Partition_1 = geompy.MakePartition([Cylinder_2], [Rotation_1], [], [], geompy.ShapeType["SOLID"], 0, [], 0)
+[Edge_4,Edge_5,Edge_6,Edge_7,Edge_8] = geompy.ExtractShapes(Partition_1, geompy.ShapeType["EDGE"], True)
+
+assert GetShapeType(Face_1) == "Plane"
+assert GetShapeType(Face_2) == "Cylinder"
+assert GetShapeType(Edge_3) == "Line"
+assert GetShapeType(Edge_2) == "Circle"
+assert GetShapeType(Shell_1) == "Sphere"
+assert GetShapeType(Shell_2) == "Cone"
+assert GetShapeType(Edge_5) == "Ellipse"

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)

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)

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
         ## @}