-// Copyright (C) 2014-2017 CEA/DEN, EDF R&D
+// Copyright (C) 2014-2019 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
//
// 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
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.salome-platform.org/ or
-// email : webmaster.salome@opencascade.com<mailto:webmaster.salome@opencascade.com>
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
#include "GeomAlgoAPI_ShapeTools.h"
#include <Geom2d_Curve.hxx>
#include <BRepLib_CheckCurveOnSurface.hxx>
#include <BRep_Tool.hxx>
+#include <Geom_CylindricalSurface.hxx>
#include <Geom_Line.hxx>
#include <Geom_Plane.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
+#include <GeomAPI_ShapeIterator.h>
#include <GeomLib_IsPlanarSurface.hxx>
#include <GeomLib_Tool.hxx>
#include <GeomAPI_IntCS.hxx>
#include <TopoDS_Edge.hxx>
//==================================================================================================
-double GeomAlgoAPI_ShapeTools::volume(const std::shared_ptr<GeomAPI_Shape> theShape)
+static GProp_GProps props(const TopoDS_Shape& theShape)
{
GProp_GProps aGProps;
+
+ if (theShape.ShapeType() == TopAbs_EDGE || theShape.ShapeType() == TopAbs_WIRE)
+ {
+ BRepGProp::LinearProperties(theShape, aGProps);
+ }
+ else if (theShape.ShapeType() == TopAbs_FACE || theShape.ShapeType() == TopAbs_SHELL)
+ {
+ const Standard_Real anEps = 1.e-6;
+ BRepGProp::SurfaceProperties(theShape, aGProps, anEps);
+ }
+ else if (theShape.ShapeType() == TopAbs_SOLID || theShape.ShapeType() == TopAbs_COMPSOLID)
+ {
+ BRepGProp::VolumeProperties(theShape, aGProps);
+ }
+ else if (theShape.ShapeType() == TopAbs_COMPOUND)
+ {
+ for (TopoDS_Iterator anIt(theShape); anIt.More(); anIt.Next())
+ {
+ aGProps.Add(props(anIt.Value()));
+ }
+ }
+
+ return aGProps;
+}
+
+//==================================================================================================
+double GeomAlgoAPI_ShapeTools::volume(const std::shared_ptr<GeomAPI_Shape> theShape)
+{
if(!theShape.get()) {
return 0.0;
}
return 0.0;
}
const Standard_Real anEps = 1.e-6;
- if (aShape.ShapeType() <= TopAbs_SOLID)
- BRepGProp::VolumeProperties(aShape, aGProps, anEps);
- else
- BRepGProp::SurfaceProperties(aShape, aGProps, anEps);
+ TopExp_Explorer anExp(aShape, TopAbs_SOLID);
+ if (anExp.More()) { // return volume if there is at least one solid
+ double aVolume = 0.0;
+ for (; anExp.More(); anExp.Next()) {
+ GProp_GProps aGProps;
+ BRepGProp::VolumeProperties(anExp.Current(), aGProps, anEps);
+ aVolume += aGProps.Mass();
+ }
+ return aVolume;
+ }
+ // return surfaces area
+ GProp_GProps aGProps;
+ BRepGProp::SurfaceProperties(aShape, aGProps, anEps);
return aGProps.Mass();
}
gp_Pnt aCentre;
if(aShape.ShapeType() == TopAbs_VERTEX) {
aCentre = BRep_Tool::Pnt(TopoDS::Vertex(aShape));
- } else if(aShape.ShapeType() == TopAbs_EDGE || aShape.ShapeType() == TopAbs_WIRE) {
- BRepGProp::LinearProperties(aShape, aGProps);
- aCentre = aGProps.CentreOfMass();
} else {
- const Standard_Real anEps = 1.e-6;
- BRepGProp::SurfaceProperties(aShape, aGProps, anEps);
+ aGProps = props(aShape);
aCentre = aGProps.CentreOfMass();
}
+
return std::shared_ptr<GeomAPI_Pnt>(new GeomAPI_Pnt(aCentre.X(), aCentre.Y(), aCentre.Z()));
}
+//==================================================================================================
+double GeomAlgoAPI_ShapeTools::radius(const std::shared_ptr<GeomAPI_Face>& theCylinder)
+{
+ double aRadius = -1.0;
+ if (theCylinder->isCylindrical()) {
+ const TopoDS_Shape& aShape = theCylinder->impl<TopoDS_Shape>();
+ Handle(Geom_Surface) aSurf = BRep_Tool::Surface(TopoDS::Face(aShape));
+ Handle(Geom_CylindricalSurface) aCyl = Handle(Geom_CylindricalSurface)::DownCast(aSurf);
+ if (!aCyl.IsNull())
+ aRadius = aCyl->Radius();
+ }
+ return aRadius;
+}
+
+//==================================================================================================
+double GeomAlgoAPI_ShapeTools::minimalDistance(const GeomShapePtr& theShape1,
+ const GeomShapePtr& theShape2)
+{
+ const TopoDS_Shape& aShape1 = theShape1->impl<TopoDS_Shape>();
+ const TopoDS_Shape& aShape2 = theShape2->impl<TopoDS_Shape>();
+
+ BRepExtrema_DistShapeShape aDist(aShape1, aShape2);
+ aDist.Perform();
+ return aDist.IsDone() ? aDist.Value() : Precision::Infinite();
+}
+
//==================================================================================================
std::shared_ptr<GeomAPI_Shape> GeomAlgoAPI_ShapeTools::combineShapes(
const std::shared_ptr<GeomAPI_Shape> theCompound,
const GeomAPI_Shape::ShapeType theType,
- ListOfShape& theCombinedShapes,
- ListOfShape& theFreeShapes)
+ ListOfShape& theResuts)
{
+
+ ListOfShape aResCombinedShapes;
+ ListOfShape aResFreeShapes;
+
GeomShapePtr aResult = theCompound;
if(!theCompound.get()) {
aTA = TopAbs_SOLID;
}
- theCombinedShapes.clear();
- theFreeShapes.clear();
+ // map from the resulting shapes to minimal index of the used shape from theCompound list
+ std::map<GeomShapePtr, int> anInputOrder;
+ // map from ancestors-shapes to the index of shapes in theCompound
+ NCollection_DataMap<TopoDS_Shape, int> anAncestorsOrder;
// Get free shapes.
+ int anOrder = 0;
const TopoDS_Shape& aShapesComp = theCompound->impl<TopoDS_Shape>();
- for(TopoDS_Iterator anIter(aShapesComp); anIter.More(); anIter.Next() ) {
+ for(TopoDS_Iterator anIter(aShapesComp); anIter.More(); anIter.Next(), anOrder++) {
const TopoDS_Shape& aShape = anIter.Value();
if(aShape.ShapeType() > aTA) {
std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape);
aGeomShape->setImpl<TopoDS_Shape>(new TopoDS_Shape(aShape));
- theFreeShapes.push_back(aGeomShape);
+ aResFreeShapes.push_back(aGeomShape);
+ anInputOrder[aGeomShape] = anOrder;
+ } else {
+ for(TopExp_Explorer anExp(aShape, aTA); anExp.More(); anExp.Next()) {
+ anAncestorsOrder.Bind(anExp.Current(), anOrder);
+ }
}
}
- // Map subshapes and shapes.
+ // Map sub-shapes and shapes.
TopTools_IndexedDataMapOfShapeListOfShape aMapSA;
TopExp::MapShapesAndAncestors(aShapesComp, aTS, aTA, aMapSA);
if(aMapSA.IsEmpty()) {
return aResult;
}
+ theResuts.clear();
- // Get all shapes with common subshapes and free shapes.
+ // Get all shapes with common sub-shapes and free shapes.
NCollection_Map<TopoDS_Shape> aFreeShapes;
NCollection_Vector<NCollection_Map<TopoDS_Shape>> aShapesWithCommonSubshapes;
for(TopTools_IndexedDataMapOfShapeListOfShape::Iterator
}
}
- // Combine shapes with common subshapes.
+ // Combine shapes with common sub-shapes.
for(NCollection_Vector<NCollection_Map<TopoDS_Shape>>::Iterator
anIter(aShapesWithCommonSubshapes); anIter.More(); anIter.Next()) {
TopoDS_Shell aShell;
TopoDS_CompSolid aCSolid;
TopoDS_Builder aBuilder;
+ anOrder = -1;
theType ==
GeomAPI_Shape::COMPSOLID ? aBuilder.MakeCompSolid(aCSolid) : aBuilder.MakeShell(aShell);
NCollection_Map<TopoDS_Shape>& aShapesMap = anIter.ChangeValue();
theType ==
GeomAPI_Shape::COMPSOLID ? aBuilder.Add(aCSolid, aShape) : aBuilder.Add(aShell, aShape);
aShapesMap.Remove(aShape);
+ int aThisOrder = anAncestorsOrder.Find(aShape);
+ if (anOrder == -1 || aThisOrder < anOrder)
+ anOrder = aThisOrder; // take the minimum order position
}
}
std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape);
TopoDS_Shape* aSh = theType == GeomAPI_Shape::COMPSOLID ? new TopoDS_Shape(aCSolid) :
new TopoDS_Shape(aShell);
aGeomShape->setImpl<TopoDS_Shape>(aSh);
- theCombinedShapes.push_back(aGeomShape);
+ aResCombinedShapes.push_back(aGeomShape);
+ anInputOrder[aGeomShape] = anOrder;
}
// Adding free shapes.
if(aFreeShapes.Contains(aShape)) {
std::shared_ptr<GeomAPI_Shape> aGeomShape(new GeomAPI_Shape);
aGeomShape->setImpl<TopoDS_Shape>(new TopoDS_Shape(aShape));
- theFreeShapes.push_back(aGeomShape);
+ aResFreeShapes.push_back(aGeomShape);
+ anInputOrder[aGeomShape] = anAncestorsOrder.Find(aShape);
}
}
- if(theCombinedShapes.size() == 1 && theFreeShapes.size() == 0) {
- aResult = theCombinedShapes.front();
- } else if(theCombinedShapes.size() == 0 && theFreeShapes.size() == 1) {
- aResult = theFreeShapes.front();
+ if(aResCombinedShapes.size() == 1 && aResFreeShapes.size() == 0) {
+ aResult = aResCombinedShapes.front();
+ theResuts.push_back(aResult);
+ } else if(aResCombinedShapes.size() == 0 && aResFreeShapes.size() == 1) {
+ aResult = aResFreeShapes.front();
+ theResuts.push_back(aResult);
} else {
TopoDS_Compound aResultComp;
TopoDS_Builder aBuilder;
aBuilder.MakeCompound(aResultComp);
- for(ListOfShape::const_iterator anIter = theCombinedShapes.cbegin();
- anIter != theCombinedShapes.cend(); anIter++) {
- aBuilder.Add(aResultComp, (*anIter)->impl<TopoDS_Shape>());
- }
- for(ListOfShape::const_iterator anIter = theFreeShapes.cbegin();
- anIter != theFreeShapes.cend(); anIter++) {
- aBuilder.Add(aResultComp, (*anIter)->impl<TopoDS_Shape>());
+ // put to result compound and result list in accordance to the order numbers
+ std::map<GeomShapePtr, int>::iterator anInputIter = anInputOrder.begin();
+ std::map<int, GeomShapePtr> aNums;
+ for(; anInputIter != anInputOrder.end(); anInputIter++)
+ aNums[anInputIter->second] = anInputIter->first;
+ std::map<int, GeomShapePtr>::iterator aNumsIter = aNums.begin();
+ for(; aNumsIter != aNums.end(); aNumsIter++) {
+ aBuilder.Add(aResultComp, (aNumsIter->second)->impl<TopoDS_Shape>());
+ theResuts.push_back(aNumsIter->second);
}
aResult->setImpl(new TopoDS_Shape(aResultComp));
}
}
// Iterate over the map and group shapes.
- NCollection_Vector<TopTools_ListOfShape> aGroups; // groups of shapes connected by vertices
+ NCollection_Vector<TopTools_MapOfShape> aGroups; // groups of shapes connected by vertices
while (!allVertices.IsEmpty()) {
// Get first group of shapes in map, and then unbind it.
const TopoDS_Shape& aKey = allVertices.First();
aKeysIt.Next()) {
const TopTools_ListOfShape& anOtherConnected = aVertexShapesMap(aKeysIt.Value());
if (!anOtherConnected.Contains(aConnected)) {
- // Other connected group does not containt shape from our connected group
+ // Other connected group does not contain shape from our connected group
continue;
}
// Other is connected to our, so add them to our connected
}
}
// Sort shapes from the most complicated to the simplest ones
- TopTools_ListOfShape aSortedGroup;
+ TopTools_MapOfShape aSortedGroup;
for (int aST = TopAbs_COMPOUND; aST <= TopAbs_SHAPE; ++aST) {
TopTools_ListOfShape::Iterator anIt(aConnectedShapes);
while (anIt.More()) {
if (anIt.Value().ShapeType() == aST) {
- aSortedGroup.Append(anIt.Value());
+ aSortedGroup.Add(anIt.Value());
aConnectedShapes.Remove(anIt);
}
else {
TopoDS_Compound aCompound;
BRep_Builder aBuilder;
aBuilder.MakeCompound(aCompound);
- ListOfShape aCompSolids, aFreeSolids;
- for(NCollection_Vector<NCollection_List<TopoDS_Shape>>::Iterator
- anIt(aGroups); anIt.More(); anIt.Next()) {
- NCollection_List<TopoDS_Shape> aGroup = anIt.Value();
+ ListOfShape aSolids;
+ for (NCollection_Vector<TopTools_MapOfShape>::Iterator anIt(aGroups); anIt.More(); anIt.Next()) {
+ const TopTools_MapOfShape& aGroup = anIt.ChangeValue();
GeomShapePtr aGeomShape(new GeomAPI_Shape());
if(aGroup.Size() == 1) {
- aGeomShape->setImpl(new TopoDS_Shape(aGroup.First()));
+ TopTools_MapOfShape::Iterator aOneShapeIter(aGroup);
+ aGeomShape->setImpl(new TopoDS_Shape(aOneShapeIter.Value()));
} else {
- aGeomShape->setImpl(new TopoDS_Shape(makeCompound(aGroup)));
+ // make sub-shapes in the group have order same as in original shape
+ TopTools_ListOfShape anOrderedGoup;
+ NCollection_List<TopoDS_Shape>::Iterator anUngrouped(anUngroupedShapes);
+ for (; anUngrouped.More(); anUngrouped.Next()) {
+ if (aGroup.Contains(anUngrouped.Value()))
+ anOrderedGoup.Append(anUngrouped.Value());
+ }
+ aGeomShape->setImpl(new TopoDS_Shape(makeCompound(anOrderedGoup)));
aGeomShape = GeomAlgoAPI_ShapeTools::combineShapes(aGeomShape,
GeomAPI_Shape::COMPSOLID,
- aCompSolids,
- aFreeSolids);
+ aSolids);
}
aBuilder.Add(aCompound, aGeomShape->impl<TopoDS_Shape>());
}
return aResult;
}
+//==================================================================================================
+bool GeomAlgoAPI_ShapeTools::hasSharedTopology(const ListOfShape& theShapes,
+ const GeomAPI_Shape::ShapeType theShapeType)
+{
+ TopTools_IndexedMapOfShape aSubs;
+ for (ListOfShape::const_iterator anIt = theShapes.begin(); anIt != theShapes.end(); ++anIt) {
+ TopTools_IndexedMapOfShape aCurSubs;
+ TopExp::MapShapes((*anIt)->impl<TopoDS_Shape>(), (TopAbs_ShapeEnum)theShapeType, aCurSubs);
+ for (TopTools_IndexedMapOfShape::Iterator aSubIt(aCurSubs); aSubIt.More(); aSubIt.Next()) {
+ if (aSubs.Contains(aSubIt.Value()))
+ return true;
+ else
+ aSubs.Add(aSubIt.Value());
+ }
+ }
+ return false;
+}
+
//==================================================================================================
std::list<std::shared_ptr<GeomAPI_Pnt> >
GeomAlgoAPI_ShapeTools::getBoundingBox(const ListOfShape& theShapes, const double theEnlarge)
return aResultPoints;
}
-//==================================================================================================
-std::shared_ptr<GeomAPI_Shape>
- GeomAlgoAPI_ShapeTools::faceToInfinitePlane(const std::shared_ptr<GeomAPI_Shape> theFace)
-{
- if (!theFace.get())
- return std::shared_ptr<GeomAPI_Shape>();
-
- TopoDS_Face aPlaneFace = TopoDS::Face(theFace->impl<TopoDS_Shape>());
- if (aPlaneFace.IsNull())
- return std::shared_ptr<GeomAPI_Shape>();
-
- Handle(Geom_Plane) aPlane = Handle(Geom_Plane)::DownCast(BRep_Tool::Surface(aPlaneFace));
- if (aPlane.IsNull())
- return std::shared_ptr<GeomAPI_Shape>();
-
- // make an infinity face on the plane
- TopoDS_Shape anInfiniteFace = BRepBuilderAPI_MakeFace(aPlane->Pln()).Shape();
-
- std::shared_ptr<GeomAPI_Shape> aResult(new GeomAPI_Shape);
- aResult->setImpl(new TopoDS_Shape(anInfiniteFace));
- return aResult;
-}
-
//==================================================================================================
std::shared_ptr<GeomAPI_Face> GeomAlgoAPI_ShapeTools::fitPlaneToBox(
const std::shared_ptr<GeomAPI_Shape> thePlane,
std::shared_ptr<GeomAPI_Vertex>& theV1,
std::shared_ptr<GeomAPI_Vertex>& theV2)
{
- if(!theShape.get()) {
- std::shared_ptr<GeomAPI_Vertex> aVertex(new GeomAPI_Vertex);
+ static GeomVertexPtr aVertex;
+ if (!aVertex) {
+ aVertex = GeomVertexPtr(new GeomAPI_Vertex);
aVertex->setImpl(new TopoDS_Vertex());
- theV1 = aVertex;
- theV2 = aVertex;
- return;
}
- const TopoDS_Shape& aShape = theShape->impl<TopoDS_Shape>();
- TopoDS_Vertex aV1, aV2;
- ShapeAnalysis::FindBounds(aShape, aV1, aV2);
-
- std::shared_ptr<GeomAPI_Vertex> aGeomV1(new GeomAPI_Vertex()), aGeomV2(new GeomAPI_Vertex());
- aGeomV1->setImpl(new TopoDS_Vertex(aV1));
- aGeomV2->setImpl(new TopoDS_Vertex(aV2));
- theV1 = aGeomV1;
- theV2 = aGeomV2;
+ theV1 = aVertex;
+ theV2 = aVertex;
+
+ if (theShape) {
+ const TopoDS_Shape& aShape = theShape->impl<TopoDS_Shape>();
+ TopoDS_Vertex aV1, aV2;
+ ShapeAnalysis::FindBounds(aShape, aV1, aV2);
+
+ std::shared_ptr<GeomAPI_Vertex> aGeomV1(new GeomAPI_Vertex()), aGeomV2(new GeomAPI_Vertex());
+ aGeomV1->setImpl(new TopoDS_Vertex(aV1));
+ aGeomV2->setImpl(new TopoDS_Vertex(aV2));
+ theV1 = aGeomV1;
+ theV2 = aGeomV2;
+ }
}
//==================================================================================================
}
//==================================================================================================
+#ifdef FEATURE_MULTIROTATION_TWO_DIRECTIONS
std::shared_ptr<GeomAPI_Dir> GeomAlgoAPI_ShapeTools::buildDirFromAxisAndShape(
const std::shared_ptr<GeomAPI_Shape> theBaseShape,
const std::shared_ptr<GeomAPI_Ax1> theAxis)
aCentreOfMassPoint.Z()-aPoint.Z()));
return aDir;
}
+#endif
//==================================================================================================
static TopoDS_Wire fixParametricGaps(const TopoDS_Wire& theWire)
}
return anEdge;
}
+
+ListOfShape GeomAlgoAPI_ShapeTools::getLowLevelSubShapes(const GeomShapePtr& theShape)
+{
+ ListOfShape aSubShapes;
+
+ if (!theShape->isCompound() && !theShape->isCompSolid() &&
+ !theShape->isShell() && !theShape->isWire()) {
+ return aSubShapes;
+ }
+
+ for (GeomAPI_ShapeIterator anIt(theShape); anIt.more(); anIt.next()) {
+ GeomShapePtr aSubShape = anIt.current();
+ if (aSubShape->isVertex() || aSubShape->isEdge() ||
+ aSubShape->isFace() || aSubShape->isSolid()) {
+ aSubShapes.push_back(aSubShape);
+ } else {
+ aSubShapes.splice(aSubShapes.end(), getLowLevelSubShapes(aSubShape));
+ }
+ }
+
+ return aSubShapes;
+}
\ No newline at end of file
