mirror of
https://git.salome-platform.org/gitpub/modules/geom.git
synced 2025-02-12 16:13:07 +05:00
bos #29469: Advanced geometry features: Detect type of shape
This commit is contained in:
vsv
parent
1b56fc0813
commit
945a7450c6
@ -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.
|
||||
@ -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);
|
||||
|
||||
|
||||
@ -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 ---
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
|
||||
222
src/GEOMImpl/GEOMImpl_ICanonicalRecognition.cxx
Normal file
222
src/GEOMImpl/GEOMImpl_ICanonicalRecognition.cxx
Normal 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
86
src/GEOMImpl/GEOMImpl_ICanonicalRecognition.hxx
Normal 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
|
||||
@ -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
|
||||
|
||||
@ -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 :
|
||||
|
||||
@ -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
319
src/GEOM_I/GEOM_ICanonicalRecognition_i.cc
Normal 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
96
src/GEOM_I/GEOM_ICanonicalRecognition_i.hh
Normal 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
|
||||
@ -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
80
src/GEOM_SWIG/GEOM_TestCR.py
Normal 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
11
src/GEOM_SWIG/GEOM_example8.py
Normal 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
57
src/GEOM_SWIG/canonicalrecognition.py
Normal 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)
|
||||
@ -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
|
||||
## @}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user