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

Merge from BR_new_bop4 (porting to new OCCT BOP) 13/09/2013

Browse Source
This commit is contained in:
vsr 2013-09-16 13:59:50 +00:00
parent fcc908e69c
commit b5c2a231e7
223 changed files with 2560 additions and 28203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -225,7 +225,7 @@ INCLUDE(CMakePackageConfigHelpers)
# They all have to be INSTALL'd with the option "EXPORT ${PROJECT_NAME}TargetGroup" # They all have to be INSTALL'd with the option "EXPORT ${PROJECT_NAME}TargetGroup"
SET(_${PROJECT_NAME}_exposed_targets SET(_${PROJECT_NAME}_exposed_targets
GEOMArchimede BREPExport BREPImport BlockFix GEOMbasic GEOMAlgo GEOMClient GEOMImpl GEOMArchimede BREPExport BREPImport BlockFix GEOMbasic GEOMAlgo GEOMClient GEOMImpl
GEOMUtils GEOMEngine GEOM_SupervEngine IGESExport IGESImport NMTDS NMTTools GEOMSketcher GEOMUtils GEOMEngine GEOM_SupervEngine IGESExport IGESImport GEOMSketcher
SalomeIDLGEOM STEPExport STEPImport STLExport ShHealOper SalomeIDLGEOM STEPExport STEPImport STLExport ShHealOper
) )
IF(SALOME_BUILD_GUI) IF(SALOME_BUILD_GUI)

2
adm_local/cmake_files/FindGEOM.cmake
View File

@ -48,8 +48,6 @@ FIND_LIBRARY(GroupGUI GroupGUI ${GEOM_ROOT_DIR}/lib/salome)
FIND_LIBRARY(IGESExport IGESExport ${GEOM_ROOT_DIR}/lib/salome) FIND_LIBRARY(IGESExport IGESExport ${GEOM_ROOT_DIR}/lib/salome)
FIND_LIBRARY(IGESImport IGESImport ${GEOM_ROOT_DIR}/lib/salome) FIND_LIBRARY(IGESImport IGESImport ${GEOM_ROOT_DIR}/lib/salome)
FIND_LIBRARY(MeasureGUI MeasureGUI ${GEOM_ROOT_DIR}/lib/salome) FIND_LIBRARY(MeasureGUI MeasureGUI ${GEOM_ROOT_DIR}/lib/salome)
FIND_LIBRARY(NMTDS NMTDS ${GEOM_ROOT_DIR}/lib/salome)
FIND_LIBRARY(NMTTools NMTTools ${GEOM_ROOT_DIR}/lib/salome)
FIND_LIBRARY(OCC2VTK OCC2VTK ${GEOM_ROOT_DIR}/lib/salome) FIND_LIBRARY(OCC2VTK OCC2VTK ${GEOM_ROOT_DIR}/lib/salome)
FIND_LIBRARY(OperationGUI OperationGUI ${GEOM_ROOT_DIR}/lib/salome) FIND_LIBRARY(OperationGUI OperationGUI ${GEOM_ROOT_DIR}/lib/salome)
FIND_LIBRARY(PrimitiveGUI PrimitiveGUI ${GEOM_ROOT_DIR}/lib/salome) FIND_LIBRARY(PrimitiveGUI PrimitiveGUI ${GEOM_ROOT_DIR}/lib/salome)

2
adm_local/cmake_files/SalomeGEOMConfig.cmake.in
View File

@ -120,8 +120,6 @@ SET(GEOM_GEOMEngine GEOMEngine)
SET(GEOM_GEOM_SupervEngine GEOM_SupervEngine) SET(GEOM_GEOM_SupervEngine GEOM_SupervEngine)
SET(GEOM_IGESExport IGESExport) SET(GEOM_IGESExport IGESExport)
SET(GEOM_IGESImport IGESImport) SET(GEOM_IGESImport IGESImport)
SET(GEOM_NMTDS NMTDS)
SET(GEOM_NMTTools NMTTools)
SET(GEOM_GEOMSketcher GEOMSketcher) SET(GEOM_GEOMSketcher GEOMSketcher)
SET(GEOM_SalomeIDLGeom SalomeIDLGeom) SET(GEOM_SalomeIDLGeom SalomeIDLGeom)
SET(GEOM_STEPExport STEPExport) SET(GEOM_STEPExport STEPExport)

2
src/AdvancedEngine/CMakeLists.txt
View File

@ -28,8 +28,6 @@ INCLUDE_DIRECTORIES(
${PROJECT_SOURCE_DIR}/src/GEOM ${PROJECT_SOURCE_DIR}/src/GEOM
${PROJECT_SOURCE_DIR}/src/GEOMAlgo ${PROJECT_SOURCE_DIR}/src/GEOMAlgo
${PROJECT_SOURCE_DIR}/src/GEOM_I ${PROJECT_SOURCE_DIR}/src/GEOM_I
${PROJECT_SOURCE_DIR}/src/NMTTools
${PROJECT_SOURCE_DIR}/src/NMTDS
${PROJECT_SOURCE_DIR}/src/GEOMUtils ${PROJECT_SOURCE_DIR}/src/GEOMUtils
${PROJECT_BINARY_DIR}/idl ${PROJECT_BINARY_DIR}/idl
${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}

83
src/AdvancedEngine/GEOMImpl_IAdvancedOperations.cxx
View File

@ -51,8 +51,6 @@
#include "GEOMImpl_IPipeTShape.hxx" #include "GEOMImpl_IPipeTShape.hxx"
#include "GEOMImpl_DividedDiskDriver.hxx" #include "GEOMImpl_DividedDiskDriver.hxx"
#include "GEOMImpl_IDividedDisk.hxx" #include "GEOMImpl_IDividedDisk.hxx"
// #include "GEOMImpl_DividedCylinderDriver.hxx"
// #include "GEOMImpl_IDividedCylinder.hxx"
#include <GEOMImpl_SmoothingSurfaceDriver.hxx> #include <GEOMImpl_SmoothingSurfaceDriver.hxx>
#include <GEOMImpl_ISmoothingSurface.hxx> #include <GEOMImpl_ISmoothingSurface.hxx>
/*@@ insert new functions before this line @@ do not remove this line @@ do not remove this line @@*/ /*@@ insert new functions before this line @@ do not remove this line @@ do not remove this line @@*/
@ -90,6 +88,8 @@
#include <GC_MakeConicalSurface.hxx> #include <GC_MakeConicalSurface.hxx>
#include <Geom_CylindricalSurface.hxx> #include <Geom_CylindricalSurface.hxx>
#include <ShapeAnalysis_Edge.hxx>
#include <cmath> #include <cmath>
#include "AdvancedEngine_Types.hxx" #include "AdvancedEngine_Types.hxx"
@ -1143,7 +1143,7 @@ bool GEOMImpl_IAdvancedOperations::MakePipeTShapePartition(Handle(GEOM_Object) t
// Build tools for partition operation: // Build tools for partition operation:
// 1 face and 2 planes // 1 face and 2 planes
// Face // Face
Handle(GEOM_Object) arete_intersect_int; Handle(GEOM_Object) arete_intersect_int, arete_intersect_ext;
Handle(GEOM_Object) wire_t, wire_t2, face_t, face_t2; Handle(GEOM_Object) wire_t, wire_t2, face_t, face_t2;
Handle(GEOM_Object) chan_racc; Handle(GEOM_Object) chan_racc;
Handle(GEOM_Object) vi1, vi2; Handle(GEOM_Object) vi1, vi2;
@ -1197,47 +1197,39 @@ bool GEOMImpl_IAdvancedOperations::MakePipeTShapePartition(Handle(GEOM_Object) t
return false; return false;
} }
double d1min = theR2+theW2, d2min=theR2+theW2;
for (int i = 1; i <= vertices_i->Length(); i++) { for (int i = 1; i <= vertices_i->Length(); i++) {
Handle(GEOM_Object) v = Handle(GEOM_Object)::DownCast(vertices_i->Value(i)); Handle(GEOM_Object) v = Handle(GEOM_Object)::DownCast(vertices_i->Value(i));
v->GetLastFunction()->SetDescription(""); v->GetLastFunction()->SetDescription("");
TopoDS_Vertex aVertex = TopoDS::Vertex(v->GetValue()); TopoDS_Vertex aVertex = TopoDS::Vertex(v->GetValue());
gp_Pnt aP = BRep_Tool::Pnt(aVertex); gp_Pnt aP = BRep_Tool::Pnt(aVertex);
// std::cout << "Coords: " << aP.X() << ", " << aP.Y() << ", " << aP.Z() << std::endl;
if (Abs(aP.X()) <= Precision::Confusion()) { if (Abs(aP.X()) <= Precision::Confusion()) {
if (Abs(aP.Y()) - theR1 <= Precision::Confusion()) { if (Abs(aP.Y()) < d1min) {
vi1 = v; vi1 = v;
} d1min = Abs(aP.Y());
}
} else if (Abs(aP.Y()) <= Precision::Confusion()) { } else if (Abs(aP.Y()) <= Precision::Confusion()) {
if (Abs(aP.X()) - theR1 <= Precision::Confusion()) { if (Abs(aP.X()) < d2min) {
vi2 = v; vi2 = v;
d2min = Abs(aP.X());
} }
} }
} }
if (vi1.IsNull() || vi2.IsNull()) {
SetErrorCode("Cannot find internal intersection vertices");
return false;
}
std::list<Handle(GEOM_Object)> theShapes; std::list<Handle(GEOM_Object)> theShapes;
if (isNormal) { if (isNormal) {
Handle(GEOM_Object) ve1, ve2; Handle(GEOM_Object) ve1, ve2;
TopoDS_Vertex vertex1, vertex2;
Handle(GEOM_Object) box_e = my3DPrimOperations->MakeBoxDXDYDZ(aR2Ext, aR2Ext, aR1Ext); Handle(GEOM_Object) box_e = my3DPrimOperations->MakeBoxDXDYDZ(aR2Ext, aR2Ext, aR1Ext);
box_e->GetLastFunction()->SetDescription(""); box_e->GetLastFunction()->SetDescription("");
box_e = myTransformOperations->TranslateDXDYDZ(box_e, -aR2Ext, -aR2Ext, 0); box_e = myTransformOperations->TranslateDXDYDZ(box_e, -aR2Ext, -aR2Ext, 0);
box_e->GetLastFunction()->SetDescription(""); box_e->GetLastFunction()->SetDescription("");
// Common edges on external cylinder
aFunction = theShape->GetLastFunction();
theDesc = aFunction->GetDescription();
Handle(TColStd_HSequenceOfTransient) edges_e =
myShapesOperations->GetShapesOnBox(box_e, theShape, TopAbs_EDGE, GEOMAlgo_ST_IN);
// Recover previous description to get rid of Propagate dump
aFunction->SetDescription(theDesc);
if (edges_e.IsNull() || edges_e->Length() == 0) {
SetErrorCode("External edges not found");
return false;
}
for (int i=1; i<=edges_e->Length();i++) {
Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(edges_e->Value(i));
anObj->GetLastFunction()->SetDescription("");
}
// search for vertices located on both external pipes // search for vertices located on both external pipes
aFunction = theShape->GetLastFunction(); aFunction = theShape->GetLastFunction();
@ -1251,26 +1243,55 @@ bool GEOMImpl_IAdvancedOperations::MakePipeTShapePartition(Handle(GEOM_Object) t
return false; return false;
} }
double d1max = 0, d2max = 0;
for (int i = 1; i <= vertices_e->Length(); i++) { for (int i = 1; i <= vertices_e->Length(); i++) {
Handle(GEOM_Object) v = Handle(GEOM_Object)::DownCast(vertices_e->Value(i)); Handle(GEOM_Object) v = Handle(GEOM_Object)::DownCast(vertices_e->Value(i));
v->GetLastFunction()->SetDescription(""); v->GetLastFunction()->SetDescription("");
TopoDS_Vertex aVertex = TopoDS::Vertex(v->GetValue()); TopoDS_Vertex aVertex = TopoDS::Vertex(v->GetValue());
gp_Pnt aP = BRep_Tool::Pnt(aVertex); gp_Pnt aP = BRep_Tool::Pnt(aVertex);
// std::cout << "Coords: " << aP.X() << ", " << aP.Y() << ", " << aP.Z() << std::endl;
if (Abs(aP.X()) <= Precision::Confusion()) { if (Abs(aP.X()) <= Precision::Confusion()) {
if (Abs(aP.Y()) - theR2 > Precision::Confusion()) { if (Abs(aP.Y()) > d1max) {
ve1 = v; ve1 = v;
vertex1 = aVertex;
d1max = Abs(aP.Y());
} }
} else if (Abs(aP.Y()) <= Precision::Confusion()) { } else if (Abs(aP.Y()) <= Precision::Confusion()) {
if (Abs(aP.X()) - theR2 > Precision::Confusion()) { if (Abs(aP.X()) > d2max) {
ve2 = v; ve2 = v;
vertex2 = aVertex;
d2max = Abs(aP.X());
} }
} }
if ( !ve1.IsNull() && !ve2.IsNull()) }
break; if (ve1.IsNull() || ve2.IsNull()) {
SetErrorCode("Cannot find external intersection vertices");
return false;
} }
Handle(GEOM_Object) edge_e1, edge_e2; Handle(GEOM_Object) edge_e1, edge_e2;
// Common edges on external cylinder
aFunction = theShape->GetLastFunction();
theDesc = aFunction->GetDescription();
Handle(TColStd_HSequenceOfTransient) edges_e =
myShapesOperations->GetShapesOnBox(box_e, theShape, TopAbs_EDGE, GEOMAlgo_ST_IN);
// Recover previous description to get rid of Propagate dump
aFunction->SetDescription(theDesc);
if (edges_e.IsNull() || edges_e->Length() == 0) {
SetErrorCode("External edges not found");
return false;
}
ShapeAnalysis_Edge sae;
for (int i=1; i<=edges_e->Length();i++) {
Handle(GEOM_Object) anObj = Handle(GEOM_Object)::DownCast(edges_e->Value(i));
anObj->GetLastFunction()->SetDescription("");
TopoDS_Edge anEdge = TopoDS::Edge(anObj->GetValue());
if ( !anEdge.IsNull() &&
(sae.FirstVertex(anEdge).IsSame(vertex1) || sae.LastVertex(anEdge).IsSame(vertex1)) &&
(sae.FirstVertex(anEdge).IsSame(vertex2) || sae.LastVertex(anEdge).IsSame(vertex2))) {
arete_intersect_ext = anObj;
}
}
edge_e1 = myBasicOperations->MakeLineTwoPnt(ve1, vi1); edge_e1 = myBasicOperations->MakeLineTwoPnt(ve1, vi1);
if (edge_e1.IsNull()) { if (edge_e1.IsNull()) {
SetErrorCode("Edge 1 could not be built"); SetErrorCode("Edge 1 could not be built");
@ -1289,7 +1310,7 @@ bool GEOMImpl_IAdvancedOperations::MakePipeTShapePartition(Handle(GEOM_Object) t
std::list<Handle(GEOM_Object)> edge_e_elist; std::list<Handle(GEOM_Object)> edge_e_elist;
edge_e_elist.push_back(arete_intersect_int); edge_e_elist.push_back(arete_intersect_int);
edge_e_elist.push_back(edge_e1); edge_e_elist.push_back(edge_e1);
edge_e_elist.push_back(Handle(GEOM_Object)::DownCast(edges_e->Value(1))); edge_e_elist.push_back(arete_intersect_ext);
edge_e_elist.push_back(edge_e2); edge_e_elist.push_back(edge_e2);
wire_t = myShapesOperations->MakeWire(edge_e_elist, 1e-7); wire_t = myShapesOperations->MakeWire(edge_e_elist, 1e-7);
if (wire_t.IsNull()) { if (wire_t.IsNull()) {
@ -1903,9 +1924,9 @@ TopoDS_Shape GEOMImpl_IAdvancedOperations::MakeThicknessReduction (gp_Ax2 theAxe
TopoDS_Shape aTool2 = BRepBuilderAPI_MakeFace(aPln2, -aSize, +aSize, -aSize, +aSize).Shape(); TopoDS_Shape aTool2 = BRepBuilderAPI_MakeFace(aPln2, -aSize, +aSize, -aSize, +aSize).Shape();
GEOMAlgo_Splitter PS; GEOMAlgo_Splitter PS;
PS.AddShape(aReduction); PS.AddArgument(aReduction);
if (isThinPart) if (isThinPart)
PS.AddShape(aThinPart); PS.AddArgument(aThinPart);
PS.AddTool(aTool1); PS.AddTool(aTool1);
PS.AddTool(aTool2); PS.AddTool(aTool2);
PS.SetLimit(TopAbs_SOLID); PS.SetLimit(TopAbs_SOLID);

2
src/CMakeLists.txt
View File

@ -21,7 +21,7 @@
# Common packages # Common packages
## ##
SET(SUBDIRS_COMMON SET(SUBDIRS_COMMON
ARCHIMEDE NMTDS NMTTools BlockFix GEOMAlgo SKETCHER GEOM BREPExport ARCHIMEDE BlockFix GEOMAlgo SKETCHER GEOM BREPExport
BREPImport IGESExport IGESImport STEPExport STEPImport STLExport BREPImport IGESExport IGESImport STEPExport STEPImport STLExport
ShHealOper GEOMUtils GEOMImpl GEOM_I GEOMClient GEOM_I_Superv GEOM_SWIG GEOM_PY ShHealOper GEOMUtils GEOMImpl GEOM_I GEOMClient GEOM_I_Superv GEOM_SWIG GEOM_PY
) )

77
src/GEOMAlgo/CMakeLists.txt
View File

@ -23,8 +23,6 @@
INCLUDE_DIRECTORIES( INCLUDE_DIRECTORIES(
${CAS_INCLUDE_DIRS} ${CAS_INCLUDE_DIRS}
${KERNEL_INCLUDE_DIRS} ${KERNEL_INCLUDE_DIRS}
${PROJECT_SOURCE_DIR}/src/NMTTools
${PROJECT_SOURCE_DIR}/src/NMTDS
${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}
) )
@ -37,54 +35,42 @@ ADD_DEFINITIONS(
SET(_link_LIBRARIES SET(_link_LIBRARIES
${CAS_KERNEL} ${CAS_TKBool} ${CAS_BO} ${CAS_TKMesh} ${CAS_KERNEL} ${CAS_TKBool} ${CAS_BO} ${CAS_TKMesh}
${KERNEL_SALOMELocalTrace} ${KERNEL_SALOMELocalTrace}
NMTTools NMTDS
) )
# --- headers --- # --- headers ---
SET(GEOMAlgo_HEADERS SET(GEOMAlgo_HEADERS
GEOMAlgo_Algo.hxx GEOMAlgo_Algo.hxx
GEOMAlgo_BuilderArea.hxx GEOMAlgo_AlgoTools.hxx
GEOMAlgo_BuilderFace.hxx GEOMAlgo_BndSphere.hxx
GEOMAlgo_Builder.hxx GEOMAlgo_BndSphereTree.hxx
GEOMAlgo_BoxBndTree.hxx
GEOMAlgo_BuilderShape.hxx GEOMAlgo_BuilderShape.hxx
GEOMAlgo_BuilderSolid.hxx
GEOMAlgo_BuilderTools.hxx
GEOMAlgo_ClsfBox.hxx
GEOMAlgo_Clsf.hxx GEOMAlgo_Clsf.hxx
GEOMAlgo_ClsfBox.hxx
GEOMAlgo_ClsfSolid.hxx GEOMAlgo_ClsfSolid.hxx
GEOMAlgo_ClsfSurf.hxx GEOMAlgo_ClsfSurf.hxx
GEOMAlgo_CoupleOfShapes.hxx GEOMAlgo_CoupleOfShapes.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfOrientedShapeShape.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyInteger.hxx GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyInteger.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyShapeShape.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfRealListOfShape.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfShapeMapOfShape.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfShapePnt.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfShapeReal.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet.hxx
GEOMAlgo_DataMapOfOrientedShapeShape.hxx
GEOMAlgo_DataMapOfPassKeyInteger.hxx GEOMAlgo_DataMapOfPassKeyInteger.hxx
GEOMAlgo_DataMapOfPassKeyShapeShape.hxx
GEOMAlgo_DataMapOfRealListOfShape.hxx
GEOMAlgo_DataMapOfShapeMapOfShape.hxx GEOMAlgo_DataMapOfShapeMapOfShape.hxx
GEOMAlgo_DataMapOfShapePnt.hxx GEOMAlgo_DataMapOfShapePnt.hxx
GEOMAlgo_DataMapOfShapeReal.hxx GEOMAlgo_FinderShapeOn.hxx
GEOMAlgo_DataMapOfShapeShapeSet.hxx
GEOMAlgo_FinderShapeOn1.hxx GEOMAlgo_FinderShapeOn1.hxx
GEOMAlgo_FinderShapeOn2.hxx GEOMAlgo_FinderShapeOn2.hxx
GEOMAlgo_FinderShapeOn.hxx
GEOMAlgo_FinderShapeOnQuad.hxx GEOMAlgo_FinderShapeOnQuad.hxx
GEOMAlgo_GetInPlace.hxx GEOMAlgo_GetInPlace.hxx
GEOMAlgo_GlueAnalyser.hxx GEOMAlgo_GlueAnalyser.hxx
GEOMAlgo_GlueDetector.hxx GEOMAlgo_GlueDetector.hxx
GEOMAlgo_Gluer.hxx
GEOMAlgo_Gluer2.hxx GEOMAlgo_Gluer2.hxx
GEOMAlgo_GluerAlgo.hxx GEOMAlgo_GluerAlgo.hxx
GEOMAlgo_Gluer.hxx
GEOMAlgo_HAlgo.hxx GEOMAlgo_HAlgo.hxx
GEOMAlgo_IndexedDataMapOfIntegerShape.hxx GEOMAlgo_IndexedDataMapOfIntegerShape.hxx
GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx
GEOMAlgo_IndexedDataMapOfShapeBndSphere.hxx
GEOMAlgo_IndexedDataMapOfShapeBox.hxx GEOMAlgo_IndexedDataMapOfShapeBox.hxx
GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape.hxx
GEOMAlgo_IndexedDataMapOfShapeShapeInfo.hxx GEOMAlgo_IndexedDataMapOfShapeShapeInfo.hxx
GEOMAlgo_IndexedDataMapOfShapeState.hxx GEOMAlgo_IndexedDataMapOfShapeState.hxx
GEOMAlgo_KindOfBounds.hxx GEOMAlgo_KindOfBounds.hxx
@ -99,65 +85,52 @@ SET(GEOMAlgo_HEADERS
GEOMAlgo_PassKeyMapHasher.hxx GEOMAlgo_PassKeyMapHasher.hxx
GEOMAlgo_PassKeyShape.hxx GEOMAlgo_PassKeyShape.hxx
GEOMAlgo_PassKeyShapeMapHasher.hxx GEOMAlgo_PassKeyShapeMapHasher.hxx
GEOMAlgo_PWireEdgeSet.hxx
GEOMAlgo_RemoverWebs.hxx GEOMAlgo_RemoverWebs.hxx
GEOMAlgo_ShapeAlgo.hxx GEOMAlgo_ShapeAlgo.hxx
GEOMAlgo_ShapeInfo.hxx GEOMAlgo_ShapeInfo.hxx
GEOMAlgo_ShapeInfoFiller.hxx GEOMAlgo_ShapeInfoFiller.hxx
GEOMAlgo_ShapeSet.hxx
GEOMAlgo_ShapeSolid.hxx GEOMAlgo_ShapeSolid.hxx
GEOMAlgo_ShellSolid.hxx GEOMAlgo_ShellSolid.hxx
GEOMAlgo_SolidSolid.hxx GEOMAlgo_SolidSolid.hxx
GEOMAlgo_Splitter.hxx GEOMAlgo_Splitter.hxx
GEOMAlgo_StateCollector.hxx
GEOMAlgo_State.hxx GEOMAlgo_State.hxx
GEOMAlgo_StateCollector.hxx
GEOMAlgo_SurfaceTools.hxx GEOMAlgo_SurfaceTools.hxx
GEOMAlgo_Tools3D.hxx
GEOMAlgo_Tools.hxx
GEOMAlgo_VertexSolid.hxx GEOMAlgo_VertexSolid.hxx
GEOMAlgo_WESCorrector.hxx
GEOMAlgo_WESScaler.hxx
GEOMAlgo_WireEdgeSet.hxx
GEOMAlgo_WireSolid.hxx GEOMAlgo_WireSolid.hxx
GEOMAlgo_WireSplitter.hxx
) )
# --- sources --- # --- sources ---
SET(GEOMAlgo_SOURCES SET(GEOMAlgo_SOURCES
GEOMAlgo_Algo.cxx GEOMAlgo_Algo.cxx
GEOMAlgo_Builder_0.cxx GEOMAlgo_AlgoTools.cxx
GEOMAlgo_Builder_1.cxx GEOMAlgo_AlgoTools_1.cxx
GEOMAlgo_Builder_2.cxx GEOMAlgo_BndSphere.cxx
GEOMAlgo_Builder_3.cxx GEOMAlgo_BndSphereTree.cxx
GEOMAlgo_Builder_4.cxx GEOMAlgo_BoxBndTree.cxx
GEOMAlgo_BuilderArea.cxx
GEOMAlgo_Builder.cxx
GEOMAlgo_BuilderFace.cxx
GEOMAlgo_BuilderShape.cxx GEOMAlgo_BuilderShape.cxx
GEOMAlgo_BuilderSolid.cxx
GEOMAlgo_BuilderTools.cxx
GEOMAlgo_ClsfBox.cxx
GEOMAlgo_Clsf.cxx GEOMAlgo_Clsf.cxx
GEOMAlgo_ClsfBox.cxx
GEOMAlgo_ClsfSolid.cxx GEOMAlgo_ClsfSolid.cxx
GEOMAlgo_ClsfSurf.cxx GEOMAlgo_ClsfSurf.cxx
GEOMAlgo_CoupleOfShapes.cxx GEOMAlgo_CoupleOfShapes.cxx
GEOMAlgo_FinderShapeOn.cxx
GEOMAlgo_FinderShapeOn1.cxx GEOMAlgo_FinderShapeOn1.cxx
GEOMAlgo_FinderShapeOn2.cxx GEOMAlgo_FinderShapeOn2.cxx
GEOMAlgo_FinderShapeOn.cxx
GEOMAlgo_FinderShapeOnQuad.cxx GEOMAlgo_FinderShapeOnQuad.cxx
GEOMAlgo_GetInPlace.cxx
GEOMAlgo_GetInPlace_1.cxx GEOMAlgo_GetInPlace_1.cxx
GEOMAlgo_GetInPlace_2.cxx GEOMAlgo_GetInPlace_2.cxx
GEOMAlgo_GetInPlace_3.cxx GEOMAlgo_GetInPlace_3.cxx
GEOMAlgo_GetInPlace.cxx
GEOMAlgo_GlueAnalyser.cxx GEOMAlgo_GlueAnalyser.cxx
GEOMAlgo_GlueDetector.cxx GEOMAlgo_GlueDetector.cxx
GEOMAlgo_Gluer.cxx
GEOMAlgo_Gluer2.cxx
GEOMAlgo_Gluer2_1.cxx GEOMAlgo_Gluer2_1.cxx
GEOMAlgo_Gluer2_2.cxx GEOMAlgo_Gluer2_2.cxx
GEOMAlgo_Gluer2_3.cxx GEOMAlgo_Gluer2_3.cxx
GEOMAlgo_Gluer2.cxx
GEOMAlgo_GluerAlgo.cxx GEOMAlgo_GluerAlgo.cxx
GEOMAlgo_Gluer.cxx
GEOMAlgo_HAlgo.cxx GEOMAlgo_HAlgo.cxx
GEOMAlgo_PassKey.cxx GEOMAlgo_PassKey.cxx
GEOMAlgo_PassKeyMapHasher.cxx GEOMAlgo_PassKeyMapHasher.cxx
@ -166,24 +139,16 @@ SET(GEOMAlgo_SOURCES
GEOMAlgo_RemoverWebs.cxx GEOMAlgo_RemoverWebs.cxx
GEOMAlgo_ShapeAlgo.cxx GEOMAlgo_ShapeAlgo.cxx
GEOMAlgo_ShapeInfo.cxx GEOMAlgo_ShapeInfo.cxx
GEOMAlgo_ShapeInfoFiller_1.cxx
GEOMAlgo_ShapeInfoFiller.cxx GEOMAlgo_ShapeInfoFiller.cxx
GEOMAlgo_ShapeSet.cxx GEOMAlgo_ShapeInfoFiller_1.cxx
GEOMAlgo_ShapeSolid.cxx GEOMAlgo_ShapeSolid.cxx
GEOMAlgo_ShellSolid.cxx GEOMAlgo_ShellSolid.cxx
GEOMAlgo_SolidSolid.cxx GEOMAlgo_SolidSolid.cxx
GEOMAlgo_Splitter.cxx GEOMAlgo_Splitter.cxx
GEOMAlgo_StateCollector.cxx GEOMAlgo_StateCollector.cxx
GEOMAlgo_SurfaceTools.cxx GEOMAlgo_SurfaceTools.cxx
GEOMAlgo_Tools_1.cxx
GEOMAlgo_Tools3D.cxx
GEOMAlgo_Tools.cxx
GEOMAlgo_VertexSolid.cxx GEOMAlgo_VertexSolid.cxx
GEOMAlgo_WESCorrector.cxx
GEOMAlgo_WESScaler.cxx
GEOMAlgo_WireEdgeSet.cxx
GEOMAlgo_WireSolid.cxx GEOMAlgo_WireSolid.cxx
GEOMAlgo_WireSplitter.cxx
) )
# --- rules --- # --- rules ---

221
src/GEOMAlgo/FILES
View File

@ -1,145 +1,110 @@
GEOMAlgo_Builder_0.cxx GEOMAlgo_Algo.hxx
GEOMAlgo_Builder_1.cxx GEOMAlgo_Algo.cxx
GEOMAlgo_Builder_2.cxx GEOMAlgo_ShapeSolid.hxx
GEOMAlgo_Builder_3.cxx GEOMAlgo_ShapeSolid.cxx
GEOMAlgo_Builder_4.cxx
GEOMAlgo_ShapeInfoFiller_1.cxx
GEOMAlgo_Tools_1.cxx
GEOMAlgo_Gluer2.hxx
GEOMAlgo_Gluer2.cxx
GEOMAlgo_Gluer2_1.cxx
GEOMAlgo_Gluer2_2.cxx
GEOMAlgo_Gluer2_3.cxx
GEOMAlgo_GluerAlgo.hxx
GEOMAlgo_GluerAlgo.cxx
GEOMAlgo_GlueDetector.hxx
GEOMAlgo_GlueDetector.cxx
GEOMAlgo_GetInPlace.hxx
GEOMAlgo_GetInPlace.cxx
GEOMAlgo_GetInPlace_1.cxx
GEOMAlgo_GetInPlace_2.cxx
GEOMAlgo_GetInPlace_3.cxx
GEOMAlgo_FinderShapeOnQuad.hxx
GEOMAlgo_FinderShapeOnQuad.cxx
GEOMAlgo_WireSplitter.hxx
GEOMAlgo_WireSplitter.cxx
GEOMAlgo_WESScaler.hxx
GEOMAlgo_WESScaler.cxx
GEOMAlgo_WESCorrector.hxx
GEOMAlgo_WESCorrector.cxx
GEOMAlgo_WireEdgeSet.hxx
GEOMAlgo_WireEdgeSet.cxx
GEOMAlgo_GlueAnalyser.hxx
GEOMAlgo_GlueAnalyser.cxx
GEOMAlgo_Gluer.hxx
GEOMAlgo_Gluer.cxx
GEOMAlgo_FinderShapeOn2.hxx
GEOMAlgo_FinderShapeOn2.cxx
GEOMAlgo_FinderShapeOn1.hxx
GEOMAlgo_FinderShapeOn1.cxx
GEOMAlgo_FinderShapeOn.hxx
GEOMAlgo_FinderShapeOn.cxx
GEOMAlgo_ShapeAlgo.hxx
GEOMAlgo_ShapeAlgo.cxx
GEOMAlgo_SolidSolid.hxx
GEOMAlgo_SolidSolid.cxx
GEOMAlgo_ShellSolid.hxx
GEOMAlgo_ShellSolid.cxx
GEOMAlgo_VertexSolid.hxx GEOMAlgo_VertexSolid.hxx
GEOMAlgo_VertexSolid.cxx GEOMAlgo_VertexSolid.cxx
GEOMAlgo_WireSolid.hxx GEOMAlgo_WireSolid.hxx
GEOMAlgo_WireSolid.cxx GEOMAlgo_WireSolid.cxx
GEOMAlgo_ShapeSolid.hxx GEOMAlgo_ShellSolid.hxx
GEOMAlgo_ShapeSolid.cxx GEOMAlgo_ShellSolid.cxx
GEOMAlgo_Splitter.hxx GEOMAlgo_AlgoTools.hxx
GEOMAlgo_Splitter.cxx GEOMAlgo_AlgoTools.cxx
GEOMAlgo_Builder.hxx GEOMAlgo_AlgoTools_1.cxx
GEOMAlgo_Builder.cxx GEOMAlgo_AlgoTools_2.cxx
GEOMAlgo_BuilderShape.hxx GEOMAlgo_SolidSolid.hxx
GEOMAlgo_BuilderShape.cxx GEOMAlgo_SolidSolid.cxx
GEOMAlgo_BuilderArea.hxx GEOMAlgo_ShapeAlgo.hxx
GEOMAlgo_BuilderArea.cxx GEOMAlgo_ShapeAlgo.cxx
GEOMAlgo_BuilderFace.hxx GEOMAlgo_FinderShapeOn.hxx
GEOMAlgo_BuilderFace.cxx GEOMAlgo_FinderShapeOn.cxx
GEOMAlgo_BuilderSolid.hxx GEOMAlgo_FinderShapeOn1.hxx
GEOMAlgo_BuilderSolid.cxx GEOMAlgo_FinderShapeOn1.cxx
GEOMAlgo_ShapeInfoFiller.hxx GEOMAlgo_HAlgo.hxx
GEOMAlgo_ShapeInfoFiller.cxx GEOMAlgo_HAlgo.cxx
GEOMAlgo_Algo.hxx GEOMAlgo_Clsf.hxx
GEOMAlgo_Algo.cxx GEOMAlgo_Clsf.cxx
GEOMAlgo_ShapeSet.hxx
GEOMAlgo_ShapeSet.cxx
GEOMAlgo_SurfaceTools.hxx
GEOMAlgo_SurfaceTools.cxx
GEOMAlgo_State.hxx
GEOMAlgo_KindOfBounds.hxx
GEOMAlgo_KindOfClosed.hxx
GEOMAlgo_KindOfName.hxx
GEOMAlgo_KindOfShape.hxx
GEOMAlgo_ShapeInfo.hxx
GEOMAlgo_ShapeInfo.cxx
GEOMAlgo_CoupleOfShapes.hxx
GEOMAlgo_CoupleOfShapes.cxx
GEOMAlgo_BuilderTools.hxx
GEOMAlgo_BuilderTools.cxx
GEOMAlgo_Tools3D.hxx
GEOMAlgo_Tools3D.cxx
GEOMAlgo_Tools.hxx
GEOMAlgo_Tools.cxx
GEOMAlgo_PWireEdgeSet.hxx
GEOMAlgo_StateCollector.cxx
GEOMAlgo_StateCollector.hxx
GEOMAlgo_PassKey.hxx
GEOMAlgo_PassKey.cxx
GEOMAlgo_PassKeyMapHasher.hxx
GEOMAlgo_PassKeyMapHasher.cxx
GEOMAlgo_PassKeyShape.hxx
GEOMAlgo_PassKeyShape.cxx
GEOMAlgo_PassKeyShapeMapHasher.hxx
GEOMAlgo_PassKeyShapeMapHasher.cxx
GEOMAlgo_ClsfBox.hxx GEOMAlgo_ClsfBox.hxx
GEOMAlgo_ClsfBox.cxx GEOMAlgo_ClsfBox.cxx
GEOMAlgo_ClsfSolid.hxx GEOMAlgo_ClsfSolid.hxx
GEOMAlgo_ClsfSolid.cxx GEOMAlgo_ClsfSolid.cxx
GEOMAlgo_ClsfSurf.hxx GEOMAlgo_ClsfSurf.hxx
GEOMAlgo_ClsfSurf.cxx GEOMAlgo_ClsfSurf.cxx
GEOMAlgo_Clsf.hxx GEOMAlgo_FinderShapeOn2.hxx
GEOMAlgo_Clsf.cxx GEOMAlgo_FinderShapeOn2.cxx
GEOMAlgo_HAlgo.hxx GEOMAlgo_FinderShapeOnQuad.hxx
GEOMAlgo_HAlgo.cxx GEOMAlgo_FinderShapeOnQuad.cxx
GEOMAlgo_Gluer.hxx
GEOMAlgo_Gluer.cxx
GEOMAlgo_GlueAnalyser.hxx
GEOMAlgo_GlueAnalyser.cxx
GEOMAlgo_GluerAlgo.hxx
GEOMAlgo_GluerAlgo.cxx
GEOMAlgo_GlueDetector.hxx
GEOMAlgo_GlueDetector.cxx
GEOMAlgo_BuilderShape.hxx
GEOMAlgo_BuilderShape.cxx
GEOMAlgo_Gluer2.hxx
GEOMAlgo_Gluer2.cxx
GEOMAlgo_Gluer2_1.cxx
GEOMAlgo_Gluer2_2.cxx
GEOMAlgo_Gluer2_3.cxx
GEOMAlgo_GetInPlace.hxx
GEOMAlgo_GetInPlace.cxx
GEOMAlgo_GetInPlace_1.cxx
GEOMAlgo_GetInPlace_2.cxx
GEOMAlgo_GetInPlace_3.cxx
GEOMAlgo_Splitter.hxx
GEOMAlgo_Splitter.cxx
GEOMAlgo_ShapeInfoFiller.hxx
GEOMAlgo_ShapeInfoFiller.cxx
GEOMAlgo_ShapeInfoFiller_1.cxx
GEOMAlgo_RemoverWebs.hxx GEOMAlgo_PassKeyShape.hxx
GEOMAlgo_RemoverWebs.cxx GEOMAlgo_PassKeyShape.cxx
GEOMAlgo_PassKeyShapeMapHasher.hxx
GEOMAlgo_ListOfCoupleOfShapes.hxx GEOMAlgo_PassKeyShapeMapHasher.cxx
GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx GEOMAlgo_IndexedDataMapOfShapeState.hxx
GEOMAlgo_State.hxx
GEOMAlgo_SurfaceTools.hxx
GEOMAlgo_SurfaceTools.cxx
GEOMAlgo_ListOfPnt.hxx GEOMAlgo_ListOfPnt.hxx
GEOMAlgo_ListIteratorOfListOfPnt.hxx GEOMAlgo_ListIteratorOfListOfPnt.hxx
GEOMAlgo_DataMapOfShapeShapeSet.hxx GEOMAlgo_StateCollector.cxx
GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet.hxx GEOMAlgo_StateCollector.hxx
GEOMAlgo_DataMapOfShapeReal.hxx GEOMAlgo_PassKey.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfShapeReal.hxx GEOMAlgo_PassKey.cxx
GEOMAlgo_DataMapOfRealListOfShape.hxx GEOMAlgo_PassKeyMapHasher.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfRealListOfShape.hxx GEOMAlgo_PassKeyMapHasher.cxx
GEOMAlgo_RemoverWebs.hxx
GEOMAlgo_RemoverWebs.cxx
GEOMAlgo_DataMapOfPassKeyInteger.hxx GEOMAlgo_DataMapOfPassKeyInteger.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyInteger.hxx GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyInteger.hxx
GEOMAlgo_DataMapOfPassKeyShapeShape.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyShapeShape.hxx
GEOMAlgo_DataMapOfOrientedShapeShape.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfOrientedShapeShape.hxx
GEOMAlgo_DataMapOfShapeMapOfShape.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfShapeMapOfShape.hxx
GEOMAlgo_DataMapOfShapePnt.hxx
GEOMAlgo_DataMapIteratorOfDataMapOfShapePnt.hxx
GEOMAlgo_IndexedDataMapOfShapeBox.hxx
GEOMAlgo_IndexedDataMapOfShapeShapeInfo.hxx
GEOMAlgo_IndexedDataMapOfShapeState.hxx
GEOMAlgo_IndexedDataMapOfIntegerShape.hxx GEOMAlgo_IndexedDataMapOfIntegerShape.hxx
GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx
GEOMAlgo_IndexedDataMapOfShapeBox.hxx
GEOMAlgo_CoupleOfShapes.hxx
GEOMAlgo_CoupleOfShapes.cxx
GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx
GEOMAlgo_ListOfCoupleOfShapes.hxx
GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape.hxx
GEOMAlgo_DataMapOfShapeMapOfShape.hxx
GEOMAlgo_DataMapOfShapePnt.hxx
GEOMAlgo_BndSphere.hxx
GEOMAlgo_BndSphere.cxx
GEOMAlgo_BndSphere.lxx
GEOMAlgo_IndexedDataMapOfShapeBndSphere.hxx
GEOMAlgo_BndSphereTree.hxx
GEOMAlgo_BndSphereTree.cxx
GEOMAlgo_BoxBndTree.hxx
GEOMAlgo_BoxBndTree.cxx
GEOMAlgo_KindOfBounds.hxx
GEOMAlgo_KindOfClosed.hxx
GEOMAlgo_KindOfName.hxx
GEOMAlgo_KindOfShape.hxx
GEOMAlgo_ShapeInfo.hxx
GEOMAlgo_ShapeInfo.cxx
GEOMAlgo_IndexedDataMapOfShapeShapeInfo.hxx
Basics_OCCTVersion.hxx

137
src/GEOMAlgo/GEOMAlgo.cdl
View File

@ -27,26 +27,7 @@ package GEOMAlgo
---Purpose: ---Purpose:
uses --uses
TCollection,
TColgp,
Geom,
Bnd,
gp,
GeomAdaptor,
TopAbs,
TopoDS,
TopTools,
IntTools,
BOPTools,
BOP,
TColStd,
BOPTColStd,
BRepAlgo,
NMTDS,
NMTTools
is is
-- Enumerations -- Enumerations
@ -56,72 +37,96 @@ is
imported KindOfBounds from GEOMAlgo; imported KindOfBounds from GEOMAlgo;
imported KindOfClosed from GEOMAlgo; imported KindOfClosed from GEOMAlgo;
-- --
-- Gluer / GetInPlace
imported Gluer2 from GEOMAlgo;
imported GlueDetector from GEOMAlgo;
imported GluerAlgo from GEOMAlgo;
imported GetInPlace from GEOMAlgo;
-- Algos -- Algos
imported RemoverWebs from GEOMAlgo; --
imported WireSplitter from GEOMAlgo; imported Algo from GEOMAlgo;
imported WESScaler from GEOMAlgo; imported ShapeSolid from GEOMAlgo;
imported WESCorrector from GEOMAlgo;
imported WireEdgeSet from GEOMAlgo;
imported GlueAnalyser from GEOMAlgo;
imported Gluer from GEOMAlgo;
imported FinderShapeOn2 from GEOMAlgo;
imported FinderShapeOn1 from GEOMAlgo;
imported FinderShapeOn from GEOMAlgo;
imported ShapeAlgo from GEOMAlgo;
imported SolidSolid from GEOMAlgo;
imported ShellSolid from GEOMAlgo;
imported VertexSolid from GEOMAlgo; imported VertexSolid from GEOMAlgo;
imported WireSolid from GEOMAlgo; imported WireSolid from GEOMAlgo;
imported ShapeSolid from GEOMAlgo; imported ShellSolid from GEOMAlgo;
imported Splitter from GEOMAlgo; imported SolidSolid from GEOMAlgo;
imported Builder from GEOMAlgo; imported FinderShapeOn from GEOMAlgo;
imported FinderShapeOn1 from GEOMAlgo;
imported HAlgo from GEOMAlgo;
imported ShapeAlgo from GEOMAlgo;
imported Clsf from GEOMAlgo;
imported ClsfBox from GEOMAlgo;
imported ClsfSurf from GEOMAlgo;
imported ClsfSolid from GEOMAlgo;
imported FinderShapeOn2 from GEOMAlgo;
imported FinderShapeOnQuad from GEOMAlgo;
imported Gluer from GEOMAlgo;
imported GlueAnalyser from GEOMAlgo;
imported GluerAlgo from GEOMAlgo;
imported GlueDetector from GEOMAlgo;
imported BuilderShape from GEOMAlgo; imported BuilderShape from GEOMAlgo;
imported BuilderSolid from GEOMAlgo; imported Gluer2 from GEOMAlgo;
imported BuilderFace from GEOMAlgo; imported GetInPlace from GEOMAlgo;
imported BuilderArea from GEOMAlgo; imported Splitter from GEOMAlgo;
--
--
imported AlgoTools from GEOMAlgo;
-- Gluer / GetInPlace
--
--
-- Algos
imported RemoverWebs from GEOMAlgo;
--imported WireSplitter from GEOMAlgo;
--imported WESScaler from GEOMAlgo;
--imported WESCorrector from GEOMAlgo;
--imported WireEdgeSet from GEOMAlgo;
--imported GlueAnalyser from GEOMAlgo;
--imported Gluer from GEOMAlgo;
--
--imported Splitter from GEOMAlgo;
--imported Builder from GEOMAlgo;
--imported BuilderSolid from GEOMAlgo;
--imported BuilderFace from GEOMAlgo;
--imported BuilderArea from GEOMAlgo;
imported ShapeInfoFiller from GEOMAlgo; imported ShapeInfoFiller from GEOMAlgo;
imported Algo from GEOMAlgo; --
-- Data / Tools -- Data / Tools
imported ShapeSet from GEOMAlgo; --imported ShapeSet from GEOMAlgo;
imported SurfaceTools from GEOMAlgo; imported SurfaceTools from GEOMAlgo;
imported ShapeInfo from GEOMAlgo; imported ShapeInfo from GEOMAlgo;
imported CoupleOfShapes from GEOMAlgo; imported CoupleOfShapes from GEOMAlgo;
imported BuilderTools from GEOMAlgo; --imported BuilderTools from GEOMAlgo;
imported Tools3D from GEOMAlgo; --imported Tools3D from GEOMAlgo;
imported Tools from GEOMAlgo; --imported Tools from GEOMAlgo;
imported PWireEdgeSet from GEOMAlgo; --imported PWireEdgeSet from GEOMAlgo;
imported BndSphere from GEOMAlgo;
imported StateCollector from GEOMAlgo; imported StateCollector from GEOMAlgo;
imported PassKey from GEOMAlgo; imported PassKey from GEOMAlgo;
imported PassKeyMapHasher from GEOMAlgo; imported PassKeyMapHasher from GEOMAlgo;
imported PassKeyShape from GEOMAlgo; imported PassKeyShape from GEOMAlgo;
imported PassKeyShapeMapHasher from GEOMAlgo; imported PassKeyShapeMapHasher from GEOMAlgo;
imported ClsfBox from GEOMAlgo;
imported ClsfSurf from GEOMAlgo;
imported ClsfSolid from GEOMAlgo;
imported Clsf from GEOMAlgo;
imported HAlgo from GEOMAlgo;
imported ListOfCoupleOfShapes from GEOMAlgo; imported ListOfCoupleOfShapes from GEOMAlgo;
imported ListIteratorOfListOfCoupleOfShapes from GEOMAlgo; imported ListIteratorOfListOfCoupleOfShapes from GEOMAlgo;
imported ListOfPnt from GEOMAlgo; imported ListOfPnt from GEOMAlgo;
imported ListIteratorOfListOfPnt from GEOMAlgo; imported ListIteratorOfListOfPnt from GEOMAlgo;
imported DataMapOfShapeShapeSet from GEOMAlgo; imported IndexedDataMapOfShapeIndexedMapOfShape from GEOMAlgo;
imported DataMapIteratorOfDataMapOfShapeShapeSet from GEOMAlgo;
imported DataMapOfShapeReal from GEOMAlgo; --imported DataMapOfShapeShapeSet from GEOMAlgo;
imported DataMapIteratorOfDataMapOfShapeReal from GEOMAlgo; --imported DataMapIteratorOfDataMapOfShapeShapeSet from GEOMAlgo;
imported DataMapOfRealListOfShape from GEOMAlgo; --imported DataMapOfShapeReal from GEOMAlgo;
imported DataMapIteratorOfDataMapOfRealListOfShape from GEOMAlgo; --imported DataMapIteratorOfDataMapOfShapeReal from GEOMAlgo;
--imported DataMapOfRealListOfShape from GEOMAlgo;
--imported DataMapIteratorOfDataMapOfRealListOfShape from GEOMAlgo;
imported DataMapOfPassKeyInteger from GEOMAlgo; imported DataMapOfPassKeyInteger from GEOMAlgo;
imported DataMapIteratorOfDataMapOfPassKeyInteger from GEOMAlgo; imported DataMapIteratorOfDataMapOfPassKeyInteger from GEOMAlgo;
imported DataMapOfPassKeyShapeShape from GEOMAlgo; --imported DataMapOfPassKeyShapeShape from GEOMAlgo;
imported DataMapIteratorOfDataMapOfPassKeyShapeShape from GEOMAlgo; --imported DataMapIteratorOfDataMapOfPassKeyShapeShape from GEOMAlgo;
imported DataMapOfOrientedShapeShape from GEOMAlgo; --imported DataMapOfOrientedShapeShape from GEOMAlgo;
imported DataMapIteratorOfDataMapOfOrientedShapeShape from GEOMAlgo; --imported DataMapIteratorOfDataMapOfOrientedShapeShape from GEOMAlgo;
imported DataMapOfShapeMapOfShape from GEOMAlgo; imported DataMapOfShapeMapOfShape from GEOMAlgo;
imported DataMapIteratorOfDataMapOfShapeMapOfShape from GEOMAlgo; imported DataMapIteratorOfDataMapOfShapeMapOfShape from GEOMAlgo;
imported DataMapOfShapePnt from GEOMAlgo; imported DataMapOfShapePnt from GEOMAlgo;

14
src/GEOMAlgo/GEOMAlgo_Algo.cxx
View File

@ -31,7 +31,7 @@
// function: // function:
// purpose: // purpose:
//======================================================================= //=======================================================================
GEOMAlgo_Algo::GEOMAlgo_Algo() GEOMAlgo_Algo::GEOMAlgo_Algo()
: :
myErrorStatus(1), myErrorStatus(1),
myWarningStatus(0), myWarningStatus(0),
@ -41,14 +41,14 @@
// function: ~ // function: ~
// purpose: // purpose:
//======================================================================= //=======================================================================
GEOMAlgo_Algo::~GEOMAlgo_Algo() GEOMAlgo_Algo::~GEOMAlgo_Algo()
{ {
} }
//======================================================================= //=======================================================================
// function: CheckData // function: CheckData
// purpose: // purpose:
//======================================================================= //=======================================================================
void GEOMAlgo_Algo::CheckData() void GEOMAlgo_Algo::CheckData()
{ {
myErrorStatus=0; myErrorStatus=0;
} }
@ -56,7 +56,7 @@
// function: CheckResult // function: CheckResult
// purpose: // purpose:
//======================================================================= //=======================================================================
void GEOMAlgo_Algo::CheckResult() void GEOMAlgo_Algo::CheckResult()
{ {
myErrorStatus=0; myErrorStatus=0;
} }
@ -64,7 +64,7 @@
// function: ErrorStatus // function: ErrorStatus
// purpose: // purpose:
//======================================================================= //=======================================================================
Standard_Integer GEOMAlgo_Algo::ErrorStatus()const Standard_Integer GEOMAlgo_Algo::ErrorStatus()const
{ {
return myErrorStatus; return myErrorStatus;
} }
@ -72,7 +72,7 @@
// function: WarningStatus // function: WarningStatus
// purpose: // purpose:
//======================================================================= //=======================================================================
Standard_Integer GEOMAlgo_Algo::WarningStatus()const Standard_Integer GEOMAlgo_Algo::WarningStatus()const
{ {
return myWarningStatus; return myWarningStatus;
} }
@ -84,7 +84,7 @@
//function : ComputeInternalShapes //function : ComputeInternalShapes
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Algo::ComputeInternalShapes(const Standard_Boolean theFlag) void GEOMAlgo_Algo::ComputeInternalShapes(const Standard_Boolean theFlag)
{ {
myComputeInternalShapes = theFlag; myComputeInternalShapes = theFlag;
} }

1211
src/GEOMAlgo/GEOMAlgo_Tools.cxx → src/GEOMAlgo/GEOMAlgo_AlgoTools.cxx Normal file → Executable file
View File

File diff suppressed because it is too large Load Diff

201
src/GEOMAlgo/GEOMAlgo_AlgoTools.hxx Executable file
View File

@ -0,0 +1,201 @@
// Copyright (C) 2007-2012 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.
//
// 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 : GEOMAlgo_AlgoTools.hxx
// Created :
// Author : Peter KURNEV
#ifndef _GEOMAlgo_AlgoTools_HeaderFile
#define _GEOMAlgo_AlgoTools_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <Standard_Boolean.hxx>
#include <Handle_BOPInt_Context.hxx>
#include <Standard_Integer.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Geom_Surface.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Edge.hxx>
#include <BOPInt_Context.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx>
#include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape.hxx>
//! Auxiliary tools for Algorithms <br>
//=======================================================================
//class : GEOMAlgo_AlgoTools
//purpose :
//=======================================================================
class GEOMAlgo_AlgoTools {
public:
Standard_EXPORT
static void FaceNormal (const TopoDS_Face& aF,
const Standard_Real U,
const Standard_Real V,
gp_Vec& aN);
//! Computes a point <theP> inside the face <theF>. <br>
//! <theP2D> - 2D representation of <theP> <br>
//! on the surface of <theF> <br>
//! Returns 0 in case of success. <br>
Standard_EXPORT
static Standard_Integer PntInFace(const TopoDS_Face& theF,
gp_Pnt& theP,
gp_Pnt2d& theP2D) ;
Standard_EXPORT
static Standard_Boolean IsCompositeShape(const TopoDS_Shape& aS) ;
Standard_EXPORT
static Standard_Boolean BuildTriangulation(const TopoDS_Shape& aS) ;
Standard_EXPORT
static Standard_Integer RefineSDShapes
(GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape& aMSD,
const Standard_Real aTol,
const Handle(BOPInt_Context)& aCtx) ;
Standard_EXPORT
static Standard_Integer FindSDShapes(const TopTools_ListOfShape& aLE,
const Standard_Real aTol,
TopTools_IndexedDataMapOfShapeListOfShape& aMEE,
const Handle(BOPInt_Context)& aCtx) ;
Standard_EXPORT
static Standard_Integer FindSDShapes(const TopoDS_Shape& aE1,
const TopTools_ListOfShape& aLE,
const Standard_Real aTol,
TopTools_ListOfShape& aLESD,
const Handle(BOPInt_Context)& aCtx) ;
Standard_EXPORT
static void PointOnShape(const TopoDS_Shape& aS,
gp_Pnt& aP3D) ;
Standard_EXPORT
static void PointOnEdge(const TopoDS_Edge& aE,
gp_Pnt& aP3D) ;
Standard_EXPORT
static void PointOnEdge(const TopoDS_Edge& aE,
const Standard_Real aT,gp_Pnt& aP3D) ;
Standard_EXPORT
static void PointOnFace(const TopoDS_Face& aF,
gp_Pnt& aP3D) ;
Standard_EXPORT
static void PointOnFace(const TopoDS_Face& aF,
const Standard_Real aU,
const Standard_Real aV,
gp_Pnt& aP3D) ;
Standard_EXPORT
static Standard_Boolean ProjectPointOnShape(const gp_Pnt& aP1,
const TopoDS_Shape& aS,
gp_Pnt& aP2,
const Handle(BOPInt_Context)& aCtx) ;
Standard_EXPORT
static void CorrectTolerances(const TopoDS_Shape& aShape,
const Standard_Real aMaxTol=0.0001);
Standard_EXPORT
static void CorrectPointOnCurve(const TopoDS_Shape& S,
const Standard_Real aMaxTol=0.0001);
Standard_EXPORT
static void CorrectCurveOnSurface(const TopoDS_Shape& S,
const Standard_Real aMaxTol=0.0001);
Standard_EXPORT
static Standard_Boolean IsSplitToReverse1 (const TopoDS_Edge& aEF1,
const TopoDS_Edge& aEF2,
const Handle(BOPInt_Context)& aContext);
Standard_EXPORT
static void RefinePCurveForEdgeOnFace(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
const Standard_Real aUMin,
const Standard_Real aUMax);
Standard_EXPORT
static Standard_Boolean IsUPeriodic(const Handle(Geom_Surface) &aS);
Standard_EXPORT
static void MakeContainer(const TopAbs_ShapeEnum theType,
TopoDS_Shape& theC);
Standard_EXPORT
static Standard_Boolean IsSplitToReverse(const TopoDS_Edge& theSplit,
const TopoDS_Edge& theEdge,
const Handle(BOPInt_Context)& theContext);
Standard_EXPORT
static Standard_Boolean IsSplitToReverse (const TopoDS_Face& theFSp,
const TopoDS_Face& theFSr,
const Handle(BOPInt_Context)& theContext);
Standard_EXPORT
static Standard_Boolean IsSplitToReverse (const TopoDS_Shape& theSp,
const TopoDS_Shape& theSr,
const Handle(BOPInt_Context)& theCtx);
Standard_EXPORT
static Standard_Integer BuildPCurveForEdgeOnFace (const TopoDS_Edge& aEold,
const TopoDS_Edge& aEnew,
const TopoDS_Face& aF,
const Handle(BOPInt_Context)& aCtx);
//
Standard_EXPORT
static void FindChains(const GEOMAlgo_ListOfCoupleOfShapes& aLCS,
GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape& aMapChains);
Standard_EXPORT
static void FindChains(const GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape& aMCV,
GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape& aMapChains);
Standard_EXPORT
static void CopyShape(const TopoDS_Shape& aS,
TopoDS_Shape& aSC) ;
Standard_EXPORT
static void CopyShape(const TopoDS_Shape& aS,
TopoDS_Shape& aSC,
TopTools_IndexedDataMapOfShapeShape& aMSS) ;
};
#endif

141
src/GEOMAlgo/GEOMAlgo_AlgoTools_1.cxx Executable file
View File

@ -0,0 +1,141 @@
// Copyright (C) 2007-2012 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.
//
// 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 : GEOMAlgo_AlgoTools_2.cxx
// Created :
// Author : Peter KURNEV
#include <GEOMAlgo_AlgoTools.hxx>
#include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <GEOMAlgo_CoupleOfShapes.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
static
void ProcessBlock(const TopoDS_Shape& aF,
const GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape& aMCV,
TopTools_IndexedMapOfShape& aProcessed,
TopTools_IndexedMapOfShape& aChain);
//=======================================================================
// function: FindChains
// purpose :
//=======================================================================
void GEOMAlgo_AlgoTools::FindChains(const GEOMAlgo_ListOfCoupleOfShapes& aLCS,
GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape& aMapChains)
{
GEOMAlgo_ListIteratorOfListOfCoupleOfShapes aItCS;
GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape aMCV;
//
aItCS.Initialize(aLCS);
for (; aItCS.More(); aItCS.Next()) {
const GEOMAlgo_CoupleOfShapes& aCS=aItCS.Value();
//
const TopoDS_Shape& aF1=aCS.Shape1();
const TopoDS_Shape& aF2=aCS.Shape2();
//
//
if (aMCV.Contains(aF1)) {
TopTools_IndexedMapOfShape& aMV=aMCV.ChangeFromKey(aF1);
aMV.Add(aF1);
aMV.Add(aF2);
}
else {
TopTools_IndexedMapOfShape aMV;
aMV.Add(aF1);
aMV.Add(aF2);
aMCV.Add(aF1, aMV);
}
//
if (aMCV.Contains(aF2)) {
TopTools_IndexedMapOfShape& aMV=aMCV.ChangeFromKey(aF2);
aMV.Add(aF1);
aMV.Add(aF2);
}
else {
TopTools_IndexedMapOfShape aMV;
aMV.Add(aF1);
aMV.Add(aF2);
aMCV.Add(aF2, aMV);
}
}
GEOMAlgo_AlgoTools::FindChains(aMCV, aMapChains);
}
//=======================================================================
// function: FindChains
// purpose :
//=======================================================================
void GEOMAlgo_AlgoTools::FindChains(const GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape& aMCV,
GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape& aMapChains)
{
Standard_Integer i, j, aNbCV, aNbV;
TopTools_IndexedMapOfShape aProcessed, aChain;
//
aNbCV=aMCV.Extent();
for (i=1; i<=aNbCV; ++i) {
const TopoDS_Shape& aF=aMCV.FindKey(i);
if (aProcessed.Contains(aF)) {
continue;
}
//
aProcessed.Add(aF);
aChain.Add(aF);
//
const TopTools_IndexedMapOfShape& aMV=aMCV(i);
aNbV=aMV.Extent();
for (j=1; j<=aNbV; ++j) {
const TopoDS_Shape& aFx=aMV(j);
ProcessBlock(aFx, aMCV, aProcessed, aChain);
}
aMapChains.Add(aF, aChain);
aChain.Clear();
}
}
//=======================================================================
// function: ProcessBlock
// purpose:
//=======================================================================
void ProcessBlock(const TopoDS_Shape& aF,
const GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape& aMCV,
TopTools_IndexedMapOfShape& aProcessed,
TopTools_IndexedMapOfShape& aChain)
{
Standard_Integer j, aNbV;
//
if (aProcessed.Contains(aF)) {
return;
}
aProcessed.Add(aF);
aChain.Add(aF);
//
const TopTools_IndexedMapOfShape& aMV=aMCV.FindFromKey(aF);
aNbV=aMV.Extent();
for (j=1; j<=aNbV; ++j) {
const TopoDS_Shape& aFx=aMV(j);
ProcessBlock(aFx, aMCV, aProcessed, aChain);
}
}

16
src/NMTDS/NMTDS_BndSphere.cxx → src/GEOMAlgo/GEOMAlgo_BndSphere.cxx Normal file → Executable file
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -17,18 +17,18 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTDS_BndSphere.cxx // File: GEOMAlgo_BndSphere.cxx
// Created: // Created:
// Author: Peter KURNEV // Author: Peter KURNEV
// <pkv@irinox> // <pkv@irinox>
// //
#include <NMTDS_BndSphere.hxx> #include <GEOMAlgo_BndSphere.hxx>
//======================================================================= //=======================================================================
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
NMTDS_BndSphere::NMTDS_BndSphere() GEOMAlgo_BndSphere::GEOMAlgo_BndSphere()
{ {
myCenter.SetCoord(0., 0., 0.); myCenter.SetCoord(0., 0., 0.);
myRadius=0.; myRadius=0.;
@ -38,14 +38,14 @@
//function : ~ //function : ~
//purpose : //purpose :
//======================================================================= //=======================================================================
NMTDS_BndSphere::~NMTDS_BndSphere() GEOMAlgo_BndSphere::~GEOMAlgo_BndSphere()
{ {
} }
//======================================================================= //=======================================================================
//function : IsOut //function : IsOut
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean NMTDS_BndSphere::IsOut(const NMTDS_BndSphere& theOther)const Standard_Boolean GEOMAlgo_BndSphere::IsOut(const GEOMAlgo_BndSphere& theOther)const
{ {
Standard_Real aD2, aT2; Standard_Real aD2, aT2;
// //

26
src/NMTDS/NMTDS_BndSphere.hxx → src/GEOMAlgo/GEOMAlgo_BndSphere.hxx Normal file → Executable file
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -17,13 +17,13 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTDS_BndSphere.hxx // File: GEOMAlgo_BndSphere.hxx
// Created: // Created:
// Author: Peter KURNEV // Author: Peter KURNEV
// <pkv@irinox> // <pkv@irinox>
#ifndef _NMTDS_BndSphere_HeaderFile #ifndef _GEOMAlgo_BndSphere_HeaderFile
#define _NMTDS_BndSphere_HeaderFile #define _GEOMAlgo_BndSphere_HeaderFile
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
@ -32,16 +32,16 @@
#include <Standard_Boolean.hxx> #include <Standard_Boolean.hxx>
//======================================================================= //=======================================================================
//class : NMTDS_BndSphere //class : GEOMAlgo_BndSphere
//purpose : //purpose :
//======================================================================= //=======================================================================
class NMTDS_BndSphere { class GEOMAlgo_BndSphere {
public: public:
Standard_EXPORT Standard_EXPORT
NMTDS_BndSphere(); GEOMAlgo_BndSphere();
Standard_EXPORT Standard_EXPORT
virtual ~NMTDS_BndSphere(); virtual ~GEOMAlgo_BndSphere();
void SetCenter(const gp_Pnt& theP) ; void SetCenter(const gp_Pnt& theP) ;
@ -55,10 +55,10 @@ class NMTDS_BndSphere {
Standard_Real Gap() const; Standard_Real Gap() const;
void Add(const NMTDS_BndSphere& theOther) ; void Add(const GEOMAlgo_BndSphere& theOther) ;
Standard_EXPORT Standard_EXPORT
Standard_Boolean IsOut(const NMTDS_BndSphere& theOther) const; Standard_Boolean IsOut(const GEOMAlgo_BndSphere& theOther) const;
Standard_Real SquareExtent() const; Standard_Real SquareExtent() const;
@ -68,6 +68,6 @@ class NMTDS_BndSphere {
Standard_Real myGap; Standard_Real myGap;
}; };
#include <NMTDS_BndSphere.lxx> #include <GEOMAlgo_BndSphere.lxx>
#endif #endif

24
src/NMTDS/NMTDS_BndSphere.lxx → src/GEOMAlgo/GEOMAlgo_BndSphere.lxx Normal file → Executable file
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -17,15 +17,15 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTDS_BndSphere.lxx // File: GEOMAlgo_BndSphere.lxx
// Created: // Created:
// Author: Peter KURNEV // Author: Peter KURNEV
// <pkv@irinox> // <pkv@irinox>
//======================================================================= //=======================================================================
//function : SetCenter //function : SetCenter
//purpose : //purpose :
//======================================================================= //=======================================================================
inline void NMTDS_BndSphere::SetCenter(const gp_Pnt& theP) inline void GEOMAlgo_BndSphere::SetCenter(const gp_Pnt& theP)
// //
{ {
myCenter=theP; myCenter=theP;
@ -34,7 +34,7 @@
//function : Center //function : Center
//purpose : //purpose :
//======================================================================= //=======================================================================
inline const gp_Pnt& NMTDS_BndSphere::Center()const inline const gp_Pnt& GEOMAlgo_BndSphere::Center()const
{ {
return myCenter; return myCenter;
} }
@ -42,7 +42,7 @@
//function : SetRadius //function : SetRadius
//purpose : //purpose :
//======================================================================= //=======================================================================
inline void NMTDS_BndSphere::SetRadius(const Standard_Real theR) inline void GEOMAlgo_BndSphere::SetRadius(const Standard_Real theR)
{ {
myRadius=theR; myRadius=theR;
} }
@ -50,7 +50,7 @@
//function : Radius //function : Radius
//purpose : //purpose :
//======================================================================= //=======================================================================
inline Standard_Real NMTDS_BndSphere::Radius()const inline Standard_Real GEOMAlgo_BndSphere::Radius()const
{ {
return myRadius; return myRadius;
} }
@ -58,7 +58,7 @@
//function : SetGap //function : SetGap
//purpose : //purpose :
//======================================================================= //=======================================================================
inline void NMTDS_BndSphere::SetGap(const Standard_Real theGap) inline void GEOMAlgo_BndSphere::SetGap(const Standard_Real theGap)
{ {
myGap=theGap; myGap=theGap;
} }
@ -66,7 +66,7 @@
//function : Gap //function : Gap
//purpose : //purpose :
//======================================================================= //=======================================================================
inline Standard_Real NMTDS_BndSphere::Gap()const inline Standard_Real GEOMAlgo_BndSphere::Gap()const
{ {
return myGap; return myGap;
} }
@ -74,7 +74,7 @@
//function : Add //function : Add
//purpose : //purpose :
//======================================================================= //=======================================================================
inline void NMTDS_BndSphere::Add(const NMTDS_BndSphere& theOther) inline void GEOMAlgo_BndSphere::Add(const GEOMAlgo_BndSphere& theOther)
{ {
Standard_Real aTmax, aR, aT, aTOther; Standard_Real aTmax, aR, aT, aTOther;
gp_Pnt aPc; gp_Pnt aPc;
@ -96,7 +96,7 @@
//function : SquareExtent //function : SquareExtent
//purpose : //purpose :
//======================================================================= //=======================================================================
inline Standard_Real NMTDS_BndSphere::SquareExtent()const inline Standard_Real GEOMAlgo_BndSphere::SquareExtent()const
{ {
Standard_Real aD; Standard_Real aD;
// //

24
src/NMTDS/NMTDS_BndSphereTree.cxx → src/GEOMAlgo/GEOMAlgo_BndSphereTree.cxx Normal file → Executable file
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -17,31 +17,31 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTDS_BndSphereTree.cxx // File: GEOMAlgo_BndSphereTree.cxx
// Created: // Created:
// Author: Peter KURNEV // Author: Peter KURNEV
// <pkv@irinox> // <pkv@irinox>
// //
#include <NMTDS_BndSphereTree.hxx> #include <GEOMAlgo_BndSphereTree.hxx>
//======================================================================= //=======================================================================
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
NMTDS_BndSphereTreeSelector::NMTDS_BndSphereTreeSelector() GEOMAlgo_BndSphereTreeSelector::GEOMAlgo_BndSphereTreeSelector()
{ {
} }
//======================================================================= //=======================================================================
//function : ~ //function : ~
//purpose : //purpose :
//======================================================================= //=======================================================================
NMTDS_BndSphereTreeSelector::~NMTDS_BndSphereTreeSelector() GEOMAlgo_BndSphereTreeSelector::~GEOMAlgo_BndSphereTreeSelector()
{ {
} }
//======================================================================= //=======================================================================
//function : Reject //function : Reject
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean NMTDS_BndSphereTreeSelector::Reject (const NMTDS_BndSphere& aBox) const Standard_Boolean GEOMAlgo_BndSphereTreeSelector::Reject (const GEOMAlgo_BndSphere& aBox) const
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
// //
@ -52,7 +52,7 @@
//function : Accept //function : Accept
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean NMTDS_BndSphereTreeSelector::Accept (const Standard_Integer& aIndex) Standard_Boolean GEOMAlgo_BndSphereTreeSelector::Accept (const Standard_Integer& aIndex)
{ {
Standard_Boolean bRet=Standard_False; Standard_Boolean bRet=Standard_False;
// //
@ -66,7 +66,7 @@
//function : SetBox //function : SetBox
//purpose : //purpose :
//======================================================================= //=======================================================================
void NMTDS_BndSphereTreeSelector::SetBox(const NMTDS_BndSphere& aBox) void GEOMAlgo_BndSphereTreeSelector::SetBox(const GEOMAlgo_BndSphere& aBox)
{ {
myBox=aBox; myBox=aBox;
} }
@ -74,7 +74,7 @@
//function : Clear //function : Clear
//purpose : //purpose :
//======================================================================= //=======================================================================
void NMTDS_BndSphereTreeSelector::Clear() void GEOMAlgo_BndSphereTreeSelector::Clear()
{ {
myFence.Clear(); myFence.Clear();
myIndices.Clear(); myIndices.Clear();
@ -83,7 +83,7 @@
//function : Indices //function : Indices
//purpose : //purpose :
//======================================================================= //=======================================================================
const TColStd_ListOfInteger& NMTDS_BndSphereTreeSelector::Indices() const const TColStd_ListOfInteger& GEOMAlgo_BndSphereTreeSelector::Indices() const
{ {
return myIndices; return myIndices;
} }

28
src/NMTDS/NMTDS_BndSphereTree.hxx → src/GEOMAlgo/GEOMAlgo_BndSphereTree.hxx Normal file → Executable file
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -17,34 +17,34 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTDS_BndSphereTree.hxx // File: GEOMAlgo_BndSphereTree.hxx
// Created: // Created:
// Author: Peter KURNEV // Author: Peter KURNEV
// <pkv@irinox> // <pkv@irinox>
// //
#ifndef NMTDS_BndSphereTree_HeaderFile #ifndef GEOMAlgo_BndSphereTree_HeaderFile
#define NMTDS_BndSphereTree_HeaderFile #define GEOMAlgo_BndSphereTree_HeaderFile
#include <NCollection_UBTree.hxx> #include <NCollection_UBTree.hxx>
#include <NMTDS_BndSphere.hxx> #include <GEOMAlgo_BndSphere.hxx>
#include <TColStd_MapOfInteger.hxx> #include <TColStd_MapOfInteger.hxx>
#include <TColStd_ListOfInteger.hxx> #include <TColStd_ListOfInteger.hxx>
typedef NCollection_UBTree <Standard_Integer , NMTDS_BndSphere> NMTDS_BndSphereTree; typedef NCollection_UBTree <Standard_Integer , GEOMAlgo_BndSphere> GEOMAlgo_BndSphereTree;
class NMTDS_BndSphereTreeSelector : public NMTDS_BndSphereTree::Selector { class GEOMAlgo_BndSphereTreeSelector : public GEOMAlgo_BndSphereTree::Selector {
public: public:
Standard_EXPORT NMTDS_BndSphereTreeSelector(); Standard_EXPORT GEOMAlgo_BndSphereTreeSelector();
Standard_EXPORT virtual Standard_Boolean Reject(const NMTDS_BndSphere&) const; Standard_EXPORT virtual Standard_Boolean Reject(const GEOMAlgo_BndSphere&) const;
Standard_EXPORT virtual Standard_Boolean Accept(const Standard_Integer &); Standard_EXPORT virtual Standard_Boolean Accept(const Standard_Integer &);
Standard_EXPORT virtual ~NMTDS_BndSphereTreeSelector(); Standard_EXPORT virtual ~GEOMAlgo_BndSphereTreeSelector();
Standard_EXPORT void Clear(); Standard_EXPORT void Clear();
Standard_EXPORT void SetBox(const NMTDS_BndSphere&); Standard_EXPORT void SetBox(const GEOMAlgo_BndSphere&);
Standard_EXPORT const TColStd_ListOfInteger& Indices() const; Standard_EXPORT const TColStd_ListOfInteger& Indices() const;
protected: protected:
NMTDS_BndSphere myBox; GEOMAlgo_BndSphere myBox;
TColStd_MapOfInteger myFence; TColStd_MapOfInteger myFence;
TColStd_ListOfInteger myIndices; TColStd_ListOfInteger myIndices;

20
src/NMTDS/NMTDS_BoxBndTree.cxx → src/GEOMAlgo/GEOMAlgo_BoxBndTree.cxx Normal file → Executable file
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -20,31 +20,31 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTDS_BoxBndTree.cxx // File: GEOMAlgo_BoxBndTree.cxx
// Created: Tue Oct 17 13:04:11 2006 // Created: Tue Oct 17 13:04:11 2006
// Author: Peter KURNEV // Author: Peter KURNEV
// <pkv@irinox> // <pkv@irinox>
// //
#include <NMTDS_BoxBndTree.hxx> #include <GEOMAlgo_BoxBndTree.hxx>
//======================================================================= //=======================================================================
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
NMTDS_BoxBndTreeSelector::NMTDS_BoxBndTreeSelector() GEOMAlgo_BoxBndTreeSelector::GEOMAlgo_BoxBndTreeSelector()
{ {
} }
//======================================================================= //=======================================================================
//function : ~ //function : ~
//purpose : //purpose :
//======================================================================= //=======================================================================
NMTDS_BoxBndTreeSelector::~NMTDS_BoxBndTreeSelector() GEOMAlgo_BoxBndTreeSelector::~GEOMAlgo_BoxBndTreeSelector()
{ {
} }
//======================================================================= //=======================================================================
//function : Reject //function : Reject
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean NMTDS_BoxBndTreeSelector::Reject (const Bnd_Box& aBox) const Standard_Boolean GEOMAlgo_BoxBndTreeSelector::Reject (const Bnd_Box& aBox) const
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
// //
@ -55,7 +55,7 @@
//function : Accept //function : Accept
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean NMTDS_BoxBndTreeSelector::Accept (const Standard_Integer& aIndex) Standard_Boolean GEOMAlgo_BoxBndTreeSelector::Accept (const Standard_Integer& aIndex)
{ {
Standard_Boolean bRet=Standard_False; Standard_Boolean bRet=Standard_False;
// //
@ -69,7 +69,7 @@
//function : SetBox //function : SetBox
//purpose : //purpose :
//======================================================================= //=======================================================================
void NMTDS_BoxBndTreeSelector::SetBox(const Bnd_Box& aBox) void GEOMAlgo_BoxBndTreeSelector::SetBox(const Bnd_Box& aBox)
{ {
myBox=aBox; myBox=aBox;
} }
@ -77,7 +77,7 @@
//function : Clear //function : Clear
//purpose : //purpose :
//======================================================================= //=======================================================================
void NMTDS_BoxBndTreeSelector::Clear() void GEOMAlgo_BoxBndTreeSelector::Clear()
{ {
myFence.Clear(); myFence.Clear();
myIndices.Clear(); myIndices.Clear();
@ -86,7 +86,7 @@
//function : Indices //function : Indices
//purpose : //purpose :
//======================================================================= //=======================================================================
const TColStd_ListOfInteger& NMTDS_BoxBndTreeSelector::Indices() const const TColStd_ListOfInteger& GEOMAlgo_BoxBndTreeSelector::Indices() const
{ {
return myIndices; return myIndices;
} }

16
src/NMTDS/NMTDS_BoxBndTree.hxx → src/GEOMAlgo/GEOMAlgo_BoxBndTree.hxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -20,27 +20,27 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTDS_BoxBndTree.hxx // File: GEOMAlgo_BoxBndTree.hxx
// Created: Tue Oct 17 12:50:31 2006 // Created: Tue Oct 17 12:50:31 2006
// Author: Peter KURNEV // Author: Peter KURNEV
// <pkv@irinox> // <pkv@irinox>
// //
#ifndef NMTDS_BoxBndTree_HeaderFile #ifndef GEOMAlgo_BoxBndTree_HeaderFile
#define NMTDS_BoxBndTree_HeaderFile #define GEOMAlgo_BoxBndTree_HeaderFile
#include <NCollection_UBTree.hxx> #include <NCollection_UBTree.hxx>
#include <Bnd_Box.hxx> #include <Bnd_Box.hxx>
#include <TColStd_MapOfInteger.hxx> #include <TColStd_MapOfInteger.hxx>
#include <TColStd_ListOfInteger.hxx> #include <TColStd_ListOfInteger.hxx>
typedef NCollection_UBTree <Standard_Integer , Bnd_Box> NMTDS_BoxBndTree; typedef NCollection_UBTree <Standard_Integer , Bnd_Box> GEOMAlgo_BoxBndTree;
class NMTDS_BoxBndTreeSelector : public NMTDS_BoxBndTree::Selector { class GEOMAlgo_BoxBndTreeSelector : public GEOMAlgo_BoxBndTree::Selector {
public: public:
Standard_EXPORT NMTDS_BoxBndTreeSelector(); Standard_EXPORT GEOMAlgo_BoxBndTreeSelector();
Standard_EXPORT virtual Standard_Boolean Reject(const Bnd_Box&) const; Standard_EXPORT virtual Standard_Boolean Reject(const Bnd_Box&) const;
Standard_EXPORT virtual Standard_Boolean Accept(const Standard_Integer &); Standard_EXPORT virtual Standard_Boolean Accept(const Standard_Integer &);
Standard_EXPORT virtual ~NMTDS_BoxBndTreeSelector(); Standard_EXPORT virtual ~GEOMAlgo_BoxBndTreeSelector();
Standard_EXPORT void Clear(); Standard_EXPORT void Clear();
Standard_EXPORT void SetBox(const Bnd_Box&); Standard_EXPORT void SetBox(const Bnd_Box&);

416
src/GEOMAlgo/GEOMAlgo_Builder.cxx
View File

@ -1,416 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_Builder.cxx
// Created:
// Author: Peter KURNEV
//
#include <GEOMAlgo_Builder.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Iterator.hxx>
#include <BRep_Builder.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <BOP_CorrectTolerances.hxx>
#include <BRepLib.hxx>
#include <NMTTools_PaveFiller.hxx>
#include <GEOMAlgo_Tools.hxx>
//=======================================================================
//function :
//purpose :
//=======================================================================
GEOMAlgo_Builder::GEOMAlgo_Builder()
:
GEOMAlgo_BuilderShape()
{
myNbTypes=9;
myPaveFiller=NULL;
myEntryPoint=0; // Entry point through PerformWithFiller ()
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
GEOMAlgo_Builder::~GEOMAlgo_Builder()
{
if (myEntryPoint==1) {
if (myPaveFiller) {
delete myPaveFiller;
myPaveFiller=NULL;
}
}
}
//=======================================================================
//function : AddCompound
//purpose :
//=======================================================================
void GEOMAlgo_Builder::AddCompound(const TopoDS_Shape& theShape)
{
TopoDS_Iterator aIt;
//
aIt.Initialize(theShape);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
AddShape(aS);
}
}
//=======================================================================
//function : AddShape
//purpose :
//=======================================================================
void GEOMAlgo_Builder::AddShape(const TopoDS_Shape& theShape)
{
if (myMapFence.Add(theShape)) {
myShapes.Append(theShape);
}
}
//=======================================================================
//function : Shapes
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_Builder::Shapes()const
{
return myShapes;
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
void GEOMAlgo_Builder::Clear()
{
myShapes.Clear();
ClearInternals();
}
//=======================================================================
//function : ClearInternals
//purpose :
//=======================================================================
void GEOMAlgo_Builder::ClearInternals()
{
Standard_Integer i;
//
for (i=0; i<myNbTypes; ++i){
myShapes1[i].Clear();
}
myImages.Clear();
//
myInParts.Clear();
mySplitFaces.Clear();
mySameDomainShapes.Clear();
myDraftSolids.Clear();
myMapFence.Clear();
}
//=======================================================================
//function : Prepare
//purpose :
//=======================================================================
void GEOMAlgo_Builder::Prepare()
{
myErrorStatus=0;
//
Standard_Integer aNb;
BRep_Builder aBB;
TopoDS_Compound aC;
TopTools_ListIteratorOfListOfShape aIt;
//
aNb=myShapes.Extent();
if (aNb<2) {
myErrorStatus=10; // No shapes to process
return;
}
//
// 1. myShape is empty compound
aBB.MakeCompound(aC);
myShape=aC;
//
// 2. myShapes1
aIt.Initialize(myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
AddShape1(aS);
}
}
//=======================================================================
//function : AddShape1
//purpose :
//=======================================================================
void GEOMAlgo_Builder::AddShape1(const TopoDS_Shape& theShape)
{
Standard_Integer iType;
TopAbs_ShapeEnum aType;
TopoDS_Iterator aIt;
TopTools_MapOfShape aM;
//
aType=theShape.ShapeType();
if (aType==TopAbs_COMPOUND) {
aIt.Initialize(theShape);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
AddShape1(aS);
}
}
//
iType=(Standard_Integer)aType;
if (aM.Add(theShape)) {
myShapes1[iType].Append(theShape);
}
}
//=======================================================================
//function : BuildResult
//purpose :
//=======================================================================
void GEOMAlgo_Builder::BuildResult(const TopAbs_ShapeEnum theType)
{
myErrorStatus=0;
//
TopAbs_ShapeEnum aType;
BRep_Builder aBB;
TopTools_MapOfShape aM;
TopTools_ListIteratorOfListOfShape aIt, aItIm;
//
aIt.Initialize(myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
aType=aS.ShapeType();
if (aType==theType) {
if (myImages.HasImage(aS)){
const TopTools_ListOfShape& aLSIm=myImages.Image(aS);
aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value();
if (aM.Add(aSIm)) {
aBB.Add(myShape, aSIm);
}
}
}
else {
if (aM.Add(aS)) {
aBB.Add(myShape, aS);
}
}
}
}
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void GEOMAlgo_Builder::Perform()
{
myErrorStatus=0;
//
BRep_Builder aBB;
TopoDS_Compound aCS;
TopTools_ListIteratorOfListOfShape aIt;
//
aBB.MakeCompound(aCS);
//
aIt.Initialize(myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
aBB.Add(aCS, aS);
}
//
NMTTools_PaveFiller* pPF=new NMTTools_PaveFiller;
//
pPF->SetCompositeShape(aCS);
pPF->Perform();
//
myEntryPoint=1;
PerformInternal(*pPF);
}
//=======================================================================
//function : PerformWithFiller
//purpose :
//=======================================================================
void GEOMAlgo_Builder::PerformWithFiller(const NMTTools_PaveFiller& theDSF)
{
myEntryPoint=0;
//
PerformInternal(theDSF);
}
//=======================================================================
//function : PerformInternal
//purpose :
//=======================================================================
void GEOMAlgo_Builder::PerformInternal(const NMTTools_PaveFiller& pPF)
{
myErrorStatus=0;
//
Standard_Boolean bIsDone;
//
// 0. myPaveFiller
myPaveFiller=(NMTTools_PaveFiller *)&pPF;
//
bIsDone=myPaveFiller->IsDone();
if (!bIsDone) {
myErrorStatus=2; // PaveFiller is failed
return;
}
//
// 1. Clear Internal fields
ClearInternals();
//
// 2. Prepare
Prepare();
if (myErrorStatus) {
return;
}
//
// 3. Fill Images
//
// 3.1 Vertices
FillImagesVertices();
if (myErrorStatus) {
return;
}
//
BuildResult(TopAbs_VERTEX);
if (myErrorStatus) {
return;
}
// 3.2 Edges
FillImagesEdges();
if (myErrorStatus) {
return;
}
BuildResult(TopAbs_EDGE);
if (myErrorStatus) {
return;
}
// 3.3 Wires
FillImagesContainers(TopAbs_WIRE);
if (myErrorStatus) {
return;
}
BuildResult(TopAbs_WIRE);
if (myErrorStatus) {
return;
}
// 3.4 Faces
FillImagesFaces();
if (myErrorStatus) {
return;
}
BuildResult(TopAbs_FACE);
if (myErrorStatus) {
return;
}
// 3.5 Shells
FillImagesContainers(TopAbs_SHELL);
if (myErrorStatus) {
return;
}
BuildResult(TopAbs_SHELL);
if (myErrorStatus) {
return;
}
// 3.6 Solids
FillImagesSolids();
if (myErrorStatus) {
return;
}
BuildResult(TopAbs_SOLID);
if (myErrorStatus) {
return;
}
// 3.7 CompSolids
FillImagesContainers(TopAbs_COMPSOLID);
if (myErrorStatus) {
return;
}
BuildResult(TopAbs_COMPSOLID);
if (myErrorStatus) {
return;
}
// 3.8 Compounds
FillImagesContainers(TopAbs_COMPOUND);
if (myErrorStatus) {
return;
}
BuildResult(TopAbs_COMPOUND);
if (myErrorStatus) {
return;
}
//
// 4.History
PrepareHistory();
//
// 5 Post-treatment
PostTreat();
}
//
// static
// void CorrectWires(const TopoDS_Shape& aS);
//
//=======================================================================
//function : PostTreat
//purpose :
//=======================================================================
void GEOMAlgo_Builder::PostTreat()
{
Standard_Integer aNbS;
TopoDS_Iterator aIt;
TopTools_ListOfShape aLS;
//
aIt.Initialize(myShape);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
aLS.Append(aS);
}
aNbS=aLS.Extent();
if (aNbS==1) {
myShape=aLS.First();
}
BRepLib::SameParameter(myShape, 1.e-7, Standard_True);
//
GEOMAlgo_Tools::CorrectWires(myShape);
}
//
// myErrorStatus
//
// 0 - Ok
// 1 - The object is just initialized
// 2 - PaveFiller is failed
// 10 - No shapes to process
// 30 - SolidBuilder failed

224
src/GEOMAlgo/GEOMAlgo_Builder.hxx
View File

@ -1,224 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_Builder.cxx
// Created:
// Author: Peter KURNEV
//
#ifndef _GEOMAlgo_Builder_HeaderFile
#define _GEOMAlgo_Builder_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <NMTTools_PPaveFiller.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Standard_Integer.hxx>
#include <TopTools_MapOfShape.hxx>
#include <BRepAlgo_Image.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeShape.hxx>
#include <GEOMAlgo_BuilderShape.hxx>
#include <NMTTools_PaveFiller.hxx>
#include <Standard_Boolean.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Shape.hxx>
#include <BRepAlgo_Image.hxx>
//=======================================================================
//function : GEOMAlgo_Builder
//purpose :
//=======================================================================
class GEOMAlgo_Builder : public GEOMAlgo_BuilderShape
{
public:
//! Empty constructor <br>
Standard_EXPORT
GEOMAlgo_Builder();
Standard_EXPORT
virtual ~GEOMAlgo_Builder();
//! Performs calculations <br>
Standard_EXPORT
virtual void Perform() ;
//! Performs calculations using prepared PaveFiller <br>
//! object theDSF <br>
Standard_EXPORT
virtual void PerformWithFiller(const NMTTools_PaveFiller& theDSF) ;
//! Adds argument theShape of the operation <br>
Standard_EXPORT
virtual void AddShape(const TopoDS_Shape& theShape) ;
//! Clears internal fields and arguments <br>
Standard_EXPORT
virtual void Clear() ;
//! Returns the arguments of the operation <br>
Standard_EXPORT
const TopTools_ListOfShape& Shapes() const;
//! Returns the list of shapes generated from the <br>
//! shape theS. <br>
Standard_EXPORT
virtual const TopTools_ListOfShape& Generated(const TopoDS_Shape& theS) ;
//! Returns the list of shapes modified from the shape <br>
//! theS. <br>
Standard_EXPORT
virtual const TopTools_ListOfShape& Modified(const TopoDS_Shape& theS) ;
//! Returns true if the shape theS has been deleted. <br>
Standard_EXPORT
virtual Standard_Boolean IsDeleted(const TopoDS_Shape& theS) ;
//! Adds arguments of the operation as <br>
//! shapes of upper level of container shape theShape <br>
Standard_EXPORT
void AddCompound(const TopoDS_Shape& theShape) ;
//! Returns list of arguments of type theType <br>
Standard_EXPORT
const TopTools_ListOfShape& Shapes1(const Standard_Integer theType) const;
//! Returns image shapes <br>
Standard_EXPORT
const BRepAlgo_Image& Images() const;
//! Returns split-parts of shapes that have <br>
//! state IN for the domain of shape theShape <br>
Standard_EXPORT
const TopTools_ListOfShape& InParts(const TopoDS_Shape& theShape) const;
protected:
//! Performs calculations using prepared DSFiller <br>
//! object theDSF <br>
Standard_EXPORT
virtual void PerformInternal(const NMTTools_PaveFiller& theDSF) ;
//! Prepare information for history support <br>
Standard_EXPORT
virtual void PrepareHistory() ;
//! Clears internal fields <br>
Standard_EXPORT
virtual void ClearInternals() ;
//! Provides preparing actions <br>
Standard_EXPORT
virtual void Prepare() ;
//! Provides post-tratment actions <br>
Standard_EXPORT
virtual void PostTreat() ;
//! Append the argument theShape to <br>
//! typified lists of arguments myShapes1 <br>
Standard_EXPORT
void AddShape1(const TopoDS_Shape& theShape) ;
//! Build the resulting shapes of type theType <br>
Standard_EXPORT
virtual void BuildResult(const TopAbs_ShapeEnum theType) ;
//! Fill Images for vertices <br>
Standard_EXPORT
void FillImagesVertices() ;
//! Fill Images for edges <br>
Standard_EXPORT
void FillImagesEdges() ;
//! Fill Images for faces <br>
Standard_EXPORT
void FillImagesFaces() ;
//! For each interferred face find split edges <br>
//! that are in 2-D domain of the face <br>
Standard_EXPORT
void FillIn2DParts() ;
//! Build draft faces <br>
Standard_EXPORT
void BuildSplitFaces() ;
//! Among draft faces find same domain faces <br>
Standard_EXPORT
void FillSameDomainFaces() ;
//! Fill Images for faces <br>
//! taking into account same domain faces <br>
Standard_EXPORT
void FillImagesFaces1() ;
//! Update Images for faces by <br>
//! internal vertices <br>
Standard_EXPORT
void FillInternalVertices() ;
//! Fill Images for Wires, Shells, Compsolids, Compounds <br>
Standard_EXPORT
void FillImagesContainers(const TopAbs_ShapeEnum theType) ;
//! Fill Images for solids <br>
Standard_EXPORT
void FillImagesSolids() ;
//! For each interferred solid find split faces <br>
//! that are in 3-D domain of the solid <br>
Standard_EXPORT
void FillIn3DParts() ;
//! Build draft solids <br>
Standard_EXPORT
void BuildSplitSolids() ;
//! Update draft solids by <br>
//! internal shells, edges, vertices <br>
Standard_EXPORT
void FillInternalShapes() ;
//! Build solid theDraftSolid that consists of <br>
//! non-internal split faces of the solid <br>
//! theSolid. <br>
//! All splits of internal faces of <br>
//! theSolid are in the list: theInternalFaces <br>
Standard_EXPORT
void BuildDraftSolid(const TopoDS_Shape& theSolid,
TopoDS_Shape& theDraftSolid,
TopTools_ListOfShape& theInternalFaces) ;
NMTTools_PPaveFiller myPaveFiller;
TopTools_ListOfShape myShapes;
Standard_Integer myNbTypes;
TopTools_MapOfShape myMapFence;
TopTools_ListOfShape myShapes1[9];
BRepAlgo_Image myImages;
TopTools_IndexedDataMapOfShapeListOfShape myInParts;
BRepAlgo_Image mySplitFaces;
TopTools_IndexedDataMapOfShapeShape mySameDomainShapes;
TopTools_IndexedDataMapOfShapeShape myDraftSolids;
Standard_Integer myEntryPoint;
};
#endif

142
src/GEOMAlgo/GEOMAlgo_BuilderArea.cxx
View File

@ -1,142 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_BuilderArea.cxx
// Created:
// Author: Peter KURNEV
//
#include <GEOMAlgo_BuilderArea.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopoDS_Shape.hxx>
#include <IntTools_Context.hxx>
//=======================================================================
//function :
//purpose :
//=======================================================================
GEOMAlgo_BuilderArea::GEOMAlgo_BuilderArea()
:
GEOMAlgo_Algo()
{
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
GEOMAlgo_BuilderArea::~GEOMAlgo_BuilderArea()
{
}
//=======================================================================
//function : SetContext
//purpose :
//=======================================================================
void GEOMAlgo_BuilderArea::SetContext(const Handle(IntTools_Context)& theContext)
{
myContext=theContext;
}
//=======================================================================
//function : Context
//purpose :
//=======================================================================
const Handle(IntTools_Context)& GEOMAlgo_BuilderArea::Context()const
{
return myContext;
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void GEOMAlgo_BuilderArea::Perform()
{
if (myContext.IsNull()) {
myContext=new IntTools_Context;
}
}
//=======================================================================
//function : SetShapes
//purpose :
//=======================================================================
void GEOMAlgo_BuilderArea::SetShapes(const TopTools_ListOfShape& theLF)
{
TopTools_ListIteratorOfListOfShape aIt;
//
myShapes.Clear();
aIt.Initialize(theLF);
for(; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
myShapes.Append(aF);
}
}
//=======================================================================
//function : Shapes
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_BuilderArea::Shapes()const
{
return myShapes;
}
//=======================================================================
//function : Loops
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_BuilderArea::Loops()const
{
return myLoops;
}
//=======================================================================
//function : Areas
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_BuilderArea::Areas()const
{
return myAreas;
}
//=======================================================================
//function :PerformShapesToAvoid
//purpose :
//=======================================================================
void GEOMAlgo_BuilderArea::PerformShapesToAvoid()
{
}
//=======================================================================
//function : PerformLoops
//purpose :
//=======================================================================
void GEOMAlgo_BuilderArea::PerformLoops()
{
}
//=======================================================================
//function : PerformAreas
//purpose :
//=======================================================================
void GEOMAlgo_BuilderArea::PerformAreas()
{
}
//=======================================================================
//function : PerformInternalShapes
//purpose :
//=======================================================================
void GEOMAlgo_BuilderArea::PerformInternalShapes()
{
}

112
src/GEOMAlgo/GEOMAlgo_BuilderArea.hxx
View File

@ -1,112 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_BuilderArea.hxx
// Created:
// Author: Peter KURNEV
//
#ifndef _GEOMAlgo_BuilderArea_HeaderFile
#define _GEOMAlgo_BuilderArea_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
#include <Handle_IntTools_Context.hxx>
#include <GEOMAlgo_Algo.hxx>
#include <IntTools_Context.hxx>
//! The root class for algorithms to build <br>
//! faces/solids from set of edges/faces <br>
//=======================================================================
//class : GEOMAlgo_BuilderArea
//purpose :
//=======================================================================
class GEOMAlgo_BuilderArea : public GEOMAlgo_Algo
{
public:
//! Sets cashed geometrical tools <br>
Standard_EXPORT
void SetContext(const Handle(IntTools_Context)& theContext) ;
//! Returns cashed geometrical tools <br>
Standard_EXPORT
const Handle_IntTools_Context& Context() const;
//! Sets edges/faces to process <br>
Standard_EXPORT
void SetShapes(const TopTools_ListOfShape& theLS) ;
//! Returns edges/faces to process <br>
Standard_EXPORT
const TopTools_ListOfShape& Shapes() const;
//! Returns wires/shells that have been built <br>
Standard_EXPORT
const TopTools_ListOfShape& Loops() const;
//! Returns faces/solids that have been built <br>
Standard_EXPORT
const TopTools_ListOfShape& Areas() const;
Standard_EXPORT
virtual void Perform() ;
protected:
//! Empty constructor <br>
Standard_EXPORT
GEOMAlgo_BuilderArea();
Standard_EXPORT
virtual ~GEOMAlgo_BuilderArea();
//! Collect the edges/faces that <br>
//! a) are internal <br>
//! b) are the same and have different orientation <br>
Standard_EXPORT
virtual void PerformShapesToAvoid() ;
//! Build draft faces/shells <br>
//! a)myLoops - draft faces/shells that consist of <br>
//! boundary edges/faces <br>
//! b)myLoopsInternal - draft faces/shells that contains <br>
//! inner edges/faces <br>
Standard_EXPORT
virtual void PerformLoops() ;
//! Build draft faces/solids that contains boundary faces <br>
Standard_EXPORT
virtual void PerformAreas() ;
//! Build finalized faces/solids with internal wires/shells <br>
Standard_EXPORT
virtual void PerformInternalShapes() ;
TopTools_ListOfShape myShapes;
TopTools_ListOfShape myLoops;
TopTools_ListOfShape myLoopsInternal;
TopTools_MapOfOrientedShape myShapesToAvoid;
TopTools_ListOfShape myAreas;
Handle_IntTools_Context myContext;
};
#endif

711
src/GEOMAlgo/GEOMAlgo_BuilderFace.cxx
View File

@ -1,711 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_BuilderFace.cxx
// Created:
// Author: Peter KURNEV
//
#include <GEOMAlgo_BuilderFace.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Pln.hxx>
#include <gp_Vec.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
#include <Geom_Surface.hxx>
#include <TopAbs.hxx>
#include <TopLoc_Location.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Wire.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
#include <TopTools_MapIteratorOfMapOfOrientedShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <IntTools_FClass2d.hxx>
#include <IntTools_Context.hxx>
#include <BOPTools_Tools2D.hxx>
#include <BOP_WireEdgeSet.hxx>
#include <BOP_WESCorrector.hxx>
#include <NMTTools_ListOfCoupleOfShape.hxx>
#include <NMTTools_CoupleOfShape.hxx>
#include <NMTTools_ListIteratorOfListOfCoupleOfShape.hxx>
#include <GEOMAlgo_Tools3D.hxx>
#include <GEOMAlgo_BuilderTools.hxx>
#include <GEOMAlgo_WireEdgeSet.hxx>
#include <GEOMAlgo_WESCorrector.hxx>
//
static
Standard_Boolean IsGrowthWire(const TopoDS_Shape& ,
const TopTools_IndexedMapOfShape& );
static
Standard_Boolean IsInside(const TopoDS_Shape& ,
const TopoDS_Shape& ,
const Handle(IntTools_Context)& );
static
void MakeInternalWires(const TopTools_MapOfShape& ,
TopTools_ListOfShape& );
//=======================================================================
//function :
//purpose :
//=======================================================================
GEOMAlgo_BuilderFace::GEOMAlgo_BuilderFace()
:
GEOMAlgo_BuilderArea()
{
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
GEOMAlgo_BuilderFace::~GEOMAlgo_BuilderFace()
{
}
//=======================================================================
//function : SetFace
//purpose :
//=======================================================================
void GEOMAlgo_BuilderFace::SetFace(const TopoDS_Face& theFace)
{
myFace=theFace;
}
//=======================================================================
//function : Face
//purpose :
//=======================================================================
const TopoDS_Face& GEOMAlgo_BuilderFace::Face()const
{
return myFace;
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void GEOMAlgo_BuilderFace::Perform()
{
myErrorStatus=0;
//
if (myFace.IsNull()) {
myErrorStatus=12;// Null face generix
return;
}
// Initialize the context
GEOMAlgo_BuilderArea::Perform();
//
PerformShapesToAvoid();
if (myErrorStatus) {
return;
}
//
PerformLoops();
if (myErrorStatus) {
return;
}
//
PerformAreas();
if (myErrorStatus) {
return;
}
//
PerformInternalShapes();
if (myErrorStatus) {
return;
}
}
//=======================================================================
//function :PerformShapesToAvoid
//purpose :
//=======================================================================
void GEOMAlgo_BuilderFace::PerformShapesToAvoid()
{
Standard_Boolean bFound;
Standard_Integer i, iCnt, aNbV, aNbE;
TopTools_IndexedDataMapOfShapeListOfShape aMVE;
TopTools_ListIteratorOfListOfShape aIt;
//
myShapesToAvoid.Clear();
//
iCnt=0;
while (1) {
++iCnt;
bFound=Standard_False;
//
// 1. MEF
aMVE.Clear();
aIt.Initialize (myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE=aIt.Value();
if (!myShapesToAvoid.Contains(aE)) {
TopExp::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
}
// else {
// int a=0;
// }
}
aNbV=aMVE.Extent();
//
// 2. myEdgesToAvoid
for (i=1; i<=aNbV; ++i) {
const TopoDS_Vertex& aV=TopoDS::Vertex(aMVE.FindKey(i));
//
TopTools_ListOfShape& aLE=aMVE.ChangeFromKey(aV);
aNbE=aLE.Extent();
if (!aNbE) {
continue;
}
//
const TopoDS_Edge& aE1=TopoDS::Edge(aLE.First());
if (aNbE==1) {
if (BRep_Tool::Degenerated(aE1)) {
continue;
}
if (aV.Orientation()==TopAbs_INTERNAL) {
continue;
}
bFound=Standard_True;
myShapesToAvoid.Add(aE1);
}
else if (aNbE==2) {
const TopoDS_Edge& aE2=TopoDS::Edge(aLE.Last());
if (aE2.IsSame(aE1)) {
TopoDS_Vertex aV1x, aV2x;
//
TopExp::Vertices(aE1, aV1x, aV2x);
if (aV1x.IsSame(aV2x)) {
continue;
}
bFound=Standard_True;
myShapesToAvoid.Add(aE1);
myShapesToAvoid.Add(aE2);
}
}
}// for (i=1; i<=aNbE; ++i) {
//
if (!bFound) {
break;
}
//
}//while (1)
//printf(" EdgesToAvoid=%d, iCnt=%d\n", EdgesToAvoid.Extent(), iCnt);
}
//=======================================================================
//function : PerformLoops
//purpose :
//=======================================================================
void GEOMAlgo_BuilderFace::PerformLoops()
{
myErrorStatus=0;
//
Standard_Boolean bFlag;
Standard_Integer aNbEA;
TopTools_ListIteratorOfListOfShape aIt;
TopTools_MapIteratorOfMapOfOrientedShape aItM;
TopTools_IndexedDataMapOfShapeListOfShape aVEMap;
TopTools_MapOfOrientedShape aMAdded;
TopoDS_Iterator aItW;
BRep_Builder aBB;
GEOMAlgo_WireEdgeSet aWES;
GEOMAlgo_WESCorrector aWESCor;
//
// 1. Usual Wires
myLoops.Clear();
aWES.SetFace(myFace);
//
aIt.Initialize (myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE=aIt.Value();
if (!myShapesToAvoid.Contains(aE)) {
aWES.AddStartElement(aE);
}
}
//
aWESCor.SetWES(aWES);
aWESCor.Perform();
//
GEOMAlgo_WireEdgeSet& aWESN=aWESCor.NewWES();
const TopTools_ListOfShape& aLW=aWESN.Shapes();
//
aIt.Initialize (aLW);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aW=aIt.Value();
myLoops.Append(aW);
}
//modified by NIZNHY-PKV Tue Aug 5 15:09:29 2008f
// Post Treatment
TopTools_MapOfOrientedShape aMEP;
//
// a. collect all edges that are in loops
aIt.Initialize (myLoops);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aW=aIt.Value();
aItW.Initialize(aW);
for (; aItW.More(); aItW.Next()) {
const TopoDS_Shape& aE=aItW.Value();
aMEP.Add(aE);
}
}
//
// b. collect all edges that are to avoid
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aE=aItM.Key();
aMEP.Add(aE);
}
//
// c. add all edges that are not processed to myShapesToAvoid
aIt.Initialize (myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE=aIt.Value();
if (!aMEP.Contains(aE)) {
myShapesToAvoid.Add(aE);
}
}
//modified by NIZNHY-PKV Tue Aug 5 15:09:35 2008t
//
// 2. Internal Wires
myLoopsInternal.Clear();
//
aNbEA=myShapesToAvoid.Extent();
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aEE=aItM.Key();
TopExp::MapShapesAndAncestors(aEE, TopAbs_VERTEX, TopAbs_EDGE, aVEMap);
}
//
bFlag=Standard_True;
aItM.Initialize(myShapesToAvoid);
for (; aItM.More()&&bFlag; aItM.Next()) {
const TopoDS_Shape& aEE=aItM.Key();
if (!aMAdded.Add(aEE)) {
continue;
}
//
// make new wire
TopoDS_Wire aW;
aBB.MakeWire(aW);
aBB.Add(aW, aEE);
//
aItW.Initialize(aW);
for (; aItW.More()&&bFlag; aItW.Next()) {
const TopoDS_Edge& aE=TopoDS::Edge(aItW.Value());
//
TopoDS_Iterator aItE(aE);
for (; aItE.More()&&bFlag; aItE.Next()) {
const TopoDS_Vertex& aV = TopoDS::Vertex(aItE.Value());
const TopTools_ListOfShape& aLE=aVEMap.FindFromKey(aV);
aIt.Initialize(aLE);
for (; aIt.More()&&bFlag; aIt.Next()) {
const TopoDS_Shape& aEx=aIt.Value();
if (aMAdded.Add(aEx)) {
aBB.Add(aW, aEx);
if(aMAdded.Extent()==aNbEA) {
bFlag=!bFlag;
}
}
}//for (; aIt.More(); aIt.Next()) {
}//for (; aItE.More(); aItE.Next()) {
}//for (; aItW.More(); aItW.Next()) {
myLoopsInternal.Append(aW);
}//for (; aItM.More(); aItM.Next()) {
}
//=======================================================================
//function : PerformAreas
//purpose :
//=======================================================================
void GEOMAlgo_BuilderFace::PerformAreas()
{
myErrorStatus=0;
//
Standard_Boolean bIsGrowth, bIsHole;
Standard_Real aTol;
TopTools_ListOfShape aNewFaces, aHoleWires;
TopoDS_Shape anInfinitePointShape;
TopTools_DataMapOfShapeShape aInOutMap;
TopTools_DataMapOfShapeListOfShape aMSH;
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItMSH;
TopTools_ListIteratorOfListOfShape aIt1, aIt2;
TopTools_IndexedMapOfShape aMHE;
BRep_Builder aBB;
Handle(Geom_Surface) aS;
TopLoc_Location aLoc;
//
aTol=BRep_Tool::Tolerance(myFace);
aS=BRep_Tool::Surface(myFace, aLoc);
//
myAreas.Clear();
//
// Draft faces [aNewFaces]
aIt1.Initialize(myLoops);
for ( ; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aWire=aIt1.Value();
//
bIsGrowth=IsGrowthWire(aWire, aMHE);
if (bIsGrowth) {
// make a growth face from a wire
TopoDS_Face aFace;
aBB.MakeFace(aFace, aS, aLoc, aTol);
aBB.Add (aFace, aWire);
//
aNewFaces.Append (aFace);
}
else{
// check if a wire is a hole
//XX
//bIsHole=IsHole(aWire, myFace, myContext);
bIsHole=GEOMAlgo_BuilderTools::IsHole(aWire, myFace);
//XX
if (bIsHole) {
aHoleWires.Append(aWire);
TopExp::MapShapes(aWire, TopAbs_EDGE, aMHE);
}
else {
// make a growth face from a wire
TopoDS_Face aFace;
aBB.MakeFace(aFace, aS, aLoc, aTol);
aBB.Add (aFace, aWire);
//
aNewFaces.Append (aFace);
}
}
}
//
// 2. Find outer growth shell that is most close to each hole shell
aIt2.Initialize(aHoleWires);
for (; aIt2.More(); aIt2.Next()) {
const TopoDS_Shape& aHole = aIt2.Value();
//
aIt1.Initialize(aNewFaces);
for ( ; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aF=aIt1.Value();
//
if (!IsInside(aHole, aF, myContext)){
continue;
}
//
if ( aInOutMap.IsBound (aHole)){
const TopoDS_Shape& aF2=aInOutMap(aHole);
if (IsInside(aF, aF2, myContext)) {
aInOutMap.UnBind(aHole);
aInOutMap.Bind (aHole, aF);
}
}
else{
aInOutMap.Bind (aHole, aF);
}
}
//
// Add aHole to a map Face/ListOfHoles [aMSH]
if (aInOutMap.IsBound(aHole)){
const TopoDS_Shape& aF=aInOutMap(aHole);
if (aMSH.IsBound(aF)) {
TopTools_ListOfShape& aLH=aMSH.ChangeFind(aF);
aLH.Append(aHole);
}
else {
TopTools_ListOfShape aLH;
aLH.Append(aHole);
aMSH.Bind(aF, aLH);
}
}
}// for (; aIt2.More(); aIt2.Next())
//
// 3. Add aHoles to Faces
aItMSH.Initialize(aMSH);
for (; aItMSH.More(); aItMSH.Next()) {
TopoDS_Face aF=TopoDS::Face(aItMSH.Key());
//
const TopTools_ListOfShape& aLH=aItMSH.Value();
aIt2.Initialize(aLH);
for (; aIt2.More(); aIt2.Next()) {
const TopoDS_Shape& aHole = aIt2.Value();
aBB.Add (aF, aHole);
}
//
// update classifier
aTol=BRep_Tool::Tolerance(aF);
IntTools_FClass2d& aClsf=myContext->FClass2d(aF);
aClsf.Init(aF, aTol);
}
//
// These aNewFaces are draft faces that
// do not contain any internal shapes
//
myAreas.Append(aNewFaces);
}
//=======================================================================
//function : PerformInternalShapes
//purpose :
//=======================================================================
void GEOMAlgo_BuilderFace::PerformInternalShapes()
{
myErrorStatus=0;
//
Standard_Integer aNbWI=myLoopsInternal.Extent();
if (!aNbWI) {// nothing to do
return;
}
//
//Standard_Real aTol;
BRep_Builder aBB;
TopTools_ListIteratorOfListOfShape aIt1, aIt2;
TopoDS_Iterator aIt;
TopTools_MapOfShape aME, aMEP;
TopTools_MapIteratorOfMapOfShape aItME;
TopTools_IndexedDataMapOfShapeListOfShape aMVE;
TopTools_ListOfShape aLSI;
//
// 1. All internal edges
aIt1.Initialize(myLoopsInternal);
for (; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aWire=aIt1.Value();
aIt.Initialize(aWire);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE=aIt.Value();
aME.Add(aE);
}
}
aNbWI=aME.Extent();
//
// 2 Process faces
aIt2.Initialize(myAreas);
for ( ; aIt2.More(); aIt2.Next()) {
TopoDS_Face& aF=TopoDS::Face(aIt2.Value());
//
aMVE.Clear();
TopExp::MapShapesAndAncestors(aF, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
//
// 2.1 Separate faces to process aMEP
aMEP.Clear();
aItME.Initialize(aME);
for (; aItME.More(); aItME.Next()) {
const TopoDS_Edge& aE=TopoDS::Edge(aItME.Key());
if (IsInside(aE, aF, myContext)) {
aMEP.Add(aE);
}
}
//
// 2.2 Make Internal Wires
aLSI.Clear();
MakeInternalWires(aMEP, aLSI);
//
// 2.3 Add them to aF
aIt1.Initialize(aLSI);
for (; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aSI=aIt1.Value();
aBB.Add (aF, aSI);
}
//
// 2.4 Remove faces aMFP from aMF
aItME.Initialize(aMEP);
for (; aItME.More(); aItME.Next()) {
const TopoDS_Shape& aE=aItME.Key();
aME.Remove(aE);
}
//
aNbWI=aME.Extent();
if (!aNbWI) {
break;
}
} //for ( ; aIt2.More(); aIt2.Next()) {
}
//=======================================================================
//function : MakeInternalWires
//purpose :
//=======================================================================
void MakeInternalWires(const TopTools_MapOfShape& theME,
TopTools_ListOfShape& theWires)
{
TopTools_MapIteratorOfMapOfShape aItM;
TopTools_MapOfShape aAddedMap;
TopTools_ListIteratorOfListOfShape aItE;
TopTools_IndexedDataMapOfShapeListOfShape aMVE;
BRep_Builder aBB;
//
aItM.Initialize(theME);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aE=aItM.Key();
TopExp::MapShapesAndAncestors(aE, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
}
//
aItM.Initialize(theME);
for (; aItM.More(); aItM.Next()) {
TopoDS_Shape aEE=aItM.Key();
if (!aAddedMap.Add(aEE)) {
continue;
}
//
// make a new shell
TopoDS_Wire aW;
aBB.MakeWire(aW);
aEE.Orientation(TopAbs_INTERNAL);
aBB.Add(aW, aEE);
//
TopoDS_Iterator aItAdded (aW);
for (; aItAdded.More(); aItAdded.Next()) {
const TopoDS_Shape& aE =aItAdded.Value();
//
TopExp_Explorer aExp(aE, TopAbs_VERTEX);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aV =aExp.Current();
const TopTools_ListOfShape& aLE=aMVE.FindFromKey(aV);
aItE.Initialize(aLE);
for (; aItE.More(); aItE.Next()) {
TopoDS_Shape aEL=aItE.Value();
if (aAddedMap.Add(aEL)){
aEL.Orientation(TopAbs_INTERNAL);
aBB.Add(aW, aEL);
}
}
}
}
theWires.Append(aW);
}
}
//=======================================================================
//function : IsInside
//purpose :
//=======================================================================
Standard_Boolean IsInside(const TopoDS_Shape& theHole,
const TopoDS_Shape& theF2,
const Handle(IntTools_Context)& theContext)
{
Standard_Boolean bRet;
Standard_Real aT, aU, aV;
TopAbs_State aState;
TopExp_Explorer aExp;
TopTools_IndexedMapOfShape aME2;
gp_Pnt2d aP2D;
//
bRet=Standard_False;
aState=TopAbs_UNKNOWN;
const TopoDS_Face& aF2=TopoDS::Face(theF2);
//
TopExp::MapShapes(aF2, TopAbs_EDGE, aME2);
//
aExp.Init(theHole, TopAbs_EDGE);
if (aExp.More()) {
const TopoDS_Edge& aE = TopoDS::Edge(aExp.Current());
if (aME2.Contains(aE)) {
return bRet;
}
//
aT=BOPTools_Tools2D::IntermediatePoint(aE);
BOPTools_Tools2D::PointOnSurface(aE, aF2, aT, aU, aV);
aP2D.SetCoord(aU, aV);
//
IntTools_FClass2d& aClsf=theContext->FClass2d(aF2);
aState=aClsf.Perform(aP2D);
bRet=(aState==TopAbs_IN);
}
//
return bRet;
}
//=======================================================================
//function : IsGrowthWire
//purpose :
//=======================================================================
Standard_Boolean IsGrowthWire(const TopoDS_Shape& theWire,
const TopTools_IndexedMapOfShape& theMHE)
{
Standard_Boolean bRet;
TopoDS_Iterator aIt;
//
bRet=Standard_False;
if (theMHE.Extent()) {
aIt.Initialize(theWire);
for(; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aE=aIt.Value();
if (theMHE.Contains(aE)) {
return !bRet;
}
}
}
return bRet;
}
//BRepTools::Write(aFF, "ff");
//
// ErrorStatus :
// 11 - Null Context
// 12 - Null face generix
/*
//=======================================================================
//function : IsInside
//purpose :
//=======================================================================
Standard_Boolean IsInside(const TopoDS_Shape& theHole,
const TopoDS_Shape& theF2,
IntTools_PContext& theContext)
{
Standard_Real aT, aU, aV;
TopExp_Explorer aExp;
TopAbs_State aState=TopAbs_UNKNOWN;
gp_Pnt2d aP2D;
//
const TopoDS_Face& aF2=TopoDS::Face(theF2);
//
aExp.Init(theHole, TopAbs_EDGE);
if (aExp.More()){
const TopoDS_Edge& aE = TopoDS::Edge(aExp.Current());
aT=BOPTools_Tools2D::IntermediatePoint(aE);
BOPTools_Tools2D::PointOnSurface(aE, aF2, aT, aU, aV);
aP2D.SetCoord(aU, aV);
//
IntTools_FClass2d& aClsf=theContext->FClass2d(aF2);
aState=aClsf.Perform(aP2D);
}
return (aState==TopAbs_IN);
}
*/

91
src/GEOMAlgo/GEOMAlgo_BuilderFace.hxx
View File

@ -1,91 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_BuilderFace.hxx
// Created:
// Author: Peter KURNEV
//
#ifndef _GEOMAlgo_BuilderFace_HeaderFile
#define _GEOMAlgo_BuilderFace_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <TopoDS_Face.hxx>
#include <GEOMAlgo_BuilderArea.hxx>
//! The algorithm to build faces from set of edges <br>
//=======================================================================
//class : GEOMAlgo_BuilderFace
//purpose :
//=======================================================================
class GEOMAlgo_BuilderFace : public GEOMAlgo_BuilderArea
{
public:
//! Empty constructor <br>
Standard_EXPORT
GEOMAlgo_BuilderFace();
Standard_EXPORT
virtual ~GEOMAlgo_BuilderFace();
//! Sets the face generatix <br>
Standard_EXPORT
void SetFace(const TopoDS_Face& theFace) ;
//! Returns the face generatix <br>
Standard_EXPORT
const TopoDS_Face& Face() const;
//! Performs the algorithm <br>
Standard_EXPORT
virtual void Perform() ;
protected:
//! Collect the edges that <br>
//! a) are internal <br>
//! b) are the same and have different orientation <br>
Standard_EXPORT
virtual void PerformShapesToAvoid() ;
//! Build draft wires <br>
//! a)myLoops - draft wires that consist of <br>
//! boundary edges <br>
//! b)myLoopsInternal - draft wires that contains <br>
//! inner edges <br>
Standard_EXPORT
virtual void PerformLoops() ;
//! Build draft faces that contains boundary edges <br>
Standard_EXPORT
virtual void PerformAreas() ;
//! Build finalized faces with internals <br>
Standard_EXPORT
virtual void PerformInternalShapes() ;
TopoDS_Face myFace;
};
#endif

5
src/GEOMAlgo/GEOMAlgo_BuilderShape.cxx
View File

@ -25,6 +25,7 @@
// Author: Peter KURNEV // Author: Peter KURNEV
// //
#include <GEOMAlgo_BuilderShape.hxx> #include <GEOMAlgo_BuilderShape.hxx>
//======================================================================= //=======================================================================
//function : //function :
//purpose : //purpose :
@ -117,11 +118,8 @@
myHasDeleted=Standard_False; myHasDeleted=Standard_False;
myHasGenerated=Standard_False; myHasGenerated=Standard_False;
myHasModified=Standard_False; myHasModified=Standard_False;
//modified by NIZNHY-PKV Thu Dec 7 11:14:15 2006
myImagesResult.Clear(); myImagesResult.Clear();
//modified by NIZNHY-PKV Thu Dec 7 11:14:17 2006t
} }
//modified by NIZNHY-PKV Thu Dec 7 11:57:00 2006f
//======================================================================= //=======================================================================
//function : ImagesResult //function : ImagesResult
//purpose : //purpose :
@ -130,4 +128,3 @@
{ {
return myImagesResult; return myImagesResult;
} }
//modified by NIZNHY-PKV Thu Dec 7 11:57:04 2006t

5
src/GEOMAlgo/GEOMAlgo_BuilderShape.hxx
View File

@ -29,11 +29,14 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <Standard_Boolean.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx> #include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx> #include <TopTools_MapOfShape.hxx>
#include <Standard_Boolean.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx> #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <GEOMAlgo_Algo.hxx> #include <GEOMAlgo_Algo.hxx>

931
src/GEOMAlgo/GEOMAlgo_BuilderSolid.cxx
View File

@ -1,931 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_BuilderSolid.cxx
// Created:
// Author: Peter KURNEV
//
#include <GEOMAlgo_BuilderSolid.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Pln.hxx>
#include <gp_Vec.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <Geom2d_Curve.hxx>
#include <TopAbs.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Solid.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Compound.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
#include <TopTools_MapIteratorOfMapOfOrientedShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <IntTools_Context.hxx>
#include <BOPTools_Tools2D.hxx>
#include <BOPTools_Tools3D.hxx>
#include <NMTTools_ListOfCoupleOfShape.hxx>
#include <NMTTools_CoupleOfShape.hxx>
#include <NMTTools_ListIteratorOfListOfCoupleOfShape.hxx>
#include <GEOMAlgo_Tools3D.hxx>
#include <GEOMAlgo_BuilderTools.hxx>
//
static
Standard_Boolean IsGrowthShell(const TopoDS_Shape& ,
const TopTools_IndexedMapOfShape& );
static
Standard_Boolean IsHole(const TopoDS_Shape& ,
const Handle(IntTools_Context)& );
static
Standard_Boolean IsInside(const TopoDS_Shape& ,
const TopoDS_Shape& ,
const Handle(IntTools_Context)& );
static
void MakeInternalShells(const TopTools_MapOfShape& ,
TopTools_ListOfShape& );
static
Standard_Boolean IsClosedShell(const TopoDS_Shell& );
static
Standard_Boolean RefineShell(const TopoDS_Shell& ,
TopoDS_Shell& );
//=======================================================================
//function :
//purpose :
//=======================================================================
GEOMAlgo_BuilderSolid::GEOMAlgo_BuilderSolid()
:
GEOMAlgo_BuilderArea()
{
}
//=======================================================================
//function : ~
//purpose :
//=======================================================================
GEOMAlgo_BuilderSolid::~GEOMAlgo_BuilderSolid()
{
}
//=======================================================================
//function : Perform
//purpose :
//=======================================================================
void GEOMAlgo_BuilderSolid::Perform()
{
myErrorStatus=0;
//
// Initialize the context
GEOMAlgo_BuilderArea::Perform();
//
TopoDS_Compound aC;
BRep_Builder aBB;
TopTools_ListIteratorOfListOfShape aIt;
aBB.MakeCompound(aC);
aIt.Initialize(myShapes);
for(; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
aBB.Add(aC, aF);
}
//
PerformShapesToAvoid();
if (myErrorStatus) {
return;
}
//
PerformLoops();
if (myErrorStatus) {
return;
}
PerformAreas();
if (myErrorStatus) {
return;
}
if (myComputeInternalShapes) {
PerformInternalShapes();
if (myErrorStatus) {
return;
}
}
}
//=======================================================================
//function :PerformShapesToAvoid
//purpose :
//=======================================================================
void GEOMAlgo_BuilderSolid::PerformShapesToAvoid()
{
Standard_Boolean bFound;
Standard_Integer i, iCnt, aNbE, aNbF;
TopAbs_Orientation aOrE;
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
TopTools_ListIteratorOfListOfShape aIt;
//
myShapesToAvoid.Clear();
//
iCnt=0;
while (1) {
++iCnt;
bFound=Standard_False;
//
// 1. MEF
aMEF.Clear();
aIt.Initialize (myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
if (!myShapesToAvoid.Contains(aF)) {
TopExp::MapShapesAndAncestors(aF, TopAbs_EDGE, TopAbs_FACE, aMEF);
}
/*
else {
int a=0;
}
*/
}
aNbE=aMEF.Extent();
//
// 2. myFacesToAvoid
for (i=1; i<=aNbE; ++i) {
const TopoDS_Edge& aE=*((TopoDS_Edge*)(&aMEF.FindKey(i)));
if (BRep_Tool::Degenerated(aE)) {
continue;
}
//
TopTools_ListOfShape& aLF=aMEF.ChangeFromKey(aE);
//
aNbF=aLF.Extent();
if (!aNbF) {
continue;
}
//
aOrE=aE.Orientation();
//
const TopoDS_Face& aF1=*((TopoDS_Face*)(&aLF.First()));
if (aNbF==1) {
if (aOrE==TopAbs_INTERNAL) {
continue;
}
bFound=Standard_True;
myShapesToAvoid.Add(aF1);
}
else if (aNbF==2) {
const TopoDS_Face& aF2=*((TopoDS_Face*)(&aLF.Last()));
if (aF2.IsSame(aF1)) {
if (BRep_Tool::IsClosed(aE, aF1)) {
continue;
}
//
if (aOrE==TopAbs_INTERNAL) {
continue;
}
//
bFound=Standard_True;
myShapesToAvoid.Add(aF1);
myShapesToAvoid.Add(aF2);
}
}
/*//DEB
else {
TopTools_ListIteratorOfListOfShape aItLF;
//
aItLF.Initialize (aLF);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Shape& aFx=aItLF.Value();
int a=0;
}
}
*///DEB
}// for (i=1; i<=aNbE; ++i) {
//
if (!bFound) {
break;
}
//
}//while (1)
}
//=======================================================================
//function : PerformLoops
//purpose :
//=======================================================================
void GEOMAlgo_BuilderSolid::PerformLoops()
{
myErrorStatus=0;
//
myLoops.Clear();
//
Standard_Integer aNbLF, aNbOff, aNbFP;
TopAbs_Orientation anOr;
TopoDS_Edge aEL;
BRep_Builder aBB;
NMTTools_CoupleOfShape aCSOff;
TopTools_MapOfOrientedShape AddedFacesMap;
TopTools_IndexedDataMapOfShapeListOfShape aEFMap, aMEFP;
TopTools_ListIteratorOfListOfShape aItF, aIt;
TopTools_MapIteratorOfMapOfOrientedShape aItM;
TopoDS_Iterator aItS;
//
//=================================================
//
// 1. Shells Usual
//
aItF.Initialize (myShapes);
for (; aItF.More(); aItF.Next()) {
const TopoDS_Shape& aFF = aItF.Value();
TopExp::MapShapesAndAncestors(aFF, TopAbs_EDGE, TopAbs_FACE, aEFMap);
}
//
aItF.Initialize (myShapes);
for (; aItF.More(); aItF.Next()) {
const TopoDS_Shape& aFF = aItF.Value();
if (myShapesToAvoid.Contains(aFF)) {
continue;
}
if (!AddedFacesMap.Add(aFF)) {
continue;
}
//
// make a new shell
TopoDS_Shell aShell;
aBB.MakeShell(aShell);
aBB.Add(aShell, aFF);
//
aMEFP.Clear();
TopExp::MapShapesAndAncestors(aFF, TopAbs_EDGE, TopAbs_FACE, aMEFP);
//
// loop on faces added to Shell; add their neighbor faces to Shell and so on
TopoDS_Iterator aItAddedF (aShell);
for (; aItAddedF.More(); aItAddedF.Next()) {
const TopoDS_Face& aF = *((TopoDS_Face*)(&aItAddedF.Value()));
//
// loop on edges of aF; find a good neighbor face of aF by aE
TopExp_Explorer aEdgeExp(aF, TopAbs_EDGE);
for (; aEdgeExp.More(); aEdgeExp.Next()) {
const TopoDS_Edge& aE=*((TopoDS_Edge*)(&aEdgeExp.Current()));
//
//1
if (aMEFP.Contains(aE)) {
const TopTools_ListOfShape& aLFP=aMEFP.FindFromKey(aE);
aNbFP=aLFP.Extent();
if (aNbFP>1) {
continue;
}
}
//2
anOr=aE.Orientation();
if (anOr==TopAbs_INTERNAL) {
continue;
}
//3
if (BRep_Tool::Degenerated(aE)) {
continue;
}
//
// candidate faces list
const TopTools_ListOfShape& aLF=aEFMap.FindFromKey(aE);
aNbLF=aLF.Extent();
if (!aNbLF) {
continue;
}
//
// try to select one of neighbors
// check if a face already added to Shell shares E
Standard_Boolean bFound;
TopTools_ListIteratorOfListOfShape aItLF;
NMTTools_ListOfCoupleOfShape aLCSOff;
//
aItLF.Initialize(aLF);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Face& aFL=*((TopoDS_Face*)(&aItLF.Value()));
if (myShapesToAvoid.Contains(aFL)) {
continue;
}
if (aF.IsSame(aFL)) {
continue;
}
if (AddedFacesMap.Contains(aFL)){
continue;
}
//
bFound=GEOMAlgo_Tools3D::GetEdgeOff(aE, aFL, aEL);
if (!bFound) {
continue;
}
//
aCSOff.SetShape1(aEL);
aCSOff.SetShape2(aFL);
aLCSOff.Append(aCSOff);
}//for (; aItLF.More(); aItLF.Next()) {
//
aNbOff=aLCSOff.Extent();
if (!aNbOff){
continue;
}
//
TopoDS_Face aSelF;
if (aNbOff==1) {
aSelF=*((TopoDS_Face*)(&aLCSOff.First().Shape2()));
}
else if (aNbOff>1){
GEOMAlgo_Tools3D::GetFaceOff(aE, aF, aLCSOff, aSelF);
}
//
if (!aSelF.IsNull() && AddedFacesMap.Add(aSelF)) {
aBB.Add(aShell, aSelF);
TopExp::MapShapesAndAncestors(aSelF, TopAbs_EDGE, TopAbs_FACE, aMEFP);
}
} // for (; aEdgeExp.More(); aEdgeExp.Next()) {
} //for (; aItAddedF.More(); aItAddedF.Next()) {
//
if (IsClosedShell(aShell)) {
myLoops.Append(aShell);
}
else {
Standard_Boolean bRefine;
TopoDS_Shell aShx;
//
bRefine=RefineShell(aShell, aShx);
if (bRefine) {
myLoops.Append(aShx);
}
}
} // for (; aItF.More(); aItF.Next()) {
//
// Post Treatment
TopTools_MapOfOrientedShape aMP;
//
// a. collect all edges that are in loops
aIt.Initialize (myLoops);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
aItS.Initialize(aS);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aF=aItS.Value();
aMP.Add(aF);
}
}
//
// b. collect all faces that are to avoid
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aF=aItM.Key();
aMP.Add(aF);
}
//
// c. add all faces that are not processed to myShapesToAvoid
aIt.Initialize (myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
if (!aMP.Contains(aF)) {
myShapesToAvoid.Add(aF);
}
}
//=================================================
//
// 2.Internal Shells
//
myLoopsInternal.Clear();
//
aEFMap.Clear();
AddedFacesMap.Clear();
//
if (myComputeInternalShapes) {
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aFF=aItM.Key();
TopExp::MapShapesAndAncestors(aFF, TopAbs_EDGE, TopAbs_FACE, aEFMap);
}
//
aItM.Initialize(myShapesToAvoid);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aFF=aItM.Key();
if (!AddedFacesMap.Add(aFF)) {
continue;
}
//
// make a new shell
TopoDS_Shell aShell;
aBB.MakeShell(aShell);
aBB.Add(aShell, aFF);
//
TopoDS_Iterator aItAddedF (aShell);
for (; aItAddedF.More(); aItAddedF.Next()) {
const TopoDS_Face& aF = *((TopoDS_Face*)(&aItAddedF.Value()));
//
TopExp_Explorer aEdgeExp(aF, TopAbs_EDGE);
for (; aEdgeExp.More(); aEdgeExp.Next()) {
const TopoDS_Edge& aE = *((TopoDS_Edge*)(&aEdgeExp.Current()));
const TopTools_ListOfShape& aLF=aEFMap.FindFromKey(aE);
aItF.Initialize(aLF);
for (; aItF.More(); aItF.Next()) {
const TopoDS_Face& aFL=*((TopoDS_Face*)(&aItF.Value()));
if (AddedFacesMap.Add(aFL)){
aBB.Add(aShell, aFL);
}
}
}
}
myLoopsInternal.Append(aShell);
}
}
}
//=======================================================================
//function : PerformAreas
//purpose :
//=======================================================================
void GEOMAlgo_BuilderSolid::PerformAreas()
{
myErrorStatus=0;
//
Standard_Boolean bIsGrowthShell, bIsHole;
TopTools_ListOfShape aNewSolids, aHoleShells;
TopoDS_Shape anInfinitePointShape;
TopTools_DataMapOfShapeShape aInOutMap;
TopTools_DataMapOfShapeListOfShape aMSH;
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItMSH;
TopTools_ListIteratorOfListOfShape aShellIt, aSolidIt;
TopTools_IndexedMapOfShape aMHF;
BRep_Builder aBB;
//
myAreas.Clear();
//
// Draft solids [aNewSolids]
aShellIt.Initialize(myLoops);
for ( ; aShellIt.More(); aShellIt.Next()) {
const TopoDS_Shape& aShell = aShellIt.Value();
//
bIsGrowthShell=IsGrowthShell(aShell, aMHF);
if (bIsGrowthShell) {
// make a growth solid from a shell
TopoDS_Solid Solid;
aBB.MakeSolid(Solid);
aBB.Add (Solid, aShell);
//
aNewSolids.Append (Solid);
}
else{
// check if a shell is a hole
bIsHole=IsHole(aShell, myContext);
//
if (bIsHole) {
aHoleShells.Append(aShell);
TopExp::MapShapes(aShell, TopAbs_FACE, aMHF);
}
else {
// make a growth solid from a shell
TopoDS_Solid Solid;
aBB.MakeSolid(Solid);
aBB.Add (Solid, aShell);
//
aNewSolids.Append (Solid);
}
}
}
//
// 2. Find outer growth shell that is most close to each hole shell
aShellIt.Initialize(aHoleShells);
for (; aShellIt.More(); aShellIt.Next()) {
const TopoDS_Shape& aHole = aShellIt.Value();
//
aSolidIt.Initialize(aNewSolids);
for ( ; aSolidIt.More(); aSolidIt.Next()) {
const TopoDS_Shape& aSolid = aSolidIt.Value();
//
if (!IsInside(aHole, aSolid, myContext)){
continue;
}
//
if ( aInOutMap.IsBound (aHole)){
const TopoDS_Shape& aSolid2 = aInOutMap(aHole);
if (IsInside(aSolid, aSolid2, myContext)) {
aInOutMap.UnBind(aHole);
aInOutMap.Bind (aHole, aSolid);
}
}
else{
aInOutMap.Bind (aHole, aSolid);
}
}
//
// Add aHole to a map Solid/ListOfHoles [aMSH]
if (aInOutMap.IsBound(aHole)){
const TopoDS_Shape& aSolid=aInOutMap(aHole);
if (aMSH.IsBound(aSolid)) {
TopTools_ListOfShape& aLH=aMSH.ChangeFind(aSolid);
aLH.Append(aHole);
}
else {
TopTools_ListOfShape aLH;
aLH.Append(aHole);
aMSH.Bind(aSolid, aLH);
}
//aBB.Add (aSolid, aHole);
}
}// for (; aShellIt.More(); aShellIt.Next()) {
//
// 3. Add aHoles to Solids
aItMSH.Initialize(aMSH);
for (; aItMSH.More(); aItMSH.Next()) {
TopoDS_Solid aSolid=*((TopoDS_Solid*)(&aItMSH.Key()));
//
const TopTools_ListOfShape& aLH=aItMSH.Value();
aShellIt.Initialize(aLH);
for (; aShellIt.More(); aShellIt.Next()) {
const TopoDS_Shape& aHole = aShellIt.Value();
aBB.Add (aSolid, aHole);
}
//
// update classifier
BRepClass3d_SolidClassifier& aSC=myContext->SolidClassifier(aSolid);
aSC.Load(aSolid);
//
}
//
// These aNewSolids are draft solids that
// do not contain any internal shapes
//
myAreas.Append(aNewSolids);
}
//=======================================================================
//function : PerformInternalShapes
//purpose :
//=======================================================================
void GEOMAlgo_BuilderSolid::PerformInternalShapes()
{
myErrorStatus=0;
//
Standard_Integer aNbFI=myLoopsInternal.Extent();
if (!aNbFI) {// nothing to do
return;
}
//
Standard_Integer bFlag;
BRep_Builder aBB;
TopTools_ListIteratorOfListOfShape aShellIt, aSolidIt;
TopoDS_Iterator aIt;
TopTools_MapOfShape aMF, aMFP, aMFS;
TopTools_MapIteratorOfMapOfShape aItMF;
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
TopTools_ListOfShape aLSI;
//
// 1. All internal faces
aShellIt.Initialize(myLoopsInternal);
for (; aShellIt.More(); aShellIt.Next()) {
const TopoDS_Shape& aShell=aShellIt.Value();
aIt.Initialize(aShell);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
aMF.Add(aF);
}
}
aNbFI=aMF.Extent();
//
// 2 Process solids
aSolidIt.Initialize(myAreas);
for ( ; aSolidIt.More(); aSolidIt.Next()) {
TopoDS_Solid& aSolid=*((TopoDS_Solid*)(&aSolidIt.Value()));
//
//modified by NIZNHY-PKV Wed Mar 07 08:52:18 2012f
aMFS.Clear();
{
TopExp_Explorer aExp(aSolid, TopAbs_FACE);
while (aExp.More()) {
aMFS.Add(aExp.Current());
aExp.Next();
}
}
//modified by NIZNHY-PKV Wed Mar 07 08:52:20 2012t
aMEF.Clear();
TopExp::MapShapesAndAncestors(aSolid, TopAbs_EDGE, TopAbs_FACE, aMEF);
//
// 2.1 Separate faces to process aMFP
aMFP.Clear();
aItMF.Initialize(aMF);
for (; aItMF.More(); aItMF.Next()) {
const TopoDS_Face& aF=*((TopoDS_Face*)(&aItMF.Key()));
//modified by NIZNHY-PKV Wed Mar 07 08:54:56 2012f
if (!aMFS.Contains(aF)) {
bFlag=GEOMAlgo_Tools3D::IsInternalFace(aF, aSolid, aMEF, 1.e-14, myContext);
if (bFlag) {
aMFP.Add(aF);
}
}
//if (GEOMAlgo_Tools3D::IsInternalFace(aF, aSolid, aMEF, 1.e-14, myContext)) {
// aMFP.Add(aF);
//}
//modified by NIZNHY-PKV Wed Mar 07 08:56:07 2012t
}
//
// 2.2 Make Internal Shells
aLSI.Clear();
MakeInternalShells(aMFP, aLSI);
//
// 2.3 Add them to aSolid
aShellIt.Initialize(aLSI);
for (; aShellIt.More(); aShellIt.Next()) {
const TopoDS_Shape& aSI=aShellIt.Value();
aBB.Add (aSolid, aSI);
}
//
// 2.4 Remove faces aMFP from aMF
aItMF.Initialize(aMFP);
for (; aItMF.More(); aItMF.Next()) {
const TopoDS_Shape& aF=aItMF.Key();
aMF.Remove(aF);
}
//
aNbFI=aMF.Extent();
if (!aNbFI) {
break;
}
} //for ( ; aSolidIt.More(); aSolidIt.Next()) {
}
//=======================================================================
//function : MakeInternalShells
//purpose :
//=======================================================================
void MakeInternalShells(const TopTools_MapOfShape& theMF,
TopTools_ListOfShape& theShells)
{
TopTools_MapIteratorOfMapOfShape aItM;
TopTools_MapOfShape aAddedFacesMap;
TopTools_ListIteratorOfListOfShape aItF;
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
BRep_Builder aBB;
//
aItM.Initialize(theMF);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aF=aItM.Key();
TopExp::MapShapesAndAncestors(aF, TopAbs_EDGE, TopAbs_FACE, aMEF);
}
//
aItM.Initialize(theMF);
for (; aItM.More(); aItM.Next()) {
TopoDS_Shape aFF=aItM.Key();
if (!aAddedFacesMap.Add(aFF)) {
continue;
}
//
// make a new shell
TopoDS_Shell aShell;
aBB.MakeShell(aShell);
aFF.Orientation(TopAbs_INTERNAL);
aBB.Add(aShell, aFF);
//
TopoDS_Iterator aItAddedF (aShell);
for (; aItAddedF.More(); aItAddedF.Next()) {
const TopoDS_Shape& aF =aItAddedF.Value();
//
TopExp_Explorer aEdgeExp(aF, TopAbs_EDGE);
for (; aEdgeExp.More(); aEdgeExp.Next()) {
const TopoDS_Shape& aE =aEdgeExp.Current();
const TopTools_ListOfShape& aLF=aMEF.FindFromKey(aE);
aItF.Initialize(aLF);
for (; aItF.More(); aItF.Next()) {
TopoDS_Shape aFL=aItF.Value();
if (aAddedFacesMap.Add(aFL)){
aFL.Orientation(TopAbs_INTERNAL);
aBB.Add(aShell, aFL);
}
}
}
}
theShells.Append(aShell);
}
}
//=======================================================================
//function : IsHole
//purpose :
//=======================================================================
Standard_Boolean IsHole(const TopoDS_Shape& theS2,
const Handle(IntTools_Context)& theContext)
{
TopoDS_Solid *pS2=(TopoDS_Solid *)&theS2;
BRepClass3d_SolidClassifier& aClsf=theContext->SolidClassifier(*pS2);
//
aClsf.PerformInfinitePoint(::RealSmall());
//
return (aClsf.State()==TopAbs_IN);
}
//=======================================================================
//function : IsInside
//purpose :
//=======================================================================
Standard_Boolean IsInside(const TopoDS_Shape& theS1,
const TopoDS_Shape& theS2,
const Handle(IntTools_Context)& theContext)
{
TopExp_Explorer aExp;
TopAbs_State aState;
//
TopoDS_Solid *pS2=(TopoDS_Solid *)&theS2;
//
aExp.Init(theS1, TopAbs_FACE);
if (!aExp.More()){
BRepClass3d_SolidClassifier& aClsf=theContext->SolidClassifier(*pS2);
aClsf.PerformInfinitePoint(::RealSmall());
aState=aClsf.State();
}
else {
TopTools_IndexedMapOfShape aBounds;
const TopoDS_Face& aF = TopoDS::Face(aExp.Current());
aState=GEOMAlgo_Tools3D::ComputeState(aF, *pS2, 1.e-14, aBounds, theContext);
}
return (aState==TopAbs_IN);
}
//=======================================================================
//function : IsGrowthShell
//purpose :
//=======================================================================
Standard_Boolean IsGrowthShell(const TopoDS_Shape& theShell,
const TopTools_IndexedMapOfShape& theMHF)
{
Standard_Boolean bRet;
TopoDS_Iterator aIt;
//
bRet=Standard_False;
if (theMHF.Extent()) {
aIt.Initialize(theShell);
for(; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
if (theMHF.Contains(aF)) {
return !bRet;
}
}
}
return bRet;
}
//=======================================================================
//function : IsClosedShell
//purpose :
//=======================================================================
Standard_Boolean IsClosedShell(const TopoDS_Shell& theShell)
{
Standard_Integer aNbE;
Standard_Boolean bRet;
TopoDS_Iterator aIt;
TopExp_Explorer aExp;
TopTools_MapOfShape aM;
//
bRet=Standard_False;
aIt.Initialize(theShell);
for(; aIt.More(); aIt.Next()) {
const TopoDS_Face& aF=TopoDS::Face(aIt.Value());
aExp.Init(aF, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE=*((TopoDS_Edge*)(&aExp.Current()));
if (BRep_Tool::Degenerated(aE)) {
continue;
}
//
if (aE.Orientation()==TopAbs_INTERNAL) {
continue;
}
//
if (!aM.Add(aE)) {
aM.Remove(aE);
}
}
}
//
aNbE=aM.Extent();
if (!aNbE) {
bRet=!bRet;
}
return bRet;
}
//=======================================================================
//function : RefineShell
//purpose :
//=======================================================================
Standard_Boolean RefineShell(const TopoDS_Shell& aShell,
TopoDS_Shell& aShx)
{
Standard_Boolean bRet;
Standard_Integer i, aNbE, aNbF;
TopAbs_Orientation aOrE;
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
TopTools_MapOfOrientedShape aMFx;
//
bRet=Standard_False;
//
TopExp::MapShapesAndAncestors(aShell, TopAbs_EDGE, TopAbs_FACE, aMEF);
aNbE=aMEF.Extent();
for (i=1; i<=aNbE; ++i) {
const TopoDS_Edge &aE=*((TopoDS_Edge*)(&aMEF.FindKey(i)));
//
if (BRep_Tool::Degenerated(aE)) {
continue;
}
//
aOrE=aE.Orientation();
//
const TopTools_ListOfShape& aLF=aMEF(i);
aNbF=aLF.Extent();
if (!aNbF) {
continue;
}
//
const TopoDS_Face& aF1=*((TopoDS_Face*)(&aLF.First()));
if (aNbF==1) {
if (aOrE==TopAbs_INTERNAL) {
continue;
}
aMFx.Add(aF1);
}
//
else if (aNbF==2) {
const TopoDS_Face& aF2=*((TopoDS_Face*)(&aLF.Last()));
if (aF2.IsSame(aF1)) {
if (BRep_Tool::IsClosed(aE, aF1)) {
continue;
}
if (aOrE==TopAbs_INTERNAL) {
continue;
}
aMFx.Add(aF1);
aMFx.Add(aF2);
}
}
}
//
aNbF=aMFx.Extent();
if (!aNbF) {
return bRet;
}
//
BRep_Builder aBB;
TopoDS_Iterator aIt;
//
aNbF=0;
aBB.MakeShell(aShx);
aIt.Initialize(aShell);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
if (!aMFx.Contains(aF)) {
aBB.Add(aShx, aF);
++aNbF;
}
}
//
if (aNbF) {
bRet=IsClosedShell(aShx);
}
//
return bRet;
}
//
// ErrorStatus :
// 11 - Null Context

77
src/GEOMAlgo/GEOMAlgo_BuilderSolid.hxx
View File

@ -1,77 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_BuilderSolid.hxx
// Created:
// Author: Peter KURNEV
//
#ifndef _GEOMAlgo_BuilderSolid_HeaderFile
#define _GEOMAlgo_BuilderSolid_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <GEOMAlgo_BuilderArea.hxx>
//! The algorithm to build solids from set of faces <br>
//=======================================================================
//function : GEOMAlgo_BuilderSolid
//purpose :
//=======================================================================
class GEOMAlgo_BuilderSolid : public GEOMAlgo_BuilderArea
{
public:
//! Empty constructor <br>
Standard_EXPORT
GEOMAlgo_BuilderSolid();
Standard_EXPORT
virtual ~GEOMAlgo_BuilderSolid();
//! Performs the algorithm <br>
Standard_EXPORT
virtual void Perform() ;
protected:
//! Collect the faces that <br>
//! a) are internal <br>
//! b) are the same and have different orientation <br>
Standard_EXPORT
virtual void PerformShapesToAvoid() ;
//! Build draft shells <br>
//! a)myLoops - draft shells that consist of <br>
//! boundary faces <br>
//! b)myLoopsInternal - draft shells that contains <br>
//! inner faces <br>
Standard_EXPORT
virtual void PerformLoops() ;
//! Build draft solids that contains boundary faces <br>
Standard_EXPORT
virtual void PerformAreas() ;
//! Build finalized solids with internal shells <br>
Standard_EXPORT
virtual void PerformInternalShapes() ;
};
#endif

292
src/GEOMAlgo/GEOMAlgo_BuilderTools.cxx
View File

@ -1,292 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_BuilderTools.cxx
// Author: Peter KURNEV
#include <GEOMAlgo_BuilderTools.hxx>
#include <Basics_OCCTVersion.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <Poly_Triangulation.hxx>
#include <Poly_Array1OfTriangle.hxx>
#include <Poly_Triangle.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2dInt_Geom2dCurveTool.hxx>
#include <TopLoc_Location.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Wire.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopExp_Explorer.hxx>
#if OCC_VERSION_LARGE > 0x06050100 // for OCC-6.5.2 and higher version
#include <TopExp.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#endif
#include <BRep_Tool.hxx>
#include <BRepBndLib.hxx>
#include <BRepMesh_FastDiscret.hxx>
#include <Bnd_Box.hxx>
#include <BRepAdaptor_Curve2d.hxx>
static
Standard_Integer ComputeProps(const TopoDS_Face& aF,
Standard_Real& aA,
Standard_Real& aV);
static
void BuildTriangulation(const TopoDS_Face& aF);
//=======================================================================
//function : IsHole
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_BuilderTools::IsHole(const TopoDS_Shape& aW,
const TopoDS_Shape& aFace)
{
Standard_Boolean bIsHole;
Standard_Integer i, aNbS;
Standard_Real aT1, aT2, aS;
Standard_Real aU1, aU2, aU, dU;
Standard_Real aX1, aY1, aX0, aY0;
TopAbs_Orientation aOr;
gp_Pnt2d aP2D0, aP2D1;
Handle(Geom2d_Curve) aC2D;
TopoDS_Face aF, aFF;
TopoDS_Iterator aItW;
//
bIsHole=Standard_False;
//
aF=TopoDS::Face(aFace);
aFF=aF;
aFF.Orientation(TopAbs_FORWARD);
//
aS=0.;
aItW.Initialize(aW);
for (; aItW.More(); aItW.Next()) {
const TopoDS_Edge& aE=TopoDS::Edge(aItW.Value());
aOr=aE.Orientation();
if (!(aOr==TopAbs_FORWARD ||
aOr==TopAbs_REVERSED)) {
continue;
}
//
aC2D=BRep_Tool::CurveOnSurface(aE, aFF, aT1, aT2);
if (aC2D.IsNull()) {
break; //xx
}
//
BRepAdaptor_Curve2d aBAC2D(aE, aFF);
aNbS=Geom2dInt_Geom2dCurveTool::NbSamples(aBAC2D);
if (aNbS>2) {
aNbS*=4;
}
//
dU=(aT2-aT1)/(Standard_Real)(aNbS-1);
aU =aT1;
aU1=aT1;
aU2=aT2;
if (aOr==TopAbs_REVERSED) {
aU =aT2;
aU1=aT2;
aU2=aT1;
dU=-dU;
}
//
aC2D->D0(aU, aP2D0);
for(i=2; i<=aNbS; i++) {
aU=aU1+(i-1)*dU;
aC2D->D0(aU, aP2D1);
aP2D0.Coord(aX0, aY0);
aP2D1.Coord(aX1, aY1);
//
aS=aS+(aY0+aY1)*(aX1-aX0);
//
aP2D0=aP2D1;
}
}//for (; aItW.More(); aItW.Next()) {
bIsHole=(aS>0.);
return bIsHole;
}
//=======================================================================
//function : IsHole
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_BuilderTools::IsHole(const TopoDS_Shape& aShell)
{
Standard_Boolean bIsHole;
Standard_Integer iRet;
Standard_Real aAi, aA, aV, aVi;
TopExp_Explorer aExp;
//
aA=0.;
aV=0.;
aExp.Init(aShell, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Face& aF=TopoDS::Face(aExp.Current());
iRet=ComputeProps(aF, aAi, aVi);
if (!iRet) {
aA+=aAi;
aV+=aVi;
}
}
//
bIsHole=aV<0.;
return bIsHole;
}
//=======================================================================
//function : ComputeProps
//purpose :
//=======================================================================
Standard_Integer ComputeProps(const TopoDS_Face& aF,
Standard_Real& aA,
Standard_Real& aV)
{
Standard_Integer j, i, i1, i2, aNbNodes, aNbTrigs, n[3];
Standard_Real aAi, aVi;
gp_Pnt aP[3], aGC, aGC1;
TopLoc_Location aLoc;
TopAbs_Orientation aOr;
Handle(Poly_Triangulation) aTri;
//
aA=0.;
aV=0.;
//
aTri=BRep_Tool::Triangulation(aF, aLoc);
if(aTri.IsNull()) {
BuildTriangulation(aF);
aTri=BRep_Tool::Triangulation(aF, aLoc);
if(aTri.IsNull()) {
return 1;// a face is without triangulation
}
}
//
aNbNodes=aTri->NbNodes();
aNbTrigs=aTri->NbTriangles();
if (!aNbTrigs){
return 2;//no triangles
}
//
aOr=aF.Orientation();
//
const TColgp_Array1OfPnt& aNodes=aTri->Nodes();
const Poly_Array1OfTriangle& aTriangles=aTri->Triangles();
//
i1=aTriangles.Lower();
i2=aTriangles.Upper();
//
for (i=i1; i<=i2; ++i){
const Poly_Triangle& aTriangle=aTriangles.Value(i);
aTriangle.Get(n[0], n[1], n[2]);
aGC.SetCoord(0.,0.,0.);
for (j=0; j<3; ++j) {
aP[j]=aNodes.Value(n[j]);
aGC.ChangeCoord()+=aP[j].XYZ();
}
aGC.ChangeCoord()*=0.333333333333;
//
// Normal
gp_Vec aV01(aP[0], aP[1]);
gp_Vec aV12(aP[1], aP[2]);
gp_Vec aVN=aV01^aV12;
aAi=aVN.Magnitude();
aA=aA+aAi;
//
if (aAi>0.0000001) {
Standard_Real aSx, aZx;
gp_Dir aDN(aVN);
if (aOr==TopAbs_REVERSED) {
aDN.Reverse();
}
//
aSx=aAi*aDN.Z();
aZx=aGC.Z();
aVi=aZx*aSx;
aV=aV+aVi;
}
}
return 0;
}
//=======================================================================
//function : BuildTriangulation
//purpose :
//=======================================================================
void BuildTriangulation(const TopoDS_Face& aF)
{
Standard_Boolean bWithShare;
Standard_Real aDiscret, aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
Standard_Real dX, dY, dZ, dMax, aCoeff, aAngle;
Bnd_Box aBox;
//
bWithShare=Standard_False;
aAngle=0.5;
//
BRepBndLib::Add(aF, aBox);
//
// aDiscret
aBox.Get(aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
dX=aXmax-aXmin;
dY=aYmax-aYmin;
dZ=aZmax-aZmin;
dMax=dX;
if (dY>dMax) {
dMax=dY;
}
if (dZ>dMax) {
dMax=dZ;
}
//
aCoeff=0.1;
aDiscret=aCoeff*dMax;
//
BRepMesh_FastDiscret aMesher(aDiscret,
aAngle,
aBox,
bWithShare,
Standard_True,
Standard_False,
Standard_True);
#if OCC_VERSION_LARGE > 0x06050100 // for OCC-6.5.2 and higher version
TopTools_IndexedDataMapOfShapeListOfShape anAncestors;
TopExp::MapShapesAndAncestors(aF, TopAbs_EDGE, TopAbs_FACE, anAncestors);
aMesher.Add(aF, anAncestors);
#else
aMesher.Add(aF);
#endif
}

48
src/GEOMAlgo/GEOMAlgo_BuilderTools.hxx
View File

@ -1,48 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_BuilderTools.hxx
// Author: Peter KURNEV
#ifndef _GEOMAlgo_BuilderTools_HeaderFile
#define _GEOMAlgo_BuilderTools_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <Standard_Boolean.hxx>
#include <TopoDS_Shape.hxx>
//=======================================================================
//class : GEOMAlgo_BuilderTools
//purpose :
//=======================================================================
class GEOMAlgo_BuilderTools
{
public:
Standard_EXPORT
static Standard_Boolean IsHole(const TopoDS_Shape& aW,
const TopoDS_Shape& aF) ;
Standard_EXPORT
static Standard_Boolean IsHole(const TopoDS_Shape& aShell) ;
};
#endif

64
src/GEOMAlgo/GEOMAlgo_Builder_0.cxx
View File

@ -1,64 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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 <GEOMAlgo_Builder.hxx>
#include <NMTDS_ShapesDataStructure.hxx>
//#include <NMTTools_DSFiller.hxx>
#include <NMTTools_PaveFiller.hxx>
#include <IntTools_Context.hxx>
#include <TopoDS_Shape.hxx>
#include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <BOPTools_ListOfPaveBlock.hxx>
#include <BOPTools_PaveBlock.hxx>
//=======================================================================
//function : Shapes1
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_Builder::Shapes1(const Standard_Integer theType)const
{
return myShapes1[theType];
}
//=======================================================================
//function : Images
//purpose :
//=======================================================================
const BRepAlgo_Image& GEOMAlgo_Builder::Images()const
{
return myImages;
}
//=======================================================================
//function : InParts
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_Builder::InParts(const TopoDS_Shape& theS)const
{
static TopTools_ListOfShape sLS;
//
if (myInParts.Contains(theS)) {
return myInParts.FindFromKey(theS);
}
return sLS;
}

360
src/GEOMAlgo/GEOMAlgo_Builder_1.cxx
View File

@ -1,360 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_Builder_1.cxx
// Created:
// Author: Peter KURNEV
//
#include <GEOMAlgo_Builder.hxx>
//
#include <TColStd_ListOfInteger.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Wire.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Iterator.hxx>
//
#include <TopTools_MapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
//
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
//
#include <IntTools_Context.hxx>
#include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
#include <BOPTools_ListOfPaveBlock.hxx>
#include <BOPTools_PaveBlock.hxx>
//
#include <NMTDS_ShapesDataStructure.hxx>
//
#include <NMTTools_PaveFiller.hxx>
#include <NMTTools_CommonBlockPool.hxx>
#include <NMTTools_ListIteratorOfListOfCommonBlock.hxx>
#include <NMTTools_CommonBlock.hxx>
#include <NMTTools_CommonBlockPool.hxx>
#include <NMTTools_ListOfCommonBlock.hxx>
#include <NMTTools_CommonBlockAPI.hxx>
//
#include <GEOMAlgo_Tools3D.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx>
static
void FillImagesCompounds(const TopTools_MapOfShape& ,
BRepAlgo_Image& );
static
void FillImagesCompound(const TopoDS_Shape& ,
BRepAlgo_Image& ,
TopTools_MapOfShape& );
//=======================================================================
//function : FillImagesVertices
//purpose :
//=======================================================================
void GEOMAlgo_Builder::FillImagesVertices()
{
myErrorStatus=0;
//
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
//
Standard_Integer i, aNb, iV;
//
aNb=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNb; ++i) {
const TopoDS_Shape& aV=aDS.Shape(i);
if (aV.ShapeType()==TopAbs_VERTEX) {
iV=pPF->FindSDVertex(i);
if (iV) {
const TopoDS_Shape& aVSD=aDS.Shape(iV);
if (!myImages.HasImage(aV)) {
myImages.Bind(aV, aVSD);
//
mySameDomainShapes.Add(aV, aVSD);
}
}
}
}
}
//=======================================================================
// function: FillImagesEdges
// purpose:
//=======================================================================
void GEOMAlgo_Builder::FillImagesEdges()
{
myErrorStatus=0;
//
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
const BOPTools_SplitShapesPool& aSSP=pPF->SplitShapesPool();
const Handle(IntTools_Context)& aCtx=pPF->Context();
//
Standard_Boolean bToReverse;
Standard_Integer i, aNb, aNbSp, nSp, nSpR, nSpx, aIsCB, aNbLB;
TColStd_ListIteratorOfListOfInteger aItLB;
TColStd_ListOfInteger aLB;
TopoDS_Edge aEE, aESpR;
TopTools_MapOfShape aMFence;
TopTools_ListOfShape aLSp;
TopTools_ListIteratorOfListOfShape aIt1;
BOPTools_ListIteratorOfListOfPaveBlock aIt;
//
aNb=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNb; ++i) {
const TopoDS_Shape& aE=aDS.Shape(i);
if (aE.ShapeType()!=TopAbs_EDGE) {
continue;
}
//
if (!aMFence.Add(aE)) {
continue;
}
//
const BOPTools_ListOfPaveBlock& aLPB=aSSP(aDS.RefEdge(i));
aNbSp=aLPB.Extent();
if (!aNbSp) {
continue;
}
//
aEE=TopoDS::Edge(aE);
aLSp.Clear();
//
if (aNbSp==1) {
const BOPTools_PaveBlock& aPB=aLPB.First();
nSp=aPB.Edge();
const TopoDS_Shape& aSp=aDS.Shape(nSp);
//
const BOPTools_PaveBlock& aPBR=pPF->RealPaveBlock(aPB, aLB, aIsCB);
//modified by NIZNHY-PKV Wed Oct 27 11:19:30 2010f
aNbLB=aLB.Extent();
if (aIsCB && aNbLB<2) {
aIsCB=0;
}
//modified by NIZNHY-PKV Wed Oct 27 11:19:34 2010t
//
nSpR=aPBR.Edge();
const TopoDS_Shape& aSpR=aDS.Shape(nSpR);
if (aSpR.IsSame(aSp) && aSpR.IsSame(aE) && !aIsCB) {
continue;
}
//
aESpR=TopoDS::Edge(aSpR);
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aESpR, aEE, aCtx);
if (bToReverse) {
aESpR.Reverse();
}
aLSp.Append(aESpR);
//
aItLB.Initialize(aLB);
for (; aItLB.More(); aItLB.Next()) {
nSpx=aItLB.Value();
const TopoDS_Shape& aSpx=aDS.Shape(nSpx);
mySameDomainShapes.Add(aSpx ,aSpR);
}
//
//
}// if (aNbSp==1) {
else {
aIt.Initialize(aLPB);
for (; aIt.More(); aIt.Next()) {
const BOPTools_PaveBlock& aPB=aIt.Value();
const BOPTools_PaveBlock& aPBR=pPF->RealPaveBlock(aPB, aLB, aIsCB);
nSpR=aPBR.Edge();
const TopoDS_Shape& aSpR=aDS.Shape(nSpR);
//
aESpR=TopoDS::Edge(aSpR);
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aESpR, aEE, aCtx);
if (bToReverse) {
aESpR.Reverse();
}
aLSp.Append(aESpR);
//
aItLB.Initialize(aLB);
for (; aItLB.More(); aItLB.Next()) {
nSpx=aItLB.Value();
const TopoDS_Shape& aSpx=aDS.Shape(nSpx);
mySameDomainShapes.Add(aSpx ,aSpR);
}
}
}
//
myImages.Bind(aE, aLSp);
}//for (i=1; i<=aNb; ++i)
}
//=======================================================================
// function: FillImagesContainers
// purpose:
//=======================================================================
void GEOMAlgo_Builder::FillImagesContainers(const TopAbs_ShapeEnum theType)
{
myErrorStatus=0;
//
Standard_Boolean bInterferred, bToReverse;
Standard_Integer i, aNbS;
TopAbs_ShapeEnum aType;
BRep_Builder aBB;
TopoDS_Iterator aIt;
TopTools_ListIteratorOfListOfShape aItIm;
TopTools_MapOfShape aMS;
TopTools_MapIteratorOfMapOfShape aItS;
//
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
aNbS=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNbS; ++i) {
const TopoDS_Shape& aC=aDS.Shape(i);
aType=aC.ShapeType();
if (aType==theType) {
aMS.Add(aC);
}
}
//
if (theType==TopAbs_COMPOUND) {
FillImagesCompounds(aMS, myImages);
return;
}
//
aItS.Initialize(aMS);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aC=aItS.Key();
// whether the shape has image
bInterferred=Standard_False;
aIt.Initialize(aC);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
if (myImages.HasImage(aF)) {
bInterferred=!bInterferred;
break;
}
}
if (!bInterferred){
continue;
}
//
TopoDS_Shape aCIm;
GEOMAlgo_Tools3D::MakeContainer(theType, aCIm);
//
aIt.Initialize(aC);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
if (myImages.HasImage(aF)) {
const TopTools_ListOfShape& aLFIm=myImages.Image(aF);
aItIm.Initialize(aLFIm);
for (; aItIm.More(); aItIm.Next()) {
TopoDS_Shape aFIm=aItIm.Value();
//
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aFIm, aF, aCtx);
if (bToReverse) {
aFIm.Reverse();
}
aBB.Add(aCIm, aFIm);
}
}
else {
aBB.Add(aCIm, aF);
}
}
myImages.Bind(aC, aCIm);
}// for (; aItS.More(); aItS.Next()) {
}
//=======================================================================
// function: FillImagesCompounds
// purpose:
//=======================================================================
void FillImagesCompounds(const TopTools_MapOfShape& theMS,
BRepAlgo_Image& theImages)
{
TopTools_MapOfShape aMFP;
TopTools_MapIteratorOfMapOfShape aItS;
//
aItS.Initialize(theMS);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aC=aItS.Key();
FillImagesCompound(aC, theImages, aMFP);
}
}
//=======================================================================
//function : FillImagesCompound
//purpose :
//=======================================================================
void FillImagesCompound(const TopoDS_Shape& theS,
BRepAlgo_Image& theImages,
TopTools_MapOfShape& theMFP)
{
Standard_Boolean bInterferred;
TopAbs_ShapeEnum aTypeX;
TopAbs_Orientation aOrX;
TopoDS_Iterator aIt;
BRep_Builder aBB;
TopTools_ListIteratorOfListOfShape aItIm;
//
if (!theMFP.Add(theS)) {
return;
}
//
bInterferred=Standard_False;
aIt.Initialize(theS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSX=aIt.Value();
aTypeX=aSX.ShapeType();
if (aTypeX==TopAbs_COMPOUND) {
FillImagesCompound(aSX, theImages, theMFP);
}
if (theImages.HasImage(aSX)) {
bInterferred=Standard_True;
}
}
if (!bInterferred){
return;
}
//
TopoDS_Shape aCIm;
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCIm);
//
aIt.Initialize(theS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSX=aIt.Value();
aOrX=aSX.Orientation();
if (theImages.HasImage(aSX)) {
const TopTools_ListOfShape& aLFIm=theImages.Image(aSX);
aItIm.Initialize(aLFIm);
for (; aItIm.More(); aItIm.Next()) {
TopoDS_Shape aSXIm=aItIm.Value();
aSXIm.Orientation(aOrX);
aBB.Add(aCIm, aSXIm);
}
}
else {
aBB.Add(aCIm, aSX);
}
}
theImages.Bind(theS, aCIm);
}

999
src/GEOMAlgo/GEOMAlgo_Builder_2.cxx
View File

@ -1,999 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_Builder_2.cxx
// Author: Peter KURNEV
#include <GEOMAlgo_Builder.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Compound.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
#include <BRepAlgo_Image.hxx>
#include <BRepTools.hxx>
#include <IntTools_Context.hxx>
#include <IntTools_FClass2d.hxx>
#include <BooleanOperations_OnceExplorer.hxx>
#include <BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger.hxx>
#include <BOPTools_ListOfPaveBlock.hxx>
#include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
#include <BOPTools_CArray1OfSSInterference.hxx>
#include <BOPTools_SSInterference.hxx>
#include <BOPTools_SequenceOfCurves.hxx>
#include <BOPTools_Curve.hxx>
#include <BOPTools_ListOfPaveBlock.hxx>
#include <BOPTools_PaveBlock.hxx>
#include <BOPTools_Tools3D.hxx>
#include <BOPTools_CArray1OfVSInterference.hxx>
#include <BOPTools_VSInterference.hxx>
#include <BOPTools_ESInterference.hxx>
#include <BOPTools_CArray1OfESInterference.hxx>
#include <NMTDS_ShapesDataStructure.hxx>
#include <NMTDS_InterfPool.hxx>
#include <NMTTools_PaveFiller.hxx>
#include <NMTTools_ListOfCoupleOfShape.hxx>
#include <NMTTools_Tools.hxx>
#include <NMTTools_CoupleOfShape.hxx>
#include <NMTTools_IndexedDataMapOfShapeIndexedMapOfShape.hxx>
#include <NMTTools_Tools.hxx>
#include <NMTTools_ListIteratorOfListOfCommonBlock.hxx>
#include <NMTTools_ListOfCommonBlock.hxx>
#include <NMTTools_CommonBlock.hxx>
#include <NMTTools_IndexedDataMapOfIndexedMapOfInteger.hxx>
//
#include <GEOMAlgo_Tools3D.hxx>
#include <GEOMAlgo_WireEdgeSet.hxx>
#include <GEOMAlgo_BuilderFace.hxx>
#include <GEOMAlgo_ShapeSet.hxx>
//
#include <NMTDS_BoxBndTree.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <Bnd_Box.hxx>
#include <BRepBndLib.hxx>
#include <TopTools_DataMapOfIntegerShape.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <TopTools_DataMapOfShapeInteger.hxx>
static
void UpdateCandidates(const Standard_Integer ,
const Standard_Integer ,
NMTTools_IndexedDataMapOfIndexedMapOfInteger& );
static
Standard_Boolean IsClosed(const TopoDS_Edge& ,
const TopoDS_Face&,
Standard_Boolean& );
//=======================================================================
//function : FillImagesFaces
//purpose :
//=======================================================================
void GEOMAlgo_Builder::FillImagesFaces()
{
myErrorStatus=0;
//
FillIn2DParts();
BuildSplitFaces();
FillSameDomainFaces();
FillImagesFaces1();
FillInternalVertices();
}
//=======================================================================
// function: FillIn2DParts
// purpose:
//=======================================================================
void GEOMAlgo_Builder::FillIn2DParts()
{
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
NMTDS_InterfPool* pIP=pPF->IP();
BOPTools_CArray1OfSSInterference& aFFs=pIP->SSInterferences();
NMTTools_CommonBlockPool& aCBP=pPF->ChangeCommonBlockPool();
//
Standard_Integer j, nSpIn, nSpSc, aNbCurves;
Standard_Integer aNbS, nF, aNbCBP, n1, n2, aNbFFs, aNbSpIn;
TopTools_MapOfShape aMFence;
TopTools_ListOfShape aLSpIn;
TopoDS_Face aF;
NMTTools_ListIteratorOfListOfCommonBlock aItCB;
BOPTools_ListIteratorOfListOfPaveBlock aItPB;
//
myInParts.Clear();
//
aNbFFs=aFFs.Extent();
aNbCBP=aCBP.Extent();
//
aNbS=aDS.NumberOfShapesOfTheObject();
for (nF=1; nF<=aNbS; ++nF) {
if (aDS.GetShapeType(nF)!=TopAbs_FACE) {
continue;
}
//
aF=TopoDS::Face(aDS.Shape(nF));
//
aMFence.Clear();
aLSpIn.Clear();
//
// 1. In Parts
BOPTools_ListOfPaveBlock aLPBIn;
//
pPF->RealSplitsInFace(nF, aLPBIn);
//
aItPB.Initialize(aLPBIn);
for (; aItPB.More(); aItPB.Next()) {
const BOPTools_PaveBlock& aPB1=aItPB.Value();
nSpIn=aPB1.Edge();
const TopoDS_Shape& aSpIn=aDS.Shape(nSpIn);
aLSpIn.Append(aSpIn);
}
//
// 2. Section Parts
for (j=1; j<=aNbFFs; ++j) {
BOPTools_SSInterference& aFF=aFFs(j);
aFF.Indices(n1, n2);
if (!(n1==nF || n2==nF)) {
continue;
}
BOPTools_SequenceOfCurves& aSC=aFF.Curves();
aNbCurves=aSC.Length();
if (!aNbCurves) {
continue;
}
//
const BOPTools_Curve& aBC=aSC(1);
const BOPTools_ListOfPaveBlock& aLPB=aBC.NewPaveBlocks();
aItPB.Initialize(aLPB);
for (; aItPB.More(); aItPB.Next()) {
const BOPTools_PaveBlock& aPBSc=aItPB.Value();
nSpSc=aPBSc.Edge();
const TopoDS_Shape& aSpSc=aDS.Shape(nSpSc);
if (aMFence.Add(aSpSc)){
aLSpIn.Append(aSpSc);
}
}
}
aNbSpIn=aLSpIn.Extent();
if (aNbSpIn) {
myInParts.Add(aF, aLSpIn);
}
}//for (nF=1; nF<=aNbS; ++nF) {
}
//=======================================================================
// function: BuildSplitFaces
// purpose:
//=======================================================================
void GEOMAlgo_Builder::BuildSplitFaces()
{
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
NMTDS_InterfPool* pIP=pPF->IP();
BOPTools_CArray1OfSSInterference& aFFs=pIP->SSInterferences();
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
Standard_Boolean bToReverse, bIsClosed, bIsDegenerated;
Standard_Boolean bFlagClosed;
Standard_Integer i, aNb, aNbF, nF;
TopTools_MapOfShape aMFence;
TColStd_IndexedMapOfInteger aMFP;
TopExp_Explorer anExp;
TopoDS_Face aFF;
TopoDS_Edge aSp, aEE;
TopTools_ListIteratorOfListOfShape aIt;
TopAbs_Orientation anOriF, anOriE;
//
mySplitFaces.Clear();
//
// 1. Select Faces to process (MFP)
aNb=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNb; ++i) {
const TopoDS_Shape& aF=aDS.Shape(i);
if (aF.ShapeType()!=TopAbs_FACE) {
continue;
}
if (!aMFence.Add(aF)) {
continue;
}
//
if (myInParts.Contains(aF)) {
aMFP.Add(i);
continue;
}
//
anExp.Init(aF, TopAbs_EDGE);
for (; anExp.More(); anExp.Next()) {
const TopoDS_Shape& aE=anExp.Current();
if (myImages.HasImage(aE)) {
aMFP.Add(i);
break;
}
}
//
//===
{
Standard_Integer aNbFFs, aNbSE, j, n1, n2;
//
aNbFFs=aFFs.Extent();
for (j=1; j<=aNbFFs; ++j) {
BOPTools_SSInterference& aFFj=aFFs(j);
aFFj.Indices(n1, n2);
if (!(n1==i || n2==i)) {
continue;
}
//
const TColStd_ListOfInteger& aLSE=aFFj.SharedEdges();
aNbSE=aLSE.Extent();
if (aNbSE) {
aMFP.Add(i);
break;
}
}
}
//===
//
}// for (i=1; i<=aNb; ++i)
//
// 2. ProcessFaces
aNbF=aMFP.Extent();
for (i=1; i<=aNbF; ++i) {
nF=aMFP(i);
const TopoDS_Face& aF=TopoDS::Face(aDS.Shape(nF));
anOriF=aF.Orientation();
aFF=aF;
aFF.Orientation(TopAbs_FORWARD);
//
aMFence.Clear();
//
// 2.1. Fill WES
GEOMAlgo_WireEdgeSet aWES;
aWES.SetFace(aFF);
//
// 2.1.1. Add Split parts
anExp.Init(aFF, TopAbs_EDGE);
for (; anExp.More(); anExp.Next()) {
const TopoDS_Edge& aE=TopoDS::Edge(anExp.Current());
anOriE=aE.Orientation();
//
if (!myImages.HasImage(aE)) {
if (anOriE==TopAbs_INTERNAL) {
aEE=aE;
aEE.Orientation(TopAbs_FORWARD);
aWES.AddStartElement(aEE);
aEE.Orientation(TopAbs_REVERSED);
aWES.AddStartElement(aEE);
}
else {
aWES.AddStartElement(aE);
}
continue;
}
//
bIsDegenerated=BRep_Tool::Degenerated(aE);
bIsClosed=IsClosed(aE, aF, bFlagClosed);
//
const TopTools_ListOfShape& aLIE=myImages.Image(aE);
aIt.Initialize(aLIE);
for (; aIt.More(); aIt.Next()) {
aSp=TopoDS::Edge(aIt.Value());
//
if (bIsDegenerated) {
aSp.Orientation(anOriE);
aWES.AddStartElement(aSp);
continue;
}
//
if (anOriE==TopAbs_INTERNAL) {
aSp.Orientation(TopAbs_FORWARD);
aWES.AddStartElement(aSp);
aSp.Orientation(TopAbs_REVERSED);
aWES.AddStartElement(aSp);
continue;
}
//
if (bIsClosed){
if (aMFence.Add(aSp)) {
//
if (!BRep_Tool::IsClosed(aSp, aF)){
BOPTools_Tools3D::DoSplitSEAMOnFace(aSp, aF);
}
//
aSp.Orientation(TopAbs_FORWARD);
aWES.AddStartElement(aSp);
aSp.Orientation(TopAbs_REVERSED);
aWES.AddStartElement(aSp);
}
continue;
}// if (bIsClosed){
//
//modified by NIZNHY-PKV Wed Nov 28 13:50:34 2012f
if (!bIsClosed && bFlagClosed) {
if (!BRep_Tool::IsClosed(aSp, aF)){
BOPTools_Tools3D::DoSplitSEAMOnFace(aSp, aF);
}
}
//modified by NIZNHY-PKV Wed Nov 28 13:50:36 2012t
//
//
aSp.Orientation(anOriE);
bToReverse=BOPTools_Tools3D::IsSplitToReverse1(aSp, aE, aCtx);
if (bToReverse) {
aSp.Reverse();
}
aWES.AddStartElement(aSp);
}// for (; aIt.More(); aIt.Next()) {
}// for (; anExp.More(); anExp.Next()) {
//
// 2.1.2. Add In2D Parts
if (myInParts.Contains(aF)) {
const TopTools_ListOfShape& aLE=myInParts.FindFromKey(aF);
aIt.Initialize(aLE);
for (; aIt.More(); aIt.Next()) {
aSp=TopoDS::Edge(aIt.Value());
//
aSp.Orientation(TopAbs_FORWARD);
aWES.AddStartElement(aSp);
//
aSp.Orientation(TopAbs_REVERSED);
aWES.AddStartElement(aSp);
}
}
//
// 2.2. Build images Faces
TopTools_ListOfShape aLFR;
GEOMAlgo_ShapeSet aS1, aS2;
//
const TopTools_ListOfShape& aSE=aWES.StartElements();
aS1.Add(aSE);
aS2.Add(aFF, TopAbs_EDGE);
if (aS1.IsEqual(aS2)) {
aLFR.Append(aF);
}
else {
GEOMAlgo_BuilderFace aBF;
//
aBF.SetFace(aFF);
aBF.SetContext(aCtx);
aBF.SetShapes(aSE);
// <-DEB
aBF.Perform();
//
const TopTools_ListOfShape& aLF=aBF.Areas();
aIt.Initialize(aLF);
for (; aIt.More(); aIt.Next()) {
TopoDS_Shape& aFR=aIt.Value();
if (anOriF==TopAbs_REVERSED) {
aFR.Orientation(TopAbs_REVERSED);
}
aLFR.Append(aFR);
}
}
//
// 2.3. Collect draft images Faces
mySplitFaces.Bind(aF, aLFR);
}//for (i=1; i<=aNbF; ++i)
}
//=======================================================================
// function: FillSameDomainFaces
// purpose:
//=======================================================================
void GEOMAlgo_Builder::FillSameDomainFaces()
{
Standard_Boolean bIsSDF, bHasImage1, bHasImage2, bForward;
Standard_Integer i, j, aNbFF, nF1, nF2, aNbPBInOn, aNbC, aNbSE;
Standard_Integer aNbF1, aNbF2, i2s, aNbSD;
TopTools_MapOfShape aMFence;
TopTools_ListOfShape aLX1, aLX2;
TopTools_ListIteratorOfListOfShape aItF1, aItF2;
NMTTools_ListOfCoupleOfShape aLCS;
//
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
NMTDS_InterfPool* pIP=pPF->IP();
BOPTools_CArray1OfSSInterference& aFFs=pIP->SSInterferences();
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
//
//mySameDomainShapes.Clear();
//
// 1. For each FF find among images of faces
// all pairs of same domain faces (SDF) [=> aLCS]
aNbFF=aFFs.Extent();
for (i=1; i<=aNbFF; ++i) {
BOPTools_SSInterference& aFF=aFFs(i);
aFF.Indices(nF1, nF2);
//
const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
//
// if there are no in/on 2D split parts the faces nF1, nF2
// can not be SDF
const BOPTools_ListOfPaveBlock& aLPBInOn=aFF.PaveBlocks();
aNbPBInOn=aLPBInOn.Extent();
//
//===
const TColStd_ListOfInteger& aLSE=aFF.SharedEdges();
aNbSE=aLSE.Extent();
if (!aNbPBInOn && !aNbSE) {
continue;
}
//===
//
// if there is at least one section edge between faces nF1, nF2
// they can not be SDF
BOPTools_SequenceOfCurves& aSC=aFF.Curves();
aNbC=aSC.Length();
if (aNbC) {
continue;
}
//
// the faces are suspected to be SDF.
// Try to find SDF among images of nF1, nF2
aMFence.Clear();
//
//--------------------------------------------------------
bHasImage1=mySplitFaces.HasImage(aF1);
bHasImage2=mySplitFaces.HasImage(aF2);
//
aLX1.Clear();
if (!bHasImage1) {
aLX1.Append(aF1);
}
//
aLX2.Clear();
if (!bHasImage2) {
aLX2.Append(aF2);
}
//
const TopTools_ListOfShape& aLF1r=(bHasImage1)? mySplitFaces.Image(aF1) : aLX1;
const TopTools_ListOfShape& aLF2r=(bHasImage2)? mySplitFaces.Image(aF2) : aLX2;
//
TopTools_DataMapOfIntegerShape aMIS;
TColStd_ListIteratorOfListOfInteger aItLI;
NMTDS_BoxBndTreeSelector aSelector;
NMTDS_BoxBndTree aBBTree;
NCollection_UBTreeFiller <Standard_Integer, Bnd_Box> aTreeFiller(aBBTree);
//
aNbF1=aLF1r.Extent();
aNbF2=aLF2r.Extent();
bForward=(aNbF1<aNbF2);
//
const TopTools_ListOfShape& aLF1=bForward ? aLF1r : aLF2r;
const TopTools_ListOfShape& aLF2=bForward ? aLF2r : aLF1r;
//
// 1. aTreeFiller
aItF2.Initialize(aLF2);
for (i2s=1; aItF2.More(); aItF2.Next(), ++i2s) {
Bnd_Box aBoxF2s;
//
const TopoDS_Face& aF2s=*((TopoDS_Face*)(&aItF2.Value()));
//
BRepBndLib::Add(aF2s, aBoxF2s);
//
aMIS.Bind(i2s, aF2s);
//
aTreeFiller.Add(i2s, aBoxF2s);
}//for (i2s=1; aItF2.More(); aItF2.Next(), ++i2s) {
//
aTreeFiller.Fill();
//
// 2.
aItF1.Initialize(aLF1);
for (j=1; aItF1.More(); aItF1.Next(), ++j) {
Bnd_Box aBoxF1x;
//
const TopoDS_Face& aF1x=*((TopoDS_Face*)(&aItF1.Value()));
//
BRepBndLib::Add(aF1x, aBoxF1x);
//
aSelector.Clear();
aSelector.SetBox(aBoxF1x);
aNbSD=aBBTree.Select(aSelector);
if (!aNbSD) {
continue;
}
//
const TColStd_ListOfInteger& aLI=aSelector.Indices();
aItLI.Initialize(aLI);
for (; aItLI.More(); aItLI.Next()) {
i2s=aItLI.Value();
const TopoDS_Face& aF2y=*((TopoDS_Face*)(&aMIS.Find(i2s)));
//
bIsSDF=NMTTools_Tools::AreFacesSameDomain(aF1x, aF2y, aCtx);
if (bIsSDF) {
if (aMFence.Contains(aF1x) || aMFence.Contains(aF2y)) {
continue;
}
aMFence.Add(aF1x);
aMFence.Add(aF2y);
//
NMTTools_CoupleOfShape aCS;
//
aCS.SetShape1(aF1x);
aCS.SetShape2(aF2y);
aLCS.Append(aCS);
//
if (bForward) {
if (aF1x==aF1) {
if (!mySplitFaces.HasImage(aF1)) {
mySplitFaces.Bind(aF1, aF1);
}
}
if (aF2y==aF2) {
if (!mySplitFaces.HasImage(aF2)) {
mySplitFaces.Bind(aF2, aF2);
}
}
}
else {
if (aF1x==aF2) {
if (!mySplitFaces.HasImage(aF2)) {
mySplitFaces.Bind(aF2, aF2);
}
}
if (aF2y==aF1) {
if (!mySplitFaces.HasImage(aF1)) {
mySplitFaces.Bind(aF1, aF1);
}
}
}
//
break;
}//if (bIsSDF) {
}//for (; aItLI.More(); aItLI.Next()) {
}//for (; aItF1.More(); aItF1.Next()) {
}//for (i=1; i<=aNbFF; ++i)
//-------------------------------------------------------------
aNbC=aLCS.Extent();
if (!aNbC) {
return;
}
//
// 2. Find Chains
NMTTools_IndexedDataMapOfShapeIndexedMapOfShape aMC;
//
NMTTools_Tools::FindChains(aLCS, aMC);
//
Standard_Boolean bIsImage;
Standard_Integer aIx, aIxMin, aNbMSDF, k, aNbMFj;
TopoDS_Shape aFOld, aFSDmin;
TopTools_IndexedMapOfShape aMFj;
TopTools_DataMapOfShapeInteger aDMSI;
//
aItF1.Initialize(myShapes);
for (j=1; aItF1.More(); aItF1.Next(), ++j) {
const TopoDS_Shape& aSj=aItF1.Value();
aMFj.Clear();
TopExp::MapShapes(aSj, TopAbs_FACE, aMFj);
aNbMFj=aMFj.Extent();
for (k=1; k<=aNbMFj; ++k) {
const TopoDS_Shape& aFk=aMFj(k);
if (!aDMSI.IsBound(aFk)) {
aDMSI.Bind(aFk, j);
}
}
}
//
// 3. Fill the map of SDF mySameDomainFaces
aNbC=aMC.Extent();
for (i=1; i<=aNbC; ++i) {
// const TopoDS_Shape& aF=aMC.FindKey(i);
const TopTools_IndexedMapOfShape& aMSDF=aMC(i);
//
aNbMSDF=aMSDF.Extent();
for (j=1; j<=aNbMSDF; ++j) {
const TopoDS_Shape& aFSD=aMSDF(j);
bIsImage=mySplitFaces.IsImage(aFSD);
aFOld=aFSD;
if (bIsImage) {
aFOld=mySplitFaces.ImageFrom(aFSD);
}
//
aIx=aDMSI.Find(aFOld);
if (j==1) {
aIxMin=aIx;
aFSDmin=aFSD;
continue;
}
else {
if (aIx<aIxMin) {
aIxMin=aIx;
aFSDmin=aFSD;
}
}
}
//
for (j=1; j<=aNbMSDF; ++j) {
const TopoDS_Shape& aFSD=aMSDF(j);
mySameDomainShapes.Add(aFSD, aFSDmin);
}
}
//
}
//=======================================================================
// function: FillImagesFaces1
// purpose:
//=======================================================================
void GEOMAlgo_Builder::FillImagesFaces1()
{
Standard_Integer i, aNb, iSense, aNbLFx;
TopoDS_Face aF, aFSp, aFSD;
TopTools_ListOfShape aLFx;
TopTools_ListIteratorOfListOfShape aIt;
//
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
//
aNb=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNb; ++i) {
const TopoDS_Shape& aS=aDS.Shape(i);
if (aS.ShapeType()!=TopAbs_FACE) {
continue;
}
//
if (!mySplitFaces.HasImage(aS)) {
continue;
}
//
aF=*((TopoDS_Face*)&aS);
//
aLFx.Clear();
const TopTools_ListOfShape& aLF=mySplitFaces.Image(aF);
aIt.Initialize(aLF);
for (; aIt.More(); aIt.Next()) {
aFSp=*((TopoDS_Face*)(&aIt.Value()));
if (!mySameDomainShapes.Contains(aFSp)) {
aLFx.Append(aFSp);
}
else {
const TopoDS_Shape& aSx=mySameDomainShapes.FindFromKey(aFSp);
aFSD=*((TopoDS_Face*)(&aSx));
iSense=GEOMAlgo_Tools3D::Sense(aFSp, aFSD);
if (iSense<0) {
aFSD.Reverse();
}
aLFx.Append(aFSD);
}
}
//
if (!myImages.HasImage(aF)) {
aNbLFx=aLFx.Extent();
if (aNbLFx==1) {
const TopoDS_Shape& aFx=aLFx.First();
if (aF.IsSame(aFx)) {
continue;
}
}
myImages.Bind(aF, aLFx);
}
}
}
//=======================================================================
// function: FillInternalVertices
// purpose:
//=======================================================================
void GEOMAlgo_Builder::FillInternalVertices()
{
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
NMTDS_InterfPool* pIP=pPF->IP();
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
BOPTools_CArray1OfVSInterference& aVFs=pIP->VSInterferences();
BOPTools_CArray1OfESInterference& aEFs=pIP->ESInterferences();
const NMTTools_IndexedDataMapOfIndexedMapOfInteger& aMAV=pPF->AloneVertices();
//
Standard_Boolean bHasImage;
Standard_Integer i, j, nF, aNbS, nV, nVSD, n1, n2, iFlag;
Standard_Integer aNbVFs, aNbAVF, aNbEFs, aNbVC, aNbE, aNbV;
Standard_Real aU1, aU2, aTol;
NMTTools_IndexedDataMapOfIndexedMapOfInteger aMFMV;
TopTools_MapOfShape aMFence;
TopTools_ListIteratorOfListOfShape aIt, aItV;
BRep_Builder aBB;
//
// 1. Collect face-vertex candidates [aMFMV]
//
// 1.1. VFs
aNbVFs=aVFs.Extent();
for (i=1; i<=aNbVFs; ++i) {
const BOPTools_VSInterference& aVS=aVFs(i);
aVS.Indices(n1, n2);
nF=n2;
nV=n1;
if (aDS.Shape(n1).ShapeType()==TopAbs_FACE) {
nF=n1;
nV=n2;
}
nVSD=pPF->FindSDVertex(nV);
if (nVSD) {
nV=nVSD;
}
//
UpdateCandidates(nF, nV, aMFMV);
}
//
// 1.2 EFs
aNbEFs=aEFs.Extent();
for (i=1; i<=aNbEFs; ++i) {
const BOPTools_ESInterference& aEF=aEFs(i);
aEF.Indices(n1, n2);
nV=aEF.NewShape();
if (!nV) {
continue;
}
const TopoDS_Shape& aSnew=aDS.Shape(nV);
if (aSnew.ShapeType()!=TopAbs_VERTEX) {
continue;
}
//
nF=(aDS.Shape(n1).ShapeType()==TopAbs_FACE) ? n1 : n2;
nVSD=pPF->FindSDVertex(nV);
if (nVSD) {
nV=nVSD;
}
UpdateCandidates(nF, nV, aMFMV);
}
//
aNbS=aDS.NumberOfShapesOfTheObject();
for (nF=1; nF<=aNbS; ++nF) {
const TopoDS_Shape& aF=aDS.Shape(nF);
//
if (aF.ShapeType()!=TopAbs_FACE) {
continue;
}
if (!aMFence.Add(aF)) {
continue;
}
//
const TopoDS_Face& aFF=TopoDS::Face(aF);
aTol=BRep_Tool::Tolerance(aFF);
//
// 1.3 FFs
if (aMAV.Contains(nF)) {
const TColStd_IndexedMapOfInteger& aMAVF=aMAV.FindFromKey(nF);
aNbAVF=aMAVF.Extent();
for (j=1; j<=aNbAVF; ++j) {
nV=aMAVF(j);
nVSD=pPF->FindSDVertex(nV);
if (nVSD) {
nV=nVSD;
}
//
UpdateCandidates(nF, nV, aMFMV);
}
}
//
// 1.4 Internal vertices of the face nF
BooleanOperations_OnceExplorer aExp(aDS);
aExp.Init(nF, TopAbs_VERTEX);
for (; aExp.More(); aExp.Next()) {
nV=aExp.Current();
const TopoDS_Shape& aV=aDS.Shape(nV);
if (aV.Orientation()==TopAbs_INTERNAL) {
nVSD=pPF->FindSDVertex(nV);
if (nVSD) {
nV=nVSD;
}
//
UpdateCandidates(nF, nV, aMFMV);
}
}
//
// 2. Process face nF
if (!aMFMV.Contains(nF)) {
continue;
}
//
const TColStd_IndexedMapOfInteger& aMVC=aMFMV.FindFromKey(nF);
aNbVC=aMVC.Extent();
if (!aNbVC) {
continue;
}
//
// 2.1 Refine candidates
TopTools_IndexedDataMapOfShapeListOfShape aMVE;
TopTools_ListOfShape aLV;
//
bHasImage=myImages.HasImage(aF);
if (bHasImage) {
const TopTools_ListOfShape& aLFx=myImages.Image(aF);
aIt.Initialize(aLFx);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aFx=aIt.Value();
TopExp::MapShapesAndAncestors(aFx, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
}
}
else {
Standard_Boolean bFaceToProcess;
//
TopExp::MapShapesAndAncestors(aF, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
bFaceToProcess=Standard_False;
for (j=1; j<=aNbVC; ++j) {
nV=aMVC(j);
const TopoDS_Shape& aV=aDS.Shape(nV);
if (!aMVE.Contains(aV)) {
bFaceToProcess=!bFaceToProcess;
break;
}
}
if (!bFaceToProcess) {
continue;
}
}// else
//
for (j=1; j<=aNbVC; ++j) {
nV=aMVC(j);
const TopoDS_Shape& aV=aDS.Shape(nV);
if (aMVE.Contains(aV)) {
const TopTools_ListOfShape& aLE=aMVE.FindFromKey(aV);
aNbE=aLE.Extent();
if (aNbE) {
continue;
}
}
aLV.Append(aV);
}
//
aNbV=aLV.Extent();
if (aNbV) {
// 3. Try to put vertices into the face(s)
aItV.Initialize(aLV);
for (; aItV.More(); aItV.Next()) {
TopoDS_Vertex aV=TopoDS::Vertex(aItV.Value());
aV.Orientation(TopAbs_INTERNAL);
//
bHasImage=myImages.HasImage(aF);
if (bHasImage) {
const TopTools_ListOfShape& aLFx=myImages.Image(aF);
aIt.Initialize(aLFx);
for (; aIt.More(); aIt.Next()) {
TopoDS_Face aFx=TopoDS::Face(aIt.Value());
// update classifier
IntTools_FClass2d& aClsf=aCtx->FClass2d(aFx);
aClsf.Init(aFx, aTol);
//
iFlag=aCtx->ComputeVS (aV, aFx, aU1, aU2);
if (!iFlag) {
aBB.Add(aFx, aV);
break;
}
}
}
else {
const TopoDS_Face& aFx=TopoDS::Face(aF);
// update classifier
IntTools_FClass2d& aClsf=aCtx->FClass2d(aFx);
aClsf.Init(aFx, aTol);
//
iFlag=aCtx->ComputeVS (aV, aFx, aU1, aU2);
if (!iFlag) {
TopoDS_Face aFz;
//
GEOMAlgo_Tools3D::CopyFace(aFx, aFz);
aBB.Add(aFz, aV);
myImages.Bind(aF, aFz);
}
}
}// for (; aItV.More(); aItV.Next()) {
}// if (aNbV) {
}// for (nF=1; nF<=aNb; ++nF) {
}
//=======================================================================
// function: UpdateCandidates
// purpose:
//=======================================================================
void UpdateCandidates(const Standard_Integer theNF,
const Standard_Integer theNV,
NMTTools_IndexedDataMapOfIndexedMapOfInteger& theMFMV)
{
if (theMFMV.Contains(theNF)) {
TColStd_IndexedMapOfInteger& aMV=theMFMV.ChangeFromKey(theNF);
aMV.Add(theNV);
}
else {
TColStd_IndexedMapOfInteger aMV;
aMV.Add(theNV);
theMFMV.Add(theNF, aMV);
}
}
//=======================================================================
//function : IsClosed
//purpose :
//=======================================================================
Standard_Boolean IsClosed(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
Standard_Boolean& bFlag)
{
Standard_Boolean bRet;
//
bRet=BRep_Tool::IsClosed(aE, aF);
bFlag=bRet;
if (bRet) {
Standard_Integer iCnt;
TopoDS_Shape aE1;
//
bRet=!bRet;
iCnt=0;
TopExp_Explorer aExp(aF, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aEx=aExp.Current();
//
if (aEx.IsSame(aE)) {
++iCnt;
if (iCnt==1) {
aE1=aEx;
}
else if (iCnt==2){
aE1.Reverse();
bRet=(aE1==aEx);
break;
}
}
}
}
return bRet;
}
/*
{
TopoDS_Compound aCx;
BRep_Builder aBBx;
TopTools_ListIteratorOfListOfShape aItx;
//
aBBx.MakeCompound(aCx);
aBBx.Add(aCx, aFF);
aItx.Initialize(aSE);
for (; aItx.More(); aItx.Next()) {
TopoDS_Shape& aEx=aItx.Value();
aBBx.Add(aCx, aEx);
}
int a=0;
}
*/

770
src/GEOMAlgo/GEOMAlgo_Builder_3.cxx
View File

@ -1,770 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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 : GEOMAlgo_Builder_3.cxx
// Created :
// Author : Peter KURNEV
#include <GEOMAlgo_Builder.hxx>
#include <TopAbs_State.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Solid.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Solid.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Compound.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <BRep_Builder.hxx>
#include <BRepTools.hxx>
#include <BRepClass3d_SolidClassifier.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_DataMapOfShapeInteger.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeInteger.hxx>
#include <TopTools_MapOfShape.hxx>
#include <IntTools_Context.hxx>
#include <NMTDS_ShapesDataStructure.hxx>
#include <NMTTools_PaveFiller.hxx>
#include <GEOMAlgo_Tools3D.hxx>
#include <GEOMAlgo_BuilderSolid.hxx>
#include <GEOMAlgo_ShapeSet.hxx>
#include <GEOMAlgo_DataMapOfShapeShapeSet.hxx>
#include <GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet.hxx>
static
void OwnInternalShapes(const TopoDS_Shape& ,
TopTools_IndexedMapOfShape& );
//=======================================================================
//function : FillImagesSolids
//purpose :
//=======================================================================
void GEOMAlgo_Builder::FillImagesSolids()
{
myErrorStatus=0;
//
FillIn3DParts();
BuildSplitSolids();
FillInternalShapes();
}
//=======================================================================
//function : BuildDraftSolid
//purpose :
//=======================================================================
void GEOMAlgo_Builder::BuildDraftSolid (const TopoDS_Shape& theSolid,
TopoDS_Shape& theDraftSolid,
TopTools_ListOfShape& theLIF)
{
myErrorStatus=0;
//
NMTTools_PaveFiller* pPF=myPaveFiller;
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
Standard_Boolean bToReverse;
Standard_Integer iFlag;
TopAbs_Orientation aOrF, aOrSh, aOrSd;
TopoDS_Iterator aIt1, aIt2;
TopTools_ListIteratorOfListOfShape aItS;
BRep_Builder aBB;
TopoDS_Shell aShD;
TopoDS_Shape aFSDx, aFx;
//
aOrSd=theSolid.Orientation();
theDraftSolid.Orientation(aOrSd);
//
aIt1.Initialize(theSolid);
for (; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aSh=aIt1.Value();
if(aSh.ShapeType()!=TopAbs_SHELL) {
continue; // mb internal edges,vertices
}
//
aOrSh=aSh.Orientation();
aBB.MakeShell(aShD);
aShD.Orientation(aOrSh);
iFlag=0;
//
aIt2.Initialize(aSh);
for (; aIt2.More(); aIt2.Next()) {
const TopoDS_Shape& aF=aIt2.Value();
aOrF=aF.Orientation();
//
if (myImages.HasImage(aF)) {
const TopTools_ListOfShape& aLSp=myImages.Image(aF);
aItS.Initialize(aLSp);
for (; aItS.More(); aItS.Next()) {
aFx=aItS.Value();
//
if (mySameDomainShapes.Contains(aFx)) {
aFSDx=mySameDomainShapes.FindFromKey(aFx);
//
if (aOrF==TopAbs_INTERNAL) {
aFSDx.Orientation(aOrF);
theLIF.Append(aFSDx);
}
else {
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aFSDx, aF, aCtx);
if (bToReverse) {
aFSDx.Reverse();
}
//
iFlag=1;
aBB.Add(aShD, aFSDx);
}
}// if (mySameDomainShapes.Contains(aFx)) {
else {
aFx.Orientation(aOrF);
if (aOrF==TopAbs_INTERNAL) {
theLIF.Append(aFx);
}
else{
iFlag=1;
aBB.Add(aShD, aFx);
}
}
}
} //if (myImages.HasImage(aF)) {
//
else {
if (aOrF==TopAbs_INTERNAL) {
theLIF.Append(aF);
}
else{
iFlag=1;
aBB.Add(aShD, aF);
}
}
} //for (; aIt2.More(); aIt2.Next()) {
//
if (iFlag) {
aBB.Add(theDraftSolid, aShD);
}
} //for (; aIt1.More(); aIt1.Next()) {
}
//=======================================================================
//function : FillIn3DParts
//purpose :
//=======================================================================
void GEOMAlgo_Builder::FillIn3DParts()
{
myErrorStatus=0;
//
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
Standard_Boolean bIsIN, bHasImage;
Standard_Integer aNbS, aNbSolids, i, j, aNbFaces, aNbFP, aNbFPx, aNbFIN, aNbLIF;
TopAbs_ShapeEnum aType;
TopAbs_State aState;
TopTools_IndexedMapOfShape aMSolids, aMS, aMFaces, aMFIN;
TopTools_MapOfShape aMFDone;
TopTools_IndexedDataMapOfShapeListOfShape aMEF;
TopTools_ListIteratorOfListOfShape aItS;
TopoDS_Iterator aIt, aItF;
BRep_Builder aBB;
TopoDS_Solid aSolidSp;
TopoDS_Face aFP;
//
myDraftSolids.Clear();
//
aNbS=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNbS; ++i) {
const TopoDS_Shape& aS=aDS.Shape(i);
//
aType=aS.ShapeType();
if (aType==TopAbs_SOLID) {
// all solids from DS
aMSolids.Add(aS);
}
else if (aType==TopAbs_FACE) {
// all faces (originals from DS or theirs images)
if (myImages.HasImage(aS)) {
const TopTools_ListOfShape& aLS=myImages.Image(aS);
aItS.Initialize(aLS);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aFx=aItS.Value();
//
if (mySameDomainShapes.Contains(aFx)) {
const TopoDS_Shape& aFSDx=mySameDomainShapes.FindFromKey(aFx);
aMFaces.Add(aFSDx);
}
else {
aMFaces.Add(aFx);
}
}
}
else {
if (mySameDomainShapes.Contains(aS)) {
const TopoDS_Shape& aFSDx=mySameDomainShapes.FindFromKey(aS);
aMFaces.Add(aFSDx);
}
else {
aMFaces.Add(aS);
}
}
}
}
//
aNbFaces=aMFaces.Extent();
aNbSolids=aMSolids.Extent();
//
for (i=1; i<=aNbSolids; ++i) {
const TopoDS_Solid& aSolid=TopoDS::Solid(aMSolids(i));
aMFDone.Clear();
aMFIN.Clear();
aMEF.Clear();
//
aBB.MakeSolid(aSolidSp);
//
TopTools_ListOfShape aLIF;
//
BuildDraftSolid(aSolid, aSolidSp, aLIF);
aNbLIF=aLIF.Extent();
//
// 1 all faces/edges from aSolid [ aMS ]
bHasImage=Standard_False;
aMS.Clear();
aIt.Initialize(aSolid);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aShell=aIt.Value();
//
if (myImages.HasImage(aShell)) {
bHasImage=Standard_True;
//
const TopTools_ListOfShape& aLS=myImages.Image(aShell);
aItS.Initialize(aLS);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aSx=aItS.Value();
aMS.Add(aSx);
TopExp::MapShapes(aSx, TopAbs_FACE, aMS);
TopExp::MapShapes(aSx, TopAbs_EDGE, aMS);
TopExp::MapShapesAndAncestors(aSx, TopAbs_EDGE, TopAbs_FACE, aMEF);
}
}
else {
//aMS.Add(aShell);
TopExp::MapShapes(aShell, TopAbs_FACE, aMS);
TopExp::MapShapes(aShell, TopAbs_EDGE, aMS);
TopExp::MapShapesAndAncestors(aShell, TopAbs_EDGE, TopAbs_FACE, aMEF);
}
}
//
// 2 all faces that are not from aSolid [ aLFP1 ]
Standard_Integer aNbEFP;
TopTools_IndexedDataMapOfShapeListOfShape aMEFP;
TopTools_ListIteratorOfListOfShape aItFP, aItEx;
TopTools_MapOfShape aMFence;
TopTools_ListOfShape aLFP1, aLFP2, aLFP, aLCBF, aLFIN, aLEx;//*pLFP,
//
// for all non-solid faces build EF map [ aMEFP ]
for (j=1; j<=aNbFaces; ++j) {
const TopoDS_Shape& aFace=aMFaces(j);
if (!aMS.Contains(aFace)) {
TopExp::MapShapesAndAncestors(aFace, TopAbs_EDGE, TopAbs_FACE, aMEFP);
}
}
//
// among all faces from aMEFP select these that have same edges
// with the solid (i.e aMEF). These faces will be treated first
// to prevent the usage of 3D classifier.
// The full list of faces to process is aLFP1.
aNbEFP=aMEFP.Extent();
for (j=1; j<=aNbEFP; ++j) {
const TopoDS_Shape& aE=aMEFP.FindKey(j);
//
if (aMEF.Contains(aE)) { // !!
const TopTools_ListOfShape& aLF=aMEFP(j);
aItFP.Initialize(aLF);
for (; aItFP.More(); aItFP.Next()) {
const TopoDS_Shape& aF=aItFP.Value();
if (aMFence.Add(aF)) {
aLFP1.Append(aF);
}
}
}
else {
aLEx.Append(aE);
}
}
//
aItEx.Initialize(aLEx);
for (; aItEx.More(); aItEx.Next()) {
const TopoDS_Shape& aE=aItEx.Value();
const TopTools_ListOfShape& aLF=aMEFP.FindFromKey(aE);
aItFP.Initialize(aLF);
for (; aItFP.More(); aItFP.Next()) {
const TopoDS_Shape& aF=aItFP.Value();
if (aMFence.Add(aF)) {
aLFP2.Append(aF);
}
}
}
aLFP1.Append(aLFP2);
//==========
//
// 3 Process faces aLFP1
aNbFP=aLFP1.Extent();
aItFP.Initialize(aLFP1);
for (; aItFP.More(); aItFP.Next()) {
const TopoDS_Shape& aSP=aItFP.Value();
if (!aMFDone.Add(aSP)) {
continue;
}
//
// first face to process
aFP=TopoDS::Face(aSP);
bIsIN= GEOMAlgo_Tools3D::IsInternalFace(aFP, aSolidSp, aMEF, 1.e-14, aCtx);
aState=(bIsIN) ? TopAbs_IN : TopAbs_OUT;
//
// collect faces to process [ aFP is the first ]
aLFP.Clear();
aLFP.Append(aFP);
aItS.Initialize(aLFP1);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aSk=aItS.Value();
if (!aMFDone.Contains(aSk)) {
aLFP.Append(aSk);
}
}
//
// Connexity Block that spreads from aFP the Bound
// or till the end of the block itself
aLCBF.Clear();
GEOMAlgo_Tools3D::MakeConnexityBlock(aLFP, aMS, aLCBF);
//
// fill states for the Connexity Block
aItS.Initialize(aLCBF);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aSx=aItS.Value();
aMFDone.Add(aSx);
if (aState==TopAbs_IN) {
aMFIN.Add(aSx);
}
}
//
aNbFPx=aMFDone.Extent();
if (aNbFPx==aNbFP) {
break;
}
}//for (; aItFP.More(); aItFP.Next())
//
// faces Inside aSolid
aLFIN.Clear();
aNbFIN=aMFIN.Extent();
if (aNbFIN || aNbLIF) {
for (j=1; j<=aNbFIN; ++j) {
const TopoDS_Shape& aFIN=aMFIN(j);
aLFIN.Append(aFIN);
}
//
aItS.Initialize(aLIF);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aFIN=aItS.Value();
aLFIN.Append(aFIN);
}
//
myInParts.Add(aSolid, aLFIN);
}
if (aNbFIN || bHasImage) {
myDraftSolids.Add(aSolid, aSolidSp);
}
}//for (i=1; i<=aNbSolids; ++i) { // next solid
}
//=======================================================================
//function : BuildSplitSolids
//purpose :
//=======================================================================
void GEOMAlgo_Builder::BuildSplitSolids()
{
myErrorStatus=0;
//
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
Standard_Integer i, aNbS, iErr;
TopExp_Explorer aExp;
TopTools_ListOfShape aSFS, aLSEmpty;
TopTools_MapOfShape aMFence;
TopTools_ListIteratorOfListOfShape aIt;
GEOMAlgo_BuilderSolid aSB;
GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet aItSS;
GEOMAlgo_DataMapOfShapeShapeSet aMSS;
GEOMAlgo_ShapeSet aSSi;
//
// 0. Find same domain solids for non-interferred solids
aNbS=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNbS; ++i) {
const TopoDS_Shape& aS=aDS.Shape(i);
if (aS.ShapeType()!=TopAbs_SOLID) {
continue;
}
if (!aMFence.Add(aS)) {
continue;
}
if(myDraftSolids.Contains(aS)) {
continue;
}
//
aSSi.Clear();
aSSi.Add(aS, TopAbs_FACE);
//
aMSS.Bind(aS, aSSi);
} //for (i=1; i<=aNbS; ++i)
//
// 1. Build solids for interferred source solids
aSB.SetContext(aCtx);
aSB.ComputeInternalShapes(myComputeInternalShapes);
aNbS=myDraftSolids.Extent();
for (i=1; i<=aNbS; ++i) {
const TopoDS_Shape& aS =myDraftSolids.FindKey(i);
const TopoDS_Shape& aSD=myDraftSolids.FindFromIndex(i);
const TopTools_ListOfShape& aLFIN=
(myInParts.Contains(aS)) ? myInParts.FindFromKey(aS) : aLSEmpty;
//
// 1.1 Fill Shell Faces Set
aSFS.Clear();
aExp.Init(aSD, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aF=aExp.Current();
aSFS.Append(aF);
}
//
aIt.Initialize(aLFIN);
for (; aIt.More(); aIt.Next()) {
TopoDS_Shape aF=aIt.Value();
//
aF.Orientation(TopAbs_FORWARD);
aSFS.Append(aF);
aF.Orientation(TopAbs_REVERSED);
aSFS.Append(aF);
}
//
Standard_Integer aNbSFS;
aNbSFS=aSFS.Extent();
//
// 1.2
// Check whether aSFS contains a subsets of faces
// of solids that have been already built.
// If yes, shrink aSFS by these subsets.
aSSi.Clear();
aSSi.Add(aSFS);
//
aItSS.Initialize(aMSS);
for (; aItSS.More(); aItSS.Next()) {
const TopoDS_Shape& aSR=aItSS.Key();
const GEOMAlgo_ShapeSet& aSSR=aItSS.Value();
if (aSSi.Contains(aSSR)) {
// the aSR is SD solid for aS
aSSi.Subtract(aSSR);
// update images
if(myImages.HasImage(aS)) {
myImages.Add(aS, aSR);
}
else {
myImages.Bind(aS, aSR);
}
//
// update SD Shapes
mySameDomainShapes.Add(aSR, aSR);
}
}
const TopTools_ListOfShape& aSFS1=aSSi.GetSet();
aNbSFS=aSFS1.Extent();
if (!aNbSFS) {
continue;
}
//
// 1.3 Build new solids
aSB.SetContext(aCtx);
aSB.SetShapes(aSFS1);
aSB.Perform();
iErr=aSB.ErrorStatus();
if (iErr) {
myErrorStatus=30; // SolidBuilder failed
return;
}
//
const TopTools_ListOfShape& aLSR=aSB.Areas();
//
// 1.4 Collect resulting solids and theirs set of faces
aIt.Initialize(aLSR);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSR=aIt.Value();
//
aSSi.Clear();
aExp.Init(aSR, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aF=aExp.Current();
aSSi.Add(aF);
}
aMSS.Bind(aSR, aSSi);
}
//
// Update images
if (myImages.HasImage(aS)) {
myImages.Add(aS, aLSR);
}
else {
myImages.Bind(aS, aLSR);
}
} // for (i=1; i<=aNbS; ++i) {
}
//=======================================================================
//function :FillInternalShapes
//purpose :
//=======================================================================
void GEOMAlgo_Builder::FillInternalShapes()
{
myErrorStatus=0;
//
const NMTDS_ShapesDataStructure& aDS=*myPaveFiller->DS();
NMTTools_PaveFiller* pPF=myPaveFiller;
const Handle(IntTools_Context)& aCtx= pPF->Context();
//
//Standard_Boolean bHasImage;
Standard_Integer i, j, jT, aNbS, aNbSI, aNbSx, aNbSd;
TopAbs_ShapeEnum aType, aT[]={ TopAbs_VERTEX, TopAbs_EDGE };
TopAbs_State aState;
TopTools_ListIteratorOfListOfShape aIt, aIt1;
TopTools_IndexedDataMapOfShapeListOfShape aMSx;
TopTools_IndexedMapOfShape aMx;
TopTools_MapOfShape aMSI, aMFence, aMSOr;
TopTools_MapIteratorOfMapOfShape aItM;
TopTools_ListOfShape aLSI, aLSd;
TopoDS_Iterator aItS;
BRep_Builder aBB;
//
// 1. Shapes to process
//
// 1.1 Shapes from pure arguments aMSI
// 1.1.1 vertex, edge
for (i=0; i<2; ++i) {
jT=(Standard_Integer)aT[i];
const TopTools_ListOfShape &aLS=myShapes1[jT];
aIt.Initialize(aLS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
if (aMFence.Add(aS)) {
aLSI.Append(aS);
}
}
}
// 1.1.2 wire
{
jT=(Standard_Integer)TopAbs_WIRE;
const TopTools_ListOfShape &aLW=myShapes1[jT];
aIt.Initialize(aLW);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aW=aIt.Value();
aItS.Initialize(aW);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aE=aItS.Value();
if (aMFence.Add(aE)) {
aLSI.Append(aE);
}
}
}
}
// 1.1.3 theirs images/sources
aIt1.Initialize(aLSI);
for (; aIt1.More(); aIt1.Next()) {
const TopoDS_Shape& aS=aIt1.Value();
if (myImages.HasImage(aS)) {
const TopTools_ListOfShape &aLSp=myImages.Image(aS);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSI=aIt.Value();
aMSI.Add(aSI);
}
}
else {
aMSI.Add(aS);
}
}
aLSI.Clear();
aNbSI=aMSI.Extent();
//
// 2. Internal vertices, edges from source solids
aMFence.Clear();
aLSd.Clear();
//
aNbS=aDS.NumberOfShapesOfTheObject();
for (i=1; i<=aNbS; ++i) {
const TopoDS_Shape& aS=aDS.Shape(i);
aType=aS.ShapeType();
if (aType==TopAbs_SOLID) {
//
aMx.Clear();
OwnInternalShapes(aS, aMx);
//
aNbSx=aMx.Extent();
for (j=1; j<=aNbSx; ++j) {
const TopoDS_Shape& aSI=aMx(j);
if (myImages.HasImage(aSI)) {
const TopTools_ListOfShape &aLSp=myImages.Image(aSI);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp=aIt.Value();
aMSI.Add(aSp);
}
}
else {
aMSI.Add(aSI);
}
}
//
// build aux map from splits of solids
if (myImages.HasImage(aS)) {
const TopTools_ListOfShape &aLSp=myImages.Image(aS);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp=aIt.Value();
if (aMFence.Add(aSp)) {
TopExp::MapShapesAndAncestors(aSp, TopAbs_VERTEX, TopAbs_EDGE, aMSx);
TopExp::MapShapesAndAncestors(aSp, TopAbs_VERTEX, TopAbs_FACE, aMSx);
TopExp::MapShapesAndAncestors(aSp, TopAbs_EDGE , TopAbs_FACE, aMSx);
aLSd.Append(aSp);
}
}
}
else {
if (aMFence.Add(aS)) {
TopExp::MapShapesAndAncestors(aS, TopAbs_VERTEX, TopAbs_EDGE, aMSx);
TopExp::MapShapesAndAncestors(aS, TopAbs_VERTEX, TopAbs_FACE, aMSx);
TopExp::MapShapesAndAncestors(aS, TopAbs_EDGE , TopAbs_FACE, aMSx);
aLSd.Append(aS);
aMSOr.Add(aS);
}
}
}//if (aType==TopAbs_SOLID)
}
//
aNbSd=aLSd.Extent();
//
// 3. Some shapes of aMSI can be already tied with faces of
// split solids
aItM.Initialize(aMSI);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aSI=aItM.Key();
if (aMSx.Contains(aSI)) {
const TopTools_ListOfShape &aLSx=aMSx.FindFromKey(aSI);
aNbSx=aLSx.Extent();
if (aNbSx) {
//modified by NIZNHY-PKV Wed Mar 27 11:39:15 2013f
//aMSI.Remove(aSI);
if (aMSI.Remove(aSI)) {
aItM.Initialize(aMSI);
}
//modified by NIZNHY-PKV Wed Mar 27 11:39:18 2013t
}
}
}
//
// 4. Just check it
aNbSI=aMSI.Extent();
if (!aNbSI) {
return;
}
//
// 5 Settle internal vertices and edges into solids
aMx.Clear();
aIt.Initialize(aLSd);
for (; aIt.More(); aIt.Next()) {
TopoDS_Solid aSd=TopoDS::Solid(aIt.Value());
//
aItM.Initialize(aMSI);
for (; aItM.More(); /*aItM.Next()*/) {
TopoDS_Shape aSI=aItM.Key();
aItM.Next(); // to safely call aMSI.Remove(aSI)
aSI.Orientation(TopAbs_INTERNAL);
//
aState=GEOMAlgo_Tools3D::ComputeStateByOnePoint(aSI, aSd, 1.e-11, aCtx);
if (aState==TopAbs_IN) {
//
if(aMSOr.Contains(aSd)) {
//
TopoDS_Solid aSdx;
//
aBB.MakeSolid(aSdx);
aItS.Initialize(aSd);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aSh=aItS.Value();
aBB.Add(aSdx, aSh);
}
//
aBB.Add(aSdx, aSI);
//
myImages.Bind(aSd, aSdx);
aMSOr.Remove(aSd);
aSd=aSdx;
}
else {
aBB.Add(aSd, aSI);
}
//
aMSI.Remove(aSI);
} //if (aState==TopAbs_IN) {
}// for (; aItM.More(); aItM.Next()) {
}//for (; aIt1.More(); aIt1.Next()) {
}
//=======================================================================
//function : OwnInternalShapes
//purpose :
//=======================================================================
void OwnInternalShapes(const TopoDS_Shape& theS,
TopTools_IndexedMapOfShape& theMx)
{
TopoDS_Iterator aIt;
//
aIt.Initialize(theS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSx=aIt.Value();
if (aSx.ShapeType()!=TopAbs_SHELL) {
theMx.Add(aSx);
}
}
}
//
// ErrorStatus
// 30 - SolidBuilder failed

316
src/GEOMAlgo/GEOMAlgo_Builder_4.cxx
View File

@ -1,316 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_Builder_4.cxx
// Created:
// Author: Peter KURNEV
//
#include <GEOMAlgo_Builder.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <IntTools_Context.hxx>
#include <NMTDS_ShapesDataStructure.hxx>
#include <NMTTools_PaveFiller.hxx>
#include <GEOMAlgo_Tools3D.hxx>
static
void MapShapes(const TopoDS_Shape& aS,
TopTools_MapOfShape& aM);
//=======================================================================
//function : Generated
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_Builder::Generated(const TopoDS_Shape& theS)
{
NMTTools_PaveFiller* pPF=myPaveFiller;
const Handle(IntTools_Context)& aCtx=pPF->Context();
//
Standard_Boolean bHasImage, bToReverse;
TopAbs_ShapeEnum aType;
TopTools_ListIteratorOfListOfShape aIt;
//
myHistShapes.Clear();
//
if (theS.IsNull()) {
return myHistShapes;
}
//
bHasImage=myImages.HasImage(theS);
if (!bHasImage) {
return myHistShapes;
}
//
aType=theS.ShapeType();
//
if (aType==TopAbs_EDGE || aType==TopAbs_FACE ||
aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
const TopTools_ListOfShape& aLSp=myImages.Image(theS);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp=aIt.Value();
if (mySameDomainShapes.Contains(aSp)) {
if (myMapShape.Contains(aSp)) {
TopoDS_Shape aSpR=mySameDomainShapes.FindFromKey(aSp);
//
if (aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
aSpR.Orientation(theS.Orientation());
}
else {
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aSpR, theS, aCtx);
if (bToReverse) {
aSpR.Reverse();
}
}
//
myHistShapes.Append(aSpR);
}
}
}
}
//
return myHistShapes;
}
//=======================================================================
//function : Modified
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_Builder::Modified(const TopoDS_Shape& theS)
{
NMTTools_PaveFiller* pPF=myPaveFiller;
const Handle(IntTools_Context)& aCtx=pPF->Context();
//
Standard_Boolean bHasImage, bToReverse;
TopAbs_ShapeEnum aType;
TopTools_ListIteratorOfListOfShape aIt;
//
myHistShapes.Clear();
//
if (theS.IsNull()) {
return myHistShapes;
}
//
bHasImage=myImages.HasImage(theS);
if (!bHasImage) {
return myHistShapes;
}
//
aType=theS.ShapeType();
//
if (aType==TopAbs_EDGE || aType==TopAbs_FACE ||
aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
const TopTools_ListOfShape& aLSp=myImages.Image(theS);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
TopoDS_Shape aSp=aIt.Value();
if (!mySameDomainShapes.Contains(aSp)) {
if (myMapShape.Contains(aSp)) {
//
if (aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
aSp.Orientation(theS.Orientation());
}
else {
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aSp, theS, aCtx);
if (bToReverse) {
aSp.Reverse();
}
}
//
myHistShapes.Append(aSp);
}
}
}
}
//
return myHistShapes;
}
//=======================================================================
//function : IsDeleted
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_Builder::IsDeleted(const TopoDS_Shape& theS)
{
Standard_Boolean bRet, bHasImage, bContains;
TopAbs_ShapeEnum aType;
TopTools_ListIteratorOfListOfShape aIt;
//
bRet=Standard_False;
//
if (theS.IsNull()) {
return !bRet; //true
}
//
bContains=myMapShape.Contains(theS);
if (bContains) {
return bRet; //false
}
//
bHasImage=myImages.HasImage(theS);
if (!bHasImage) {
return !bRet; //true
}
//
aType=theS.ShapeType();
if (aType==TopAbs_EDGE || aType==TopAbs_FACE ||
aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
const TopTools_ListOfShape& aLSp=myImages.Image(theS);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
TopoDS_Shape aSp=aIt.Value();
//
if (!mySameDomainShapes.Contains(aSp)) {
if (myMapShape.Contains(aSp)) {
return bRet; //false
}
}
else {
TopoDS_Shape aSpR=mySameDomainShapes.FindFromKey(aSp);
if (myMapShape.Contains(aSpR)) {
return bRet; //false
}
}
}
}
return !bRet; // true
}
//=======================================================================
//function : PrepareHistory
//purpose :
//=======================================================================
void GEOMAlgo_Builder::PrepareHistory()
{
if(myShape.IsNull()) {
return;
}
//
Standard_Boolean bHasImage, bContainsSD;
TopAbs_ShapeEnum aType;
TopTools_MapOfShape aMS;
TopTools_ListIteratorOfListOfShape aIt;
TopTools_MapIteratorOfMapOfShape aItM;
//
// 1. Clearing
GEOMAlgo_BuilderShape::PrepareHistory();
//
// 2. myMapShape - all shapes of result with theirs sub-shapes
MapShapes(myShape, myMapShape);
//
// 3. MS - all argument shapes with theirs sub-shapes
aIt.Initialize(myShapes);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSx=aIt.Value();
MapShapes(aSx, aMS);
}
//
// 4. Treatment
aItM.Initialize(aMS);
for (; aItM.More(); aItM.Next()) {
const TopoDS_Shape& aSx=aItM.Key();
aType=aSx.ShapeType();
//modified by NIZNHY-PKV Thu Dec 7 11:34:05 2006f
//
// 4.1 .myImagesResult
TopTools_ListOfShape aLSx;
//
bHasImage=myImages.HasImage(aSx);
if (!bHasImage) {
if (myMapShape.Contains(aSx)) {
aLSx.Append(aSx);
myImagesResult.Add(aSx, aLSx);
}
}
else {
const TopTools_ListOfShape& aLSp=myImages.Image(aSx);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp=aIt.Value();
if (myMapShape.Contains(aSp)) {
aLSx.Append(aSp);
}
}
myImagesResult.Add(aSx, aLSx);
}
//
//modified by NIZNHY-PKV Thu Dec 7 11:34:10 2006t
//
// 4.2 As it was
if (!myHasDeleted) {
myHasDeleted=IsDeleted(aSx);//xx
}
//
if (!myHasGenerated || !myHasModified) {
if (aType==TopAbs_EDGE || aType==TopAbs_FACE ||
aType==TopAbs_VERTEX || aType==TopAbs_SOLID) {
//modified by NIZNHY-PKV Thu Dec 7 11:53:01 2006f
//bHasImage=myImages.HasImage(aSx);
//modified by NIZNHY-PKV Thu Dec 7 11:53:04 2006t
if (bHasImage) {
const TopTools_ListOfShape& aLSp=myImages.Image(aSx);
aIt.Initialize(aLSp);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aSp=aIt.Value();
//
if (myMapShape.Contains(aSp)) {
bContainsSD=mySameDomainShapes.Contains(aSp);
//
if (!myHasGenerated) {
if (bContainsSD) {
myHasGenerated=Standard_True;
}
}
if (!myHasModified) {
if (!bContainsSD) {
myHasModified=Standard_True;
}
}
} // if (myMapShape.Contains(aSp))
}
}
}
}
}
}
//=======================================================================
//function : MapShapes
//purpose :
//=======================================================================
void MapShapes(const TopoDS_Shape& theS,
TopTools_MapOfShape& theM)
{
theM.Add(theS);
TopoDS_Iterator anIt;
anIt.Initialize(theS);
for (; anIt.More(); anIt.Next()) {
const TopoDS_Shape& aSx=anIt.Value();
MapShapes(aSx, theM);
}
}

24
src/GEOMAlgo/GEOMAlgo_ClsfBox.cxx
View File

@ -27,21 +27,25 @@
// //
#include <GEOMAlgo_ClsfBox.hxx> #include <GEOMAlgo_ClsfBox.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <GEOMAlgo_SurfaceTools.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopExp.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS.hxx>
#include <Geom_Surface.hxx>
#include <BRep_Tool.hxx>
#include <Geom_Plane.hxx>
#include <gp_Pnt.hxx> #include <gp_Pnt.hxx>
#include <gp_Dir.hxx> #include <gp_Dir.hxx>
#include <gp_Pln.hxx> #include <gp_Pln.hxx>
#include <gp_Ax3.hxx> #include <gp_Ax3.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <Geom_Surface.hxx>
#include <Geom_Plane.hxx> #include <Geom_Plane.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS.hxx>
#include <BRep_Tool.hxx>
#include <TopExp.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <GEOMAlgo_SurfaceTools.hxx>
IMPLEMENT_STANDARD_HANDLE(GEOMAlgo_ClsfBox, GEOMAlgo_Clsf) IMPLEMENT_STANDARD_HANDLE(GEOMAlgo_ClsfBox, GEOMAlgo_Clsf)
IMPLEMENT_STANDARD_RTTIEXT(GEOMAlgo_ClsfBox, GEOMAlgo_Clsf) IMPLEMENT_STANDARD_RTTIEXT(GEOMAlgo_ClsfBox, GEOMAlgo_Clsf)

2
src/GEOMAlgo/GEOMAlgo_ClsfBox.hxx
View File

@ -30,7 +30,7 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_DefineHandle.hxx> #include <Standard_DefineHandle.hxx>
//#include <Handle_GEOMAlgo_ClsfBox.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <GeomAdaptor_Surface.hxx> #include <GeomAdaptor_Surface.hxx>
#include <GEOMAlgo_Clsf.hxx> #include <GEOMAlgo_Clsf.hxx>

2
src/GEOMAlgo/GEOMAlgo_ClsfSolid.cxx
View File

@ -25,8 +25,10 @@
#include <GEOMAlgo_ClsfSolid.hxx> #include <GEOMAlgo_ClsfSolid.hxx>
#include <TopAbs_ShapeEnum.hxx> #include <TopAbs_ShapeEnum.hxx>
#include <TopoDS.hxx> #include <TopoDS.hxx>
#include <TopoDS_Solid.hxx> #include <TopoDS_Solid.hxx>
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>
#include <BRepClass3d_SolidClassifier.hxx> #include <BRepClass3d_SolidClassifier.hxx>

1
src/GEOMAlgo/GEOMAlgo_ClsfSolid.hxx
View File

@ -27,7 +27,6 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_DefineHandle.hxx> #include <Standard_DefineHandle.hxx>
//#include <Handle_GEOMAlgo_ClsfSolid.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <Standard_Address.hxx> #include <Standard_Address.hxx>
#include <GEOMAlgo_Clsf.hxx> #include <GEOMAlgo_Clsf.hxx>

4
src/GEOMAlgo/GEOMAlgo_ClsfSurf.cxx
View File

@ -26,10 +26,12 @@
// <pkv@irinox> // <pkv@irinox>
// //
#include <GEOMAlgo_ClsfSurf.hxx> #include <GEOMAlgo_ClsfSurf.hxx>
#include <GeomAbs_SurfaceType.hxx> #include <GeomAbs_SurfaceType.hxx>
#include <GEOMAlgo_SurfaceTools.hxx>
#include <GeomAdaptor_Curve.hxx> #include <GeomAdaptor_Curve.hxx>
#include <GEOMAlgo_SurfaceTools.hxx>
IMPLEMENT_STANDARD_HANDLE(GEOMAlgo_ClsfSurf, GEOMAlgo_Clsf); IMPLEMENT_STANDARD_HANDLE(GEOMAlgo_ClsfSurf, GEOMAlgo_Clsf);
IMPLEMENT_STANDARD_RTTIEXT(GEOMAlgo_ClsfSurf, GEOMAlgo_Clsf); IMPLEMENT_STANDARD_RTTIEXT(GEOMAlgo_ClsfSurf, GEOMAlgo_Clsf);

1
src/GEOMAlgo/GEOMAlgo_ClsfSurf.hxx
View File

@ -30,7 +30,6 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_DefineHandle.hxx> #include <Standard_DefineHandle.hxx>
//#include <Handle_GEOMAlgo_ClsfSurf.hxx>
#include <Handle_Geom_Surface.hxx> #include <Handle_Geom_Surface.hxx>
#include <GeomAdaptor_Surface.hxx> #include <GeomAdaptor_Surface.hxx>
#include <GEOMAlgo_Clsf.hxx> #include <GEOMAlgo_Clsf.hxx>

32
src/GEOMAlgo/GEOMAlgo_DataMapIteratorOfDataMapOfOrientedShapeShape.hxx
View File

@ -1,32 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapIteratorOfDataMapOfOrientedShapeShape.hxx
// Created: Wed Feb 22 11:05:01 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapIteratorOfDataMapOfOrientedShapeShape_HeaderFile
#define GEOMAlgo_DataMapIteratorOfDataMapOfOrientedShapeShape_HeaderFile
#ifndef GEOMAlgo_DataMapOfOrientedShapeShape_HeaderFile
#include <GEOMAlgo_DataMapOfOrientedShapeShape.hxx>
#endif
#endif

31
src/GEOMAlgo/GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyShapeShape.hxx
View File

@ -1,31 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyShapeShape.hxx
// Created: Wed Feb 22 11:01:34 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyShapeShape_HeaderFile
#define GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyShapeShape_HeaderFile
#ifndef GEOMAlgo_DataMapOfPassKeyShapeShape_HeaderFile
#include <GEOMAlgo_DataMapOfPassKeyShapeShape.hxx>
#endif
#endif

31
src/GEOMAlgo/GEOMAlgo_DataMapIteratorOfDataMapOfRealListOfShape.hxx
View File

@ -1,31 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapIteratorOfDataMapOfRealListOfShape.hxx
// Created: Wed Feb 22 10:53:47 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapIteratorOfDataMapOfRealListOfShape_HeaderFile
#define GEOMAlgo_DataMapIteratorOfDataMapOfRealListOfShape_HeaderFile
#ifndef GEOMAlgo_DataMapOfRealListOfShape_HeaderFile
#include <GEOMAlgo_DataMapOfRealListOfShape.hxx>
#endif
#endif

31
src/GEOMAlgo/GEOMAlgo_DataMapIteratorOfDataMapOfShapeMapOfShape.hxx
View File

@ -1,31 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapIteratorOfDataMapOfShapeMapOfShape.hxx
// Created: Wed Feb 22 11:08:26 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapIteratorOfDataMapOfShapeMapOfShape_HeaderFile
#define GEOMAlgo_DataMapIteratorOfDataMapOfShapeMapOfShape_HeaderFile
#ifndef GEOMAlgo_DataMapOfShapeMapOfShape_HeaderFile
#include <GEOMAlgo_DataMapOfShapeMapOfShape.hxx>
#endif
#endif

31
src/GEOMAlgo/GEOMAlgo_DataMapIteratorOfDataMapOfShapePnt.hxx
View File

@ -1,31 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapIteratorOfDataMapOfShapePnt.hxx
// Created: Wed Feb 22 11:11:09 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapIteratorOfDataMapOfShapePnt_HeaderFile
#define GEOMAlgo_DataMapIteratorOfDataMapOfShapePnt_HeaderFile
#ifndef GEOMAlgo_DataMapOfShapePnt_HeaderFile
#include <GEOMAlgo_DataMapOfShapePnt.hxx>
#endif
#endif

32
src/GEOMAlgo/GEOMAlgo_DataMapIteratorOfDataMapOfShapeReal.hxx
View File

@ -1,32 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapIteratorOfDataMapOfShapeReal.hxx
// Created: Wed Feb 22 10:49:11 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapIteratorOfDataMapOfShapeReal_HeaderFile
#define GEOMAlgo_DataMapIteratorOfDataMapOfShapeReal_HeaderFile
#ifndef GEOMAlgo_DataMapOfShapeReal_HeaderFile
#include <GEOMAlgo_DataMapOfShapeReal.hxx>
#endif
#endif

32
src/GEOMAlgo/GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet.hxx
View File

@ -1,32 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet.hxx
// Created: Wed Feb 22 08:39:02 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet_HeaderFile
#define GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet_HeaderFile
#ifndef GEOMAlgo_DataMapOfShapeShapeSet_HeaderFile
#include <GEOMAlgo_DataMapOfShapeShapeSet.hxx>
#endif
#endif

42
src/GEOMAlgo/GEOMAlgo_DataMapOfOrientedShapeShape.hxx
View File

@ -1,42 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapOfOrientedShapeShape.hxx
// Created: Wed Feb 22 11:03:36 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapOfOrientedShapeShape_HeaderFile
#define GEOMAlgo_DataMapOfOrientedShapeShape_HeaderFile
#include <TopoDS_Shape.hxx>
#include <TopTools_OrientedShapeMapHasher.hxx>
#define _NCollection_MapHasher
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<TopoDS_Shape, TopoDS_Shape, TopTools_OrientedShapeMapHasher> GEOMAlgo_DataMapOfOrientedShapeShape;
typedef GEOMAlgo_DataMapOfOrientedShapeShape::Iterator GEOMAlgo_DataMapIteratorOfDataMapOfOrientedShapeShape;
#undef _NCollection_MapHasher
#endif

40
src/GEOMAlgo/GEOMAlgo_DataMapOfPassKeyShapeShape.hxx
View File

@ -1,40 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapOfPassKeyShapeShape.hxx
// Created: Wed Feb 22 11:00:16 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapOfPassKeyShapeShape_HeaderFile
#define GEOMAlgo_DataMapOfPassKeyShapeShape_HeaderFile
#include <GEOMAlgo_PassKey.hxx>
#include <TopoDS_Shape.hxx>
#include <GEOMAlgo_PassKeyMapHasher.hxx>
#define _NCollection_MapHasher
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<GEOMAlgo_PassKey, TopoDS_Shape, GEOMAlgo_PassKeyMapHasher> GEOMAlgo_DataMapOfPassKeyShapeShape;
typedef GEOMAlgo_DataMapOfPassKeyShapeShape::Iterator GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyShapeShape;
#endif

43
src/GEOMAlgo/GEOMAlgo_DataMapOfRealListOfShape.hxx
View File

@ -1,43 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapOfRealListOfShape.hxx
// Created: Wed Feb 22 10:51:48 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapOfRealListOfShape_HeaderFile
#define GEOMAlgo_DataMapOfRealListOfShape_HeaderFile
#include <Standard_Real.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TColStd_MapRealHasher.hxx>
#define _NCollection_MapHasher
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<Standard_Real, TopTools_ListOfShape, TColStd_MapRealHasher> GEOMAlgo_DataMapOfRealListOfShape;
typedef GEOMAlgo_DataMapOfRealListOfShape::Iterator GEOMAlgo_DataMapIteratorOfDataMapOfRealListOfShape;
#undef _NCollection_MapHasher
#endif

41
src/GEOMAlgo/GEOMAlgo_DataMapOfShapeReal.hxx
View File

@ -1,41 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapOfShapeReal.hxx
// Created: Wed Feb 22 10:47:23 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapOfShapeReal_HeaderFile
#define GEOMAlgo_DataMapOfShapeReal_HeaderFile
#include <TopoDS_Shape.hxx>
#include <Standard_Real.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#define _NCollection_MapHasher
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher> GEOMAlgo_DataMapOfShapeReal;
typedef GEOMAlgo_DataMapOfShapeReal::Iterator GEOMAlgo_DataMapIteratorOfDataMapOfShapeReal;
#undef _NCollection_MapHasher
#endif

42
src/GEOMAlgo/GEOMAlgo_DataMapOfShapeShapeSet.hxx
View File

@ -1,42 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_DataMapOfShapeShapeSet.hxx
// Created: Wed Feb 22 08:36:15 2012
// Author:
// <pkv@BDEURI37616>
#ifndef GEOMAlgo_DataMapOfShapeShapeSet_HeaderFile
#define GEOMAlgo_DataMapOfShapeShapeSet_HeaderFile
#include <TopoDS_Shape.hxx>
#include <GEOMAlgo_ShapeSet.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#define _NCollection_MapHasher
#include <NCollection_DataMap.hxx>
typedef NCollection_DataMap<TopoDS_Shape, GEOMAlgo_ShapeSet, TopTools_ShapeMapHasher> GEOMAlgo_DataMapOfShapeShapeSet;
typedef GEOMAlgo_DataMapOfShapeShapeSet::Iterator GEOMAlgo_DataMapIteratorOfDataMapOfShapeShapeSet;
#undef _NCollection_MapHasher
#endif

34
src/GEOMAlgo/GEOMAlgo_FinderShapeOn.cxx
View File

@ -64,7 +64,7 @@
#include <BRepLib_MakeFace.hxx> #include <BRepLib_MakeFace.hxx>
#include <BRepLib_FaceError.hxx> #include <BRepLib_FaceError.hxx>
#include <BOPTools_DSFiller.hxx> //#include <BOPTools_DSFiller.hxx>
#include <GEOMAlgo_WireSolid.hxx> #include <GEOMAlgo_WireSolid.hxx>
#include <GEOMAlgo_ShellSolid.hxx> #include <GEOMAlgo_ShellSolid.hxx>
@ -72,7 +72,10 @@
#include <GEOMAlgo_ShapeSolid.hxx> #include <GEOMAlgo_ShapeSolid.hxx>
#include <GEOMAlgo_SolidSolid.hxx> #include <GEOMAlgo_SolidSolid.hxx>
#include <GEOMAlgo_SurfaceTools.hxx> #include <GEOMAlgo_SurfaceTools.hxx>
#include <GEOMAlgo_Tools.hxx> #include <GEOMAlgo_AlgoTools.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPCol_ListOfShape.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_FinderShapeOn //function : GEOMAlgo_FinderShapeOn
@ -267,7 +270,7 @@ void GEOMAlgo_FinderShapeOn::Find()
return; return;
} }
// //
bICS=GEOMAlgo_Tools::IsCompositeShape(myArg2); bICS=GEOMAlgo_AlgoTools::IsCompositeShape(myArg2);
if (!bICS || myIsAnalytic) { if (!bICS || myIsAnalytic) {
TopoDS_Compound aCmp; TopoDS_Compound aCmp;
BRep_Builder aBB; BRep_Builder aBB;
@ -303,19 +306,18 @@ void GEOMAlgo_FinderShapeOn::Find(const TopoDS_Shape& aS)
Standard_Integer i, iErr; Standard_Integer i, iErr;
TopAbs_State aSts[]={TopAbs_IN, TopAbs_OUT, TopAbs_ON}; TopAbs_State aSts[]={TopAbs_IN, TopAbs_OUT, TopAbs_ON};
TopTools_ListIteratorOfListOfShape aIt; TopTools_ListIteratorOfListOfShape aIt;
BOPTools_DSFiller aDF; BOPCol_ListOfShape aLS;
BOPAlgo_PaveFiller aPF;
// //
// 1. Prepare DSFiller // 1. Prepare DSFiller
aDF.SetShapes (myArg1, aS); aLS.Append(myArg1);
bIsDone=aDF.IsDone(); aLS.Append(aS);
if (!bIsDone) { aPF.SetArguments(aLS);
myErrorStatus=30; // wrong args are used for DSFiller //
return; aPF.Perform();
} iErr=aPF.ErrorStatus();
aDF.Perform(); if (iErr) {
bIsDone=aDF.IsDone(); myErrorStatus=31; // PaveFiller is failed
if (!bIsDone) {
myErrorStatus=31; // DSFiller failed
return; return;
} }
// //
@ -347,7 +349,7 @@ void GEOMAlgo_FinderShapeOn::Find(const TopoDS_Shape& aS)
return; return;
} }
// //
pSS->SetFiller(aDF); pSS->SetFiller(aPF);
pSS->Perform(); pSS->Perform();
iErr=pSS->ErrorStatus(); iErr=pSS->ErrorStatus();
if (iErr) { if (iErr) {
@ -396,6 +398,7 @@ void GEOMAlgo_FinderShapeOn::MakeArgument1()
#else #else
aMF.Init(mySurface, Standard_True); aMF.Init(mySurface, Standard_True);
#endif #endif
aFErr=aMF.Error(); aFErr=aMF.Error();
if (aFErr!=BRepLib_FaceDone) { if (aFErr!=BRepLib_FaceDone) {
myErrorStatus=20; // can not build the face myErrorStatus=20; // can not build the face
@ -409,6 +412,7 @@ void GEOMAlgo_FinderShapeOn::MakeArgument1()
aM.Add(aF); aM.Add(aF);
TopExp::MapShapes(aF, TopAbs_VERTEX, aM); TopExp::MapShapes(aF, TopAbs_VERTEX, aM);
TopExp::MapShapes(aF, TopAbs_EDGE, aM); TopExp::MapShapes(aF, TopAbs_EDGE, aM);
aNb=aM.Extent(); aNb=aM.Extent();
for (i=1; i<=aNb; ++i) { for (i=1; i<=aNb; ++i) {
const TopoDS_Shape& aS=aM(i); const TopoDS_Shape& aS=aM(i);

15
src/GEOMAlgo/GEOMAlgo_FinderShapeOn.hxx
View File

@ -30,17 +30,22 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <Standard_Boolean.hxx>
#include <Handle_Geom_Surface.hxx> #include <Handle_Geom_Surface.hxx>
#include <Geom_Surface.hxx>
#include <TopAbs_ShapeEnum.hxx> #include <TopAbs_ShapeEnum.hxx>
#include <GEOMAlgo_State.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TopTools_ListOfShape.hxx> #include <TopTools_ListOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx> #include <TopTools_DataMapOfShapeShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeState.hxx>
#include <Standard_Boolean.hxx>
#include <GEOMAlgo_State.hxx>
#include <GEOMAlgo_ShapeAlgo.hxx> #include <GEOMAlgo_ShapeAlgo.hxx>
#include <Geom_Surface.hxx> #include <GEOMAlgo_IndexedDataMapOfShapeState.hxx>
#include <TopoDS_Shape.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_FinderShapeOn //function : GEOMAlgo_FinderShapeOn

67
src/GEOMAlgo/GEOMAlgo_FinderShapeOn1.cxx
View File

@ -69,15 +69,14 @@
#include <BRepLib_MakeEdge.hxx> #include <BRepLib_MakeEdge.hxx>
#include <GEOMAlgo_ListIteratorOfListOfPnt.hxx> #include <GEOMAlgo_ListIteratorOfListOfPnt.hxx>
#include <GEOMAlgo_SurfaceTools.hxx> #include <GEOMAlgo_SurfaceTools.hxx>
#include <GEOMAlgo_StateCollector.hxx> #include <GEOMAlgo_StateCollector.hxx>
#include <GEOMAlgo_FinderShapeOn.hxx> #include <GEOMAlgo_AlgoTools.hxx>
#include <GEOMAlgo_PassKey.hxx> #include <GEOMAlgo_PassKey.hxx>
#include <GEOMAlgo_DataMapOfPassKeyInteger.hxx> #include <GEOMAlgo_DataMapOfPassKeyInteger.hxx>
#include <GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyInteger.hxx> #include <GEOMAlgo_DataMapIteratorOfDataMapOfPassKeyInteger.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_FinderShapeOn1 //function : GEOMAlgo_FinderShapeOn1
//purpose : //purpose :
@ -548,7 +547,7 @@ void GEOMAlgo_FinderShapeOn1::InnerPoints(const TopoDS_Face& aF,
// //
aTRF=BRep_Tool::Triangulation(aF, aLoc); aTRF=BRep_Tool::Triangulation(aF, aLoc);
if (aTRF.IsNull()) { if (aTRF.IsNull()) {
if (!GEOMAlgo_FinderShapeOn::BuildTriangulation(aF)) { if (!GEOMAlgo_AlgoTools::BuildTriangulation(aF)) {
myWarningStatus=20; // no triangulation found myWarningStatus=20; // no triangulation found
return; return;
} }
@ -793,63 +792,3 @@ TopAbs_State GEOMAlgo_FinderShapeOn1::GetPointState(const gp_Pnt& aP)
// 20- no triangulation found // 20- no triangulation found
// 30- can not obtain the line from the link // 30- can not obtain the line from the link
//modified by NIZNHY-PKV Thu Jan 26 10:01:14 2012f
/*
//=======================================================================
//function : InnerPoints
//purpose :
//=======================================================================
void GEOMAlgo_FinderShapeOn1::InnerPoints(const TopoDS_Edge& aE,
GEOMAlgo_ListOfPnt& aLP)
{
myErrorStatus=0;
//
Standard_Integer j, aNbNodes, aIndex, aNb;
Handle(Poly_PolygonOnTriangulation) aPTE;
Handle(Poly_Triangulation) aTRE;
TopLoc_Location aLoc;
gp_Pnt aP;
//
aLP.Clear();
BRep_Tool::PolygonOnTriangulation(aE, aPTE, aTRE, aLoc);
if (aTRE.IsNull() || aPTE.IsNull()) {
Handle(Poly_Polygon3D) aPE = BRep_Tool::Polygon3D(aE, aLoc);
if (aPE.IsNull()) {
if (!GEOMAlgo_FinderShapeOn::BuildTriangulation(aE)) {
myErrorStatus=20; // no triangulation found
return;
}
aPE = BRep_Tool::Polygon3D(aE, aLoc);
}
const gp_Trsf& aTrsf=aLoc.Transformation();
const TColgp_Array1OfPnt& aNodes=aPE->Nodes();
//
aNbNodes=aPE->NbNodes();
Standard_Integer low = aNodes.Lower(), up = aNodes.Upper();
for (j=low+1; j<up; ++j) {
aP=aNodes(j).Transformed(aTrsf);
aLP.Append(aP);
}
}
else {
const gp_Trsf& aTrsf=aLoc.Transformation();
const TColgp_Array1OfPnt& aNodes=aTRE->Nodes();
//
aNbNodes=aPTE->NbNodes();
const TColStd_Array1OfInteger& aInds=aPTE->Nodes();
for (j=2; j<aNbNodes; ++j) {
aIndex=aInds(j);
aP=aNodes(aIndex).Transformed(aTrsf);
aLP.Append(aP);
}
}
//
aNb=aLP.Extent();
if (!aNb && myNbPntsMin) {
// try to fill it yourself
InnerPoints(aE, myNbPntsMin, aLP);
aNb=aLP.Extent();
}
}
*/
//modified by NIZNHY-PKV Thu Jan 26 10:01:17 2012t

5
src/GEOMAlgo/GEOMAlgo_FinderShapeOn2.cxx
View File

@ -70,7 +70,6 @@
#include <BRepLib_MakeEdge.hxx> #include <BRepLib_MakeEdge.hxx>
#include <GEOMAlgo_ListIteratorOfListOfPnt.hxx> #include <GEOMAlgo_ListIteratorOfListOfPnt.hxx>
#include <GEOMAlgo_SurfaceTools.hxx> #include <GEOMAlgo_SurfaceTools.hxx>
#include <GEOMAlgo_StateCollector.hxx> #include <GEOMAlgo_StateCollector.hxx>
#include <GEOMAlgo_FinderShapeOn.hxx> #include <GEOMAlgo_FinderShapeOn.hxx>
@ -88,12 +87,12 @@
#include <TColStd_ListIteratorOfListOfInteger.hxx> #include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <HatchGen_Domain.hxx> #include <HatchGen_Domain.hxx>
#include <Geom2dHatch_Hatcher.hxx> #include <Geom2dHatch_Hatcher.hxx>
#include <IntTools_Context.hxx> #include <BOPInt_Context.hxx>
#include <BRepTools.hxx> #include <BRepTools.hxx>
#include <IntTools_Tools.hxx> #include <IntTools_Tools.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_FinderShapeOn1 //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
GEOMAlgo_FinderShapeOn2::GEOMAlgo_FinderShapeOn2() GEOMAlgo_FinderShapeOn2::GEOMAlgo_FinderShapeOn2()

17
src/GEOMAlgo/GEOMAlgo_FinderShapeOn2.hxx
View File

@ -29,18 +29,21 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <TopAbs_ShapeEnum.hxx> #include <TopAbs_ShapeEnum.hxx>
#include <GEOMAlgo_State.hxx>
#include <Standard_Integer.hxx> #include <Standard_Integer.hxx>
//#include <Handle_GEOMAlgo_Clsf.hxx>
#include <GEOMAlgo_Clsf.hxx>
#include <TopTools_ListOfShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeState.hxx>
#include <GEOMAlgo_ShapeAlgo.hxx>
#include <GEOMAlgo_Clsf.hxx>
#include <TopoDS_Face.hxx> #include <TopoDS_Face.hxx>
#include <TopoDS_Edge.hxx> #include <TopoDS_Edge.hxx>
#include <TopTools_ListOfShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeState.hxx>
#include <GEOMAlgo_State.hxx>
#include <GEOMAlgo_ListOfPnt.hxx> #include <GEOMAlgo_ListOfPnt.hxx>
#include <GEOMAlgo_Clsf.hxx>
#include <GEOMAlgo_ShapeAlgo.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_FinderShapeOn2 //function : GEOMAlgo_FinderShapeOn2

29
src/GEOMAlgo/GEOMAlgo_GetInPlace.cxx
View File

@ -25,7 +25,7 @@
#include <GEOMAlgo_GetInPlace.hxx> #include <GEOMAlgo_GetInPlace.hxx>
#include <NMTDS_BoxBndTree.hxx>
#include <NCollection_UBTreeFiller.hxx> #include <NCollection_UBTreeFiller.hxx>
#include <Bnd_Box.hxx> #include <Bnd_Box.hxx>
@ -58,9 +58,8 @@
#include <TopTools_MapOfShape.hxx> #include <TopTools_MapOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx> #include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <GEOMAlgo_BoxBndTree.hxx>
#include <NMTTools_CoupleOfShape.hxx> #include <GEOMAlgo_CoupleOfShapes.hxx>
#include <GEOMAlgo_Tools.hxx>
static static
@ -301,10 +300,10 @@ void GEOMAlgo_GetInPlace::Intersect()
TopTools_DataMapOfShapeListOfShape aDMSLS; TopTools_DataMapOfShapeListOfShape aDMSLS;
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS; TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS;
TopTools_ListIteratorOfListOfShape aItLS; TopTools_ListIteratorOfListOfShape aItLS;
NMTTools_CoupleOfShape aCS; GEOMAlgo_CoupleOfShapes aCS;
// //
NMTDS_BoxBndTreeSelector aSelector; GEOMAlgo_BoxBndTreeSelector aSelector;
NMTDS_BoxBndTree aBBTree; GEOMAlgo_BoxBndTree aBBTree;
NCollection_UBTreeFiller <Standard_Integer, Bnd_Box> aTreeFiller(aBBTree); NCollection_UBTreeFiller <Standard_Integer, Bnd_Box> aTreeFiller(aBBTree);
// //
myErrorStatus=0; myErrorStatus=0;
@ -391,7 +390,7 @@ void GEOMAlgo_GetInPlace::PerformVV()
// //
myIterator.Initialize(TopAbs_VERTEX, TopAbs_VERTEX); myIterator.Initialize(TopAbs_VERTEX, TopAbs_VERTEX);
for (; myIterator.More(); myIterator.Next()) { for (; myIterator.More(); myIterator.Next()) {
const NMTTools_CoupleOfShape& aCS=myIterator.Value(); const GEOMAlgo_CoupleOfShapes& aCS=myIterator.Value();
const TopoDS_Shape& aV1=aCS.Shape1(); const TopoDS_Shape& aV1=aCS.Shape1();
const TopoDS_Shape& aV2=aCS.Shape2(); const TopoDS_Shape& aV2=aCS.Shape2();
// //
@ -446,7 +445,7 @@ void GEOMAlgo_GetInPlace::PerformVE()
// 2. Fill Shapes In // 2. Fill Shapes In
myIterator.Initialize(TopAbs_EDGE, TopAbs_VERTEX); myIterator.Initialize(TopAbs_EDGE, TopAbs_VERTEX);
for (; myIterator.More(); myIterator.Next()) { for (; myIterator.More(); myIterator.Next()) {
const NMTTools_CoupleOfShape& aCS=myIterator.Value(); const GEOMAlgo_CoupleOfShapes& aCS=myIterator.Value();
const TopoDS_Shape& aE1=aCS.Shape1(); const TopoDS_Shape& aE1=aCS.Shape1();
const TopoDS_Shape& aV2=aCS.Shape2(); const TopoDS_Shape& aV2=aCS.Shape2();
// //
@ -481,7 +480,7 @@ void GEOMAlgo_GetInPlace::PerformEE()
// //
myIterator.Initialize(TopAbs_EDGE, TopAbs_EDGE); myIterator.Initialize(TopAbs_EDGE, TopAbs_EDGE);
for (; myIterator.More(); myIterator.Next()) { for (; myIterator.More(); myIterator.Next()) {
const NMTTools_CoupleOfShape& aCS=myIterator.Value(); const GEOMAlgo_CoupleOfShapes& aCS=myIterator.Value();
const TopoDS_Shape& aE1=aCS.Shape1(); const TopoDS_Shape& aE1=aCS.Shape1();
const TopoDS_Shape& aE2=aCS.Shape2(); const TopoDS_Shape& aE2=aCS.Shape2();
// //
@ -528,7 +527,7 @@ void GEOMAlgo_GetInPlace::PerformVF()
// //
myIterator.Initialize(TopAbs_FACE, TopAbs_VERTEX); myIterator.Initialize(TopAbs_FACE, TopAbs_VERTEX);
for (; myIterator.More(); myIterator.Next()) { for (; myIterator.More(); myIterator.Next()) {
const NMTTools_CoupleOfShape& aCS=myIterator.Value(); const GEOMAlgo_CoupleOfShapes& aCS=myIterator.Value();
const TopoDS_Shape& aF1=aCS.Shape1(); const TopoDS_Shape& aF1=aCS.Shape1();
const TopoDS_Shape& aV2=aCS.Shape2(); const TopoDS_Shape& aV2=aCS.Shape2();
// //
@ -626,7 +625,7 @@ void GEOMAlgo_GetInPlace::PerformEF()
// //
myIterator.Initialize(TopAbs_FACE, TopAbs_EDGE); myIterator.Initialize(TopAbs_FACE, TopAbs_EDGE);
for (; myIterator.More(); myIterator.Next()) { for (; myIterator.More(); myIterator.Next()) {
const NMTTools_CoupleOfShape& aCS=myIterator.Value(); const GEOMAlgo_CoupleOfShapes& aCS=myIterator.Value();
const TopoDS_Shape& aF1=aCS.Shape1(); const TopoDS_Shape& aF1=aCS.Shape1();
const TopoDS_Shape& aE2=aCS.Shape2(); const TopoDS_Shape& aE2=aCS.Shape2();
// //
@ -679,7 +678,7 @@ void GEOMAlgo_GetInPlace::PerformFF()
// //
myIterator.Initialize(TopAbs_FACE, TopAbs_FACE); myIterator.Initialize(TopAbs_FACE, TopAbs_FACE);
for (; myIterator.More(); myIterator.Next()) { for (; myIterator.More(); myIterator.Next()) {
const NMTTools_CoupleOfShape& aCS=myIterator.Value(); const GEOMAlgo_CoupleOfShapes& aCS=myIterator.Value();
const TopoDS_Shape& aF1=aCS.Shape1(); const TopoDS_Shape& aF1=aCS.Shape1();
const TopoDS_Shape& aF2=aCS.Shape2(); const TopoDS_Shape& aF2=aCS.Shape2();
// //
@ -773,7 +772,7 @@ void GEOMAlgo_GetInPlace::PerformZF()
// //
myIterator.Initialize(TopAbs_SOLID, TopAbs_FACE); myIterator.Initialize(TopAbs_SOLID, TopAbs_FACE);
for (; myIterator.More(); myIterator.Next()) { for (; myIterator.More(); myIterator.Next()) {
const NMTTools_CoupleOfShape& aCS=myIterator.Value(); const GEOMAlgo_CoupleOfShapes& aCS=myIterator.Value();
const TopoDS_Shape& aSo1=aCS.Shape1(); const TopoDS_Shape& aSo1=aCS.Shape1();
const TopoDS_Shape& aF2=aCS.Shape2(); const TopoDS_Shape& aF2=aCS.Shape2();
// //
@ -809,7 +808,7 @@ void GEOMAlgo_GetInPlace::PerformZZ()
// //
myIterator.Initialize(TopAbs_SOLID, TopAbs_SOLID); myIterator.Initialize(TopAbs_SOLID, TopAbs_SOLID);
for (; myIterator.More(); myIterator.Next()) { for (; myIterator.More(); myIterator.Next()) {
const NMTTools_CoupleOfShape& aCS=myIterator.Value(); const GEOMAlgo_CoupleOfShapes& aCS=myIterator.Value();
const TopoDS_Shape& aSo1=aCS.Shape1(); const TopoDS_Shape& aSo1=aCS.Shape1();
const TopoDS_Shape& aSo2=aCS.Shape2(); const TopoDS_Shape& aSo2=aCS.Shape2();
// //

16
src/GEOMAlgo/GEOMAlgo_GetInPlace.hxx
View File

@ -35,9 +35,9 @@
#include <TopAbs_ShapeEnum.hxx> #include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <NMTTools_CoupleOfShape.hxx> #include <GEOMAlgo_CoupleOfShapes.hxx>
#include <NMTTools_ListOfCoupleOfShape.hxx> #include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
#include <NMTTools_ListIteratorOfListOfCoupleOfShape.hxx> #include <GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx>
#include <GEOMAlgo_DataMapOfShapeMapOfShape.hxx> #include <GEOMAlgo_DataMapOfShapeMapOfShape.hxx>
#include <GEOMAlgo_GluerAlgo.hxx> #include <GEOMAlgo_GluerAlgo.hxx>
@ -81,7 +81,7 @@ class GEOMAlgo_GetInPlaceIterator {
* The pair of intersected shapes. * The pair of intersected shapes.
*/ */
//Standard_EXPORT //Standard_EXPORT
void AppendPair(const NMTTools_CoupleOfShape& theCS) ; void AppendPair(const GEOMAlgo_CoupleOfShapes& theCS) ;
/** /**
* Initialize the iterator. * Initialize the iterator.
@ -113,13 +113,13 @@ class GEOMAlgo_GetInPlaceIterator {
* The pair of intersected shapes. * The pair of intersected shapes.
*/ */
//Standard_EXPORT //Standard_EXPORT
const NMTTools_CoupleOfShape& Value() const; const GEOMAlgo_CoupleOfShapes& Value() const;
protected: protected:
Standard_Integer myDim; Standard_Integer myDim;
NMTTools_ListOfCoupleOfShape myLists[10]; GEOMAlgo_ListOfCoupleOfShapes myLists[10];
NMTTools_ListOfCoupleOfShape myEmptyList; GEOMAlgo_ListOfCoupleOfShapes myEmptyList;
NMTTools_ListIteratorOfListOfCoupleOfShape myIterator; GEOMAlgo_ListIteratorOfListOfCoupleOfShapes myIterator;
private: private:
}; };

5
src/GEOMAlgo/GEOMAlgo_GetInPlace_1.cxx
View File

@ -59,8 +59,7 @@
#include <IntTools_Tools.hxx> #include <IntTools_Tools.hxx>
#include <BOPTools_Tools3D.hxx> #include <GEOMAlgo_AlgoTools.hxx>
#include <BOPTools_Tools2D.hxx>
@ -259,7 +258,7 @@ Standard_Integer PntInSolid(const TopoDS_Solid& aZ,
} }
// //
aP2Dx.Coord(aUx, aVx); aP2Dx.Coord(aUx, aVx);
BOPTools_Tools2D::FaceNormal(aF, aUx, aVx, aDNx); GEOMAlgo_AlgoTools::FaceNormal(aF, aUx, aVx, aDNx);
aDNx.Reverse(); aDNx.Reverse();
// //
aP.SetXYZ(aPx.XYZ()+aCoef*aTol*aDNx.XYZ()); aP.SetXYZ(aPx.XYZ()+aCoef*aTol*aDNx.XYZ());

6
src/GEOMAlgo/GEOMAlgo_GetInPlace_3.cxx
View File

@ -25,7 +25,7 @@
#include <GEOMAlgo_GetInPlace.hxx> #include <GEOMAlgo_GetInPlace.hxx>
#include <NMTTools_CoupleOfShape.hxx> #include <GEOMAlgo_CoupleOfShapes.hxx>
static static
Standard_Integer TypeToInteger(const TopAbs_ShapeEnum aType1, Standard_Integer TypeToInteger(const TopAbs_ShapeEnum aType1,
@ -62,7 +62,7 @@ void GEOMAlgo_GetInPlaceIterator::Clear()
//function : AppendPair //function : AppendPair
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_GetInPlaceIterator::AppendPair(const NMTTools_CoupleOfShape& theCS) void GEOMAlgo_GetInPlaceIterator::AppendPair(const GEOMAlgo_CoupleOfShapes& theCS)
{ {
Standard_Integer iX; Standard_Integer iX;
TopAbs_ShapeEnum aType1, aType2; TopAbs_ShapeEnum aType1, aType2;
@ -114,7 +114,7 @@ void GEOMAlgo_GetInPlaceIterator::Next()
// function: Value // function: Value
// purpose: // purpose:
//======================================================================= //=======================================================================
const NMTTools_CoupleOfShape& GEOMAlgo_GetInPlaceIterator::Value()const const GEOMAlgo_CoupleOfShapes& GEOMAlgo_GetInPlaceIterator::Value()const
{ {
return myIterator.Value(); return myIterator.Value();
} }

33
src/GEOMAlgo/GEOMAlgo_GlueAnalyser.cxx
View File

@ -26,11 +26,20 @@
#include <GEOMAlgo_GlueAnalyser.hxx> #include <GEOMAlgo_GlueAnalyser.hxx>
#include <Bnd_Box.hxx>
#include <Bnd_HArray1OfBox.hxx>
#include <Bnd_BoundSortBox.hxx>
#include <BRepBndLib.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx>
#include <TColStd_ListOfInteger.hxx>
#include <TopoDS.hxx> #include <TopoDS.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TopoDS_Face.hxx> #include <TopoDS_Face.hxx>
#include <TopoDS_Edge.hxx> #include <TopoDS_Edge.hxx>
#include <TopoDS_Compound.hxx> #include <TopoDS_Compound.hxx>
#include <TopoDS_Vertex.hxx>
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>
@ -41,24 +50,16 @@
#include <TopTools_ListIteratorOfListOfShape.hxx> #include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx> #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx> #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <GEOMAlgo_PassKeyShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx>
#include <GEOMAlgo_Tools.hxx>
#include <GEOMAlgo_CoupleOfShapes.hxx>
#include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
#include <GEOMAlgo_Gluer.hxx>
#include <Bnd_HArray1OfBox.hxx>
#include <Bnd_BoundSortBox.hxx>
#include <TopoDS_Vertex.hxx>
#include <GEOMAlgo_IndexedDataMapOfIntegerShape.hxx> #include <GEOMAlgo_IndexedDataMapOfIntegerShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeBox.hxx> #include <GEOMAlgo_IndexedDataMapOfShapeBox.hxx>
#include <Bnd_Box.hxx> #include <GEOMAlgo_PassKeyShape.hxx>
#include <TColStd_ListOfInteger.hxx> #include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx>
#include <TopTools_MapOfShape.hxx> #include <GEOMAlgo_AlgoTools.hxx>
#include <TColStd_ListIteratorOfListOfInteger.hxx> #include <GEOMAlgo_CoupleOfShapes.hxx>
#include <BRepBndLib.hxx> #include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
#include <GEOMAlgo_Gluer.hxx>
//======================================================================= //=======================================================================
//function : //function :
@ -302,7 +303,7 @@
} }
// check geometric coincidence // check geometric coincidence
if (myCheckGeometry) { if (myCheckGeometry) {
iErr=GEOMAlgo_Tools::RefineSDShapes(aMPKLF, myTol, myContext); //XX iErr=GEOMAlgo_AlgoTools::RefineSDShapes(aMPKLF, myTol, myContext); //XX
if (iErr) { if (iErr) {
myErrorStatus=200; myErrorStatus=200;
return; return;

35
src/GEOMAlgo/GEOMAlgo_GlueDetector.cxx
View File

@ -52,21 +52,21 @@
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>
#include <BRepBndLib.hxx> #include <BRepBndLib.hxx>
#include <NMTDS_BndSphereTree.hxx>
#include <NMTDS_BndSphere.hxx>
#include <NMTDS_IndexedDataMapOfShapeBndSphere.hxx>
#include <GEOMAlgo_IndexedDataMapOfIntegerShape.hxx>
#include <GEOMAlgo_PassKeyShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx>
#include <GEOMAlgo_Tools.hxx>
//
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx> #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopExp.hxx> #include <TopExp.hxx>
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
#include <TopTools_MapOfShape.hxx> #include <TopTools_MapOfShape.hxx>
//modified by NIZNHY-PKV Tue Mar 13 10:25:47 2012f #include <GEOMAlgo_BndSphereTree.hxx>
#include <GEOMAlgo_BndSphere.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeBndSphere.hxx>
#include <GEOMAlgo_IndexedDataMapOfIntegerShape.hxx>
#include <GEOMAlgo_PassKeyShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx>
#include <GEOMAlgo_AlgoTools.hxx>
//
static static
Standard_Integer CheckAncesstors Standard_Integer CheckAncesstors
(const TopoDS_Shape& aVSD, (const TopoDS_Shape& aVSD,
@ -74,7 +74,6 @@ static
const TopTools_IndexedDataMapOfShapeListOfShape& aMVE, const TopTools_IndexedDataMapOfShapeListOfShape& aMVE,
const TopTools_IndexedDataMapOfShapeListOfShape& aMEV, const TopTools_IndexedDataMapOfShapeListOfShape& aMEV,
TopTools_IndexedDataMapOfShapeListOfShape& aMEVZ); TopTools_IndexedDataMapOfShapeListOfShape& aMEVZ);
//modified by NIZNHY-PKV Tue Mar 13 10:25:50 2012t
//======================================================================= //=======================================================================
//function : //function :
@ -159,10 +158,10 @@ void GEOMAlgo_GlueDetector::DetectVertices()
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItIm; TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItIm;
TopTools_DataMapOfShapeListOfShape aMVV; TopTools_DataMapOfShapeListOfShape aMVV;
GEOMAlgo_IndexedDataMapOfIntegerShape aMIS; GEOMAlgo_IndexedDataMapOfIntegerShape aMIS;
NMTDS_IndexedDataMapOfShapeBndSphere aMSB; GEOMAlgo_IndexedDataMapOfShapeBndSphere aMSB;
NMTDS_BndSphereTreeSelector aSelector; GEOMAlgo_BndSphereTreeSelector aSelector;
NMTDS_BndSphereTree aBBTree; GEOMAlgo_BndSphereTree aBBTree;
NCollection_UBTreeFiller <Standard_Integer, NMTDS_BndSphere> aTreeFiller(aBBTree); NCollection_UBTreeFiller <Standard_Integer, GEOMAlgo_BndSphere> aTreeFiller(aBBTree);
// //
myErrorStatus=0; myErrorStatus=0;
// //
@ -174,7 +173,7 @@ void GEOMAlgo_GlueDetector::DetectVertices()
} }
// //
for (i=1; i<=aNbV; ++i) { for (i=1; i<=aNbV; ++i) {
NMTDS_BndSphere aBox; GEOMAlgo_BndSphere aBox;
// //
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aMV(i)); const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aMV(i));
aPV=BRep_Tool::Pnt(aV); aPV=BRep_Tool::Pnt(aV);
@ -217,7 +216,7 @@ void GEOMAlgo_GlueDetector::DetectVertices()
} }
// //
const TopoDS_Shape& aVP=aMIS.FindFromKey(aIP); const TopoDS_Shape& aVP=aMIS.FindFromKey(aIP);
const NMTDS_BndSphere& aBoxVP=aMSB.FindFromKey(aVP); const GEOMAlgo_BndSphere& aBoxVP=aMSB.FindFromKey(aVP);
// //
aSelector.Clear(); aSelector.Clear();
aSelector.SetBox(aBoxVP); aSelector.SetBox(aBoxVP);
@ -357,7 +356,7 @@ void GEOMAlgo_GlueDetector::DetectShapes(const TopAbs_ShapeEnum aType)
} }
// check geometric coincidence // check geometric coincidence
if (myCheckGeometry) { if (myCheckGeometry) {
iErr=GEOMAlgo_Tools::RefineSDShapes(aMPKLF, myTolerance, myContext); iErr=GEOMAlgo_AlgoTools::RefineSDShapes(aMPKLF, myTolerance, myContext);
if (iErr) { if (iErr) {
myErrorStatus=200; myErrorStatus=200;
return; return;

6
src/GEOMAlgo/GEOMAlgo_GlueDetector.hxx
View File

@ -55,11 +55,9 @@ public:
Standard_EXPORT virtual Standard_EXPORT virtual
void Perform() ; void Perform() ;
//modified by NIZNHY-PKV Tue Mar 13 12:23:20 2012f
Standard_EXPORT Standard_EXPORT
const TopTools_IndexedDataMapOfShapeListOfShape& StickedShapes(); const TopTools_IndexedDataMapOfShapeListOfShape& StickedShapes();
//modified by NIZNHY-PKV Tue Mar 13 12:23:26 2012t
//------------------------------------------------
protected: protected:
Standard_EXPORT Standard_EXPORT
void DetectVertices() ; void DetectVertices() ;
@ -81,7 +79,6 @@ protected:
void FacePassKey(const TopoDS_Face& aF, void FacePassKey(const TopoDS_Face& aF,
GEOMAlgo_PassKeyShape& aPK) ; GEOMAlgo_PassKeyShape& aPK) ;
//modified by NIZNHY-PKV Tue Mar 13 09:53:03 2012f
Standard_EXPORT Standard_EXPORT
void CheckDetected(); void CheckDetected();
// //
@ -94,7 +91,6 @@ protected:
protected: protected:
TopTools_IndexedDataMapOfShapeListOfShape myStickedShapes; TopTools_IndexedDataMapOfShapeListOfShape myStickedShapes;
//modified by NIZNHY-PKV Tue Mar 13 09:53:08 2012t
}; };
#endif #endif

233
src/GEOMAlgo/GEOMAlgo_Gluer.cxx
View File

@ -20,14 +20,14 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: GEOMAlgo_Gluer.cxx // File: GEOMAlgo_Gluer.cxx
// Created: Sat Dec 04 12:45:53 2004 // Created: Sat Dec 04 12:45:53 2004
// Author: Peter KURNEV // Author: Peter KURNEV
// <peter@PREFEX> // <peter@PREFEX>
// //
#include <GEOMAlgo_Gluer.hxx> #include <GEOMAlgo_Gluer.hxx>
#include <NMTDS_BoxBndTree.hxx>
#include <NCollection_UBTreeFiller.hxx> #include <NCollection_UBTreeFiller.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx> #include <TColStd_MapIteratorOfMapOfInteger.hxx>
@ -75,28 +75,27 @@
#include <BRepLib.hxx> #include <BRepLib.hxx>
#include <BRepTools.hxx> #include <BRepTools.hxx>
#include <BRepBndLib.hxx> #include <BRepBndLib.hxx>
//
#include <IntTools_Tools.hxx>
#include <BOPInt_Context.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools3D.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <IntTools_Context.hxx> #include <GEOMAlgo_BoxBndTree.hxx>
#include <BOPTools_Tools.hxx> #include <GEOMAlgo_AlgoTools.hxx>
#include <BOPTools_Tools3D.hxx>
#include <BOPTools_Tools2D.hxx>
#include <BOP_CorrectTolerances.hxx>
#include <GEOMAlgo_IndexedDataMapOfIntegerShape.hxx> #include <GEOMAlgo_IndexedDataMapOfIntegerShape.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeBox.hxx> #include <GEOMAlgo_IndexedDataMapOfShapeBox.hxx>
#include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx> #include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx>
#include <GEOMAlgo_PassKeyShape.hxx> #include <GEOMAlgo_PassKeyShape.hxx>
#include <GEOMAlgo_Tools.hxx> #include <GEOMAlgo_BndSphereTree.hxx>
// #include <GEOMAlgo_BndSphere.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeBndSphere.hxx>
#include <NMTDS_BndSphereTree.hxx>
#include <NMTDS_BndSphere.hxx>
#include <NMTDS_IndexedDataMapOfShapeBndSphere.hxx>
// //
static static
void GetSubShapes(const TopoDS_Shape& aS, void GetSubShapes(const TopoDS_Shape& aS,
TopTools_IndexedMapOfShape& aMSS); TopTools_IndexedMapOfShape& aMSS);
//======================================================================= //=======================================================================
//function : GEOMAlgo_Gluer //function : GEOMAlgo_Gluer
@ -226,12 +225,12 @@ void GEOMAlgo_Gluer::MakeVertices()
GEOMAlgo_IndexedDataMapOfIntegerShape aMIS; GEOMAlgo_IndexedDataMapOfIntegerShape aMIS;
//modified by NIZNHY-PKV Thu Jan 21 10:03:07 2010f //modified by NIZNHY-PKV Thu Jan 21 10:03:07 2010f
//GEOMAlgo_IndexedDataMapOfShapeBox aMSB; //GEOMAlgo_IndexedDataMapOfShapeBox aMSB;
NMTDS_IndexedDataMapOfShapeBndSphere aMSB; GEOMAlgo_IndexedDataMapOfShapeBndSphere aMSB;
//modified by NIZNHY-PKV Thu Jan 21 10:03:10 2010t //modified by NIZNHY-PKV Thu Jan 21 10:03:10 2010t
// //
NMTDS_BndSphereTreeSelector aSelector; GEOMAlgo_BndSphereTreeSelector aSelector;
NMTDS_BndSphereTree aBBTree; GEOMAlgo_BndSphereTree aBBTree;
NCollection_UBTreeFiller <Standard_Integer, NMTDS_BndSphere> aTreeFiller(aBBTree); NCollection_UBTreeFiller <Standard_Integer, GEOMAlgo_BndSphere> aTreeFiller(aBBTree);
// //
TopExp::MapShapes(myShape, TopAbs_VERTEX, aMV); TopExp::MapShapes(myShape, TopAbs_VERTEX, aMV);
aNbV=aMV.Extent(); aNbV=aMV.Extent();
@ -241,7 +240,7 @@ void GEOMAlgo_Gluer::MakeVertices()
} }
// //
for (i=1; i<=aNbV; ++i) { for (i=1; i<=aNbV; ++i) {
NMTDS_BndSphere aBox; GEOMAlgo_BndSphere aBox;
// //
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aMV(i)); const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aMV(i));
aPV=BRep_Tool::Pnt(aV); aPV=BRep_Tool::Pnt(aV);
@ -278,53 +277,53 @@ void GEOMAlgo_Gluer::MakeVertices()
aNbIP=aMIP.Extent(); aNbIP=aMIP.Extent();
aIt1.Initialize(aMIP); aIt1.Initialize(aMIP);
for(; aIt1.More(); aIt1.Next()) { for(; aIt1.More(); aIt1.Next()) {
aIP=aIt1.Key(); aIP=aIt1.Key();
if (aMIPC.Contains(aIP)) { if (aMIPC.Contains(aIP)) {
continue; continue;
} }
// //
const TopoDS_Shape& aVP=aMIS.FindFromKey(aIP); const TopoDS_Shape& aVP=aMIS.FindFromKey(aIP);
//modified by NIZNHY-PKV Thu Jan 21 10:04:09 2010f //modified by NIZNHY-PKV Thu Jan 21 10:04:09 2010f
const NMTDS_BndSphere& aBoxVP=aMSB.FindFromKey(aVP); const GEOMAlgo_BndSphere& aBoxVP=aMSB.FindFromKey(aVP);
//const Bnd_Box& aBoxVP=aMSB.FindFromKey(aVP); //const Bnd_Box& aBoxVP=aMSB.FindFromKey(aVP);
//modified by NIZNHY-PKV Thu Jan 21 10:04:11 2010t //modified by NIZNHY-PKV Thu Jan 21 10:04:11 2010t
// //
aSelector.Clear(); aSelector.Clear();
aSelector.SetBox(aBoxVP); aSelector.SetBox(aBoxVP);
// //
aNbVSD=aBBTree.Select(aSelector); aNbVSD=aBBTree.Select(aSelector);
if (!aNbVSD) { if (!aNbVSD) {
continue; // it must not be continue; // it must not be
} }
// //
const TColStd_ListOfInteger& aLI=aSelector.Indices(); const TColStd_ListOfInteger& aLI=aSelector.Indices();
// //
aIt.Initialize(aLI); aIt.Initialize(aLI);
for (; aIt.More(); aIt.Next()) { for (; aIt.More(); aIt.Next()) {
aIP1=aIt.Value(); aIP1=aIt.Value();
if (aMIP.Contains(aIP1)) { if (aMIP.Contains(aIP1)) {
continue; continue;
} }
aMIP1.Add(aIP1); aMIP1.Add(aIP1);
} //for (; aIt.More(); aIt.Next()) { } //for (; aIt.More(); aIt.Next()) {
}//for(; aIt1.More(); aIt1.Next()) { }//for(; aIt1.More(); aIt1.Next()) {
// //
aNbIP1=aMIP1.Extent(); aNbIP1=aMIP1.Extent();
if (!aNbIP1) { if (!aNbIP1) {
break; break;
} }
// //
aIt1.Initialize(aMIP); aIt1.Initialize(aMIP);
for(; aIt1.More(); aIt1.Next()) { for(; aIt1.More(); aIt1.Next()) {
aIP=aIt1.Key(); aIP=aIt1.Key();
aMIPC.Add(aIP); aMIPC.Add(aIP);
} }
// //
aMIP.Clear(); aMIP.Clear();
aIt1.Initialize(aMIP1); aIt1.Initialize(aMIP1);
for(; aIt1.More(); aIt1.Next()) { for(; aIt1.More(); aIt1.Next()) {
aIP=aIt1.Key(); aIP=aIt1.Key();
aMIP.Add(aIP); aMIP.Add(aIP);
} }
aMIP1.Clear(); aMIP1.Clear();
}// while(1) }// while(1)
@ -340,13 +339,13 @@ void GEOMAlgo_Gluer::MakeVertices()
else { // SD vertices founded [ aMIPC ] else { // SD vertices founded [ aMIPC ]
aIt1.Initialize(aMIPC); aIt1.Initialize(aMIPC);
for(j=0; aIt1.More(); aIt1.Next(), ++j) { for(j=0; aIt1.More(); aIt1.Next(), ++j) {
aIP=aIt1.Key(); aIP=aIt1.Key();
const TopoDS_Shape& aVP=aMIS.FindFromKey(aIP); const TopoDS_Shape& aVP=aMIS.FindFromKey(aIP);
if (!j) { if (!j) {
aVF=aVP; aVF=aVP;
} }
aLVSD.Append(aVP); aLVSD.Append(aVP);
aMVProcessed.Add(aVP); aMVProcessed.Add(aVP);
} }
} }
myImages.Bind(aVF, aLVSD); myImages.Bind(aVF, aLVSD);
@ -391,7 +390,7 @@ void GEOMAlgo_Gluer::MakeVertices()
for (; aItS.More(); aItS.Next()) { for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aVSD=aItS.Value(); const TopoDS_Shape& aVSD=aItS.Value();
if (!myOrigins.IsBound(aVSD)) { if (!myOrigins.IsBound(aVSD)) {
myOrigins.Bind(aVSD, aV); myOrigins.Bind(aVSD, aV);
} }
} }
} }
@ -463,14 +462,8 @@ void GEOMAlgo_Gluer::MakeSubShapes (const TopoDS_Shape& theShape,
// //
aER.Orientation(TopAbs_FORWARD); aER.Orientation(TopAbs_FORWARD);
if (!BRep_Tool::Degenerated(aER)) { if (!BRep_Tool::Degenerated(aER)) {
// build p-curve
//if (bIsUPeriodic) {
// GEOMAlgo_Tools::RefinePCurveForEdgeOnFace(aER, aFFWD, aUMin, aUMax);
//}
//BOPTools_Tools2D::BuildPCurveForEdgeOnFace(aER, aFFWD);
//
// orient image // orient image
Standard_Boolean bIsToReverse=BOPTools_Tools3D::IsSplitToReverse1(aER, aE, myContext); Standard_Boolean bIsToReverse=GEOMAlgo_AlgoTools::IsSplitToReverse(aER, aE, myContext);
if (bIsToReverse) { if (bIsToReverse) {
aER.Reverse(); aER.Reverse();
} }
@ -522,7 +515,7 @@ void GEOMAlgo_Gluer::MakeSolids()
myResult=aCmp; myResult=aCmp;
// //
if (aMS.Extent()) { if (aMS.Extent()) {
BOP_CorrectTolerances::CorrectCurveOnSurface(myResult); BOPTools_AlgoTools::CorrectCurveOnSurface(myResult, 0.0001);
} }
} }
//======================================================================= //=======================================================================
@ -556,12 +549,12 @@ void GEOMAlgo_Gluer::MakeShells()
const TopoDS_Face& aF=TopoDS::Face(aExp.Current()); const TopoDS_Face& aF=TopoDS::Face(aExp.Current());
aFR=TopoDS::Face(myOrigins.Find(aF)); aFR=TopoDS::Face(myOrigins.Find(aF));
if (aFR.IsSame(aF)) { if (aFR.IsSame(aF)) {
aBB.Add(aNewShell, aF); aBB.Add(aNewShell, aF);
continue; continue;
} }
bIsToReverse=IsToReverse(aFR, aF); bIsToReverse=IsToReverse(aFR, aF);
if (bIsToReverse) { if (bIsToReverse) {
aFR.Reverse(); aFR.Reverse();
} }
aBB.Add(aNewShell, aFR); aBB.Add(aNewShell, aFR);
} }
@ -637,7 +630,7 @@ void GEOMAlgo_Gluer::MakeShapes(const TopAbs_ShapeEnum aType)
} }
// check geometric coincidence // check geometric coincidence
if (myCheckGeometry) { if (myCheckGeometry) {
iErr=GEOMAlgo_Tools::RefineSDShapes(aMPKLF, myTol, myContext); iErr=GEOMAlgo_AlgoTools::RefineSDShapes(aMPKLF, myTol, myContext);
if (iErr) { if (iErr) {
myErrorStatus=200; myErrorStatus=200;
return; return;
@ -662,25 +655,25 @@ void GEOMAlgo_Gluer::MakeShapes(const TopAbs_ShapeEnum aType)
if (aNbSDF==1) { if (aNbSDF==1) {
bHasNewSubShape=HasNewSubShape(aS1); bHasNewSubShape=HasNewSubShape(aS1);
if (!bHasNewSubShape) { if (!bHasNewSubShape) {
aNewShape=aS1; aNewShape=aS1;
aNewShape.Orientation(TopAbs_FORWARD); aNewShape.Orientation(TopAbs_FORWARD);
} }
} }
// //
if (bHasNewSubShape) { if (bHasNewSubShape) {
if (aType==TopAbs_FACE) { if (aType==TopAbs_FACE) {
TopoDS_Face aNewFace; TopoDS_Face aNewFace;
// //
const TopoDS_Face& aF1=TopoDS::Face(aS1); const TopoDS_Face& aF1=TopoDS::Face(aS1);
MakeFace(aF1, aNewFace); MakeFace(aF1, aNewFace);
aNewShape=aNewFace; aNewShape=aNewFace;
} }
else if (aType==TopAbs_EDGE) { else if (aType==TopAbs_EDGE) {
TopoDS_Edge aNewEdge; TopoDS_Edge aNewEdge;
// //
const TopoDS_Edge& aE1=TopoDS::Edge(aS1); const TopoDS_Edge& aE1=TopoDS::Edge(aS1);
MakeEdge(aE1, aNewEdge); MakeEdge(aE1, aNewEdge);
aNewShape=aNewEdge; aNewShape=aNewEdge;
} }
} }
// //
@ -690,7 +683,7 @@ void GEOMAlgo_Gluer::MakeShapes(const TopAbs_ShapeEnum aType)
for (; aItS.More(); aItS.Next()) { for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aFSD=aItS.Value(); const TopoDS_Shape& aFSD=aItS.Value();
if (!myOrigins.IsBound(aFSD)) { if (!myOrigins.IsBound(aFSD)) {
myOrigins.Bind(aFSD, aNewShape); myOrigins.Bind(aFSD, aNewShape);
} }
} }
} }
@ -730,12 +723,12 @@ void GEOMAlgo_Gluer::CheckResult()
for (j=1; j<=aNbFS; ++j) { for (j=1; j<=aNbFS; ++j) {
const TopoDS_Shape& aFS=aMFS(j); const TopoDS_Shape& aFS=aMFS(j);
if (aMFR.Contains(aFS)) { if (aMFR.Contains(aFS)) {
const TopTools_ListOfShape& aLSx=aMFR.FindFromKey(aFS); const TopTools_ListOfShape& aLSx=aMFR.FindFromKey(aFS);
aNbSx=aLSx.Extent(); aNbSx=aLSx.Extent();
if (aNbSx==2) { if (aNbSx==2) {
bFound=!bFound; bFound=!bFound;
break; break;
} }
} }
} }
// //
@ -797,7 +790,7 @@ void GEOMAlgo_Gluer::InnerTolerance()
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Gluer::FacePassKey(const TopoDS_Face& aF, void GEOMAlgo_Gluer::FacePassKey(const TopoDS_Face& aF,
GEOMAlgo_PassKeyShape& aPK) GEOMAlgo_PassKeyShape& aPK)
{ {
Standard_Integer i, aNbE; Standard_Integer i, aNbE;
TopTools_ListOfShape aLE; TopTools_ListOfShape aLE;
@ -822,7 +815,7 @@ void GEOMAlgo_Gluer::FacePassKey(const TopoDS_Face& aF,
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Gluer::EdgePassKey(const TopoDS_Edge& aE, void GEOMAlgo_Gluer::EdgePassKey(const TopoDS_Edge& aE,
GEOMAlgo_PassKeyShape& aPK) GEOMAlgo_PassKeyShape& aPK)
{ {
TopoDS_Vertex aV1, aV2; TopoDS_Vertex aV1, aV2;
// //
@ -841,7 +834,7 @@ void GEOMAlgo_Gluer::EdgePassKey(const TopoDS_Edge& aE,
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Gluer::MakeVertex(const TopTools_ListOfShape& aLV, void GEOMAlgo_Gluer::MakeVertex(const TopTools_ListOfShape& aLV,
TopoDS_Vertex& aNewVertex) TopoDS_Vertex& aNewVertex)
{ {
Standard_Integer aNbV; Standard_Integer aNbV;
Standard_Real aTolV, aD, aDmax; Standard_Real aTolV, aD, aDmax;
@ -887,7 +880,7 @@ void GEOMAlgo_Gluer::MakeVertex(const TopTools_ListOfShape& aLV,
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Gluer::MakeEdge(const TopoDS_Edge& aE, void GEOMAlgo_Gluer::MakeEdge(const TopoDS_Edge& aE,
TopoDS_Edge& aNewEdge) TopoDS_Edge& aNewEdge)
{ {
myErrorStatus=0; myErrorStatus=0;
// //
@ -933,7 +926,7 @@ void GEOMAlgo_Gluer::MakeEdge(const TopoDS_Edge& aE,
} }
// //
else { else {
BOPTools_Tools::MakeSplitEdge(aEx, aVR1, aT1, aVR2, aT2, aNewEdge); BOPTools_AlgoTools::MakeSplitEdge(aEx, aVR1, aT1, aVR2, aT2, aNewEdge);
} }
} }
//======================================================================= //=======================================================================
@ -941,7 +934,7 @@ void GEOMAlgo_Gluer::MakeEdge(const TopoDS_Edge& aE,
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Gluer::MakeFace(const TopoDS_Face& aF, void GEOMAlgo_Gluer::MakeFace(const TopoDS_Face& aF,
TopoDS_Face& aNewFace) TopoDS_Face& aNewFace)
{ {
myErrorStatus=0; myErrorStatus=0;
// //
@ -960,7 +953,7 @@ void GEOMAlgo_Gluer::MakeFace(const TopoDS_Face& aF,
aFFWD.Orientation(TopAbs_FORWARD); aFFWD.Orientation(TopAbs_FORWARD);
// //
aS=BRep_Tool::Surface(aFFWD, aLoc); aS=BRep_Tool::Surface(aFFWD, aLoc);
bIsUPeriodic=GEOMAlgo_Tools::IsUPeriodic(aS); bIsUPeriodic=GEOMAlgo_AlgoTools::IsUPeriodic(aS);
aTol=BRep_Tool::Tolerance(aFFWD); aTol=BRep_Tool::Tolerance(aFFWD);
BRepTools::UVBounds(aF, aUMin, aUMax, aVMin, aVMax); BRepTools::UVBounds(aF, aUMin, aUMax, aVMin, aVMax);
// //
@ -977,20 +970,20 @@ void GEOMAlgo_Gluer::MakeFace(const TopoDS_Face& aF,
// //
aER.Orientation(TopAbs_FORWARD); aER.Orientation(TopAbs_FORWARD);
if (!BRep_Tool::Degenerated(aER)) { if (!BRep_Tool::Degenerated(aER)) {
// build p-curve // build p-curve
if (bIsUPeriodic) { if (bIsUPeriodic) {
GEOMAlgo_Tools::RefinePCurveForEdgeOnFace(aER, aFFWD, aUMin, aUMax); GEOMAlgo_AlgoTools::RefinePCurveForEdgeOnFace(aER, aFFWD, aUMin, aUMax);
} }
BOPTools_Tools2D::BuildPCurveForEdgeOnFace(aER, aFFWD); BOPTools_AlgoTools2D::BuildPCurveForEdgeOnFace(aER, aFFWD);
// orient image // orient image
bIsToReverse=BOPTools_Tools3D::IsSplitToReverse1(aER, aE, myContext); bIsToReverse=GEOMAlgo_AlgoTools::IsSplitToReverse(aER, aE, myContext);
if (bIsToReverse) { if (bIsToReverse) {
aER.Reverse(); aER.Reverse();
} }
} }
else { else {
aER.Orientation(aE.Orientation()); aER.Orientation(aE.Orientation());
} }
// //
aBB.Add(newWire, aER); aBB.Add(newWire, aER);
@ -1011,7 +1004,7 @@ void GEOMAlgo_Gluer::MakeFace(const TopoDS_Face& aF,
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean GEOMAlgo_Gluer::IsToReverse(const TopoDS_Face& aFR, Standard_Boolean GEOMAlgo_Gluer::IsToReverse(const TopoDS_Face& aFR,
const TopoDS_Face& aF) const TopoDS_Face& aF)
{ {
Standard_Boolean bRet; Standard_Boolean bRet;
Standard_Real aT, aT1, aT2, aTR, aScPr; Standard_Real aT, aT1, aT2, aTR, aScPr;
@ -1033,16 +1026,16 @@ Standard_Boolean GEOMAlgo_Gluer::IsToReverse(const TopoDS_Face& aFR,
const TopoDS_Edge& aER=TopoDS::Edge(myOrigins.Find(aE)); const TopoDS_Edge& aER=TopoDS::Edge(myOrigins.Find(aE));
// //
aC3D=BRep_Tool::Curve(aE, aT1, aT2); aC3D=BRep_Tool::Curve(aE, aT1, aT2);
aT=BOPTools_Tools2D::IntermediatePoint(aT1, aT2); aT=IntTools_Tools::IntermediatePoint(aT1, aT2);
aC3D->D0(aT, aP); aC3D->D0(aT, aP);
myContext->ProjectPointOnEdge(aP, aER, aTR); myContext->ProjectPointOnEdge(aP, aER, aTR);
// //
BOPTools_Tools3D::GetNormalToFaceOnEdge (aE, aF, aT, aDNF); BOPTools_AlgoTools3D::GetNormalToFaceOnEdge (aE, aF, aT, aDNF);
if (aF.Orientation()==TopAbs_REVERSED) { if (aF.Orientation()==TopAbs_REVERSED) {
aDNF.Reverse(); aDNF.Reverse();
} }
// //
BOPTools_Tools3D::GetNormalToFaceOnEdge (aER, aFR, aTR, aDNFR); BOPTools_AlgoTools3D::GetNormalToFaceOnEdge (aER, aFR, aTR, aDNFR);
if (aFR.Orientation()==TopAbs_REVERSED) { if (aFR.Orientation()==TopAbs_REVERSED) {
aDNFR.Reverse(); aDNFR.Reverse();
} }
@ -1090,7 +1083,7 @@ Standard_Boolean GEOMAlgo_Gluer::HasNewSubShape(const TopoDS_Shape& aS)const
//purpose : //purpose :
//======================================================================= //=======================================================================
void GetSubShapes(const TopoDS_Shape& aS, void GetSubShapes(const TopoDS_Shape& aS,
TopTools_IndexedMapOfShape& aMSS) TopTools_IndexedMapOfShape& aMSS)
{ {
Standard_Integer aR; Standard_Integer aR;
TopAbs_ShapeEnum aType; TopAbs_ShapeEnum aType;
@ -1129,7 +1122,7 @@ const TopTools_ListOfShape& GEOMAlgo_Gluer::Modified (const TopoDS_Shape& aS)
if(myOrigins.IsBound(aS)) { if(myOrigins.IsBound(aS)) {
const TopoDS_Shape& aSnew=myOrigins.Find(aS); const TopoDS_Shape& aSnew=myOrigins.Find(aS);
if (!aSnew.IsSame(aS)) { if (!aSnew.IsSame(aS)) {
myGenerated.Append(aSnew); myGenerated.Append(aSnew);
} }
} }
} }

17
src/GEOMAlgo/GEOMAlgo_Gluer.hxx
View File

@ -31,22 +31,27 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <Standard_Boolean.hxx> #include <Standard_Boolean.hxx>
#include <Standard_Real.hxx> #include <Standard_Real.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <Standard_Integer.hxx> #include <Standard_Integer.hxx>
#include <TopTools_ListOfShape.hxx>
#include <GEOMAlgo_ShapeAlgo.hxx>
#include <TopAbs_ShapeEnum.hxx> #include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TopoDS_Edge.hxx> #include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx> #include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx> #include <TopoDS_Vertex.hxx>
#include <GEOMAlgo_PassKeyShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopoDS_Compound.hxx> #include <TopoDS_Compound.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <GEOMAlgo_ShapeAlgo.hxx>
#include <GEOMAlgo_PassKeyShape.hxx>
//======================================================================= //=======================================================================
//class : GEOMAlgo_Gluer //class : GEOMAlgo_Gluer
//purpose : //purpose :

14
src/GEOMAlgo/GEOMAlgo_Gluer2.cxx
View File

@ -44,8 +44,10 @@
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx> #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx> #include <TopTools_IndexedMapOfShape.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <GEOMAlgo_GlueDetector.hxx> #include <GEOMAlgo_GlueDetector.hxx>
#include <GEOMAlgo_Tools3D.hxx> #include <GEOMAlgo_AlgoTools.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_Gluer2 //function : GEOMAlgo_Gluer2
@ -441,7 +443,7 @@ void GEOMAlgo_Gluer2::FillContainers(const TopAbs_ShapeEnum aType)
continue; continue;
} }
// //
GEOMAlgo_Tools3D::MakeContainer(aType, aWnew); GEOMAlgo_AlgoTools::MakeContainer(aType, aWnew);
aWnew.Orientation(aW.Orientation()); aWnew.Orientation(aW.Orientation());
// //
aItS.Initialize(aW); aItS.Initialize(aW);
@ -450,7 +452,7 @@ void GEOMAlgo_Gluer2::FillContainers(const TopAbs_ShapeEnum aType)
if (myOrigins.IsBound(aE)) { if (myOrigins.IsBound(aE)) {
aEnew=myOrigins.Find(aE); aEnew=myOrigins.Find(aE);
// //
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aEnew, aE, myContext); bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aEnew, aE, myContext);
if (bToReverse) { if (bToReverse) {
aEnew.Reverse(); aEnew.Reverse();
} }
@ -509,7 +511,7 @@ void GEOMAlgo_Gluer2::FillCompound(const TopoDS_Shape& aC)
return; return;
} }
// //
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew); GEOMAlgo_AlgoTools::MakeContainer(TopAbs_COMPOUND, aCnew);
// //
aItC.Initialize(aC); aItC.Initialize(aC);
for (; aItC.More(); aItC.Next()) { for (; aItC.More(); aItC.Next()) {
@ -599,7 +601,7 @@ void GEOMAlgo_Gluer2::BuildResult()
return; return;
} }
// //
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew); GEOMAlgo_AlgoTools::MakeContainer(TopAbs_COMPOUND, aCnew);
// //
aItC.Initialize(myArgument); aItC.Initialize(myArgument);
for (; aItC.More(); aItC.Next()) { for (; aItC.More(); aItC.Next()) {
@ -619,7 +621,7 @@ void GEOMAlgo_Gluer2::BuildResult()
TopoDS_Shape aCnew1; TopoDS_Shape aCnew1;
TopTools_IndexedMapOfShape aM; TopTools_IndexedMapOfShape aM;
// //
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew1); GEOMAlgo_AlgoTools::MakeContainer(TopAbs_COMPOUND, aCnew1);
// //
TopExp::MapShapes(aCnew, TopAbs_SOLID, aM); TopExp::MapShapes(aCnew, TopAbs_SOLID, aM);

12
src/GEOMAlgo/GEOMAlgo_Gluer2.hxx
View File

@ -35,12 +35,11 @@
#include <TopTools_DataMapOfShapeListOfShape.hxx> #include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx> #include <TopTools_DataMapOfShapeShape.hxx>
#include <NMTTools_CoupleOfShape.hxx>
#include <NMTTools_ListOfCoupleOfShape.hxx>
#include <GEOMAlgo_GluerAlgo.hxx> #include <GEOMAlgo_GluerAlgo.hxx>
#include <GEOMAlgo_BuilderShape.hxx> #include <GEOMAlgo_BuilderShape.hxx>
#include <GEOMAlgo_GlueDetector.hxx> #include <GEOMAlgo_GlueDetector.hxx>
#include <GEOMAlgo_CoupleOfShapes.hxx>
#include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
//======================================================================= //=======================================================================
//class : GEOMAlgo_Gluer2 //class : GEOMAlgo_Gluer2
@ -170,8 +169,8 @@ protected:
TopoDS_Face& theFnew) ; TopoDS_Face& theFnew) ;
Standard_EXPORT Standard_EXPORT
void TreatPair(const NMTTools_CoupleOfShape& theCS, void TreatPair(const GEOMAlgo_CoupleOfShapes& theCS,
NMTTools_ListOfCoupleOfShape& theLCS) ; GEOMAlgo_ListOfCoupleOfShapes& theLCS) ;
protected: protected:
TopTools_DataMapOfShapeListOfShape myShapesToGlue; TopTools_DataMapOfShapeListOfShape myShapesToGlue;
@ -180,9 +179,8 @@ protected:
TopTools_DataMapOfShapeListOfShape myImagesToWork; TopTools_DataMapOfShapeListOfShape myImagesToWork;
TopTools_DataMapOfShapeShape myOriginsToWork; TopTools_DataMapOfShapeShape myOriginsToWork;
Standard_Boolean myKeepNonSolids; Standard_Boolean myKeepNonSolids;
//modified by NIZNHY-PKV Tue Mar 13 13:30:40 2012f
GEOMAlgo_GlueDetector myDetector; GEOMAlgo_GlueDetector myDetector;
//modified by NIZNHY-PKV Tue Mar 13 13:30:43 2012t
private: private:
}; };
#endif #endif

19
src/GEOMAlgo/GEOMAlgo_Gluer2_1.cxx
View File

@ -51,11 +51,9 @@
#include <TopTools_ListIteratorOfListOfShape.hxx> #include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx> #include <TopTools_ListOfShape.hxx>
#include <BOPTools_Tools.hxx> #include <BOPTools_AlgoTools.hxx>
#include <BOPTools_Tools2D.hxx> #include <GEOMAlgo_AlgoTools.hxx>
#include <BOPTools_Tools3D.hxx> #include <BOPTools_AlgoTools2D.hxx>
#include <GEOMAlgo_Tools.hxx>
//======================================================================= //=======================================================================
//function : MakeBRepShapes //function : MakeBRepShapes
@ -117,7 +115,7 @@ void GEOMAlgo_Gluer2::MakeFace(const TopoDS_Face& theF,
// //
aTol=BRep_Tool::Tolerance(aFF); aTol=BRep_Tool::Tolerance(aFF);
aS=BRep_Tool::Surface(aFF, aLoc); aS=BRep_Tool::Surface(aFF, aLoc);
bIsUPeriodic=GEOMAlgo_Tools::IsUPeriodic(aS); bIsUPeriodic=GEOMAlgo_AlgoTools::IsUPeriodic(aS);
BRepTools::UVBounds(aFF, aUMin, aUMax, aVMin, aVMax); BRepTools::UVBounds(aFF, aUMin, aUMax, aVMin, aVMax);
// //
aBB.MakeFace (aFnew, aS, aLoc, aTol); aBB.MakeFace (aFnew, aS, aLoc, aTol);
@ -160,18 +158,17 @@ void GEOMAlgo_Gluer2::MakeFace(const TopoDS_Face& theF,
if (!BRep_Tool::Degenerated(aEx)) { if (!BRep_Tool::Degenerated(aEx)) {
aEx.Orientation(TopAbs_FORWARD); aEx.Orientation(TopAbs_FORWARD);
if (bIsUPeriodic) { if (bIsUPeriodic) {
GEOMAlgo_Tools::RefinePCurveForEdgeOnFace(aEx, aFF, aUMin, aUMax); GEOMAlgo_AlgoTools::RefinePCurveForEdgeOnFace(aEx, aFF, aUMin, aUMax);
} }
// //
//modified by NIZNHY-PKV Fri Feb 03 11:18:17 2012f //modified by NIZNHY-PKV Fri Feb 03 11:18:17 2012f
iRet=GEOMAlgo_Tools::BuildPCurveForEdgeOnFace(aE, aEx, aFF, myContext); iRet=GEOMAlgo_AlgoTools::BuildPCurveForEdgeOnFace(aE, aEx, aFF, myContext);
if (iRet) { if (iRet) {
continue; continue;
} }
//BOPTools_Tools2D::BuildPCurveForEdgeOnFace(aEx, aFF);
//modified by NIZNHY-PKV Fri Feb 03 11:18:20 2012t //modified by NIZNHY-PKV Fri Feb 03 11:18:20 2012t
// //
bIsToReverse=BOPTools_Tools3D::IsSplitToReverse1(aEx, aE, myContext); bIsToReverse=GEOMAlgo_AlgoTools::IsSplitToReverse(aEx, aE, myContext);
if (bIsToReverse) { if (bIsToReverse) {
aEx.Reverse(); aEx.Reverse();
} }
@ -223,7 +220,7 @@ void GEOMAlgo_Gluer2::MakeEdge(const TopoDS_Edge& aE,
aVR2.Orientation(TopAbs_REVERSED); aVR2.Orientation(TopAbs_REVERSED);
// //
if (!bIsDE) { if (!bIsDE) {
BOPTools_Tools::MakeSplitEdge(aEx, aVR1, aT1, aVR2, aT2, aNewEdge); BOPTools_AlgoTools::MakeSplitEdge(aEx, aVR1, aT1, aVR2, aT2, aNewEdge);
} }
else { else {
Standard_Real aTol; Standard_Real aTol;

5
src/GEOMAlgo/GEOMAlgo_Gluer2_2.cxx
View File

@ -31,8 +31,9 @@
#include <TopoDS_Iterator.hxx> #include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <GEOMAlgo_BuilderShape.hxx> #include <GEOMAlgo_BuilderShape.hxx>
#include <GEOMAlgo_Tools3D.hxx>
//======================================================================= //=======================================================================
//function : PrepareHistory //function : PrepareHistory
@ -98,7 +99,7 @@ const TopTools_ListOfShape& GEOMAlgo_Gluer2::Modified(const TopoDS_Shape& theS)
aSim.Orientation(theS.Orientation()); aSim.Orientation(theS.Orientation());
} }
else { else {
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aSim, theS, myContext); bToReverse=BOPTools_AlgoTools::IsSplitToReverse(aSim, theS, myContext);
if (bToReverse) { if (bToReverse) {
aSim.Reverse(); aSim.Reverse();
} }

26
src/GEOMAlgo/GEOMAlgo_Gluer2_3.cxx
View File

@ -44,13 +44,13 @@
#include <TopTools_ListIteratorOfListOfShape.hxx> #include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx> #include <TopTools_IndexedMapOfShape.hxx>
#include <NMTTools_CoupleOfShape.hxx> #include <GEOMAlgo_CoupleOfShapes.hxx>
#include <NMTTools_ListOfCoupleOfShape.hxx> #include <GEOMAlgo_ListOfCoupleOfShapes.hxx>
#include <NMTTools_ListIteratorOfListOfCoupleOfShape.hxx> #include <GEOMAlgo_ListIteratorOfListOfCoupleOfShapes.hxx>
#include <NMTTools_IndexedDataMapOfShapeIndexedMapOfShape.hxx>
#include <NMTTools_Tools.hxx>
#include <GEOMAlgo_AlgoTools.hxx>
#include <GEOMAlgo_GlueDetector.hxx> #include <GEOMAlgo_GlueDetector.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape.hxx>
static static
@ -130,9 +130,9 @@ void GEOMAlgo_Gluer2::PerformShapesToWork()
Standard_Integer aNbSG, i, j, k, aNbC, aNb, aNbSD; Standard_Integer aNbSG, i, j, k, aNbC, aNb, aNbSD;
TopTools_ListIteratorOfListOfShape aItLS1, aItLS2; TopTools_ListIteratorOfListOfShape aItLS1, aItLS2;
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS; TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS;
NMTTools_CoupleOfShape aCS; GEOMAlgo_CoupleOfShapes aCS;
NMTTools_ListOfCoupleOfShape aLCS; GEOMAlgo_ListOfCoupleOfShapes aLCS;
NMTTools_ListIteratorOfListOfCoupleOfShape aItCS; GEOMAlgo_ListIteratorOfListOfCoupleOfShapes aItCS;
// //
myErrorStatus=0; myErrorStatus=0;
myWarningStatus=0; myWarningStatus=0;
@ -186,9 +186,9 @@ void GEOMAlgo_Gluer2::PerformShapesToWork()
// //
// 2. Find Chains // 2. Find Chains
TopTools_ListOfShape aLSX; TopTools_ListOfShape aLSX;
NMTTools_IndexedDataMapOfShapeIndexedMapOfShape aMC; GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape aMC;
// //
NMTTools_Tools::FindChains(aLCS, aMC); GEOMAlgo_AlgoTools::FindChains(aLCS, aMC);
// //
// 3. myImagesToWork, myOriginsToWork // 3. myImagesToWork, myOriginsToWork
aNbC=aMC.Extent(); aNbC=aMC.Extent();
@ -209,8 +209,8 @@ void GEOMAlgo_Gluer2::PerformShapesToWork()
//function : TreatPair //function : TreatPair
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Gluer2::TreatPair(const NMTTools_CoupleOfShape& aCS, void GEOMAlgo_Gluer2::TreatPair(const GEOMAlgo_CoupleOfShapes& aCS,
NMTTools_ListOfCoupleOfShape& aLCS) GEOMAlgo_ListOfCoupleOfShapes& aLCS)
{ {
if (myErrorStatus) { if (myErrorStatus) {
return; return;
@ -222,7 +222,7 @@ void GEOMAlgo_Gluer2::TreatPair(const NMTTools_CoupleOfShape& aCS,
TopTools_IndexedMapOfShape aMS1, aMS2; TopTools_IndexedMapOfShape aMS1, aMS2;
TopTools_DataMapOfShapeListOfShape aDMSLS; TopTools_DataMapOfShapeListOfShape aDMSLS;
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS; TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMSLS;
NMTTools_CoupleOfShape aCSS; GEOMAlgo_CoupleOfShapes aCSS;
// //
// 1. Checking the pair on whether it can be glued at all // 1. Checking the pair on whether it can be glued at all
// 1.1 // 1.1

8
src/GEOMAlgo/GEOMAlgo_GluerAlgo.cxx
View File

@ -25,7 +25,7 @@
// <peter@PREFEX> // <peter@PREFEX>
// //
#include <GEOMAlgo_GluerAlgo.hxx> #include <GEOMAlgo_GluerAlgo.hxx>
#include <IntTools_Context.hxx> #include <BOPInt_Context.hxx>
//======================================================================= //=======================================================================
@ -97,7 +97,7 @@ Standard_Boolean GEOMAlgo_GluerAlgo::CheckGeometry() const
//function : SetContext //function : SetContext
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_GluerAlgo::SetContext(const Handle(IntTools_Context)& theContext) void GEOMAlgo_GluerAlgo::SetContext(const Handle(BOPInt_Context)& theContext)
{ {
myContext=theContext; myContext=theContext;
} }
@ -105,7 +105,7 @@ void GEOMAlgo_GluerAlgo::SetContext(const Handle(IntTools_Context)& theContext)
//function : Context //function : Context
//purpose : //purpose :
//======================================================================= //=======================================================================
const Handle(IntTools_Context)& GEOMAlgo_GluerAlgo::Context() const Handle(BOPInt_Context)& GEOMAlgo_GluerAlgo::Context()
{ {
return myContext; return myContext;
} }
@ -141,6 +141,6 @@ void GEOMAlgo_GluerAlgo::Clear()
void GEOMAlgo_GluerAlgo::Perform() void GEOMAlgo_GluerAlgo::Perform()
{ {
if (myContext.IsNull()) { if (myContext.IsNull()) {
myContext=new IntTools_Context; myContext=new BOPInt_Context;
} }
} }

10
src/GEOMAlgo/GEOMAlgo_GluerAlgo.hxx
View File

@ -31,10 +31,10 @@
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <Standard_Real.hxx> #include <Standard_Real.hxx>
#include <Standard_Boolean.hxx> #include <Standard_Boolean.hxx>
#include <IntTools_Context.hxx>
#include <BOPInt_Context.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx> #include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_DataMapOfShapeShape.hxx> #include <TopTools_DataMapOfShapeShape.hxx>
#include <GEOMAlgo_BuilderShape.hxx>
//======================================================================= //=======================================================================
//class : GEOMAlgo_GluerAlgo //class : GEOMAlgo_GluerAlgo
@ -74,10 +74,10 @@ public:
virtual void Clear() ; virtual void Clear() ;
Standard_EXPORT Standard_EXPORT
void SetContext(const Handle(IntTools_Context)&) ; void SetContext(const Handle(BOPInt_Context)&) ;
Standard_EXPORT Standard_EXPORT
const Handle(IntTools_Context)& Context() ; const Handle(BOPInt_Context)& Context() ;
Standard_EXPORT Standard_EXPORT
const TopTools_DataMapOfShapeListOfShape& Images() const; const TopTools_DataMapOfShapeListOfShape& Images() const;
@ -89,7 +89,7 @@ protected:
TopoDS_Shape myArgument; TopoDS_Shape myArgument;
Standard_Real myTolerance; Standard_Real myTolerance;
Standard_Boolean myCheckGeometry; Standard_Boolean myCheckGeometry;
Handle(IntTools_Context) myContext; Handle(BOPInt_Context) myContext;
TopTools_DataMapOfShapeListOfShape myImages; TopTools_DataMapOfShapeListOfShape myImages;
TopTools_DataMapOfShapeShape myOrigins; TopTools_DataMapOfShapeShape myOrigins;

1
src/GEOMAlgo/GEOMAlgo_HAlgo.hxx
View File

@ -31,7 +31,6 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_DefineHandle.hxx> #include <Standard_DefineHandle.hxx>
//#include <Handle_GEOMAlgo_HAlgo.hxx>
#include <Standard_Integer.hxx> #include <Standard_Integer.hxx>
#include <MMgt_TShared.hxx> #include <MMgt_TShared.hxx>

17
src/NMTDS/NMTDS_IndexedDataMapOfShapeBox.hxx → src/GEOMAlgo/GEOMAlgo_IndexedDataMapOfShapeBndSphere.hxx Normal file → Executable file
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -17,24 +17,25 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTDS_IndexedDataMapOfShapeBox.hxx // File: GEOMAlgo_IndexedDataMapOfShapeBndSphere.hxx
// Created: Mon Feb 20 09:17:01 2012 // Created: Mon Feb 20 09:17:01 2012
// Author: // Author:
// <pkv@BDEURI37616> // <pkv@BDEURI37616>
#ifndef NMTDS_IndexedDataMapOfShapeBox_HeaderFile #ifndef GEOMAlgo_IndexedDataMapOfShapeBndSphere_HeaderFile
#define NMTDS_IndexedDataMapOfShapeBox_HeaderFile #define GEOMAlgo_IndexedDataMapOfShapeBndSphere_HeaderFile
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx> #include <TopTools_ShapeMapHasher.hxx>
#include <Bnd_Box.hxx> #include <GEOMAlgo_BndSphere.hxx>
#define _NCollection_MapHasher #define _NCollection_MapHasher
#include <NCollection_IndexedDataMap.hxx> #include <NCollection_IndexedDataMap.hxx>
typedef NCollection_IndexedDataMap<TopoDS_Shape, Bnd_Box, TopTools_ShapeMapHasher> NMTDS_IndexedDataMapOfShapeBox;
typedef NCollection_IndexedDataMap<TopoDS_Shape, GEOMAlgo_BndSphere, TopTools_ShapeMapHasher> GEOMAlgo_IndexedDataMapOfShapeBndSphere;
#undef _NCollection_MapHasher #undef _NCollection_MapHasher

20
src/NMTTools/NMTTools_IndexedDataMapOfShapeIndexedMapOfShape.hxx → src/GEOMAlgo/GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape.hxx Normal file → Executable file
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
@ -16,18 +16,18 @@
// //
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: NMTTools_IndexedDataMapOfIndexedMapOfInteger.hxx // File: GEOMAlgo_IndexedDataMapOfIndexedMapOfInteger.hxx
// Created: Mon Feb 20 09:20:07 2012 // Created: Mon Feb 20 09:20:07 2012
// Author: // Author:
// <pkv@BDEURI37616> // <pkv@BDEURI37616>
// File: NMTTools_IndexedDataMapOfShapeIndexedMapOfShape.hxx // File: GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape.hxx
// Created: Mon Feb 20 11:59:23 2012 // Created: Mon Feb 20 11:59:23 2012
// Author: // Author:
// <pkv@BDEURI37616> // <pkv@BDEURI37616>
#ifndef NMTTools_IndexedDataMapOfShapeIndexedMapOfShape_HeaderFile #ifndef GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape_HeaderFile
#define NMTTools_IndexedDataMapOfShapeIndexedMapOfShape_HeaderFile #define GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape_HeaderFile
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
@ -38,7 +38,7 @@
#include <NCollection_IndexedDataMap.hxx> #include <NCollection_IndexedDataMap.hxx>
typedef NCollection_IndexedDataMap <TopoDS_Shape, TopTools_IndexedMapOfShape, TopTools_ShapeMapHasher> NMTTools_IndexedDataMapOfShapeIndexedMapOfShape; typedef NCollection_IndexedDataMap <TopoDS_Shape, TopTools_IndexedMapOfShape, TopTools_ShapeMapHasher> GEOMAlgo_IndexedDataMapOfShapeIndexedMapOfShape;
#undef _NCollection_MapHasher #undef _NCollection_MapHasher

35
src/GEOMAlgo/GEOMAlgo_PWireEdgeSet.hxx
View File

@ -1,35 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_PWireEdgeSet.hxx
// Created:
// Author: Peter KURNEV
// <peter@PREFEX>
//
#ifndef _GEOMAlgo_PWireEdgeSet_HeaderFile
#define _GEOMAlgo_PWireEdgeSet_HeaderFile
class GEOMAlgo_WireEdgeSet;
typedef GEOMAlgo_WireEdgeSet* GEOMAlgo_PWireEdgeSet;
#endif

3
src/GEOMAlgo/GEOMAlgo_PassKey.hxx
View File

@ -31,9 +31,10 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <Standard_Integer.hxx> #include <Standard_Integer.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <Standard_Boolean.hxx> #include <Standard_Boolean.hxx>
#include <TColStd_ListOfInteger.hxx> #include <TColStd_ListOfInteger.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
//======================================================================= //=======================================================================
//class : GEOMAlgo_PassKey //class : GEOMAlgo_PassKey

62
src/GEOMAlgo/GEOMAlgo_RemoverWebs.cxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -24,28 +24,24 @@
// Author: Peter KURNEV // Author: Peter KURNEV
#include <GEOMAlgo_RemoverWebs.hxx> #include <GEOMAlgo_RemoverWebs.hxx>
#include <GEOMAlgo_ShapeAlgo.hxx>
#include <TopoDS_Iterator.hxx> #include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <TopoDS_Solid.hxx> #include <TopoDS_Solid.hxx>
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <TopExp.hxx> #include <TopExp.hxx>
#include <BRepClass3d_SolidClassifier.hxx> #include <BRepClass3d_SolidClassifier.hxx>
#include <IntTools_Context.hxx> #include <BOPInt_Context.hxx>
#include <GEOMAlgo_ShapeAlgo.hxx> #include <BOPAlgo_BuilderSolid.hxx>
#include <GEOMAlgo_BuilderSolid.hxx>
#include <GEOMAlgo_Tools3D.hxx> #include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPCol_MapOfShape.hxx>
//======================================================================= //=======================================================================
//function : //function :
@ -106,7 +102,7 @@ void GEOMAlgo_RemoverWebs::Perform()
if (!myContext.IsNull()) { if (!myContext.IsNull()) {
myContext.Nullify(); myContext.Nullify();
} }
myContext=new IntTools_Context; myContext=new BOPInt_Context;
// //
BuildSolid(); BuildSolid();
// //
@ -123,14 +119,14 @@ void GEOMAlgo_RemoverWebs::BuildSolid()
TopoDS_Iterator aIt1, aIt2; TopoDS_Iterator aIt1, aIt2;
TopoDS_Shape aShape; TopoDS_Shape aShape;
BRep_Builder aBB; BRep_Builder aBB;
TopTools_MapOfShape aMFence; BOPCol_MapOfShape aMFence;
TopTools_IndexedMapOfShape aMSI; BOPCol_IndexedMapOfShape aMSI;
TopTools_IndexedDataMapOfShapeListOfShape aMFS; BOPCol_IndexedDataMapOfShapeListOfShape aMFS;
TopTools_ListOfShape aSFS; BOPCol_ListOfShape aSFS;
TopTools_ListIteratorOfListOfShape aItLS; BOPCol_ListIteratorOfListOfShape aItLS;
GEOMAlgo_BuilderSolid aSB; BOPAlgo_BuilderSolid aSB;
// //
//modified by NIZNHY-PKV Fri Jul 12 07:22:58 2013f //modified by NIZNHY-PKV Thu Jul 11 06:54:51 2013f
// //
// 0. // 0.
// The compound myShape may contain equal solids // The compound myShape may contain equal solids
@ -148,9 +144,9 @@ void GEOMAlgo_RemoverWebs::BuildSolid()
// //
aNbR=aMFence.Extent(); aNbR=aMFence.Extent();
if (aNbS!=aNbR) { if (aNbS!=aNbR) {
TopTools_MapIteratorOfMapOfShape aItMS; BOPCol_MapIteratorOfMapOfShape aItMS;
// //
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aShape); BOPTools_AlgoTools::MakeContainer(TopAbs_COMPOUND, aShape);
// //
aItMS.Initialize(aMFence); aItMS.Initialize(aMFence);
for (; aItMS.More(); aItMS.Next()) { for (; aItMS.More(); aItMS.Next()) {
@ -158,12 +154,12 @@ void GEOMAlgo_RemoverWebs::BuildSolid()
aBB.Add(aShape, aS); aBB.Add(aShape, aS);
} }
} }
//modified by NIZNHY-PKV Fri Jul 12 07:23:02 2013t //modified by NIZNHY-PKV Thu Jul 11 06:54:54 2013t
// //
aNbF2=0; aNbF2=0;
// //
// 1. aSFS: Faces // 1. aSFS: Faces
TopExp::MapShapesAndAncestors(aShape, TopAbs_FACE, TopAbs_SOLID, aMFS); BOPTools::MapShapesAndAncestors(aShape, TopAbs_FACE, TopAbs_SOLID, aMFS);
// //
aNbF=aMFS.Extent(); aNbF=aMFS.Extent();
for (i=1; i<=aNbF; ++i) { for (i=1; i<=aNbF; ++i) {
@ -179,7 +175,7 @@ void GEOMAlgo_RemoverWebs::BuildSolid()
aSFS.Append(aFi); aSFS.Append(aFi);
} }
else { else {
const TopTools_ListOfShape& aLSx=aMFS(i); const BOPCol_ListOfShape& aLSx=aMFS(i);
aNbSx=aLSx.Extent(); aNbSx=aLSx.Extent();
if (aNbSx==1) { if (aNbSx==1) {
aSFS.Append(aFx); aSFS.Append(aFx);
@ -214,7 +210,7 @@ void GEOMAlgo_RemoverWebs::BuildSolid()
aNbSI=aMSI.Extent(); aNbSI=aMSI.Extent();
// //
// 3 Solids without internals // 3 Solids without internals
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, myResult); BOPTools_AlgoTools::MakeContainer(TopAbs_COMPOUND, myResult);
// //
aSB.SetContext(myContext); aSB.SetContext(myContext);
aSB.SetShapes(aSFS); aSB.SetShapes(aSFS);
@ -225,7 +221,7 @@ void GEOMAlgo_RemoverWebs::BuildSolid()
return; return;
} }
// //
const TopTools_ListOfShape& aLSR=aSB.Areas(); const BOPCol_ListOfShape& aLSR=aSB.Areas();
// //
// 4 Add the internals // 4 Add the internals
if (aNbSI) { if (aNbSI) {
@ -243,17 +239,17 @@ void GEOMAlgo_RemoverWebs::BuildSolid()
//function : AddInternalShapes //function : AddInternalShapes
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_RemoverWebs::AddInternalShapes(const TopTools_ListOfShape& aLSR, void GEOMAlgo_RemoverWebs::AddInternalShapes(const BOPCol_ListOfShape& aLSR,
const TopTools_IndexedMapOfShape& aMSI) const BOPCol_IndexedMapOfShape& aMSI)
{ {
Standard_Integer i, aNbSI; Standard_Integer i, aNbSI;
TopAbs_State aState; TopAbs_State aState;
TopoDS_Solid aSd; TopoDS_Solid aSd;
BRep_Builder aBB; BRep_Builder aBB;
TopTools_ListIteratorOfListOfShape aItLS; BOPCol_ListIteratorOfListOfShape aItLS;
Handle(IntTools_Context) aCtx; Handle(BOPInt_Context) aCtx;
// //
aCtx=new IntTools_Context; aCtx=new BOPInt_Context;
// //
aNbSI=aMSI.Extent(); aNbSI=aMSI.Extent();
for (i=1; i<=aNbSI; ++i) { for (i=1; i<=aNbSI; ++i) {
@ -263,7 +259,7 @@ void GEOMAlgo_RemoverWebs::AddInternalShapes(const TopTools_ListOfShape& aLSR,
for (; aItLS.More(); aItLS.Next()) { for (; aItLS.More(); aItLS.Next()) {
aSd=*((TopoDS_Solid*)&aItLS.Value()); aSd=*((TopoDS_Solid*)&aItLS.Value());
// //
aState=GEOMAlgo_Tools3D::ComputeStateByOnePoint(aSI, aSd, 1.e-11, aCtx); aState=BOPTools_AlgoTools::ComputeStateByOnePoint(aSI, aSd, 1.e-11, aCtx);
if (aState==TopAbs_IN) { if (aState==TopAbs_IN) {
aBB.Add(aSd, aSI); aBB.Add(aSd, aSI);
// //

13
src/GEOMAlgo/GEOMAlgo_RemoverWebs.hxx
View File

@ -1,4 +1,4 @@
// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE // Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
// //
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@ -22,8 +22,7 @@
// File: GEOMAlgo_RemoverWebs.hxx // File: GEOMAlgo_RemoverWebs.hxx
// Created: Thu Mar 28 08:02:59 2013 // Created: Thu Mar 28 08:02:59 2013
// Author: Peter KURNEV // Author: Peter KURNEV
// <pkv@petrex>
//
// The algorithm is intended to build result [solid(s)] // The algorithm is intended to build result [solid(s)]
// from given set of solids [argument]. // from given set of solids [argument].
// The result cosists of: // The result cosists of:
@ -39,8 +38,8 @@
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
// //
#include <GEOMAlgo_ShapeAlgo.hxx> #include <GEOMAlgo_ShapeAlgo.hxx>
#include <TopTools_ListOfShape.hxx> #include <BOPCol_ListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx> #include <BOPCol_IndexedMapOfShape.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_RemoverWebs //function : GEOMAlgo_RemoverWebs
@ -67,8 +66,8 @@ protected:
void BuildSolid() ; void BuildSolid() ;
Standard_EXPORT Standard_EXPORT
static void AddInternalShapes(const TopTools_ListOfShape& , static void AddInternalShapes(const BOPCol_ListOfShape& ,
const TopTools_IndexedMapOfShape& ); const BOPCol_IndexedMapOfShape& );
// //
}; };

8
src/GEOMAlgo/GEOMAlgo_ShapeAlgo.cxx
View File

@ -26,7 +26,7 @@
// <pkv@irinox> // <pkv@irinox>
// //
#include <GEOMAlgo_ShapeAlgo.hxx> #include <GEOMAlgo_ShapeAlgo.hxx>
#include <IntTools_Context.hxx> #include <BOPInt_Context.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_ShapeAlgo //function : GEOMAlgo_ShapeAlgo
@ -50,7 +50,7 @@ GEOMAlgo_ShapeAlgo::~GEOMAlgo_ShapeAlgo()
//function : SetContext //function : SetContext
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_ShapeAlgo::SetContext(const Handle(IntTools_Context)& theContext) void GEOMAlgo_ShapeAlgo::SetContext(const Handle(BOPInt_Context)& theContext)
{ {
myContext=theContext; myContext=theContext;
} }
@ -58,7 +58,7 @@ void GEOMAlgo_ShapeAlgo::SetContext(const Handle(IntTools_Context)& theContext)
//function : Context //function : Context
//purpose : //purpose :
//======================================================================= //=======================================================================
const Handle(IntTools_Context)& GEOMAlgo_ShapeAlgo::Context()const const Handle(BOPInt_Context)& GEOMAlgo_ShapeAlgo::Context()const
{ {
return myContext; return myContext;
} }
@ -109,6 +109,6 @@ const TopoDS_Shape& GEOMAlgo_ShapeAlgo::Result()const
void GEOMAlgo_ShapeAlgo::Perform() void GEOMAlgo_ShapeAlgo::Perform()
{ {
if (myContext.IsNull()) { if (myContext.IsNull()) {
myContext=new IntTools_Context; myContext=new BOPInt_Context;
} }
} }

8
src/GEOMAlgo/GEOMAlgo_ShapeAlgo.hxx
View File

@ -32,7 +32,7 @@
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <Standard_Real.hxx> #include <Standard_Real.hxx>
#include <Handle_IntTools_Context.hxx> #include <Handle_BOPInt_Context.hxx>
#include <GEOMAlgo_Algo.hxx> #include <GEOMAlgo_Algo.hxx>
//======================================================================= //=======================================================================
@ -45,11 +45,11 @@ class GEOMAlgo_ShapeAlgo : public GEOMAlgo_Algo
//! Sets cashed geometrical tools <br> //! Sets cashed geometrical tools <br>
Standard_EXPORT Standard_EXPORT
void SetContext(const Handle(IntTools_Context)& theContext) ; void SetContext(const Handle(BOPInt_Context)& theContext) ;
//! Returns cashed geometrical tools <br> //! Returns cashed geometrical tools <br>
Standard_EXPORT Standard_EXPORT
const Handle_IntTools_Context& Context() const; const Handle_BOPInt_Context& Context() const;
Standard_EXPORT Standard_EXPORT
void SetShape(const TopoDS_Shape& aS) ; void SetShape(const TopoDS_Shape& aS) ;
@ -80,6 +80,6 @@ protected:
TopoDS_Shape myShape; TopoDS_Shape myShape;
Standard_Real myTolerance; Standard_Real myTolerance;
TopoDS_Shape myResult; TopoDS_Shape myResult;
Handle_IntTools_Context myContext; Handle_BOPInt_Context myContext;
}; };
#endif #endif

10
src/GEOMAlgo/GEOMAlgo_ShapeInfo.hxx
View File

@ -25,16 +25,18 @@
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <TopAbs_ShapeEnum.hxx> #include <TopAbs_ShapeEnum.hxx>
#include <Standard_Integer.hxx> #include <Standard_Integer.hxx>
#include <GEOMAlgo_KindOfShape.hxx>
#include <GEOMAlgo_KindOfName.hxx>
#include <GEOMAlgo_KindOfBounds.hxx>
#include <GEOMAlgo_KindOfClosed.hxx>
#include <gp_Pnt.hxx> #include <gp_Pnt.hxx>
#include <gp_Dir.hxx> #include <gp_Dir.hxx>
#include <gp_Ax3.hxx> #include <gp_Ax3.hxx>
#include <Standard_Real.hxx> #include <Standard_Real.hxx>
#include <gp_Ax2.hxx> #include <gp_Ax2.hxx>
#include <GEOMAlgo_KindOfShape.hxx>
#include <GEOMAlgo_KindOfName.hxx>
#include <GEOMAlgo_KindOfBounds.hxx>
#include <GEOMAlgo_KindOfClosed.hxx>
//======================================================================= //=======================================================================

177
src/GEOMAlgo/GEOMAlgo_ShapeSet.cxx
View File

@ -1,177 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_ShapeSet.cxx
// Created:
// Author: Peter KURNEV
//
#include <GEOMAlgo_ShapeSet.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfOrientedShape.hxx>
//=======================================================================
//function :
//purpose :
//=======================================================================
GEOMAlgo_ShapeSet::GEOMAlgo_ShapeSet()
{
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
void GEOMAlgo_ShapeSet::Clear()
{
myMap.Clear();
myList.Clear();
}
//=======================================================================
//function : Add
//purpose :
//=======================================================================
void GEOMAlgo_ShapeSet::Add(const TopoDS_Shape& theShape)
{
if (myMap.Add(theShape)) {
myList.Append(theShape);
}
}
//=======================================================================
//function : Add
//purpose :
//=======================================================================
void GEOMAlgo_ShapeSet::Add(const TopoDS_Shape& theShape,
const TopAbs_ShapeEnum theType)
{
TopExp_Explorer aExp;
//
aExp.Init(theShape, theType);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Shape& aS=aExp.Current();
if (myMap.Add(aS)) {
myList.Append(aS);
}
}
}
//=======================================================================
//function : Add
//purpose :
//=======================================================================
void GEOMAlgo_ShapeSet::Add(const TopTools_ListOfShape& theLS)
{
TopTools_ListIteratorOfListOfShape aIt;
//
aIt.Initialize(theLS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
if (myMap.Add(aS)) {
myList.Append(aS);
}
}
}
//=======================================================================
//function :GetSet
//purpose :
//=======================================================================
const TopTools_ListOfShape& GEOMAlgo_ShapeSet::GetSet()const
{
return myList;
}
//=======================================================================
//function : Contains
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_ShapeSet::Contains(const GEOMAlgo_ShapeSet& theOther)const
{
Standard_Boolean bRet;
TopAbs_Orientation aOr;
TopTools_ListIteratorOfListOfShape aIt;
//
bRet=Standard_True;
const TopTools_ListOfShape& aLS=theOther.GetSet();
aIt.Initialize(aLS);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aF=aIt.Value();
aOr=aF.Orientation();
if (aOr==TopAbs_FORWARD || aOr==TopAbs_REVERSED) {
bRet=myMap.Contains(aF);
if (!bRet) {
break;
}
}
}
return bRet;
}
//=======================================================================
//function : Subtract
//purpose :
//=======================================================================
void GEOMAlgo_ShapeSet::Subtract(const GEOMAlgo_ShapeSet& theOther)
{
TopTools_ListIteratorOfListOfShape aIt;
TopTools_ListOfShape aLS;
//
myMap.Clear();
aIt.Initialize(myList);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
if (!theOther.myMap.Contains(aS)) {
if(myMap.Add(aS)){
aLS.Append(aS);
}
}
}
//
myList=aLS;
}
//modified by NIZNHY-PKV Wed Oct 28 13:51:36 2010f
//=======================================================================
//function : IsEqual
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_ShapeSet::IsEqual(const GEOMAlgo_ShapeSet& theOther)const
{
Standard_Boolean bRet;
Standard_Integer aNb1, aNb2;
TopTools_ListIteratorOfListOfShape aIt;
//
bRet=Standard_True;
aNb1=myList.Extent();
const TopTools_ListOfShape& aLS2=theOther.GetSet();
aNb2=aLS2.Extent();
if (aNb1!=aNb2) {
return !bRet;
}
//
aIt.Initialize(myList);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
if(!theOther.myMap.Contains(aS)) {
bRet=!bRet;
break;
}
}
return bRet;
}
//modified by NIZNHY-PKV Wed Oct 28 13:51:38 2010t

92
src/GEOMAlgo/GEOMAlgo_ShapeSet.hxx
View File

@ -1,92 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_ShapeSet.hxx
// Created:
// Author: Peter KURNEV
//
#ifndef _GEOMAlgo_ShapeSet_HeaderFile
#define _GEOMAlgo_ShapeSet_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <TopTools_MapOfOrientedShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <Standard_Boolean.hxx>
#include <TopoDS_Shape.hxx>
//! Implementation some formal <br>
//! opereations with Set of shapes <br>
//=======================================================================
//class : GEOMAlgo_ShapeSet
//purpose :
//=======================================================================
class GEOMAlgo_ShapeSet
{
public:
//! Empty constructor <br>
Standard_EXPORT
GEOMAlgo_ShapeSet();
//! Adds shapes from the list theLS to the Set <br>
Standard_EXPORT
void Add(const TopTools_ListOfShape& theLS) ;
//! Adds shape theShape to the Set <br>
Standard_EXPORT
void Add(const TopoDS_Shape& theShape) ;
//! Adds sub-shapes of shape theShape, <br>
//! that have type theType to the Set <br>
Standard_EXPORT
void Add(const TopoDS_Shape& theShape,const TopAbs_ShapeEnum theType) ;
//! Removes shapes of theSet from the Set <br>
Standard_EXPORT
void Subtract(const GEOMAlgo_ShapeSet& theSet) ;
//! Clears internal fields <br>
Standard_EXPORT void Clear() ;
//! Returns True if the Set contains <br>
//! all shapes of theSet <br>
Standard_EXPORT
Standard_Boolean Contains(const GEOMAlgo_ShapeSet& theSet) const;
//! Returns the Set <br>
Standard_EXPORT
const TopTools_ListOfShape& GetSet() const;
//! Returns True if the Set==theSet <br>
Standard_EXPORT
Standard_Boolean IsEqual(const GEOMAlgo_ShapeSet& theOther) const;
Standard_Boolean operator ==(const GEOMAlgo_ShapeSet& theOther) const {
return IsEqual(theOther);
}
protected:
TopTools_MapOfOrientedShape myMap;
TopTools_ListOfShape myList;
};
#endif

4
src/GEOMAlgo/GEOMAlgo_ShapeSolid.cxx
View File

@ -52,9 +52,9 @@ GEOMAlgo_ShapeSolid::~GEOMAlgo_ShapeSolid()
//function : SetFiller //function : SetFiller
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_ShapeSolid::SetFiller(const BOPTools_DSFiller& aDSFiller) void GEOMAlgo_ShapeSolid::SetFiller(const BOPAlgo_PaveFiller& aDSFiller)
{ {
myDSFiller=(BOPTools_DSFiller*) &aDSFiller; myDSFiller=(BOPAlgo_PaveFiller*) &aDSFiller;
} }
//======================================================================= //=======================================================================
// function: Shapes // function: Shapes

20
src/GEOMAlgo/GEOMAlgo_ShapeSolid.hxx
View File

@ -30,12 +30,15 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Standard_Integer.hxx> #include <Standard_Integer.hxx>
#include <BOPTools_PDSFiller.hxx>
#include <GEOMAlgo_Algo.hxx>
#include <TopAbs_State.hxx> #include <TopAbs_State.hxx>
#include <BOPTools_DSFiller.hxx> #include <TopTools_ListOfShape.hxx>
#include <BOPAlgo_PaveFiller.hxx>
#include <BOPAlgo_PPaveFiller.hxx>
#include <GEOMAlgo_Algo.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_ShapeSolid //function : GEOMAlgo_ShapeSolid
@ -45,7 +48,7 @@ class GEOMAlgo_ShapeSolid : public GEOMAlgo_Algo
{ {
public: public:
Standard_EXPORT Standard_EXPORT
void SetFiller(const BOPTools_DSFiller& aDSF) ; void SetFiller(const BOPAlgo_PaveFiller& aDSF) ;
Standard_EXPORT Standard_EXPORT
virtual ~GEOMAlgo_ShapeSolid(); virtual ~GEOMAlgo_ShapeSolid();
@ -58,16 +61,13 @@ protected:
GEOMAlgo_ShapeSolid(); GEOMAlgo_ShapeSolid();
Standard_EXPORT Standard_EXPORT
virtual void BuildResult() = 0; virtual void BuildResult()=0;
Standard_EXPORT
virtual void Prepare() = 0;
TopTools_ListOfShape myLSIN; TopTools_ListOfShape myLSIN;
TopTools_ListOfShape myLSOUT; TopTools_ListOfShape myLSOUT;
TopTools_ListOfShape myLSON; TopTools_ListOfShape myLSON;
Standard_Integer myRank; Standard_Integer myRank;
BOPTools_PDSFiller myDSFiller; BOPAlgo_PPaveFiller myDSFiller;
}; };
#endif #endif

495
src/GEOMAlgo/GEOMAlgo_ShellSolid.cxx
View File

@ -46,33 +46,118 @@
#include <TopTools_ListIteratorOfListOfShape.hxx> #include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
#include <BRepClass3d_SolidClassifier.hxx> #include <BOPTools_AlgoTools.hxx>
#include <IntTools_Context.hxx> #include <BOPCol_DataMapOfShapeListOfShape.hxx>
#include <BOPTColStd_Dump.hxx> #include <BOPCol_ListOfShape.hxx>
#include <BooleanOperations_ShapesDataStructure.hxx> #include <BOPInt_Context.hxx>
#include <BOPDS_DS.hxx>
#include <BOPAlgo_Builder.hxx>
#include <BOPTools_PaveFiller.hxx> #include <GEOMAlgo_AlgoTools.hxx>
#include <BOPTools_SolidStateFiller.hxx> /////////////////////////////////////////////////////////////////////////
#include <BOPTools_PCurveMaker.hxx> //=======================================================================
#include <BOPTools_DEProcessor.hxx> //class : GEOMAlgo_ShellSolidBuilder
#include <BOPTools_InterferencePool.hxx> //purpose :
#include <BOPTools_CArray1OfSSInterference.hxx> //=======================================================================
#include <BOPTools_ListOfPaveBlock.hxx> class GEOMAlgo_ShellSolidBuilder : public BOPAlgo_Builder {
#include <BOPTools_ListIteratorOfListOfPaveBlock.hxx> public:
#include <BOPTools_PaveBlock.hxx> Standard_EXPORT
#include <BOPTools_SSInterference.hxx> GEOMAlgo_ShellSolidBuilder();
#include <BOPTools_SequenceOfCurves.hxx>
#include <BOPTools_Curve.hxx>
#include <BOPTools_PaveFiller.hxx>
#include <BOPTools_SplitShapesPool.hxx>
#include <BOPTools_Tools3D.hxx>
#include <BOPTools_DSFiller.hxx>
#include <BOP_WireEdgeSet.hxx> Standard_EXPORT
#include <BOP_SDFWESFiller.hxx> virtual ~GEOMAlgo_ShellSolidBuilder();
#include <BOP_FaceBuilder.hxx>
protected:
Standard_EXPORT
virtual void PerformInternal(const BOPAlgo_PaveFiller& theFiller);
};
//=======================================================================
//function : GEOMAlgo_ShellSolidBuilder
//purpose :
//=======================================================================
GEOMAlgo_ShellSolidBuilder::GEOMAlgo_ShellSolidBuilder()
:
BOPAlgo_Builder()
{
}
//=======================================================================
//function : ~GEOMAlgo_ShellSolidBuilder
//purpose :
//=======================================================================
GEOMAlgo_ShellSolidBuilder::~GEOMAlgo_ShellSolidBuilder()
{
}
//=======================================================================
//function : PerformInternal
//purpose :
//=======================================================================
void GEOMAlgo_ShellSolidBuilder::PerformInternal(const BOPAlgo_PaveFiller& theFiller)
{
myErrorStatus=0;
//
myPaveFiller=(BOPAlgo_PaveFiller*)&theFiller;
myDS=myPaveFiller->PDS();
myContext=myPaveFiller->Context();
//
// 1. CheckData
CheckData();
if (myErrorStatus) {
return;
}
//
// 2. Prepare
Prepare();
if (myErrorStatus) {
return;
}
//
// 3. Fill Images
// 3.1 Vertice
FillImagesVertices();
if (myErrorStatus) {
return;
}
//
BuildResult(TopAbs_VERTEX);
if (myErrorStatus) {
return;
}
// 3.2 Edges
FillImagesEdges();
if (myErrorStatus) {
return;
}
//
BuildResult(TopAbs_EDGE);
if (myErrorStatus) {
return;
}
//
// 3.3 Wires
FillImagesContainers(TopAbs_WIRE);
if (myErrorStatus) {
return;
}
//
BuildResult(TopAbs_WIRE);
if (myErrorStatus) {
return;
}
// 3.4 Faces
FillImagesFaces();
if (myErrorStatus) {
return;
}
//
BuildResult(TopAbs_FACE);
if (myErrorStatus) {
return;
}
}
/////////////////////////////////////////////////////////////////////////
//======================================================================= //=======================================================================
//function : GEOMAlgo_ShellSolid //function : GEOMAlgo_ShellSolid
//purpose : //purpose :
@ -98,274 +183,126 @@ void GEOMAlgo_ShellSolid::Perform()
myErrorStatus=0; myErrorStatus=0;
// //
try { try {
Standard_Integer aNbArgs, iRank, iErr, iBeg, iEnd, i, aNbSp;
Standard_Real aTol;
TopAbs_ShapeEnum aType;
TopAbs_State aState;
gp_Pnt aP;
gp_Pnt2d aP2D;
TopoDS_Face aF;
//
myLSIN.Clear();
myLSOUT.Clear();
myLSON.Clear();
//
aTol=1.e-7;
//
if (myDSFiller==NULL) { if (myDSFiller==NULL) {
myErrorStatus=10; myErrorStatus=10;
return; return;
} }
if(!myDSFiller->IsDone()) { if(myDSFiller->ErrorStatus()) {
myErrorStatus=11; myErrorStatus=11;
return; return;
} }
// //
Standard_Boolean bIsNewFiller; const BOPDS_DS& aDS=myDSFiller->DS();
BOPDS_DS* pDS=(BOPDS_DS*)&aDS;
const BOPCol_ListOfShape& aLS=pDS->Arguments();
// //
bIsNewFiller=myDSFiller->IsNewFiller(); aNbArgs=aLS.Extent();
if (bIsNewFiller) { if (aNbArgs!=2) {
Prepare(); myErrorStatus=13;
myDSFiller->SetNewFiller(!bIsNewFiller); return;
} }
// //
myRank=(myDSFiller->DS().Object().ShapeType()==TopAbs_SHELL) ? 1 : 2; iRank=-1;
BuildResult(); const TopoDS_Shape& aObj=aLS.First();
} if (aObj.ShapeType()==TopAbs_SHELL) {
iRank=0;
}
const TopoDS_Shape& aTool=aLS.Last();
if (aTool.ShapeType()==TopAbs_SHELL) {
iRank=1;
}
//
if (iRank==-1) {
myErrorStatus=14;
return;
}
//
Handle(BOPInt_Context) aCtx=myDSFiller->Context();
const BOPDS_IndexRange& aRange=pDS->Range(iRank);
aRange.Indices(iBeg, iEnd);
const TopoDS_Solid& aSolid=(!iRank) ? *((TopoDS_Solid*)&aTool) : *((TopoDS_Solid*)&aObj);
BRepClass3d_SolidClassifier& aSC=aCtx->SolidClassifier(aSolid);
//
//------------------------------ShellSolidBuilder
GEOMAlgo_ShellSolidBuilder aSSB;
//
aSSB.PerformWithFiller(*myDSFiller);
iErr=aSSB.ErrorStatus();
if (iErr) {
myErrorStatus=15;
return;
}
//
const BOPCol_DataMapOfShapeListOfShape& aImages=aSSB.Images();
//
//-------------------------------
for (i=iBeg; i<=iEnd; ++i) {
const TopoDS_Shape& aS=pDS->Shape(i);
aType=aS.ShapeType();
if (aType!=TopAbs_FACE) {
continue;
}
//
aState=TopAbs_UNKNOWN;
aF=*((TopoDS_Face*)&aS);
//
if (!aImages.IsBound(aS)) {
iErr=GEOMAlgo_AlgoTools::PntInFace(aF, aP, aP2D);
if (iErr) {
myErrorStatus=16;
return;
}
//
aState=BOPTools_AlgoTools::ComputeState(aP, aSolid, aTol, aCtx);
}
else {
const BOPCol_ListOfShape& aLSp=aImages.Find(aS);
aNbSp=aLSp.Extent();
if (aNbSp>0) {
continue;
}
//
if (aNbSp==1) {
aF=*((TopoDS_Face*)&aLSp.First());
}
//
iErr=GEOMAlgo_AlgoTools::PntInFace(aF, aP, aP2D);
if (iErr) {
myErrorStatus=16;
return;
}
//
aState=BOPTools_AlgoTools::ComputeState(aP, aSolid, aTol, aCtx);
}
//----------
if (aState==TopAbs_ON) {
myLSON.Append(aF);
}
else if (aState==TopAbs_OUT) {
myLSOUT.Append(aF);
}
else if (aState==TopAbs_IN) {
myLSIN.Append(aF);
}
//----------
}//for (i=iBeg; i<=iEnd; ++i) {
}// try
catch (Standard_Failure) { catch (Standard_Failure) {
myErrorStatus=12; myErrorStatus=12;
} }
} }
//=======================================================================
// function: Prepare
// purpose:
//=======================================================================
void GEOMAlgo_ShellSolid::Prepare()
{
const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
//
// 1 States
BOPTools_SolidStateFiller aStateFiller(aPaveFiller);
aStateFiller.Do();
//
// 2 Project section edges on corresp. faces -> P-Curves on edges.
BOPTools_PCurveMaker aPCurveMaker(aPaveFiller);
aPCurveMaker.Do();
//
// 3. Degenerated Edges Processing
BOPTools_DEProcessor aDEProcessor(aPaveFiller);
aDEProcessor.Do();
//
// 4. Detect Same Domain Faces
DetectSDFaces();
}
//=================================================================================
// function: BuildResult
// purpose:
//=================================================================================
void GEOMAlgo_ShellSolid::BuildResult()
{
Standard_Boolean bIsTouchCase;
Standard_Integer i, j, nF1, nF2, aNbFFs, aNbS, aNbCurves, nSp, iRank1;
Standard_Integer nE, nF, aNbPB, iBeg, iEnd;
BooleanOperations_StateOfShape aState;
TopExp_Explorer anExp;
TopAbs_ShapeEnum aType;
gp_Pnt2d aP2D;
gp_Pnt aP3D;
//
const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
const BOPTools_InterferencePool& anInterfPool=myDSFiller->InterfPool();
BOPTools_InterferencePool* pInterfPool=(BOPTools_InterferencePool*) &anInterfPool;
BOPTools_CArray1OfSSInterference& aFFs=pInterfPool->SSInterferences();
const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
const BOPTools_SplitShapesPool& aSplitShapesPool=aPaveFiller.SplitShapesPool();
//
// 1. process pf non-interferring faces
iBeg=1;
iEnd=aDS.NumberOfShapesOfTheObject();
if (myRank==2) {
iBeg=iEnd+1;
iEnd=aDS.NumberOfSourceShapes();
}
//
for (i=iBeg; i<=iEnd; ++i) {
aType=aDS.GetShapeType(i);
if (aType!=TopAbs_FACE) {
continue;
}
//
const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(i));
aState=aDS.GetState(i);
if (aState==BooleanOperations_IN) {
myLSIN.Append(aF1);
}
else if (aState==BooleanOperations_OUT) {
myLSOUT.Append(aF1);
}
}
//
// 2. process pf interferred faces
aNbFFs=aFFs.Extent();
for (i=1; i<=aNbFFs; ++i) {
BOPTools_SSInterference& aFFi=aFFs(i);
//
nF1=aFFi.Index1();
nF2=aFFi.Index2();
iRank1=aDS.Rank(nF1);
nF=(iRank1==myRank) ? nF1 : nF2;
const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF));
//
bIsTouchCase=aFFi.IsTangentFaces();
//
if (bIsTouchCase) {
myLSON.Append(aF1);
continue;
}
//
// Has section edges ?
aNbS=0;
BOPTools_SequenceOfCurves& aBCurves=aFFi.Curves();
aNbCurves=aBCurves.Length();
for (j=1; j<=aNbCurves; j++) {
BOPTools_Curve& aBC=aBCurves(j);
const BOPTools_ListOfPaveBlock& aSectEdges=aBC.NewPaveBlocks();
aNbS=aSectEdges.Extent();
if (aNbS) {
break;
}
}
//
if (aNbS) { // it has
continue;
}
//
anExp.Init(aF1, TopAbs_EDGE);
for (; anExp.More(); anExp.Next()) {
const TopoDS_Edge& aE=TopoDS::Edge(anExp.Current());
if (BRep_Tool::Degenerated(aE)) {
continue;
}
//
nE=aDS.ShapeIndex(aE, myRank);
const BOPTools_ListOfPaveBlock& aLPB=aSplitShapesPool(aDS.RefEdge(nE));
aNbPB=aLPB.Extent();
//
if (aNbPB<2) {
nSp=nE;
if (aNbPB) {
const BOPTools_PaveBlock& aPB=aLPB.First();
nSp=aPB.Edge();
}
/*const TopoDS_Shape& aSp=*/aDS.Shape(nSp);
//
aState=aDS.GetState(nSp);
if (aState==BooleanOperations_IN) {
myLSIN.Append(aF1);
}
else if (aState==BooleanOperations_OUT) {
myLSOUT.Append(aF1);
}
else if (aState==BooleanOperations_ON) {
Standard_Real aTol;
TopAbs_State aSt;
//
//const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape((iRank1==myRank)? nF2 : nF1));
//aTol=BRep_Tool::Tolerance(aF2);
aTol=1.e-7;
//
BOPTools_Tools3D::PointNearEdge(aE, aF1, aP2D, aP3D);
const TopoDS_Solid& aRefSolid=(myRank==1) ?
TopoDS::Solid(aDS.Tool()) : TopoDS::Solid(aDS.Object());
//
BOPTools_PaveFiller* pPF=(BOPTools_PaveFiller*)& aPaveFiller;
const Handle(IntTools_Context)& aCtx=pPF->Context();
//
BRepClass3d_SolidClassifier& aSC=aCtx->SolidClassifier(aRefSolid);
aSC.Perform(aP3D, aTol);
aSt=aSC.State();
if (aSt==TopAbs_IN) {
myLSIN.Append(aF1);
}
else if (aSt==TopAbs_OUT) {
myLSOUT.Append(aF1);
}
}
break;
} // if (aNbPB<2) {
} //for (; anExp.More(); anExp.Next())
}
}
//=======================================================================
// function: DetectSDFaces
// purpose:
//=======================================================================
void GEOMAlgo_ShellSolid::DetectSDFaces()
{
const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
BOPTools_InterferencePool* pIntrPool=(BOPTools_InterferencePool*)&myDSFiller->InterfPool();
BOPTools_CArray1OfSSInterference& aFFs=pIntrPool->SSInterferences();
//
Standard_Boolean bFlag;
Standard_Integer i, aNb, nF1, nF2, iZone, aNbSps, iSenseFlag;
gp_Dir aDNF1, aDNF2;
aNb=aFFs.Extent();
for (i=1; i<=aNb; i++) {
bFlag=Standard_False;
BOPTools_SSInterference& aFF=aFFs(i);
nF1=aFF.Index1();
nF2=aFF.Index2();
const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
const TopoDS_Face& aF2=TopoDS::Face(aDS.Shape(nF2));
//
// iSenseFlag;
const BOPTools_ListOfPaveBlock& aLPB=aFF.PaveBlocks();
aNbSps=aLPB.Extent();
if (!aNbSps) {
continue;
}
const BOPTools_PaveBlock& aPB=aLPB.First();
const TopoDS_Edge& aSpE=TopoDS::Edge(aDS.Shape(aPB.Edge()));
BOPTools_Tools3D::GetNormalToFaceOnEdge (aSpE, aF1, aDNF1);
BOPTools_Tools3D::GetNormalToFaceOnEdge (aSpE, aF2, aDNF2);
iSenseFlag=BOPTools_Tools3D::SenseFlag (aDNF1, aDNF2);
//
if (iSenseFlag==1 || iSenseFlag==-1) {
//
//
TopoDS_Face aF1FWD=aF1;
aF1FWD.Orientation (TopAbs_FORWARD);
BOP_WireEdgeSet aWES (aF1FWD);
BOP_SDFWESFiller aWESFiller(nF1, nF2, *myDSFiller);
aWESFiller.SetSenseFlag(iSenseFlag);
aWESFiller.SetOperation(BOP_COMMON);
aWESFiller.Do(aWES);
BOP_FaceBuilder aFB;
aFB.Do(aWES);
const TopTools_ListOfShape& aLF=aFB.NewFaces();
iZone=0;
TopTools_ListIteratorOfListOfShape anIt(aLF);
for (; anIt.More(); anIt.Next()) {
const TopoDS_Shape& aFR=anIt.Value();
if (aFR.ShapeType()==TopAbs_FACE) {
const TopoDS_Face& aFaceResult=TopoDS::Face(aFR);
//
Standard_Boolean bIsValidIn2D, bNegativeFlag;
bIsValidIn2D=BOPTools_Tools3D::IsValidArea (aFaceResult, bNegativeFlag);
if (bIsValidIn2D) {
//if(CheckSameDomainFaceInside(aFaceResult, aF2)) {
iZone=1;
break;
//}
}
//
}
}
if (iZone) {
bFlag=Standard_True;
aFF.SetStatesMap(aWESFiller.StatesMap());
}
}// if (iSenseFlag)
aFF.SetTangentFacesFlag(bFlag);
aFF.SetSenseFlag (iSenseFlag);
}// end of for (i=1; i<=aNb; i++)
}

7
src/GEOMAlgo/GEOMAlgo_ShellSolid.hxx
View File

@ -50,12 +50,9 @@ class GEOMAlgo_ShellSolid : public GEOMAlgo_ShapeSolid
protected: protected:
Standard_EXPORT Standard_EXPORT
virtual void Prepare() ; virtual void BuildResult() {
};
Standard_EXPORT
virtual void BuildResult() ;
Standard_EXPORT
void DetectSDFaces() ;
}; };
#endif #endif

15
src/GEOMAlgo/GEOMAlgo_SolidSolid.cxx
View File

@ -37,8 +37,6 @@
#include <TopTools_ListIteratorOfListOfShape.hxx> #include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx> #include <TopTools_IndexedMapOfShape.hxx>
#include <BooleanOperations_ShapesDataStructure.hxx>
#include <BOPTools_DSFiller.hxx>
#include <GEOMAlgo_IndexedDataMapOfShapeState.hxx> #include <GEOMAlgo_IndexedDataMapOfShapeState.hxx>
@ -86,19 +84,11 @@ void GEOMAlgo_SolidSolid::Perform()
myErrorStatus=10; myErrorStatus=10;
return; return;
} }
if(!myDSFiller->IsDone()) { if(myDSFiller->ErrorStatus()) {
myErrorStatus=11; myErrorStatus=11;
return; return;
} }
// //
Standard_Boolean bIsNewFiller;
//
bIsNewFiller=myDSFiller->IsNewFiller();
if (bIsNewFiller) {
Prepare();
myDSFiller->SetNewFiller(!bIsNewFiller);
}
//
myRank=2; myRank=2;
BuildResult(); BuildResult();
} }
@ -122,7 +112,7 @@ void GEOMAlgo_SolidSolid::BuildResult()
GEOMAlgo_IndexedDataMapOfShapeState aMFS; GEOMAlgo_IndexedDataMapOfShapeState aMFS;
// //
// 1. classify the faces // 1. classify the faces
GEOMAlgo_ShellSolid::BuildResult(); GEOMAlgo_ShellSolid::Perform();
// //
// 2. fill Shape-State map // 2. fill Shape-State map
aIt.Initialize(myLSIN); aIt.Initialize(myLSIN);
@ -140,6 +130,7 @@ void GEOMAlgo_SolidSolid::BuildResult()
const TopoDS_Shape& aF=aIt.Value(); const TopoDS_Shape& aF=aIt.Value();
aMFS.Add(aF, TopAbs_ON); aMFS.Add(aF, TopAbs_ON);
} }
//
myLSIN.Clear(); myLSIN.Clear();
myLSON.Clear(); myLSON.Clear();
myLSOUT.Clear(); myLSOUT.Clear();

6
src/GEOMAlgo/GEOMAlgo_SolidSolid.hxx
View File

@ -31,6 +31,7 @@
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
#include <GEOMAlgo_ShellSolid.hxx> #include <GEOMAlgo_ShellSolid.hxx>
//======================================================================= //=======================================================================
@ -47,7 +48,7 @@ class GEOMAlgo_SolidSolid : public GEOMAlgo_ShellSolid
virtual ~GEOMAlgo_SolidSolid(); virtual ~GEOMAlgo_SolidSolid();
Standard_EXPORT Standard_EXPORT
virtual void Perform() ; virtual void Perform() ;
Standard_EXPORT Standard_EXPORT
void SetShape2(const TopoDS_Shape& aS) ; void SetShape2(const TopoDS_Shape& aS) ;
@ -57,8 +58,7 @@ class GEOMAlgo_SolidSolid : public GEOMAlgo_ShellSolid
protected: protected:
Standard_EXPORT Standard_EXPORT
virtual void BuildResult() ; virtual void BuildResult() ;
TopoDS_Shape myS2; TopoDS_Shape myS2;
}; };

140
src/GEOMAlgo/GEOMAlgo_Splitter.cxx
View File

@ -20,9 +20,12 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// File: GEOMAlgo_Splitter.cxx // File: GEOMAlgo_Splitter.cxx
// Author: Peter KURNEV // Created: Thu Sep 06 10:54:04 2012
// Author: Peter KURNEV
// <pkv@irinox>
// //
#include <GEOMAlgo_Splitter.hxx> #include <GEOMAlgo_Splitter.hxx>
#include <TopAbs_ShapeEnum.hxx> #include <TopAbs_ShapeEnum.hxx>
@ -31,30 +34,41 @@
#include <TopoDS_Compound.hxx> #include <TopoDS_Compound.hxx>
#include <TopoDS_Iterator.hxx> #include <TopoDS_Iterator.hxx>
#include <TopExp.hxx>
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>
#include <BRepLib.hxx>
#include <TopTools_MapOfShape.hxx> #include <BOPCol_MapOfShape.hxx>
#include <TopTools_ListOfShape.hxx> #include <BOPCol_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <BOP_CorrectTolerances.hxx> #include <BOPTools.hxx>
static static
void TreatCompound(const TopoDS_Shape& aC, void TreatCompound(const TopoDS_Shape& aC,
TopTools_ListOfShape& aLSX); BOPCol_ListOfShape& aLSX);
//======================================================================= //=======================================================================
//function : //function :
//purpose : //purpose :
//======================================================================= //=======================================================================
GEOMAlgo_Splitter::GEOMAlgo_Splitter() GEOMAlgo_Splitter::GEOMAlgo_Splitter()
: :
GEOMAlgo_Builder() BOPAlgo_Builder(),
myTools(myAllocator),
myMapTools(100, myAllocator)
{
myLimit=TopAbs_SHAPE;
myLimitMode=0;
}
//=======================================================================
//function :
//purpose :
//=======================================================================
GEOMAlgo_Splitter::GEOMAlgo_Splitter
(const Handle(NCollection_BaseAllocator)& theAllocator)
:
BOPAlgo_Builder(theAllocator),
myTools(myAllocator),
myMapTools(100, myAllocator)
{ {
myLimit=TopAbs_SHAPE; myLimit=TopAbs_SHAPE;
myLimitMode=0; myLimitMode=0;
@ -63,40 +77,26 @@ static
//function : ~ //function : ~
//purpose : //purpose :
//======================================================================= //=======================================================================
GEOMAlgo_Splitter::~GEOMAlgo_Splitter() GEOMAlgo_Splitter::~GEOMAlgo_Splitter()
{ {
} }
//======================================================================= //=======================================================================
//function : AddToolCompound
//purpose :
//=======================================================================
void GEOMAlgo_Splitter::AddToolCompound(const TopoDS_Shape& theShape)
{
TopoDS_Iterator aIt;
//
aIt.Initialize(theShape);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
AddTool(aS);
}
}
//=======================================================================
//function : AddTool //function : AddTool
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Splitter::AddTool(const TopoDS_Shape& theShape) void GEOMAlgo_Splitter::AddTool(const TopoDS_Shape& theShape)
{ {
if (myMapTools.Add(theShape)) { if (myMapTools.Add(theShape)) {
myTools.Append(theShape); myTools.Append(theShape);
// //
AddShape(theShape); AddArgument(theShape);
} }
} }
//======================================================================= //=======================================================================
//function : Tools //function : Tools
//purpose : //purpose :
//======================================================================= //=======================================================================
const TopTools_ListOfShape& GEOMAlgo_Splitter::Tools()const const BOPCol_ListOfShape& GEOMAlgo_Splitter::Tools()const
{ {
return myTools; return myTools;
} }
@ -104,7 +104,7 @@ static
//function : SetLimit //function : SetLimit
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Splitter::SetLimit(const TopAbs_ShapeEnum aLimit) void GEOMAlgo_Splitter::SetLimit(const TopAbs_ShapeEnum aLimit)
{ {
myLimit=aLimit; myLimit=aLimit;
} }
@ -112,7 +112,7 @@ static
//function : Limit //function : Limit
//purpose : //purpose :
//======================================================================= //=======================================================================
TopAbs_ShapeEnum GEOMAlgo_Splitter::Limit()const TopAbs_ShapeEnum GEOMAlgo_Splitter::Limit()const
{ {
return myLimit; return myLimit;
} }
@ -120,7 +120,7 @@ static
//function : SetLimitMode //function : SetLimitMode
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Splitter::SetLimitMode(const Standard_Integer aMode) void GEOMAlgo_Splitter::SetLimitMode(const Standard_Integer aMode)
{ {
myLimitMode=aMode; myLimitMode=aMode;
} }
@ -128,7 +128,7 @@ static
//function : LimitMode //function : LimitMode
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Integer GEOMAlgo_Splitter::LimitMode()const Standard_Integer GEOMAlgo_Splitter::LimitMode()const
{ {
return myLimitMode; return myLimitMode;
} }
@ -136,33 +136,33 @@ static
//function : Clear //function : Clear
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Splitter::Clear() void GEOMAlgo_Splitter::Clear()
{ {
myTools.Clear(); myTools.Clear();
myMapTools.Clear(); myMapTools.Clear();
myLimit=TopAbs_SHAPE; myLimit=TopAbs_SHAPE;
GEOMAlgo_Builder::Clear(); BOPAlgo_Builder::Clear();
} }
//======================================================================= //=======================================================================
//function : BuildResult //function : BuildResult
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Splitter::BuildResult(const TopAbs_ShapeEnum theType) void GEOMAlgo_Splitter::BuildResult(const TopAbs_ShapeEnum theType)
{ {
myErrorStatus=0; myErrorStatus=0;
// //
TopAbs_ShapeEnum aType; TopAbs_ShapeEnum aType;
BRep_Builder aBB; BRep_Builder aBB;
TopTools_MapOfShape aM; BOPCol_MapOfShape aM;
TopTools_ListIteratorOfListOfShape aIt, aItIm; BOPCol_ListIteratorOfListOfShape aIt, aItIm;
// //
aIt.Initialize(myShapes); aIt.Initialize(myArguments);
for (; aIt.More(); aIt.Next()) { for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value(); const TopoDS_Shape& aS=aIt.Value();
aType=aS.ShapeType(); aType=aS.ShapeType();
if (aType==theType && !myMapTools.Contains(aS)) { if (aType==theType && !myMapTools.Contains(aS)) {
if (myImages.HasImage(aS)) { if (myImages.IsBound(aS)) {
const TopTools_ListOfShape& aLSIm=myImages.Image(aS); const BOPCol_ListOfShape& aLSIm=myImages.Find(aS);
aItIm.Initialize(aLSIm); aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) { for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value(); const TopoDS_Shape& aSIm=aItIm.Value();
@ -183,34 +183,33 @@ static
//function : PostTreat //function : PostTreat
//purpose : //purpose :
//======================================================================= //=======================================================================
void GEOMAlgo_Splitter::PostTreat() void GEOMAlgo_Splitter::PostTreat()
{ {
if (myLimit!=TopAbs_SHAPE) { if (myLimit!=TopAbs_SHAPE) {
Standard_Integer i, aNbS; Standard_Integer i, aNbS;
BRep_Builder aBB; BRep_Builder aBB;
TopoDS_Compound aC; TopoDS_Compound aC;
TopTools_IndexedMapOfShape aMx; BOPCol_IndexedMapOfShape aMx;
// //
aBB.MakeCompound(aC); aBB.MakeCompound(aC);
// //
TopExp::MapShapes(myShape, myLimit, aMx); BOPTools::MapShapes(myShape, myLimit, aMx);
aNbS=aMx.Extent(); aNbS=aMx.Extent();
for (i=1; i<=aNbS; ++i) { for (i=1; i<=aNbS; ++i) {
const TopoDS_Shape& aS=aMx(i); const TopoDS_Shape& aS=aMx(i);
aBB.Add(aC, aS); aBB.Add(aC, aS);
} }
//
if (myLimitMode) { if (myLimitMode) {
Standard_Integer iType, iLimit, iTypeX; Standard_Integer iType, iLimit, iTypeX;
TopAbs_ShapeEnum aType, aTypeX; TopAbs_ShapeEnum aType, aTypeX;
TopTools_ListOfShape aLSP, aLSX; BOPCol_ListOfShape aLSP, aLSX;
TopTools_ListIteratorOfListOfShape aIt, aItX, aItIm; BOPCol_ListIteratorOfListOfShape aIt, aItX, aItIm;
TopTools_MapOfShape aM; BOPCol_MapOfShape aM;
// //
iLimit=(Standard_Integer)myLimit; iLimit=(Standard_Integer)myLimit;
// //
// 1. Collect the shapes to process aLSP // 1. Collect the shapes to process aLSP
aIt.Initialize(myShapes); aIt.Initialize(myArguments);
for (; aIt.More(); aIt.Next()) { for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value(); const TopoDS_Shape& aS=aIt.Value();
if (myMapTools.Contains(aS)) { if (myMapTools.Contains(aS)) {
@ -242,38 +241,29 @@ static
} }
}// for (; aIt.More(); aIt.Next()) { }// for (; aIt.More(); aIt.Next()) {
// //
//modified by NIZNHY-PKV Fri Oct 30 11:07:08 2009 f
aMx.Clear(); aMx.Clear();
TopExp::MapShapes(aC, aMx); BOPTools::MapShapes(aC, aMx);
//modified by NIZNHY-PKV Fri Oct 30 11:12:30 2009t // 2. Add them to aC
//
// 2. Add them to aC
aIt.Initialize(aLSP); aIt.Initialize(aLSP);
for (; aIt.More(); aIt.Next()) { for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value(); const TopoDS_Shape& aS=aIt.Value();
if (myImages.HasImage(aS)) { if (myImages.IsBound(aS)) {
const TopTools_ListOfShape& aLSIm=myImages.Image(aS); const BOPCol_ListOfShape& aLSIm=myImages.Find(aS);
aItIm.Initialize(aLSIm); aItIm.Initialize(aLSIm);
for (; aItIm.More(); aItIm.Next()) { for (; aItIm.More(); aItIm.Next()) {
const TopoDS_Shape& aSIm=aItIm.Value(); const TopoDS_Shape& aSIm=aItIm.Value();
if (aM.Add(aSIm)) { if (aM.Add(aSIm)) {
//modified by NIZNHY-PKV Fri Oct 30 11:09:57 2009f
if (!aMx.Contains(aSIm)) { if (!aMx.Contains(aSIm)) {
aBB.Add(aC, aSIm); aBB.Add(aC, aSIm);
} }
//aBB.Add(aC, aSIm);
//modified by NIZNHY-PKV Fri Oct 30 11:10:02 2009
} }
} }
} }
else { else {
if (aM.Add(aS)) { if (aM.Add(aS)) {
//modified by NIZNHY-PKV Fri Oct 30 11:10:46 2009f
if (!aMx.Contains(aS)) { if (!aMx.Contains(aS)) {
aBB.Add(aC, aS); aBB.Add(aC, aS);
} }
//aBB.Add(aC, aS);
//modified by NIZNHY-PKV Fri Oct 30 11:11:00 2009t
} }
} }
} }
@ -281,19 +271,33 @@ static
myShape=aC; myShape=aC;
}//if (myLimit!=TopAbs_SHAPE) { }//if (myLimit!=TopAbs_SHAPE) {
// //
GEOMAlgo_Builder::PostTreat(); Standard_Integer aNbS;
TopoDS_Iterator aIt;
BOPCol_ListOfShape aLS;
//
aIt.Initialize(myShape);
for (; aIt.More(); aIt.Next()) {
const TopoDS_Shape& aS=aIt.Value();
aLS.Append(aS);
}
aNbS=aLS.Extent();
if (aNbS==1) {
myShape=aLS.First();
}
//
BOPAlgo_Builder::PostTreat();
} }
//======================================================================= //=======================================================================
//function : TreatCompound //function : TreatCompound
//purpose : //purpose :
//======================================================================= //=======================================================================
void TreatCompound(const TopoDS_Shape& aC1, void TreatCompound(const TopoDS_Shape& aC1,
TopTools_ListOfShape& aLSX) BOPCol_ListOfShape& aLSX)
{ {
Standard_Integer aNbC1; Standard_Integer aNbC1;
TopAbs_ShapeEnum aType; TopAbs_ShapeEnum aType;
TopTools_ListOfShape aLC, aLC1; BOPCol_ListOfShape aLC, aLC1;
TopTools_ListIteratorOfListOfShape aIt, aIt1; BOPCol_ListIteratorOfListOfShape aIt, aIt1;
TopoDS_Iterator aItC; TopoDS_Iterator aItC;
// //
aLC.Append (aC1); aLC.Append (aC1);

73
src/GEOMAlgo/GEOMAlgo_Splitter.hxx
View File

@ -22,76 +22,77 @@
// File: GEOMAlgo_Splitter.hxx // File: GEOMAlgo_Splitter.hxx
// //
// Author: Peter KURNEV // Author: Peter KURNEV
// // Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
#ifndef _GEOMAlgo_Splitter_HeaderFile
#define _GEOMAlgo_Splitter_HeaderFile #ifndef GEOMAlgo_Splitter_HeaderFile
#define GEOMAlgo_Splitter_HeaderFile
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <TopTools_ListOfShape.hxx> #include <Standard_Boolean.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <Standard_Integer.hxx> #include <Standard_Integer.hxx>
#include <GEOMAlgo_Builder.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopoDS_Shape.hxx> #include <TopoDS_Shape.hxx>
//! Implementation of Gluing Operation Algorithm (GA) <br> #include <BOPCol_ListOfShape.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPAlgo_Builder.hxx>
//======================================================================= //=======================================================================
//function : GEOMAlgo_Splitter //class : GEOMAlgo_Splitter
//purpose : //purpose :
//======================================================================= //=======================================================================
class GEOMAlgo_Splitter : public GEOMAlgo_Builder class GEOMAlgo_Splitter : public BOPAlgo_Builder
{ {
public: public:
//! Empty constructor <br>
Standard_EXPORT Standard_EXPORT
GEOMAlgo_Splitter(); GEOMAlgo_Splitter();
Standard_EXPORT
GEOMAlgo_Splitter(const Handle(NCollection_BaseAllocator)& theAllocator);
Standard_EXPORT Standard_EXPORT
virtual ~GEOMAlgo_Splitter(); virtual ~GEOMAlgo_Splitter();
//! Clears internal fields and arguments <br>
Standard_EXPORT Standard_EXPORT
virtual void Clear() ; void AddTool(const TopoDS_Shape& theShape);
//! Adds Tool argument theShape of the operation <br>
Standard_EXPORT
virtual void AddTool(const TopoDS_Shape& theShape) ;
//! Returns the arguments of the operation <br>
Standard_EXPORT
const TopTools_ListOfShape& Tools() const;
Standard_EXPORT Standard_EXPORT
void SetLimit(const TopAbs_ShapeEnum aLimit) ; const BOPCol_ListOfShape& Tools()const;
Standard_EXPORT Standard_EXPORT
TopAbs_ShapeEnum Limit() const; void SetLimit(const TopAbs_ShapeEnum aLimit);
Standard_EXPORT Standard_EXPORT
void SetLimitMode(const Standard_Integer aLimitMode) ; TopAbs_ShapeEnum Limit()const;
Standard_EXPORT Standard_EXPORT
Standard_Integer LimitMode() const; void SetLimitMode(const Standard_Integer aMode);
//! Adds Tool arguments of the operation as <br>
//! shapes of upper level of container shape theShape <br>
//! ===================================================== <br>
Standard_EXPORT Standard_EXPORT
void AddToolCompound(const TopoDS_Shape& theShape) ; Standard_Integer LimitMode()const;
Standard_EXPORT
virtual void Clear();
protected: protected:
//! Build the resulting shapes of type theType <br>
Standard_EXPORT Standard_EXPORT
virtual void BuildResult(const TopAbs_ShapeEnum theType) ; virtual void BuildResult(const TopAbs_ShapeEnum theType);
//! Provides post-tratment actions <br>
Standard_EXPORT Standard_EXPORT
virtual void PostTreat() ; virtual void PostTreat();
protected:
TopTools_ListOfShape myTools; BOPCol_ListOfShape myTools;
TopTools_MapOfShape myMapTools; BOPCol_MapOfShape myMapTools;
TopAbs_ShapeEnum myLimit; TopAbs_ShapeEnum myLimit;
Standard_Integer myLimitMode; Standard_Integer myLimitMode;
}; };
#endif #endif

121
src/GEOMAlgo/GEOMAlgo_Tools.hxx
View File

@ -1,121 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_Tools.hxx
// Created: Mon Dec 6 11:35:29 2004
// Author: Peter KURNEV
#ifndef _GEOMAlgo_Tools_HeaderFile
#define _GEOMAlgo_Tools_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Handle_IntTools_Context.hxx>
#include <Handle_Geom_Surface.hxx>
#include <TopoDS_Shape.hxx>
#include <GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape.hxx>
#include <IntTools_Context.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <gp_Pnt.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <Geom_Surface.hxx>
//=======================================================================
//class : GEOMAlgo_Tools
//purpose :
//=======================================================================
class GEOMAlgo_Tools
{
public:
Standard_EXPORT
static Standard_Boolean IsCompositeShape(const TopoDS_Shape& aS) ;
Standard_EXPORT
static Standard_Integer RefineSDShapes(GEOMAlgo_IndexedDataMapOfPassKeyShapeListOfShape& aMSD,
const Standard_Real aTol,
const Handle(IntTools_Context)& aCtx) ;
Standard_EXPORT
static Standard_Integer FindSDShapes(const TopTools_ListOfShape& aLE,
const Standard_Real aTol,
TopTools_IndexedDataMapOfShapeListOfShape& aMEE,
const Handle(IntTools_Context)& aCtx) ;
Standard_EXPORT
static Standard_Integer FindSDShapes(const TopoDS_Shape& aE1,
const TopTools_ListOfShape& aLE,
const Standard_Real aTol,
TopTools_ListOfShape& aLESD,
const Handle(IntTools_Context)& aCtx) ;
Standard_EXPORT
static Standard_Boolean ProjectPointOnShape(const gp_Pnt& aP1,
const TopoDS_Shape& aS,gp_Pnt& aP2,
const Handle(IntTools_Context)& aCtx) ;
Standard_EXPORT
static void PointOnShape(const TopoDS_Shape& aS,
gp_Pnt& aP3D) ;
Standard_EXPORT
static void PointOnEdge(const TopoDS_Edge& aE,
gp_Pnt& aP3D) ;
Standard_EXPORT
static void PointOnEdge(const TopoDS_Edge& aE,
const Standard_Real aT,gp_Pnt& aP3D) ;
Standard_EXPORT
static void PointOnFace(const TopoDS_Face& aF,
gp_Pnt& aP3D) ;
Standard_EXPORT
static void PointOnFace(const TopoDS_Face& aF,
const Standard_Real aU,
const Standard_Real aV,
gp_Pnt& aP3D) ;
Standard_EXPORT
static void RefinePCurveForEdgeOnFace(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
const Standard_Real aU1,
const Standard_Real aU2) ;
Standard_EXPORT
static Standard_Boolean IsUPeriodic(const Handle(Geom_Surface)& aS) ;
Standard_EXPORT
static Standard_Boolean CorrectWires(const TopoDS_Shape& aS) ;
Standard_EXPORT
static Standard_Integer BuildPCurveForEdgeOnFace(const TopoDS_Edge& aE,
const TopoDS_Edge& aEold,
const TopoDS_Face& aF,
const Handle(IntTools_Context)& aCtx) ;
};
#endif

1301
src/GEOMAlgo/GEOMAlgo_Tools3D.cxx
View File

File diff suppressed because it is too large Load Diff

240
src/GEOMAlgo/GEOMAlgo_Tools3D.hxx
View File

@ -1,240 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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 : GEOMAlgo_Tools3D.hxx
// Created :
// Author : Peter KURNEV
#ifndef _GEOMAlgo_Tools3D_HeaderFile
#define _GEOMAlgo_Tools3D_HeaderFile
#include <Standard.hxx>
#include <Standard_Macro.hxx>
#include <Standard_Boolean.hxx>
#include <Handle_IntTools_Context.hxx>
#include <Standard_Integer.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopAbs_State.hxx>
#include <Standard_Real.hxx>
#include <NMTTools_ListOfCoupleOfShape.hxx>
#include <TopoDS_Shape.hxx>
#include <IntTools_Context.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Edge.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopoDS_Solid.hxx>
#include <gp_Pnt.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <gp_Pnt2d.hxx>
//! Auxiliary tools for Algorithms <br>
//=======================================================================
//class : GEOMAlgo_Tools3D
//purpose :
//=======================================================================
class GEOMAlgo_Tools3D {
public:
//! Returns True if the shape theSplit has opposite <br>
//! direction than theShape <br>
//! theContext - cashed geometrical tools <br>
Standard_EXPORT
static Standard_Boolean IsSplitToReverse(const TopoDS_Shape& theSplit,
const TopoDS_Shape& theShape,
const Handle(IntTools_Context)& theContext) ;
//! Returns True if normal direction of the face <br>
//! theShape is not the same as for the face <br>
//! theSplit <br>
//! theContext - cashed geometrical tools <br>
Standard_EXPORT
static Standard_Boolean IsSplitToReverse(const TopoDS_Face& theSplit,
const TopoDS_Face& theShape,
const Handle(IntTools_Context)& theContext) ;
//! Returns True if tangent direction of the edge <br>
//! theEdge is not the same as for the edge <br>
//! theSplit <br>
//! theContext - cashed geometrical tools <br>
Standard_EXPORT
static Standard_Boolean IsSplitToReverse(const TopoDS_Edge& theEdge,
const TopoDS_Edge& theSplit,
const Handle(IntTools_Context)& theContext) ;
//! For the couple of faces theF1, theF2 <br>
//! computes sense value <br>
//! Returns 0 if the faces are not sensible <br>
//! Returns 1 if the faces have same sense <br>
//! Returns 2 if the faces have opposite sense <br>
Standard_EXPORT
static Standard_Integer Sense(const TopoDS_Face& theF1,
const TopoDS_Face& theF2) ;
//! Makes new face theF2 from surface and wires <br>
//! of the face theF1 <br>
Standard_EXPORT
static void CopyFace(const TopoDS_Face& theF1,
TopoDS_Face& theF2) ;
//! Makes empty shape theShape of the type theType <br>
Standard_EXPORT
static void MakeContainer(const TopAbs_ShapeEnum theType,
TopoDS_Shape& theShape) ;
//! For the list of faces theLS build block <br>
//! theLSCB in terms of connexity by edges <br>
//! theMapAvoid - set of edges to avoid for <br>
//! the treatment <br>
Standard_EXPORT
static void MakeConnexityBlock(const TopTools_ListOfShape& theLS,
const TopTools_IndexedMapOfShape& theMapAvoid,
TopTools_ListOfShape& theLSCB) ;
//! Computes the 3-D state of the shape theShape <br>
//! toward solid theSolid. <br>
//! theTol - value of precision of computation <br>
//! theContext- cahed geometrical tools <br>
//! Returns 3-D state. <br>
Standard_EXPORT
static TopAbs_State ComputeStateByOnePoint(const TopoDS_Shape& theShape,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext) ;
//! Computes the 3-D state of the point thePoint <br>
//! toward solid theSolid. <br>
//! theTol - value of precision of computation <br>
//! theContext- cahed geometrical tools <br>
//! Returns 3-D state. <br>
Standard_EXPORT
static TopAbs_State ComputeState(const gp_Pnt& thePoint,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext) ;
//! Computes the 3-D state of the vertex theVertex <br>
//! toward solid theSolid. <br>
//! theTol - value of precision of computation <br>
//! theContext- cahed geometrical tools <br>
//! Returns 3-D state. <br>
Standard_EXPORT
static TopAbs_State ComputeState(const TopoDS_Vertex& theVertex,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext) ;
//! Computes the 3-D state of the edge theEdge <br>
//! toward solid theSolid. <br>
//! theTol - value of precision of computation <br>
//! theContext- cahed geometrical tools <br>
//! Returns 3-D state. <br>
Standard_EXPORT
static TopAbs_State ComputeState(const TopoDS_Edge& theEdge,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext) ;
//! Computes the 3-D state of the face theFace <br>
//! toward solid theSolid. <br>
//! theTol - value of precision of computation <br>
//! theBounds - set of edges of theFace to avoid <br>
//! theContext- cahed geometrical tools <br>
//! Returns 3-D state. <br>
Standard_EXPORT
static TopAbs_State ComputeState(const TopoDS_Face& theFace,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const TopTools_IndexedMapOfShape& theBounds,
const Handle(IntTools_Context)& theContext) ;
//! Returns True if the face theFace is inside of the <br>
//! couple of faces theFace1, theFace2. <br>
//! The faces theFace, theFace1, theFace2 must <br>
//! share the edge theEdge <br>
Standard_EXPORT
static Standard_Boolean IsInternalFace(const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace1,
const TopoDS_Face& theFace2,
const Handle(IntTools_Context)& theContext) ;
//! Returns True if the face theFace is inside of the <br>
//! appropriate couple of faces (from the set theLF) . <br>
//! The faces of the set theLF and theFace must <br>
//! share the edge theEdge <br>
Standard_EXPORT
static Standard_Boolean IsInternalFace(const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge,
const TopTools_ListOfShape& theLF,
const Handle(IntTools_Context)& theContext) ;
//! Returns True if the face theFace is inside the <br>
//! solid theSolid. <br>
//! theMEF - Map Edge/Faces for theSolid <br>
//! theTol - value of precision of computation <br>
//! theContext- cahed geometrical tools <br>
Standard_EXPORT
static Standard_Boolean IsInternalFace(const TopoDS_Face& theFace,
const TopoDS_Solid& theSolid,
const TopTools_IndexedDataMapOfShapeListOfShape& theMEF,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext) ;
//! For the face theFace and its edge theEdge <br>
//! finds the face suitable to produce shell. <br>
//! theLCEF - set of faces to search. All faces <br>
//! from theLCEF must share edge theEdge <br>
Standard_EXPORT
static void GetFaceOff(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
const NMTTools_ListOfCoupleOfShape& theLCEF,
TopoDS_Face& theFaceOff) ;
//! For the face theFace gets the edge theEdgeOnF <br>
//! that is the same as theEdge <br>
//! Returns True if such edge exists <br>
//! Returns False if there is no such edge <br>
Standard_EXPORT
static Standard_Boolean GetEdgeOnFace(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
TopoDS_Edge& theEdgeOnF) ;
//! Returns True if the face theFace contains <br>
//! the edge theEdge but with opposite orientation. <br>
//! If the method returns True theEdgeOff is the <br>
//! edge founded <br>
Standard_EXPORT
static Standard_Boolean GetEdgeOff(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
TopoDS_Edge& theEdgeOff) ;
//! Computes a point <theP> inside the face <theF>. <br>
//! <theP2D> - 2D representation of <theP> <br>
//! on the surface of <theF> <br>
//! Returns 0 in case of success. <br>
Standard_EXPORT
static Standard_Integer PntInFace(const TopoDS_Face& theF,
gp_Pnt& theP,
gp_Pnt2d& theP2D) ;
};
#endif

352
src/GEOMAlgo/GEOMAlgo_Tools_1.cxx
View File

@ -1,352 +0,0 @@
// Copyright (C) 2007-2013 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.
//
// 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: GEOMAlgo_Tools_1.cxx
// Created: Thu May 6 10:46:21 2010
// Author: Peter KURNEV
#include <GEOMAlgo_Tools.hxx>
#include <NCollection_DataMap.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Pnt.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom2dInt_GInter.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <IntRes2d_Domain.hxx>
#include <IntRes2d_IntersectionPoint.hxx>
#include <IntRes2d_Transition.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Wire.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopExp_Explorer.hxx>
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_DataMapOfShapeListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <BRepTools.hxx>
static
inline Standard_Boolean IsEqual(const TopoDS_Shape& aS1,
const TopoDS_Shape& aS2) {
return TopTools_ShapeMapHasher::IsEqual(aS1, aS2);
}
//
static
Standard_Boolean CorrectWire(const TopoDS_Wire& aW,
const TopoDS_Face& aF);
//=======================================================================
//function : CorrectWires
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_Tools::CorrectWires(const TopoDS_Shape& aShape)
{
Standard_Boolean bRet;
TopoDS_Iterator aItF;
TopExp_Explorer aExp;
TopTools_MapOfShape aMF;
GeomAdaptor_Surface aGAS;
GeomAbs_SurfaceType aTS;
TopLoc_Location aLoc;
//
bRet=Standard_False;
//
aExp.Init(aShape, TopAbs_FACE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Face& aF=*((TopoDS_Face*)&aExp.Current());
if (aMF.Add(aF)) {
const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aF, aLoc);
aGAS.Load(aS);
aTS=aGAS.GetType();
//modified by NIZNHY-PKV Mon Jul 02 13:58:30 2012f
if (aTS==GeomAbs_Cylinder || aTS==GeomAbs_Plane || aTS==GeomAbs_BSplineSurface) {
//if (aTS==GeomAbs_Cylinder || aTS==GeomAbs_Plane) {
//modified by NIZNHY-PKV Mon Jul 02 13:58:33 2012t
aItF.Initialize(aF);
for (; aItF.More(); aItF.Next()) {
const TopoDS_Wire& aW=*((TopoDS_Wire*)&aItF.Value());
if (CorrectWire(aW, aF)) {
bRet=Standard_True;
}
}
}
}
}
return bRet;
}
//=======================================================================
//class: GEOMAlgo_InfoEdge
//purpose :
//=======================================================================
class GEOMAlgo_InfoEdge {
public:
//
GEOMAlgo_InfoEdge() {
myErrorStatus=0;
myTolInt=1.0e-10;
};
//
~GEOMAlgo_InfoEdge(){
};
//
void Init(const TopoDS_Edge& aE,
const TopoDS_Face& aF);
//
void SetTolInt(const Standard_Real aTolInt) {
myTolInt=aTolInt;
};
//
const Standard_Real TolInt() const {
return myTolInt;
}
//
const Geom2dAdaptor_Curve& Adaptor() const {
return myGAC2D;
}
//
const IntRes2d_Domain& Domain()const {
return myDomain;
}
//
const Handle(Geom2d_Curve)& CurveOnSurface()const {
return myC2D;
}
//
const Handle(Geom_Curve)& Curve()const {
return myC3D;
}
//
Standard_Integer ErrorStatus()const {
return myErrorStatus;
}
//
protected:
Standard_Integer myErrorStatus;
Standard_Real myTolInt;
Geom2dAdaptor_Curve myGAC2D;
IntRes2d_Domain myDomain;
Handle(Geom2d_Curve) myC2D;
Handle(Geom_Curve) myC3D;
};
//
typedef NCollection_DataMap<TopoDS_Shape, GEOMAlgo_InfoEdge> GEOMAlgo_DataMapOfShapeInfoEdge;
typedef GEOMAlgo_DataMapOfShapeInfoEdge::Iterator GEOMAlgo_DataMapIteratorOfDataMapOfShapeInfoEdge;
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void GEOMAlgo_InfoEdge::Init(const TopoDS_Edge& aE,
const TopoDS_Face& aF)
{
Standard_Real aT1, aT2, aT1x, aT2x;
gp_Pnt2d aP2D1, aP2D2;
//
myErrorStatus=0;
//
myC3D=BRep_Tool::Curve(aE, aT1, aT2);
myC2D=BRep_Tool::CurveOnSurface(aE ,aF, aT1, aT2);
if (!myC2D.IsNull() && aT2>aT1) {
myGAC2D.Load(myC2D);
if(!myGAC2D.IsPeriodic()) {
aT1x=myGAC2D.FirstParameter();
aT2x=myGAC2D.LastParameter();
if(aT1x > aT1) {
aT1=aT1x;
}
if(aT2x < aT2) {
aT2=aT2x;
}
}
//
BRep_Tool::UVPoints(aE, aF, aP2D1, aP2D2);
myDomain.SetValues(aP2D1, aT1, myTolInt, aP2D2, aT2, myTolInt);
}
else {
myErrorStatus=10;
return;
}
}
//=======================================================================
//function : CorrectWire
//purpose :
//=======================================================================
Standard_Boolean CorrectWire(const TopoDS_Wire& aW,
const TopoDS_Face& aF)
{
Standard_Boolean bRet;
Standard_Real aTolInt;
Standard_Integer iErr, aNbV, aNbE;
TopoDS_Iterator aItW, aItE;
Geom2dInt_GInter aInter;
GEOMAlgo_DataMapOfShapeInfoEdge aDMEIE;
TopTools_DataMapOfShapeListOfShape aDMVLE;
TopTools_DataMapIteratorOfDataMapOfShapeListOfShape aItDMVLE;
//
bRet=Standard_False;
aTolInt=1.0e-10;
//
aItW.Initialize(aW);
for (; aItW.More(); aItW.Next()) {
const TopoDS_Edge& aE=*((TopoDS_Edge*)&aItW.Value());
aItE.Initialize(aE);
for (aNbV=0; aItE.More(); aItE.Next(), ++aNbV) {
}
if (aNbV<2) {
return bRet; //
}
//
if (!aDMEIE.IsBound(aE)) {
GEOMAlgo_InfoEdge aInfoEdge;
//
aInfoEdge.Init (aE, aF);
iErr=aInfoEdge.ErrorStatus();
if (iErr) {
return bRet; //
}
//
aDMEIE.Bind(aE, aInfoEdge);
}
//
aItE.Initialize(aE);
for (; aItE.More(); aItE.Next()) {
const TopoDS_Shape& aV=aItE.Value();
if (aDMVLE.IsBound(aV)) {
TopTools_ListOfShape& aLE=aDMVLE.ChangeFind(aV);
aLE.Append(aE);
}
else {
TopTools_ListOfShape aLE;
aLE.Append(aE);
aDMVLE.Bind(aV, aLE);
}
}
}
//
// 2
Standard_Real aTolV, aD1, aD2, aDmax, aCoeff;
gp_Pnt aPV;
Handle(Geom_Surface) aS;
BRep_Builder aBB;
//
aCoeff=1.1;
aS=BRep_Tool::Surface(aF);
//
aItDMVLE.Initialize(aDMVLE);
for(; aItDMVLE.More(); aItDMVLE.Next()) {
const TopoDS_Vertex& aV=*((TopoDS_Vertex*)&aItDMVLE.Key());
const TopTools_ListOfShape& aLE=aItDMVLE.Value();
aNbE=aLE.Extent();
if (aNbE!=2) {
continue;
}
//
aPV=BRep_Tool::Pnt(aV);
aTolV=BRep_Tool::Tolerance(aV);
//
const TopoDS_Edge& aE1=*((TopoDS_Edge*)&aLE.First());
const GEOMAlgo_InfoEdge& aIE1=aDMEIE.Find(aE1);
const Geom2dAdaptor_Curve& aGAC1=aIE1.Adaptor();
const IntRes2d_Domain& aDomain1=aIE1.Domain();
//
const TopoDS_Edge& aE2=*((TopoDS_Edge*)&aLE.Last());
const GEOMAlgo_InfoEdge& aIE2=aDMEIE.Find(aE2);
const Geom2dAdaptor_Curve& aGAC2=aIE2.Adaptor();
const IntRes2d_Domain& aDomain2=aIE2.Domain();
//
aInter.Perform(aGAC1, aDomain1,aGAC2, aDomain2, aTolInt, aTolInt);
if(!aInter.IsDone()) {
continue;
}
//
Standard_Integer i, aNbP;
Standard_Real aIP_ParamOnFirst, aIP_ParamOnSecond, aDTresh, aDT;
gp_Pnt aP3D1, aP3D2;
gp_Pnt2d aP2D1, aP2D2;
IntRes2d_Transition aTr1, aTr2;
//
aDTresh=0.001;
//
aNbP=aInter.NbPoints();
for (i=1; i<=aNbP; ++i) {
const IntRes2d_IntersectionPoint& aIP = aInter.Point(i);
aIP_ParamOnFirst = aIP.ParamOnFirst();
aIP_ParamOnSecond = aIP.ParamOnSecond();
aTr1 =aIP.TransitionOfFirst();
aTr2 =aIP.TransitionOfSecond();
if(aTr1.PositionOnCurve()==IntRes2d_Middle ||
aTr2.PositionOnCurve()==IntRes2d_Middle) {
//
const Handle(Geom_Curve)& aC3D1=aIE1.Curve();
if (!aC3D1.IsNull()) {
aP3D1=aC3D1->Value(aIP_ParamOnFirst);
}
else {
aP2D1=aGAC1.Value(aIP_ParamOnFirst);
aS->D0(aP2D1.X(), aP2D1.Y(), aP3D1);
}
//
const Handle(Geom_Curve)& aC3D2=aIE2.Curve();
if (!aC3D2.IsNull()) {
aP3D2=aC3D2->Value(aIP_ParamOnSecond);
}
else {
aP2D2=aGAC2.Value(aIP_ParamOnSecond);
aS->D0(aP2D2.X(), aP2D2.Y(), aP3D2);
}
//
aD1=aPV.Distance(aP3D1);
aD2=aPV.Distance(aP3D2);
aDmax=(aD1>aD2)? aD1 : aD2;
if (aDmax>aCoeff*aTolV) {
//modified by NIZNHY-PKV Mon Jul 02 13:56:35 2012f
aDT=10.*aTolV;
if (aDT<aDTresh) {
aDT=aDTresh;
}
if (aDmax<aDT){
//if (aDmax<10.*aTolV){
//modified by NIZNHY-PKV Mon Jul 02 13:56:40 2012t
aBB.UpdateVertex(aV, aDmax);
bRet=Standard_True;
}
}
}//
}//for (i=1; i<=aNbP; ++i) {
}//for(; aItDMVLE.More(); aItDMVLE.Next()) {
return bRet;
}

Some files were not shown because too many files have changed in this diff Show More