ForkMaster/geom
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/geom.git synced 2025-02-12 15:33:07 +05:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
vsv 2022-06-15 17:48:49 +03:00
parent 1b56fc0813
commit 945a7450c6
16 changed files with 1002 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
idl/GEOM_Gen.idl
View File

@ -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.
@ -5021,20 +5063,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);

2
src/GEOMImpl/CMakeLists.txt
View File

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

12
src/GEOMImpl/GEOMImpl_Gen.cxx
View File

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

32
src/GEOMImpl/GEOMImpl_Gen.hxx
View File

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

222
src/GEOMImpl/GEOMImpl_ICanonicalRecognition.cxx Normal file
View File

@ -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);
}

86
src/GEOMImpl/GEOMImpl_ICanonicalRecognition.hxx Normal file
View File

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

2
src/GEOM_I/CMakeLists.txt
View File

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

19
src/GEOM_I/GEOM_Gen_i.cc
View File

@ -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 :

3
src/GEOM_I/GEOM_Gen_i.hh
View File

@ -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)
;

319
src/GEOM_I/GEOM_ICanonicalRecognition_i.cc Normal file
View File

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

96
src/GEOM_I/GEOM_ICanonicalRecognition_i.hh Normal file
View File

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

2
src/GEOM_SWIG/CMakeLists.txt
View File

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

80
src/GEOM_SWIG/GEOM_TestCR.py Normal file
View File

@ -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"

11
src/GEOM_SWIG/GEOM_example8.py Normal file
View File

@ -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)

57
src/GEOM_SWIG/canonicalrecognition.py Normal file
View File

@ -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)

16
src/GEOM_SWIG/geomBuilder.py
View File

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