-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2020 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
#include "GEOMImpl_GlueDriver.hxx"
#include "GEOMImpl_FillingDriver.hxx"
+#include "GEOMImpl_IExtract.hxx"
#include "GEOMImpl_IVector.hxx"
#include "GEOMImpl_IShapes.hxx"
#include "GEOMImpl_IShapeExtend.hxx"
#include "GEOMUtils.hxx"
#include "GEOMAlgo_ClsfBox.hxx"
+#include "GEOMAlgo_ClsfQuad.hxx"
#include "GEOMAlgo_ClsfSolid.hxx"
-#include "GEOMAlgo_FinderShapeOn1.hxx"
-#include "GEOMAlgo_FinderShapeOnQuad.hxx"
+#include "GEOMAlgo_ClsfSurf.hxx"
#include "GEOMAlgo_FinderShapeOn2.hxx"
#include "GEOMAlgo_GetInPlace.hxx"
#include "GEOMAlgo_GetInPlaceAPI.hxx"
#include <Geom_Plane.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_Surface.hxx>
+#include <Geom_TrimmedCurve.hxx>
#include <Precision.hxx>
-#include <TColStd_HArray1OfInteger.hxx>
#include <TDF_Tool.hxx>
#include <TDataStd_Integer.hxx>
#include <TDataStd_ListIteratorOfListOfExtendedString.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_SequenceOfShape.hxx>
#include <TopoDS.hxx>
+#include <TopoDS_TShape.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx> // CAREFUL ! position of this file is critic : see Lucien PIGNOLONI / OCC
+// VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+// Next macro, when defined, causes appearing of SubShapeAllIDs(), SubShapeAllSortedIDs(), GetSameIDs()
+// and other such commands in Python dump.
+// See also GEOM_Engine.cxx.
+// ---------------------------------------
+// #define DUMP_SUBSHAPE_IDS
+// ---------------------------------------
+
namespace {
void AddFlatSubShapes(const TopoDS_Shape& S, TopTools_ListOfShape& L, TopTools_MapOfShape& M)
else {
TopoDS_Iterator It(S, Standard_True, Standard_True);
for (; It.More(); It.Next()) {
- TopoDS_Shape SS = It.Value();
- if (M.Add(SS))
- AddFlatSubShapes(SS, L, M);
+ TopoDS_Shape SS = It.Value();
+ if (M.Add(SS))
+ AddFlatSubShapes(SS, L, M);
}
}
}
}
+namespace
+{
+ const double MAX_TOLERANCE = 1.e-7;
+
+ /**
+ * \brief Returns the vertex from theWhere shape that is coincident with
+ * theVertex.
+ *
+ * \param theWhere the shape where the coincident vertex is searched.
+ * \param theVertex the vertex to be searched.
+ * \return the coincident vertex if it is found. Otherwise null object.
+ */
+ static TopoDS_Vertex getSameVertex(const TopoDS_Shape &theWhere,
+ const TopoDS_Vertex &theVertex)
+ {
+ TopoDS_Vertex aResult;
+ gp_Pnt aPoint = BRep_Tool::Pnt(theVertex);
+ TopExp_Explorer anExp(theWhere, TopAbs_VERTEX);
+ TopTools_MapOfShape aMap;
+
+ for(; anExp.More(); anExp.Next()) {
+ const TopoDS_Shape &aLocalShape = anExp.Current();
+
+ if(!aMap.Add(aLocalShape)) {
+ continue;
+ }
+
+ TopoDS_Vertex aVertex = TopoDS::Vertex(aLocalShape);
+ gp_Pnt aPoint2 = BRep_Tool::Pnt(aVertex);
+
+ if(aPoint.Distance(aPoint2) <= MAX_TOLERANCE) {
+ aResult = aVertex;
+ break;
+ }
+ }
+
+ return aResult;
+ }
+} // end of namespace
+
//=============================================================================
/*!
* constructor:
*/
//=============================================================================
-GEOMImpl_IShapesOperations::GEOMImpl_IShapesOperations (GEOM_Engine* theEngine, int theDocID)
-: GEOM_IOperations(theEngine, theDocID)
+GEOMImpl_IShapesOperations::GEOMImpl_IShapesOperations (GEOM_Engine* theEngine)
+: GEOM_IOperations(theEngine)
{
MESSAGE("GEOMImpl_IShapesOperations::GEOMImpl_IShapesOperations");
}
if (thePnt1.IsNull() || thePnt2.IsNull()) return NULL;
//Add a new Edge object
- Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GetDocID(), GEOM_EDGE);
+ Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GEOM_EDGE);
//Add a new Vector function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
if (theRefCurve.IsNull()) return NULL;
//Add a new Edge object
- Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GetDocID(), GEOM_EDGE);
+ Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GEOM_EDGE);
//Add a new Vector function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
if (theWire.IsNull()) return NULL;
//Add a new Edge object
- Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GetDocID(), GEOM_EDGE);
+ Handle(GEOM_Object) anEdge = GetEngine()->AddObject(GEOM_EDGE);
//Add a new Vector function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
SetErrorCode(KO);
//Add a new object
- Handle(GEOM_Object) aWire = GetEngine()->AddObject(GetDocID(), GEOM_WIRE);
+ Handle(GEOM_Object) aWire = GetEngine()->AddObject(GEOM_WIRE);
//Add a new function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
if (theWire.IsNull()) return NULL;
//Add a new Face object
- Handle(GEOM_Object) aFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
+ Handle(GEOM_Object) aFace = GetEngine()->AddObject(GEOM_FACE);
//Add a new Shape function for creation of a face from a wire
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
SetErrorCode(KO);
//Add a new object
- Handle(GEOM_Object) aShape = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
+ Handle(GEOM_Object) aShape = GetEngine()->AddObject(GEOM_FACE);
//Add a new function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
SetErrorCode(KO);
//Add a new object
- Handle(GEOM_Object) aShape = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
+ Handle(GEOM_Object) aShape = GetEngine()->AddObject(GEOM_FACE);
//Add a new function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
SetErrorCode(KO);
//Add a new object
- Handle(GEOM_Object) aShape = GetEngine()->AddObject(GetDocID(), GEOM_FILLING);
+ Handle(GEOM_Object) aShape = GetEngine()->AddObject(GEOM_FILLING);
//Add a new function
Handle(GEOM_Function) aFunction =
if ( aFace->GetValue().ShapeType() != TopAbs_FACE )
// constraint face can be omitted - it is a valid case
continue;
+ // Keep the old error code as IsSubShapeBelongsTo changes it.
+ TCollection_AsciiString anOldCode = GetErrorCode();
+
if ( IsSubShapeBelongsTo( anObject, 0, aFace, 0 ) ) {
// valid constraint
+ SetErrorCode(anOldCode);
aRefSh = aFace->GetLastFunction();
aConstraints->Append(aRefSh);
it++;
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
SetErrorCode(KO);
//Add a new object
- Handle(GEOM_Object) aShape = GetEngine()->AddObject(GetDocID(), theObjectType);
+ Handle(GEOM_Object) aShape = GetEngine()->AddObject(theObjectType);
//Add a new function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
SetErrorCode(KO);
//Add a new object
- Handle(GEOM_Object) aSolid = GetEngine()->AddObject(GetDocID(), GEOM_SOLID);
+ Handle(GEOM_Object) aSolid = GetEngine()->AddObject(GEOM_SOLID);
//Add a new function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
}
//Add a new Glued object
- Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GetDocID(), GEOM_GLUED);
+ Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GEOM_GLUED);
//Add a new Glue function
Handle(GEOM_Function) aFunction;
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
}
//Add a new Glued object
- Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GetDocID(), GEOM_GLUED);
+ Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GEOM_GLUED);
//Add a new Glue function
Handle(GEOM_Function) aFunction;
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
}
//Add a new Glued object
- Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GetDocID(), GEOM_GLUED);
+ Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GEOM_GLUED);
//Add a new Glue function
Handle(GEOM_Function) aFunction;
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
TopoDS_Shape aShape;
TopTools_SequenceOfShape shapes;
std::list< Handle(GEOM_Object) >::iterator s = theShapes.begin();
- Handle(GEOM_Object) lastCreatedGO;
+ Handle(GEOM_BaseObject) lastCreatedGO;
for ( ; s != theShapes.end(); ++s )
{
Handle(GEOM_Object) go = *s;
return NULL;
}
//Add a new Glued object
- Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GetDocID(), GEOM_GLUED);
+ Handle(GEOM_Object) aGlued = GetEngine()->AddObject(GEOM_GLUED);
//Add a new Glue function
Handle(GEOM_Function) aFunction;
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
// to provide warning
if (!aFunction->GetValue().IsNull()) {
isWarning = Standard_True;
Standard_Integer types = theGroupsOnly ? Groups : Groups|SubShapes;
Handle(TColStd_HSequenceOfTransient) results = GetExistingSubObjects(theShape, types);
+ Handle(GEOM_BaseObject) lastCreatedGO = GEOM::GetCreatedLast(results);
+ lastCreatedGO = GEOM::GetCreatedLast(lastCreatedGO, theShape);
+
if (results->Length() > 0) {
- //Make a Python command
- TCollection_AsciiString anAsciiList;
- for (int i = 1; i <= results->Length(); i++)
+ // Make a Python command
+ GEOM::TPythonDump pd (lastCreatedGO->GetLastFunction(), /*append=*/true);
+ pd << "[";
+ Standard_Integer i, aLen = results->Length();
+ for (i = 1; i <= aLen; i++)
{
- Handle(GEOM_BaseObject) obj = Handle(GEOM_BaseObject)::DownCast( results->Value(i));
- obj->GetEntryString();
- if ( i < results->Length() )
- anAsciiList += ",";
+ Handle(GEOM_BaseObject) obj = Handle(GEOM_BaseObject)::DownCast(results->Value(i));
+ pd << obj << ((i < aLen) ? ", " : "");
}
-
- GEOM::TPythonDump pd (theShape->GetLastFunction(), /*append=*/true);
- pd << "[" << anAsciiList.ToCString();
pd << "] = geompy.GetExistingSubObjects(";
pd << theShape << ", " << (bool)theGroupsOnly << ")";
}
-
+
return results;
}
Standard_Integer aStrLen = anEntry.LengthOfCString();
char* anEntryStr = new char[aStrLen+1];
anEntry.ToUTF8CString(anEntryStr);
- Handle(GEOM_BaseObject) anObj = GetEngine()->GetObject(GetDocID(), anEntryStr, false);
+ Handle(GEOM_BaseObject) anObj = GetEngine()->GetObject(anEntryStr, false);
if (!anObj.IsNull() ) {
bool isGroup = anObj->IsKind(STANDARD_TYPE(GEOM_Object)) && anObj->GetType() == GEOM_GROUP;
bool isSubShape = anObj->IsKind(STANDARD_TYPE(GEOM_Object)) && anObj->GetType() != GEOM_GROUP;
bool isField = anObj->IsKind(STANDARD_TYPE(GEOM_Field));
- if (theTypes & Groups && isGroup ||
- theTypes & SubShapes && isSubShape ||
- theTypes & Fields && isField) {
+ if ((theTypes & Groups && isGroup ) ||
+ (theTypes & SubShapes && isSubShape ) ||
+ (theTypes & Fields && isField ))
aSeq->Append(anObj);
- }
}
delete [] anEntryStr;
}
for (; It.More(); It.Next()) {
TopoDS_Shape SS = It.Value();
if (mapShape.Add(SS)) {
- if (theShapeType == TopAbs_FLAT) {
+ if (theShapeType == TopAbs_FLAT) {
AddFlatSubShapes(SS, listShape, mapShape);
- }
+ }
else if (theShapeType == TopAbs_SHAPE || theShapeType == SS.ShapeType()) {
- listShape.Append(SS);
+ listShape.Append(SS);
}
// VSR: for EXPLODE_NEW_INCLUDE_MAIN and EXPLODE_OLD_INCLUDE_MAIN:
// it seems it is necessary to add top-level shape if theShapeType == TopAbs_COMPOUND
//anObj = GetEngine()->AddSubShape(theShape, anArray);
{
- anObj = GetEngine()->AddObject(GetDocID(), GEOM_SUBSHAPE);
+ anObj = GetEngine()->AddObject(GEOM_SUBSHAPE);
Handle(GEOM_Function) aFunction = anObj->AddFunction(GEOM_Object::GetSubShapeID(), 1);
if (aFunction.IsNull()) return aSeq;
for (; It.More(); It.Next()) {
TopoDS_Shape SS = It.Value();
if (mapShape.Add(SS)) {
- if (theShapeType == TopAbs_FLAT) {
+ if (theShapeType == TopAbs_FLAT) {
AddFlatSubShapes(SS, listShape, mapShape);
- }
+ }
else if (theShapeType == TopAbs_SHAPE || theShapeType == SS.ShapeType()) {
listShape.Append(SS);
}
Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
//Make a Python command
GEOM::TPythonDump pd (aFunction, /*append=*/true);
pd << "listSubShapeIDs = geompy.SubShapeAll";
break;
default: ;
}
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
anArray = new TColStd_HArray1OfInteger(1,1);
anArray->SetValue(1, id);
- anObj = GetEngine()->AddObject(GetDocID(), GEOM_SUBSHAPE);
+ anObj = GetEngine()->AddObject(GEOM_SUBSHAPE);
if (!anObj.IsNull()) {
Handle(GEOM_Function) aFunction = anObj->AddFunction(GEOM_Object::GetSubShapeID(), 1);
if (aFunction.IsNull()) return aSeq;
Handle(GEOM_Object) theObject,
const Standard_Integer theObjectIndex)
{
+ SetErrorCode(KO);
+
if ( theObject.IsNull() || theSubObject.IsNull() )
return false;
if ( theObjectIndex > 0 ) {
TopExp::MapShapes( shape, anIndices );
shape = anIndices.FindKey(theObjectIndex);
+ anIndices.Clear();
}
if ( theSubObjectIndex > 0 ) {
TopExp::MapShapes( subShape, anIndices );
subShape = anIndices.FindKey(theSubObjectIndex);
+ anIndices.Clear();
}
TopExp::MapShapes( shape, anIndices );
- return anIndices.Contains( subShape );
+
+ const Standard_Boolean isBelongTo = anIndices.Contains(subShape);
+
+ SetErrorCode(OK);
+
+ return isBelongTo;
}
//=============================================================================
nbShapes = nbTypes[theShapeType];
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return -1;
}
/*
//Add a new reversed object
- Handle(GEOM_Object) aReversed = GetEngine()->AddObject(GetDocID(), theShape->GetType());
+ Handle(GEOM_Object) aReversed = GetEngine()->AddObject(theShape->GetType());
//Add a new Revese function
Handle(GEOM_Function) aFunction;
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
if (aGen) {
GEOMImpl_IHealingOperations* anIHealingOperations =
- aGen->GetIHealingOperations(GetDocID());
+ aGen->GetIHealingOperations();
aReversed = anIHealingOperations->ChangeOrientationCopy(theShape);
SetErrorCode(anIHealingOperations->GetErrorCode());
}
//The explode doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = theShape->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
//Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listFreeFacesIDs = geompy.GetFreeFacesIDs(" << theShape << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
}
if (aSeq->IsEmpty()) {
- SetErrorCode("The given shapes have no shared sub-shapes of the requested type");
+ SetErrorCode(NOT_FOUND_ANY);
return aSeq;
}
//=======================================================================
//function : GetSharedShapes
//purpose :
+//
+// NOTE on the implementation
+//
+// 1) Resulting sub-shapes are published as a children of the 1st input shape
+// from theShapes list. Due to this reason only direct sub-shapes of the 1st
+// shape can be contained in the result of the operation (i.e. shares between
+// 2nd/3rd, etc couples cannot be retrieved.
+// 2) An exception from above case is when a single compound is specified as an
+// input. In this case we search shares between its top-level content, so we
+// are able to search shares between all possible couples of shapes.
+// 3) Parameter theMultiShare controls what types of shares to search:
+// - True: get sub-shapes that are shared between ALL input shapes;
+// - False: get shares between couples of input sub-shapes (see points 1 and 2).
+//
+// Thus, we have the following cases:
+// [1] theShapes = N shapes (N>1), theMultiShare = True
+// Result: sub-shapes that are shared by all theShapes
+// [2] theShapes = N shapes (N>1), theMultiShare = False
+// Result: sub-shapes of 1st shape from theShapes that are shared with any shape
+// from theShapes
+// [3] theShapes = 1 shape, theMultiShare = True
+// Result: sub-shapes that are shared by all top-level sub-objects of theShapes[0]
+// [4] theShapes = 1 shape, theMultiShare = False
+// Result: sub-shapes of all possible couples of all top-level sub-objects of
+// theShapes[0].
//=======================================================================
Handle(TColStd_HSequenceOfTransient) GEOMImpl_IShapesOperations::GetSharedShapes
(std::list<Handle(GEOM_Object)> & theShapes,
- const Standard_Integer theShapeType)
+ const Standard_Integer theShapeType,
+ const bool theMultiShare)
{
SetErrorCode(KO);
int aLen = theShapes.size();
if (aLen < 1) return NULL;
- int ind = 1;
std::list<Handle(GEOM_Object)>::iterator it = theShapes.begin();
+ // main object is always first in the input list
+ // it is the object from which sub-shapes indices are taken
+ // and where results are published
Handle(GEOM_Object) aMainObj = *it;
Handle(GEOM_Function) aMainShape = aMainObj->GetLastFunction();
+ // collect all shapes from the input list (including first one) for processing
TopTools_SequenceOfShape shapeSeq;
- for (; it != theShapes.end(); it++, ind++) {
+ for (; it != theShapes.end(); it++) {
Handle(GEOM_Function) aRefShape = (*it)->GetLastFunction();
if (aRefShape.IsNull()) {
SetErrorCode("NULL shape for GetSharedShapes");
return NULL;
}
- TopoDS_Shape aShape2 = aRefShape->GetValue();
- if (aShape2.IsNull()) return NULL;
- shapeSeq.Append( aShape2 );
+ TopoDS_Shape aShape = aRefShape->GetValue();
+ if (aShape.IsNull()) {
+ SetErrorCode("NULL shape for GetSharedShapes");
+ return NULL;
+ }
+ shapeSeq.Append( aShape );
}
- TopoDS_Shape aShape1 = shapeSeq.First();
-
+ // if only single shape is specified as input
+ // collect all ites top-level sub-shapes for processing
if ( shapeSeq.Length() == 1 )
{
+ TopoDS_Shape aShape = shapeSeq.First();
shapeSeq.Clear();
- for ( TopoDS_Iterator it( aShape1); it.More(); it.Next() )
+ for ( TopoDS_Iterator it( aShape ); it.More(); it.Next() )
shapeSeq.Append( it.Value() );
- aShape1 = shapeSeq.First();
}
+ // map all sub-shapes in a main shape to their indices
TopTools_IndexedMapOfShape anIndices;
TopExp::MapShapes(aMainShape->GetValue(), anIndices);
+ TopTools_MapOfShape mapShape;
- TopTools_IndexedMapOfShape mapSelected;
- TopExp::MapShapes(aShape1, TopAbs_ShapeEnum(theShapeType), mapSelected);
-
- // Find shared shapes
- BRep_Builder B;
- TopoDS_Compound aCurrSelection;
-
- for ( ind = 2; ind <= shapeSeq.Length(); ind++) {
-
- TopoDS_Compound aCompound;
- B.MakeCompound(aCompound);
+ // find shared shapes
- const TopoDS_Shape& aShape2 = shapeSeq.Value( ind );
+ // here we will collect all shares
+ TopTools_ListOfShape aShared;
- TopTools_MapOfShape mapShape2;
- TopExp_Explorer exp (aShape2, TopAbs_ShapeEnum(theShapeType));
- for (; exp.More(); exp.Next()) {
- const TopoDS_Shape& aSS = exp.Current();
- if (mapShape2.Add(aSS) && mapSelected.Contains(aSS)) {
- B.Add(aCompound, aSS);
+ // number of iterations
+ int nbIters = theMultiShare || theShapes.size() > 1 ? 1 : shapeSeq.Length()-1;
+ // numShares factor to search (i.e. by what nb of shapes each found sub-shape should be shared)
+ int nbShares = theMultiShare ? shapeSeq.Length()-1 : 1;
+
+ for ( int iter = 1; iter <= nbIters; iter++) {
+ for ( int ind = iter+1; ind <= shapeSeq.Length(); ind++) {
+ if ( ind-1+nbShares > shapeSeq.Length() ) break;
+ TopoDS_Compound aCurrSelection;
+ TopoDS_Shape aShape1 = shapeSeq.Value( iter );
+ TopTools_IndexedMapOfShape mapSelected;
+ TopExp::MapShapes(aShape1, TopAbs_ShapeEnum(theShapeType), mapSelected);
+ for ( int s = 0; s < nbShares; s++ ) {
+ BRep_Builder B;
+ TopoDS_Compound aCompound;
+ B.MakeCompound(aCompound);
+ const TopoDS_Shape& aShape2 = shapeSeq.Value( ind+s );
+ TopTools_MapOfShape mapShape2;
+ TopExp_Explorer exp (aShape2, TopAbs_ShapeEnum(theShapeType));
+ for (; exp.More(); exp.Next()) {
+ const TopoDS_Shape& aSS = exp.Current();
+ if (mapShape2.Add(aSS) && mapSelected.Contains(aSS)) {
+ B.Add(aCompound, aSS);
+ }
+ }
+ mapSelected.Clear();
+ aCurrSelection = aCompound;
+ TopExp::MapShapes(aCurrSelection, TopAbs_ShapeEnum(theShapeType), mapSelected);
+ }
+ TopoDS_Iterator itSel(aCurrSelection, Standard_True, Standard_True);
+ for (; itSel.More(); itSel.Next()) {
+ const TopoDS_Shape& aSS = itSel.Value();
+ if (mapShape.Add(aSS) )
+ aShared.Append(aSS);
}
}
-
- mapSelected.Clear();
- TopExp::MapShapes(aCompound, TopAbs_ShapeEnum(theShapeType), mapSelected);
- aCurrSelection = aCompound;
}
- // Create GEOM_Object for each found shared shape (collected in aCurrSelection)
- Handle(GEOM_Object) anObj, aLastCreated;
- Handle(TColStd_HArray1OfInteger) anArray;
Handle(TColStd_HSequenceOfTransient) aSeq = new TColStd_HSequenceOfTransient;
- TCollection_AsciiString anAsciiList, anEntry;
- TopoDS_Iterator itSel (aCurrSelection, Standard_True, Standard_True);
- for (; itSel.More(); itSel.Next()) {
- anArray = new TColStd_HArray1OfInteger(1,1);
- anArray->SetValue(1, anIndices.FindIndex(itSel.Value()));
+ if (aShared.IsEmpty()){
+ SetErrorCode(NOT_FOUND_ANY);
+ return aSeq;
+ }
+
+ // create GEOM_Object for each found shared shape (collected in aShared)
+ TCollection_AsciiString anAsciiList;
+ Handle(GEOM_Object) anObj;
+ TopTools_ListIteratorOfListOfShape itSub (aShared);
+ for (; itSub.More(); itSub.Next()) {
+ TopoDS_Shape aValue = itSub.Value();
+ Handle(TColStd_HArray1OfInteger) anArray = new TColStd_HArray1OfInteger(1,1);
+ anArray->SetValue(1, anIndices.FindIndex(aValue));
anObj = GetEngine()->AddSubShape(aMainObj, anArray);
aSeq->Append(anObj);
- aLastCreated = GEOM::GetCreatedLast( aLastCreated, anObj );
-
// for python command
+ TCollection_AsciiString anEntry;
TDF_Tool::Entry(anObj->GetEntry(), anEntry);
anAsciiList += anEntry;
anAsciiList += ",";
}
- if (aSeq->IsEmpty()) {
- SetErrorCode("The given shapes have no shared sub-shapes of the requested type");
- return aSeq;
- }
-
- // Make a Python command
+ // make a Python command
anAsciiList.Trunc(anAsciiList.Length() - 1);
- // IPAL22904: TC6.5.0: order of python commands is wrong after dump study
- // Get the function of the latest published object
- Handle(GEOM_Function) aFunction = aLastCreated->GetLastFunction();
- if( aFunction.IsNull() ) // just in case
- aFunction = aMainShape;
-
- GEOM::TPythonDump pd (aFunction, /*append=*/true);
+ GEOM::TPythonDump pd (anObj->GetLastFunction());
pd << "[" << anAsciiList.ToCString()
- << "] = geompy.GetSharedShapesMulti([";
+ << "] = geompy.GetSharedShapesMulti(";
+
+ if ( aLen > 1 )
+ pd << "[";
it = theShapes.begin();
pd << (*it++);
while (it != theShapes.end()) {
pd << ", " << (*it++);
}
+ if ( aLen > 1 )
+ pd << "]";
- pd << "], " << TopAbs_ShapeEnum(theShapeType) << ")";
+ pd << ", " << TopAbs_ShapeEnum(theShapeType) << ", " << theMultiShare << ")";
SetErrorCode(OK);
return aSeq;
TopoDS_Shape aShape = theShape->GetValue();
// Check presence of triangulation, build if need
- if (!GEOMUtils::CheckTriangulation(aShape)) {
+ if (theShapeType != TopAbs_VERTEX && !GEOMUtils::CheckTriangulation(aShape)) {
SetErrorCode("Cannot build triangulation on the shape");
return aSeqOfIDs;
}
aFinder.SetState(theState);
aFinder.Perform();
- // Interprete results
+ // Interpret results
Standard_Integer iErr = aFinder.ErrorStatus();
- // the detailed description of error codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of error codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iErr) {
MESSAGE(" iErr : " << iErr);
TCollection_AsciiString aMsg (" iErr : ");
return aSeqOfIDs;
}
Standard_Integer iWrn = aFinder.WarningStatus();
- // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iWrn) {
MESSAGE(" *** iWrn : " << iWrn);
}
// The GetShapesOnBox() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theBox)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnBoxIDs = geompy.GetShapesOnBoxIDs("
<< theShape << ", "
<< TopAbs_ShapeEnum(theShapeType) << ", "
<< theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeqOfIDs;
TopTools_ListOfShape res;
// Check presence of triangulation, build if need
- if (!GEOMUtils::CheckTriangulation(aShape)) {
+ if (theShapeType != TopAbs_VERTEX && !GEOMUtils::CheckTriangulation(aShape)) {
SetErrorCode("Cannot build triangulation on the shape");
return aSeqOfIDs;
}
+ // Compute classification tolerance.
+ TopTools_IndexedMapOfShape aMapVtx;
+ Standard_Real aTol = Precision::Confusion();
+
+ TopExp::MapShapes(aShape, TopAbs_VERTEX, aMapVtx);
+
+ Standard_Integer i;
+ Standard_Integer aNbVtx = aMapVtx.Extent();
+
+ for (i = 1; i <= aNbVtx; ++i) {
+ const TopoDS_Vertex aVtx = TopoDS::Vertex(aMapVtx.FindKey(i));
+ const Standard_Real aVtxTol = BRep_Tool::Tolerance(aVtx);
+
+ if (aTol < aVtxTol) {
+ aTol = aVtxTol;
+ }
+ }
+
+ // Bound the tolerance value.
+ if (aTol > 0.0001) {
+ aTol = 0.0001;
+ }
+
// Call algo
GEOMAlgo_FinderShapeOn2 aFinder;
- Standard_Real aTol = 0.0001; // default value
Handle(GEOMAlgo_ClsfSolid) aClsfSolid = new GEOMAlgo_ClsfSolid;
aClsfSolid->SetShape(aCheckShape);
aFinder.SetState(theState);
aFinder.Perform();
- // Interprete results
+ // Interpret results
Standard_Integer iErr = aFinder.ErrorStatus();
- // the detailed description of error codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of error codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iErr) {
if (iErr == 41) {
SetErrorCode("theCheckShape must be a solid");
return aSeqOfIDs;
}
Standard_Integer iWrn = aFinder.WarningStatus();
- // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iWrn) {
MESSAGE(" *** iWrn : " << iWrn);
}
Handle(GEOM_Function) aFunction =
GEOM::GetCreatedLast(theShape,theCheckShape)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
- << "listShapesOnBoxIDs = geompy.GetShapesOnShapeIDs("
+ << "listShapesOnShapeIDs = geompy.GetShapesOnShapeIDs("
<< theCheckShape << ", "
<< theShape << ", "
<< TopAbs_ShapeEnum(theShapeType) << ", "
<< theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeqOfIDs;
}
//Add a new result object
- Handle(GEOM_Object) aRes = GetEngine()->AddObject(GetDocID(), GEOM_SHAPES_ON_SHAPE);
+ Handle(GEOM_Object) aRes = GetEngine()->AddObject(GEOM_SHAPES_ON_SHAPE);
Handle(GEOM_Function) aFunction =
aRes->AddFunction(GEOMImpl_ShapeDriver::GetID(), SHAPES_ON_SHAPE);
aFunction->SetValue(aCompound);
return aRes;
}
+//=============================================================================
+/*!
+ * GetSubShapeEdgeSorted
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient)
+ GEOMImpl_IShapesOperations::GetSubShapeEdgeSorted
+ (const Handle(GEOM_Object) &theShape,
+ const Handle(GEOM_Object) &theStartPoint)
+{
+ // Get the sorted edges indices.
+ Handle(TColStd_HSequenceOfInteger) aSortedIDs =
+ getSubShapeEdgeSortedIDs(theShape, theStartPoint);
+
+ // Get object by indices.
+ TCollection_AsciiString anAsciiList;
+ Handle(TColStd_HSequenceOfTransient) aSeq =
+ getObjectsShapesOn(theShape, aSortedIDs, anAsciiList);
+
+ if (aSeq.IsNull() || aSeq->IsEmpty()) {
+ SetErrorCode("Empty sequence of edges");
+ return NULL;
+ }
+
+ // Make a Python command
+ Handle(GEOM_Object) anObj =
+ Handle(GEOM_Object)::DownCast(aSeq->Value(1));
+ Handle(GEOM_Function) aFunction = anObj->GetLastFunction();
+
+ GEOM::TPythonDump(aFunction)
+ << "[" << anAsciiList.ToCString() << "] = geompy.GetSubShapeEdgeSorted("
+ << theShape << ", " << theStartPoint << ")";
+
+ SetErrorCode(OK);
+
+ return aSeq;
+}
+
+//=============================================================================
+/*!
+ * GetSubShapesWithTolerance
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfTransient)
+ GEOMImpl_IShapesOperations::GetSubShapesWithTolerance
+ (const Handle(GEOM_Object) &theShape,
+ const Standard_Integer theShapeType,
+ const GEOMUtils::ComparisonCondition theCondition,
+ const Standard_Real theTolerance)
+{
+ if (theShape.IsNull()) {
+ SetErrorCode("NULL GEOM object");
+ return NULL;
+ }
+
+ TopoDS_Shape aShape = theShape->GetValue();
+
+ if (aShape.IsNull()) {
+ SetErrorCode("NULL Shape");
+ return NULL;
+ }
+
+ if (theShapeType != TopAbs_FACE && theShapeType != TopAbs_EDGE &&
+ theShapeType != TopAbs_VERTEX && aShape.ShapeType() >= theShapeType) {
+ SetErrorCode("Invalid shape type");
+ return NULL;
+ }
+
+ TopTools_IndexedMapOfShape anIndices;
+ TopTools_MapOfShape aMapFence;
+ TopExp_Explorer anExp(aShape,
+ (TopAbs_ShapeEnum) theShapeType);
+ Handle(TColStd_HSequenceOfInteger) anIDs = new TColStd_HSequenceOfInteger;
+
+ TopExp::MapShapes(aShape, anIndices);
+
+ for (; anExp.More(); anExp.Next()) {
+ const TopoDS_Shape &aSubShape = anExp.Current();
+
+ if (aMapFence.Add(aSubShape)) {
+ // Compute tolerance
+ Standard_Real aTolerance = -1.;
+
+ switch (aSubShape.ShapeType()) {
+ case TopAbs_FACE:
+ aTolerance = BRep_Tool::Tolerance(TopoDS::Face(aSubShape));
+ break;
+ case TopAbs_EDGE:
+ aTolerance = BRep_Tool::Tolerance(TopoDS::Edge(aSubShape));
+ break;
+ case TopAbs_VERTEX:
+ aTolerance = BRep_Tool::Tolerance(TopoDS::Vertex(aSubShape));
+ break;
+ default:
+ break;
+ }
+
+ if (aTolerance < 0.) {
+ continue;
+ }
+
+ // Compare the tolerance with reference value.
+ if (GEOMUtils::IsFitCondition (theCondition, aTolerance, theTolerance)) {
+ anIDs->Append(anIndices.FindIndex(aSubShape));
+ }
+ }
+ }
+
+ if (anIDs->IsEmpty()) {
+ SetErrorCode("Empty sequence of sub-shapes");
+ return NULL;
+ }
+
+ // Get objects by indices.
+ TCollection_AsciiString anAsciiList;
+ Handle(TColStd_HSequenceOfTransient) aSeq =
+ getObjectsShapesOn(theShape, anIDs, anAsciiList);
+
+ if (aSeq.IsNull() || aSeq->IsEmpty()) {
+ SetErrorCode("Empty sequence of edges");
+ return NULL;
+ }
+
+ // Make a Python command
+ Handle(GEOM_Object) anObj =
+ Handle(GEOM_Object)::DownCast(aSeq->Value(1));
+ Handle(GEOM_Function) aFunction = anObj->GetLastFunction();
+
+ GEOM::TPythonDump(aFunction)
+ << "[" << anAsciiList.ToCString() << "] = geompy.GetSubShapesWithTolerance("
+ << theShape << ", " << theShapeType << ", " << theCondition << ", "
+ << theTolerance << ")";
+
+ SetErrorCode(OK);
+
+ return aSeq;
+}
+
+//=============================================================================
+/*!
+ * MakeExtraction
+ */
+//=============================================================================
+Handle(GEOM_Object) GEOMImpl_IShapesOperations::MakeExtraction
+ (const Handle(GEOM_Object) &theShape,
+ const Handle(TColStd_HArray1OfInteger) &theSubShapeIDs,
+ std::list<ExtractionStat> &theStats)
+{
+ SetErrorCode(KO);
+
+ if (theShape.IsNull()) {
+ return NULL;
+ }
+
+ //Add a new Result object
+ Handle(GEOM_Object) aResult =
+ GetEngine()->AddObject(GEOM_EXTRACTION);
+
+ //Add a new Extraction function
+ Handle(GEOM_Function) aFunction =
+ aResult->AddFunction(GEOMImpl_ShapeDriver::GetID(), EXTRACTION);
+
+ //Check if the function is set correctly
+ if (aFunction->GetDriverGUID() != GEOMImpl_ShapeDriver::GetID()) {
+ return NULL;
+ }
+
+ Handle(GEOM_Function) aShape = theShape->GetLastFunction();
+
+ if (aShape.IsNull()) {
+ return NULL;
+ }
+
+ GEOMImpl_IExtract aCI (aFunction);
+
+ aCI.SetShape(aShape);
+ aCI.SetSubShapeIDs(theSubShapeIDs);
+
+ //Compute the Edge value
+ try {
+ OCC_CATCH_SIGNALS;
+ if (!GetSolver()->ComputeFunction(aFunction)) {
+ SetErrorCode("Shape driver failed");
+
+ return NULL;
+ }
+ }
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
+
+ return NULL;
+ }
+
+ // Fill in statistics.
+ theStats.clear();
+
+ Handle(TColStd_HArray1OfInteger) aStatIDsArray[3] =
+ { aCI.GetRemovedIDs(), aCI.GetModifiedIDs(), aCI.GetAddedIDs() };
+ int i;
+ int j;
+
+ for (j = 0; j < 3; ++j) {
+ if (!aStatIDsArray[j].IsNull()) {
+ const int anUpperID = aStatIDsArray[j]->Upper();
+ ExtractionStat aStat;
+
+ for (i = aStatIDsArray[j]->Lower(); i <= anUpperID; ++i) {
+ aStat.indices.push_back(aStatIDsArray[j]->Value(i));
+ }
+
+ aStat.type = (ExtractionStatType) j;
+ theStats.push_back(aStat);
+ }
+ }
+
+ //Make a Python command
+ GEOM::TPythonDump pd(aFunction);
+
+ pd << aResult << " = geompy.MakeExtraction(" << theShape << ", [";
+
+ if (!theSubShapeIDs.IsNull()) {
+ const int aNbIDs = theSubShapeIDs->Upper();
+
+ for (i = theSubShapeIDs->Lower(); i < aNbIDs; ++i) {
+ pd << theSubShapeIDs->Value(i) << ", ";
+ }
+
+ // Dump the last value without a comma.
+ pd << theSubShapeIDs->Value(i);
+ }
+
+ pd << "])";
+
+ SetErrorCode(OK);
+
+ return aResult;
+}
+
//=======================================================================
//function : getShapesOnSurfaceIDs
/*!
Handle(TColStd_HSequenceOfInteger) aSeqOfIDs;
// Check presence of triangulation, build if need
- if (!GEOMUtils::CheckTriangulation(theShape)) {
+ if (theShapeType != TopAbs_VERTEX &&
+ !GEOMUtils::CheckTriangulation(theShape)) {
SetErrorCode("Cannot build triangulation on the shape");
return aSeqOfIDs;
}
VertMax = T;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return aSeqOfIDs;
}
// END: Mantis issue 0020961
// Call algo
- GEOMAlgo_FinderShapeOn1 aFinder;
- //Standard_Real aTol = 0.0001; // default value
- Standard_Real aTol = VertMax; // Mantis issue 0020961
+ GEOMAlgo_FinderShapeOn2 aFinder;
+ Handle(GEOMAlgo_ClsfSurf) aClsfSurf = new GEOMAlgo_ClsfSurf;
+ Standard_Real aTol = VertMax; // Mantis issue 0020961
+ aClsfSurf->SetSurface(theSurface);
aFinder.SetShape(theShape);
aFinder.SetTolerance(aTol);
- aFinder.SetSurface(theSurface);
+ aFinder.SetClsf(aClsfSurf);
aFinder.SetShapeType(theShapeType);
aFinder.SetState(theState);
// Default value=3
aFinder.SetNbPntsMin(3);
// Sets the maximal number of inner points for edges or faces.
- // It is usefull for the cases when this number is very big (e.g =2000) to improve
+ // It is useful for the cases when this number is very big (e.g =2000) to improve
// the performance. If this value =0, all inner points will be taken into account.
// Default value=0
aFinder.SetNbPntsMax(100);
aFinder.Perform();
- // Interprete results
+ // Interpret results
Standard_Integer iErr = aFinder.ErrorStatus();
- // the detailed description of error codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of error codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iErr) {
MESSAGE(" iErr : " << iErr);
TCollection_AsciiString aMsg (" iErr : ");
return aSeqOfIDs;
}
Standard_Integer iWrn = aFinder.WarningStatus();
- // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iWrn) {
MESSAGE(" *** iWrn : " << iWrn);
}
return aSeq;
}
+//=============================================================================
+/*!
+ * getSubShapeEdgeSortedIDs
+ */
+//=============================================================================
+Handle(TColStd_HSequenceOfInteger)
+ GEOMImpl_IShapesOperations::getSubShapeEdgeSortedIDs
+ (const Handle(GEOM_Object) &theShape,
+ const Handle(GEOM_Object) &theStartPoint)
+{
+ Handle(TColStd_HSequenceOfInteger) aResult;
+
+ if (theShape.IsNull() || theStartPoint.IsNull()) {
+ SetErrorCode("NULL GEOM object");
+ return aResult;
+ }
+
+ const TopoDS_Shape aShape = theShape->GetValue();
+ const TopoDS_Shape aStartPoint = theStartPoint->GetValue();
+
+ if (aShape.IsNull() || aStartPoint.IsNull()) {
+ SetErrorCode("NULL Shape");
+ return aResult;
+ }
+
+ if (aStartPoint.ShapeType() != TopAbs_VERTEX) {
+ SetErrorCode("Starting point is not a vertex");
+ return aResult;
+ }
+
+ TopExp_Explorer anExp(aShape, TopAbs_EDGE);
+ TopTools_MapOfShape aMapFence;
+ TopTools_ListOfShape anEdges;
+
+ for (; anExp.More(); anExp.Next()) {
+ const TopoDS_Shape &anEdge = anExp.Current();
+
+ if (aMapFence.Add(anEdge)) {
+ anEdges.Append(anEdge);
+ }
+ }
+
+ if (anEdges.IsEmpty()) {
+ SetErrorCode("Shape doesn't contain edges");
+ return aResult;
+ }
+
+ // Step 1: Sort edges
+ GEOMUtils::SortShapes(anEdges, Standard_False);
+
+ TopTools_ListIteratorOfListOfShape anIter(anEdges);
+ TopoDS_Vertex aV[2];
+ TopTools_DataMapOfShapeListOfShape aMapVE;
+
+ // Step 2: Fill the map vertex - list of edges.
+ for (; anIter.More(); anIter.Next()) {
+ TopoDS_Edge anEdge = TopoDS::Edge(anIter.Value());
+
+ TopExp::Vertices(anEdge, aV[0], aV[1]);
+
+ const Standard_Integer aNbV = aV[0].IsSame(aV[1]) ? 1 : 2;
+ Standard_Integer i;
+
+ for (i = 0; i < aNbV; ++i) {
+ if (aV[i].IsNull() == Standard_False) {
+ if (!aMapVE.IsBound(aV[i])) {
+ // There is no this vertex in the map.
+ aMapVE.Bind(aV[i], TopTools_ListOfShape());
+ }
+
+ // Add the edge to the list bound with the vertex aV[i].
+ TopTools_ListOfShape &aLEdges = aMapVE.ChangeFind(aV[i]);
+
+ aLEdges.Append(anEdge);
+ }
+ }
+ }
+
+ // Step 3: Find starting point in aMapVE.
+ TopoDS_Vertex aStartVtx = TopoDS::Vertex(aStartPoint);
+
+ if (!aMapVE.IsBound(aStartVtx)) {
+ aStartVtx = getSameVertex(aShape, aStartVtx);
+
+ if (aStartVtx.IsNull()) {
+ SetErrorCode("Invalid Starting point");
+ return aResult;
+ }
+ }
+
+ TopTools_IndexedMapOfShape anIndices;
+ TopTools_MapOfShape aMapVFence;
+ TopoDS_Shape aCurVtx = aStartVtx;
+ TopoDS_Edge aCurEdge =
+ TopoDS::Edge(aMapVE.Find(aCurVtx).First());
+
+ aResult = new TColStd_HSequenceOfInteger;
+ TopExp::MapShapes(aShape, anIndices);
+
+ // Step 4: Fill the list of sorted edges.
+ while (aMapVFence.Add(aCurVtx)) {
+ // Append the ID of the current edge to the list of sorted.
+ aResult->Append(anIndices.FindIndex(aCurEdge));
+ TopExp::Vertices(aCurEdge, aV[0], aV[1]);
+
+ // Get the next vertex.
+ if (aCurVtx.IsSame(aV[0])) {
+ if (aCurVtx.IsSame(aV[1])) {
+ // There is no next vertex.
+ break;
+ } else {
+ aCurVtx = aV[1];
+ }
+ } else {
+ aCurVtx = aV[0];
+ }
+
+ if (aCurVtx.IsNull()) {
+ // There is no next vertex.
+ break;
+ }
+
+ // Get the next edge.
+ const TopTools_ListOfShape &aLEdges = aMapVE.Find(aCurVtx);
+ TopTools_ListIteratorOfListOfShape anEIter(aLEdges);
+
+ for (; anEIter.More(); anEIter.Next()) {
+ const TopoDS_Shape &aLocalEdge = anEIter.Value();
+
+ if (aLocalEdge.IsNull() == Standard_False) {
+ if (!aCurEdge.IsSame(aLocalEdge)) {
+ aCurEdge = TopoDS::Edge(aLocalEdge);
+ break;
+ }
+ }
+ }
+
+ if (!anEIter.More()) {
+ // There is no next edge.
+ break;
+ }
+ }
+
+ return aResult;
+}
+
//=======================================================================
//function : getShapesOnSurface
/*!
// The GetShapesOnPlaneIDs() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theAx1)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnPlane = geompy.GetShapesOnPlaneIDs"
<< "(" << theShape << "," << aShapeType << "," << theAx1 << "," << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
// The GetShapesOnPlaneIDs() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theAx1)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnPlane = geompy.GetShapesOnPlaneWithLocationIDs"
<< "(" << theShape << ", " << aShapeType << ", " << theAx1 << ", "<< thePnt << ", " << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
// The GetShapesOnCylinder() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theAxis)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnCylinder = geompy.GetShapesOnCylinderIDs"
<< "(" << theShape << ", " << aShapeType << ", " << theAxis << ", "
<< theRadius << ", " << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
Handle(GEOM_Function) aFunction =
GEOM::GetCreatedLast(theShape, GEOM::GetCreatedLast(thePnt,theAxis))->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnCylinder = geompy.GetShapesOnCylinderWithLocationIDs"
<< "(" << theShape << ", " << aShapeType << ", " << theAxis << ", "
<< thePnt << ", " << theRadius << ", " << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
// The GetShapesOnSphere() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShape,theCenter)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
- << "listShapesOnCylinder = geompy.GetShapesOnSphereIDs"
+ << "listShapesOnSphere = geompy.GetShapesOnSphereIDs"
<< "(" << theShape << ", " << aShapeType << ", " << theCenter << ", "
<< theRadius << ", " << theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeq;
* \param theShape - the shape to explore
* \param theShapeType - type of sub-shape of theShape
* \param theTopLeftPoint - top left quadrangle corner
- * \param theTopRigthPoint - top right quadrangle corner
+ * \param theTopRightPoint - top right quadrangle corner
* \param theBottomLeftPoint - bottom left quadrangle corner
- * \param theBottomRigthPoint - bottom right quadrangle corner
+ * \param theBottomRightPoint - bottom right quadrangle corner
* \param theState - required state
* \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
GEOMImpl_IShapesOperations::getShapesOnQuadrangleIDs (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theTopLeftPoint,
- const Handle(GEOM_Object)& theTopRigthPoint,
+ const Handle(GEOM_Object)& theTopRightPoint,
const Handle(GEOM_Object)& theBottomLeftPoint,
- const Handle(GEOM_Object)& theBottomRigthPoint,
+ const Handle(GEOM_Object)& theBottomRightPoint,
const GEOMAlgo_State theState)
{
SetErrorCode(KO);
if ( theShape.IsNull() ||
theTopLeftPoint.IsNull() ||
- theTopRigthPoint.IsNull() ||
+ theTopRightPoint.IsNull() ||
theBottomLeftPoint.IsNull() ||
- theBottomRigthPoint.IsNull() )
+ theBottomRightPoint.IsNull() )
return NULL;
TopoDS_Shape aShape = theShape->GetValue();
TopoDS_Shape aTL = theTopLeftPoint->GetValue();
- TopoDS_Shape aTR = theTopRigthPoint->GetValue();
+ TopoDS_Shape aTR = theTopRightPoint->GetValue();
TopoDS_Shape aBL = theBottomLeftPoint->GetValue();
- TopoDS_Shape aBR = theBottomRigthPoint->GetValue();
+ TopoDS_Shape aBR = theBottomRightPoint->GetValue();
if (aShape.IsNull() ||
aTL.IsNull() ||
Handle(TColStd_HSequenceOfInteger) aSeqOfIDs;
// Check presence of triangulation, build if need
- if (!GEOMUtils::CheckTriangulation(aShape)) {
+ if (theShapeType != TopAbs_VERTEX && !GEOMUtils::CheckTriangulation(aShape)) {
SetErrorCode("Cannot build triangulation on the shape");
return aSeqOfIDs;
}
gp_Pnt aPntBL = BRep_Tool::Pnt(TopoDS::Vertex(aBL));
gp_Pnt aPntBR = BRep_Tool::Pnt(TopoDS::Vertex(aBR));
- GEOMAlgo_FinderShapeOnQuad aFinder( aPntTL, aPntTR, aPntBL, aPntBR );
+ GEOMAlgo_FinderShapeOn2 aFinder;
+ Handle(GEOMAlgo_ClsfQuad) aClsfQuad = new GEOMAlgo_ClsfQuad;
+
Standard_Real aTol = 0.0001; // default value
+ aClsfQuad->SetCorners(aPntTL, aPntTR, aPntBL, aPntBR);
aFinder.SetShape(aShape);
aFinder.SetTolerance(aTol);
- //aFinder.SetSurface(theSurface);
+ aFinder.SetClsf(aClsfQuad);
aFinder.SetShapeType(aShapeType);
aFinder.SetState(theState);
// Default value=3
aFinder.SetNbPntsMin(3);
// Sets the maximal number of inner points for edges or faces.
- // It is usefull for the cases when this number is very big (e.g =2000) to improve
+ // It is useful for the cases when this number is very big (e.g =2000) to improve
// the performance. If this value =0, all inner points will be taken into account.
// Default value=0
aFinder.SetNbPntsMax(100);
aFinder.Perform();
- // Interprete results
+ // Interpret results
Standard_Integer iErr = aFinder.ErrorStatus();
- // the detailed description of error codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of error codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iErr) {
MESSAGE(" iErr : " << iErr);
TCollection_AsciiString aMsg (" iErr : ");
return aSeqOfIDs;
}
Standard_Integer iWrn = aFinder.WarningStatus();
- // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn1.cxx
+ // the detailed description of warning codes is in GEOMAlgo_FinderShapeOn2.cxx
if (iWrn) {
MESSAGE(" *** iWrn : " << iWrn);
}
* \param theShape - the shape to explore
* \param theShapeType - type of sub-shape of theShape
* \param theTopLeftPoint - top left quadrangle corner
- * \param theTopRigthPoint - top right quadrangle corner
+ * \param theTopRightPoint - top right quadrangle corner
* \param theBottomLeftPoint - bottom left quadrangle corner
- * \param theBottomRigthPoint - bottom right quadrangle corner
+ * \param theBottomRightPoint - bottom right quadrangle corner
* \param theState - required state
* \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
GEOMImpl_IShapesOperations::GetShapesOnQuadrangle (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theTopLeftPoint,
- const Handle(GEOM_Object)& theTopRigthPoint,
+ const Handle(GEOM_Object)& theTopRightPoint,
const Handle(GEOM_Object)& theBottomLeftPoint,
- const Handle(GEOM_Object)& theBottomRigthPoint,
+ const Handle(GEOM_Object)& theBottomRightPoint,
const GEOMAlgo_State theState)
{
// Find indices
getShapesOnQuadrangleIDs( theShape,
theShapeType,
theTopLeftPoint,
- theTopRigthPoint,
+ theTopRightPoint,
theBottomLeftPoint,
- theBottomRigthPoint,
+ theBottomRightPoint,
theState);
if ( aSeqOfIDs.IsNull() || aSeqOfIDs->IsEmpty() )
return NULL;
<< theShape << ", "
<< TopAbs_ShapeEnum(theShapeType) << ", "
<< theTopLeftPoint << ", "
- << theTopRigthPoint << ", "
+ << theTopRightPoint << ", "
<< theBottomLeftPoint << ", "
- << theBottomRigthPoint << ", "
+ << theBottomRightPoint << ", "
<< theState << ")";
SetErrorCode(OK);
* \param theShape - the shape to explore
* \param theShapeType - type of sub-shape of theShape
* \param theTopLeftPoint - top left quadrangle corner
- * \param theTopRigthPoint - top right quadrangle corner
+ * \param theTopRightPoint - top right quadrangle corner
* \param theBottomLeftPoint - bottom left quadrangle corner
- * \param theBottomRigthPoint - bottom right quadrangle corner
+ * \param theBottomRightPoint - bottom right quadrangle corner
* \param theState - required state
* \retval Handle(TColStd_HSequenceOfInteger) - IDs of found sub-shapes
*/
GEOMImpl_IShapesOperations::GetShapesOnQuadrangleIDs (const Handle(GEOM_Object)& theShape,
const Standard_Integer theShapeType,
const Handle(GEOM_Object)& theTopLeftPoint,
- const Handle(GEOM_Object)& theTopRigthPoint,
+ const Handle(GEOM_Object)& theTopRightPoint,
const Handle(GEOM_Object)& theBottomLeftPoint,
- const Handle(GEOM_Object)& theBottomRigthPoint,
+ const Handle(GEOM_Object)& theBottomRightPoint,
const GEOMAlgo_State theState)
{
// Find indices
getShapesOnQuadrangleIDs( theShape,
theShapeType,
theTopLeftPoint,
- theTopRigthPoint,
+ theTopRightPoint,
theBottomLeftPoint,
- theBottomRigthPoint,
+ theBottomRightPoint,
theState);
if ( aSeqOfIDs.IsNull() || aSeqOfIDs->IsEmpty() )
return NULL;
// Make a Python command
// The GetShapesOnCylinder() doesn't change object so no new function is required.
- Handle(GEOM_Object) lastObj = GEOM::GetCreatedLast(theShape,theTopLeftPoint);
- lastObj = GEOM::GetCreatedLast(lastObj,theTopRigthPoint);
- lastObj = GEOM::GetCreatedLast(lastObj,theBottomRigthPoint);
+ Handle(GEOM_BaseObject) lastObj = GEOM::GetCreatedLast(theShape,theTopLeftPoint);
+ lastObj = GEOM::GetCreatedLast(lastObj,theTopRightPoint);
+ lastObj = GEOM::GetCreatedLast(lastObj,theBottomRightPoint);
lastObj = GEOM::GetCreatedLast(lastObj,theBottomLeftPoint);
Handle(GEOM_Function) aFunction = lastObj->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listShapesOnQuadrangle = geompy.GetShapesOnQuadrangleIDs("
<< theShape << ", "
<< TopAbs_ShapeEnum(theShapeType) << ", "
<< theTopLeftPoint << ", "
- << theTopRigthPoint << ", "
+ << theTopRightPoint << ", "
<< theBottomLeftPoint << ", "
- << theBottomRigthPoint << ", "
+ << theBottomRightPoint << ", "
<< theState << ")";
+#endif // DUMP_SUBSHAPE_IDS
SetErrorCode(OK);
return aSeqOfIDs;
const TopoDS_Shape &aShapeResult = aGIP.Result();
TopTools_MapOfShape aMFence;
TopTools_IndexedMapOfShape aWhereIndices;
+ Standard_Integer aShapeType = -1;
TopExp::MapShapes(aWhere, aWhereIndices);
if (aShapeResult.IsNull() == Standard_False) {
- TopoDS_Iterator anIt(aShapeResult);
+ TopoDS_Iterator anIt(aShapeResult);
for (; anIt.More(); anIt.Next()) {
const TopoDS_Shape &aPart = anIt.Value();
if(aWhereIndices.Contains(aPart) && aMFence.Add(aPart)) {
+ const TopAbs_ShapeEnum aType = aPart.ShapeType();
+
+ if (aShapeType == -1) {
+ // Initialization.
+ aShapeType = aType;
+ } else if (aShapeType != TopAbs_SHAPE && aShapeType != aType) {
+ // Different types.
+ aShapeType = TopAbs_SHAPE;
+ }
+
aLSA.Append(aPart);
}
}
Handle(TColStd_HArray1OfInteger) aModifiedArray = new TColStd_HArray1OfInteger (1, aLSA.Extent());
TopTools_ListIteratorOfListOfShape anIterModif (aLSA);
for (Standard_Integer imod = 1; anIterModif.More(); anIterModif.Next(), imod++) {
- if (aWhereIndices.Contains(anIterModif.Value())) {
- aModifiedArray->SetValue(imod, aWhereIndices.FindIndex(anIterModif.Value()));
- }
- else {
- SetErrorCode("Error: wrong sub-shape returned");
- return NULL;
- }
+ aModifiedArray->SetValue(imod, aWhereIndices.FindIndex(anIterModif.Value()));
}
//Add a new object
return NULL;
}
- if (aModifiedArray->Length() > 1 || theShapeWhat->GetType() == GEOM_GROUP) {
+ const Standard_Boolean isSameType = (aShapeType != TopAbs_SHAPE);
+
+ if ((aModifiedArray->Length() > 1 && isSameType) ||
+ theShapeWhat->GetType() == GEOM_GROUP) {
//Set a GROUP type
aResult->SetType(GEOM_GROUP);
new TColStd_HArray1OfInteger (1, aModifiedList.Extent());
TopTools_ListIteratorOfListOfShape anIterModif (aModifiedList);
Standard_Integer imod;
+ Standard_Integer aShapeType = -1;
for (imod = 1; anIterModif.More(); anIterModif.Next(), imod++) {
const Standard_Integer anIndex =
aWhereIndices.FindIndex(anIterModif.Value());
+ const TopAbs_ShapeEnum aType = anIterModif.Value().ShapeType();
+
+ if (aShapeType == -1) {
+ // Initialization.
+ aShapeType = aType;
+ } else if (aShapeType != TopAbs_SHAPE && aShapeType != aType) {
+ // Different types.
+ aShapeType = TopAbs_SHAPE;
+ }
aModifiedArray->SetValue(imod, anIndex);
}
return NULL;
}
- if (aModifiedArray->Length() > 1 || theShapeWhat->GetType() == GEOM_GROUP) {
+ const Standard_Boolean isSameType = (aShapeType != TopAbs_SHAPE);
+
+ if ((aModifiedArray->Length() > 1 && isSameType) ||
+ theShapeWhat->GetType() == GEOM_GROUP) {
//Set a GROUP type
aResult->SetType(GEOM_GROUP);
return NULL;
}
- Standard_Integer nbFound = aModifiedList.Extent();
+ Handle(TColStd_HArray1OfInteger) aModifiedArray =
+ new TColStd_HArray1OfInteger (1, aModifiedList.Extent());
TopTools_ListIteratorOfListOfShape anIterModif (aModifiedList);
- if ( nbFound > 1 )
- {
- // remove sub-shapes inappropriate for group creation
- TopAbs_ShapeEnum subType = TopAbs_SHAPE;
- while ( anIterModif.More() ) {
- TopAbs_ShapeEnum type = anIterModif.Value().ShapeType();
- bool okForGroup = ( type == TopAbs_VERTEX || type == TopAbs_EDGE ||
- type == TopAbs_FACE || type == TopAbs_SOLID );
- if ( okForGroup ) {
- if ( subType == TopAbs_SHAPE )
- subType = type;
- else
- okForGroup = ( subType == type );
- }
- if ( okForGroup )
- anIterModif.Next();
- else
- aModifiedList.Remove( anIterModif );
- nbFound -= ( !okForGroup );
- }
- if ( nbFound == 0 ) {
- SetErrorCode("Error: result found but it's type is inappropriate for group creation.");
- return NULL;
+ Standard_Integer imod;
+ Standard_Integer aShapeType = -1;
+
+ for (imod = 1; anIterModif.More(); anIterModif.Next(), imod++) {
+ const Standard_Integer anIndex =
+ aWhereIndices.FindIndex(anIterModif.Value());
+ const TopAbs_ShapeEnum aType = anIterModif.Value().ShapeType();
+
+ if (aShapeType == -1) {
+ // Initialization.
+ aShapeType = aType;
+ } else if (aShapeType != TopAbs_SHAPE && aShapeType != aType) {
+ // Different types.
+ aShapeType = TopAbs_SHAPE;
}
- }
- Handle(TColStd_HArray1OfInteger) aModifiedArray =
- new TColStd_HArray1OfInteger( 1, nbFound );
- anIterModif.Initialize(aModifiedList);
- for (Standard_Integer imod = 1; anIterModif.More(); anIterModif.Next(), imod++)
- aModifiedArray->SetValue
- (imod, aWhereIndices.FindIndex(anIterModif.Value()));
+ aModifiedArray->SetValue(imod, anIndex);
+ }
//Add a new object
Handle(GEOM_Object) aResult = GetEngine()->AddSubShape(theShapeWhere, aModifiedArray);
return NULL;
}
- if (aModifiedArray->Length() > 1) {
+ const Standard_Boolean isSameType = (aShapeType != TopAbs_SHAPE);
+
+ if ((aModifiedArray->Length() > 1 && isSameType) ||
+ theShapeWhat->GetType() == GEOM_GROUP) {
//Set a GROUP type
aResult->SetType(GEOM_GROUP);
return aResult;
}
-#define MAX_TOLERANCE 1.e-7
+//=======================================================================
+//function : GetInPlaceMap
+//purpose :
+//=======================================================================
+void GEOMImpl_IShapesOperations::GetInPlaceMap (Handle(GEOM_Object) theShapeWhere,
+ Handle(GEOM_Object) theShapeWhat,
+ std::vector< std::vector< int > > & theResVec)
+{
+ SetErrorCode(KO);
+
+ if (theShapeWhere.IsNull() || theShapeWhat.IsNull()) return;
+
+ TopoDS_Shape aWhere = theShapeWhere->GetValue();
+ TopoDS_Shape aWhat = theShapeWhat->GetValue();
+
+ if (aWhere.IsNull() || aWhat.IsNull()) return;
+
+ Handle(GEOM_Function) aWhereFunction = theShapeWhere->GetLastFunction();
+ if (aWhereFunction.IsNull()) return;
+
+ bool isFound = GEOMAlgo_GetInPlaceAPI::GetInPlaceMap( aWhereFunction, aWhat, theResVec );
+
+ if ( isFound )
+ SetErrorCode(OK);
+
+ Handle(GEOM_Function) aFunction =
+ GEOM::GetCreatedLast(theShapeWhere,theShapeWhat)->GetLastFunction();
+
+ GEOM::TPythonDump(aFunction, /*append=*/true)
+ << "resultList = geompy.GetInPlaceMap( "
+ << theShapeWhere << ", "
+ << theShapeWhat << ")";
+
+ return;
+}
//=======================================================================
//function : isSameEdge
double U11, U12, U21, U22;
Handle(Geom_Curve) C1 = BRep_Tool::Curve(theEdge1, U11, U12);
Handle(Geom_Curve) C2 = BRep_Tool::Curve(theEdge2, U21, U22);
- if(C1->DynamicType() == C2->DynamicType()) return true;
//Check that both edges has the same geometry
double range = U12-U11;
U = U11+range*2.0/3.0;
gp_Pnt P2 = C1->Value(U); //Compute a point on two thirds of the edge's length
+ C2 = new Geom_TrimmedCurve(C2, U21, U22);
+ // vsr 04/10/2018: 0023312 - As curve may be periodic, its parameters may be normalized
+ // so, we re-take them from trimmed curve
+ U21 = C2->FirstParameter();
+ U22 = C2->LastParameter();
+
if(!GeomLib_Tool::Parameter(C2, P1, MAX_TOLERANCE, U) || U < U21 || U > U22)
return false;
return true;
}
-#include <TopoDS_TShape.hxx>
//=======================================================================
//function : isSameFace
//purpose : Returns True if two faces coincide
switch (aWhat.ShapeType()) {
case TopAbs_VERTEX: {
- gp_Pnt P = BRep_Tool::Pnt(TopoDS::Vertex(aWhat));
- TopExp_Explorer E(aWhere, TopAbs_VERTEX);
- for(; E.More(); E.Next()) {
- if(!aMap.Add(E.Current())) continue;
- gp_Pnt P2 = BRep_Tool::Pnt(TopoDS::Vertex(E.Current()));
- if(P.Distance(P2) <= MAX_TOLERANCE) {
- isFound = true;
- aSubShape = E.Current();
- break;
- }
- }
+ aSubShape = getSameVertex(aWhere, TopoDS::Vertex(aWhat));
+ isFound = !aSubShape.IsNull();
break;
}
case TopAbs_EDGE: {
// The GetSameIDs() doesn't change object so no new function is required.
Handle(GEOM_Function) aFunction = GEOM::GetCreatedLast(theShapeWhere,theShapeWhat)->GetLastFunction();
+ // VSR 29/08/2017: 0023327, 0023428: eliminate unnecessary lines in Python dump
+#ifdef DUMP_SUBSHAPE_IDS
// Make a Python command
GEOM::TPythonDump(aFunction, /*append=*/true)
<< "listSameIDs = geompy.GetSameIDs("
<< theShapeWhere << ", "
<< theShapeWhat << ")";
+#endif // DUMP_SUBSHAPE_IDS
return aSeq;
} else {
SetErrorCode(NOT_FOUND_ANY);
}
//Add a new Edge object
- Handle(GEOM_Object) aResEdge = GetEngine()->AddObject(GetDocID(), GEOM_EDGE);
+ Handle(GEOM_Object) aResEdge = GetEngine()->AddObject(GEOM_EDGE);
//Add a new Vector function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
}
//Add a new Face object
- Handle(GEOM_Object) aResFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
+ Handle(GEOM_Object) aResFace = GetEngine()->AddObject(GEOM_FACE);
//Add a new Vector function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
}
//Add a new Face object
- Handle(GEOM_Object) aResFace = GetEngine()->AddObject(GetDocID(), GEOM_FACE);
+ Handle(GEOM_Object) aResFace = GetEngine()->AddObject(GEOM_FACE);
//Add a new Vector function
Handle(GEOM_Function) aFunction =
return NULL;
}
}
- catch (Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
- SetErrorCode(aFail->GetMessageString());
+ catch (Standard_Failure& aFail) {
+ SetErrorCode(aFail.GetMessageString());
return NULL;
}
