ForkMaster/geom
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/geom.git synced 2024-12-25 17:00:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

sources v1.2c

Browse Source
This commit is contained in:
nri 2003-10-13 14:55:19 +00:00
parent fc17badd1a
commit 8403de1815
25 changed files with 7262 additions and 1121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/ARCHIMEDE/Makefile.in
View File

@ -46,7 +46,7 @@ EXPORT_HEADERS = Archimede_VolumeSection.hxx
# additionnal information to compil and link file
CPPFLAGS += $(OCC_INCLUDES) $(QT_INCLUDES)
CXXFLAGS += $(OCC_CXXFLAGS)
LDFLAGS += $(OCC_LIBS)
LDFLAGS += $(CAS_LDPATH) -lTKGeomBase
# additional file to be cleaned
MOSTLYCLEAN =

55
src/GEOM/GEOM_Gen_i.cc
View File

@ -54,7 +54,11 @@ using namespace std;
#include <GC_Root.hxx>
#include <BRepCheck_Analyzer.hxx>
#if OCC_VERSION_MAJOR >= 5
#include <BRepAlgo.hxx>
#else
#include <BRepAlgoAPI.hxx>
#endif
#include <BRepAdaptor_Surface.hxx>
#include <BRepBuilderAPI_Copy.hxx>
#include <BRepAlgoAPI_Common.hxx>
@ -149,6 +153,14 @@ using namespace std;
#include CORBA_SERVER_HEADER(SALOMEDS_Attributes)
Standard_EXPORT static Standard_Boolean IsValid(const TopoDS_Shape& S) {
#if OCC_VERSION_MAJOR >= 5
return BRepAlgo::IsValid(S);
#else
return BRepAlgoAPI::IsValid(S);
#endif
}
//============================================================================
// function : GEOM_Gen_i()
// purpose : constructor to be called for servant creation.
@ -760,8 +772,13 @@ const char* GEOM_Gen_i::GetStringFromIOR(GEOM::GEOM_Shape_var shapeIOR) {
// purpose : returns a 'GEOM::GEOM_Shape_var' from a string representing it
//=================================================================================
GEOM::GEOM_Shape_ptr GEOM_Gen_i::GetIORFromString(const char* stringIOR) {
GEOM::GEOM_Shape_var shapeIOR = GEOM::GEOM_Shape::_narrow(_orb->string_to_object(stringIOR)) ;
return shapeIOR ;
GEOM::GEOM_Shape_var shapeIOR;
if(strcmp(stringIOR,"") != 0){
CORBA::Object_var anObject = _orb->string_to_object(stringIOR);
if(!CORBA::is_nil(anObject))
shapeIOR = GEOM::GEOM_Shape::_narrow(anObject.in()) ;
}
return shapeIOR._retn() ;
}
@ -1445,7 +1462,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::SuppressHolesInFaceOrShell( GEOM::GEOM_Shape_pt
THROW_SALOME_CORBA_EXCEPTION("in GEOM_Gen_i::SuppressHolesInFace : no holes selected", SALOME::BAD_PARAM);
const TopoDS_Shape tds = GetTopoShape(shapeFaceShell) ;
if( tds.IsNull() || !BRepAlgoAPI::IsValid(tds) )
if( tds.IsNull() || !IsValid(tds) )
THROW_SALOME_CORBA_EXCEPTION("in GEOM_Gen_i::SuppressHolesInFace() : non valid main argument", SALOME::BAD_PARAM);
/* Create a map of wires/holes to suppress */
@ -1551,7 +1568,7 @@ bool GEOM_Gen_i::RebuildFaceRemovingHoles( const TopoDS_Face& aFace,
{
/* Get the outer wire of the face 'aFace' */
TopoDS_Wire outW = BRepTools::OuterWire( aFace ) ;
if( outW.IsNull() || !BRepAlgoAPI::IsValid(outW) )
if( outW.IsNull() || !IsValid(outW) )
THROW_SALOME_CORBA_EXCEPTION("in GEOM_Gen_i::SuppressHolesInFace : bad outer wire of 'aFace'", SALOME::BAD_PARAM);
/* Rebuild a face avoiding holes in the map 'mapHoles' */
@ -1611,7 +1628,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::SuppressHole( GEOM::GEOM_Shape_ptr shape,
/* Retrieve 'aShape' the initial main shape selection */
const TopoDS_Shape aShape = GetTopoShape(shape);
if( !BRepAlgoAPI::IsValid(aShape) )
if( !IsValid(aShape) )
THROW_SALOME_CORBA_EXCEPTION("in GEOM_Gen_i::SuppressHole() : non valid main shape", SALOME::BAD_PARAM);
if( ListIdFace.length() != 1 || ListIdWire.length() != 1 )
@ -1624,7 +1641,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::SuppressHole( GEOM::GEOM_Shape_ptr shape,
else {
aFace = TopoDS::Face(tmp) ;
}
if( !BRepAlgoAPI::IsValid(aFace) )
if( !IsValid(aFace) )
THROW_SALOME_CORBA_EXCEPTION("in GEOM_Gen_i::SuppressHole() : face shape not valid", SALOME::BAD_PARAM);
/* Retrieve 'aWire' selection : Warning : index of wire refers to the face ! */
@ -1635,12 +1652,12 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::SuppressHole( GEOM::GEOM_Shape_ptr shape,
else {
aWire = TopoDS::Wire(aTmp) ;
}
if( !BRepAlgoAPI::IsValid(aWire) )
if( !IsValid(aWire) )
THROW_SALOME_CORBA_EXCEPTION("in GEOM_Gen_i::SuppressHole() : bad wire" , SALOME::BAD_PARAM);
/* Get the outer wire of aFace */
TopoDS_Wire outerW = BRepTools::OuterWire( aFace ) ;
if( outerW.IsNull() || !BRepAlgoAPI::IsValid(outerW) )
if( outerW.IsNull() || !IsValid(outerW) )
THROW_SALOME_CORBA_EXCEPTION("in GEOM_Gen_i::SuppressHole() : bad outer wire", SALOME::BAD_PARAM);
/* Test bad user selection aWire */
@ -1654,7 +1671,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::SuppressHole( GEOM::GEOM_Shape_ptr shape,
}
else {
TopoDS_Shape aTemp ;
if( !GetShapeFromIndex( aShape, TopAbs_FACE, ListIdEndFace[0], aTemp ) || tmp.IsNull() || !BRepAlgoAPI::IsValid(aTemp) )
if( !GetShapeFromIndex( aShape, TopAbs_FACE, ListIdEndFace[0], aTemp ) || tmp.IsNull() || !IsValid(aTemp) )
THROW_SALOME_CORBA_EXCEPTION("in GEOM_Gen_i::SuppressHole() : non valid endFace", SALOME::BAD_PARAM);
/* Test if 'endFace' as at least one hole */
@ -1664,7 +1681,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::SuppressHole( GEOM::GEOM_Shape_ptr shape,
int nbWires = 0 ;
for( fExp.Init(endFace, TopAbs_WIRE); fExp.More(); fExp.Next() ) {
TopoDS_Wire W = TopoDS::Wire( fExp.Current() ) ;
if( !W.IsNull() && BRepAlgoAPI::IsValid(W) )
if( !W.IsNull() && IsValid(W) )
nbWires++ ;
}
if(nbWires > 1)
@ -1815,7 +1832,7 @@ bool GEOM_Gen_i::BuildShellWithFaceCompound( const TopoDS_Compound Comp,
int i = 0 ;
for( ex.Init( Comp, TopAbs_FACE); ex.More(); ex.Next() ) {
TopoDS_Face F = TopoDS::Face( ex.Current() ) ;
if( !BRepAlgoAPI::IsValid(F) ) {
if( !IsValid(F) ) {
return false ;
}
B.AddShellFace( resultShell, F ) ;
@ -1846,7 +1863,7 @@ bool GEOM_Gen_i::FindCompareWireHoleOnFace( const TopoDS_Face& F,
/* Get the outer wire of aFace */
TopoDS_Wire outerW = BRepTools::OuterWire(F) ;
if( outerW.IsNull() || !BRepAlgoAPI::IsValid(outerW) ) {
if( outerW.IsNull() || !IsValid(outerW) ) {
return false ;
}
@ -2353,7 +2370,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::MakeBoolean(GEOM::GEOM_Shape_ptr shape1,
}
/* We test the validity of resulting shape */
if( !BRepAlgoAPI::IsValid(shape) ) {
if( !IsValid(shape) ) {
THROW_SALOME_CORBA_EXCEPTION("Boolean aborted : non valid shape result", SALOME::BAD_PARAM);
}
@ -2407,7 +2424,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::MakeFuse(GEOM::GEOM_Shape_ptr shape1,
}
/* We test the validity of resulting shape */
if( !BRepAlgoAPI::IsValid(shape) ) {
if( !IsValid(shape) ) {
THROW_SALOME_CORBA_EXCEPTION("Fuse aborted : non valid shape result", SALOME::BAD_PARAM);
}
@ -2863,7 +2880,7 @@ throw (SALOME::SALOME_Exception)
tds = PS.Shape();
if( !BRepAlgoAPI::IsValid(tds) ) {
if( !IsValid(tds) ) {
//MESSAGE ( "In Partition: non valid shape result" );
THROW_SALOME_CORBA_EXCEPTION("Partition aborted : non valid shape result", SALOME::BAD_PARAM);
}
@ -3007,7 +3024,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::MakeFilling(GEOM::GEOM_Shape_ptr myShape,
}
/* We test the validity of resulting shape */
if( !BRepAlgoAPI::IsValid(tds) ) {
if( !IsValid(tds) ) {
THROW_SALOME_CORBA_EXCEPTION("Filling aborted : non valid shape result", SALOME::BAD_PARAM);
}
else {
@ -3299,7 +3316,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::MakeSewing( const GEOM::GEOM_Gen::ListOfIOR& Li
aMethod.Perform() ;
tds = aMethod.SewedShape() ;
if( !BRepAlgoAPI::IsValid(tds) ) {
if( !IsValid(tds) ) {
THROW_SALOME_CORBA_EXCEPTION("Make Sewing aborted : non valid shape", SALOME::BAD_PARAM);
}
if( tds.IsNull() ) {
@ -3338,7 +3355,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::MakeSewingShape( GEOM::GEOM_Shape_ptr aShape,
aMethod.Perform() ;
tds = aMethod.SewedShape() ;
if( !BRepAlgoAPI::IsValid(tds) ) {
if( !IsValid(tds) ) {
THROW_SALOME_CORBA_EXCEPTION("Make Sewing aborted : non valid shape", SALOME::BAD_PARAM);
}
}
@ -4357,7 +4374,7 @@ GEOM::GEOM_Shape_ptr GEOM_Gen_i::MakePipe( GEOM::GEOM_Shape_ptr pathShape,
THROW_SALOME_CORBA_EXCEPTION("Exception catched in GEOM_Gen_i::MakePipe", SALOME::BAD_PARAM);
}
if ( !BRepAlgoAPI::IsValid(tds) ) {
if ( !IsValid(tds) ) {
THROW_SALOME_CORBA_EXCEPTION("MakePipe aborted : non valid shape result", SALOME::BAD_PARAM);
}
else {

2
src/GEOM/Makefile.in
View File

@ -51,7 +51,7 @@ EXPORT_HEADERS =
# additionnal information to compil and link file
CPPFLAGS += $(OCC_INCLUDES)
CXXFLAGS += $(OCC_CXXFLAGS)
LDFLAGS += $(OCC_LIBS) -lGeometryDS -lTOOLSDS -lSalomeNS -lSalomeContainer -lGeometryPartition -lGeometryArchimede
LDFLAGS += -lGeometryDS -lTOOLSDS -lSalomeNS -lSalomeContainer -lGeometryPartition -lGeometryArchimede $(CAS_LDPATH) -lTKIGES -lTKSTEP -lTKFillet -lTKOffset
# additional file to be cleaned
MOSTLYCLEAN =

2
src/GEOMClient/Makefile.in
View File

@ -53,7 +53,7 @@ BIN_SERVER_IDL =
# additionnal information to compil and link file
CPPFLAGS += $(OCC_INCLUDES)
CXXFLAGS += $(OCC_CXXFLAGS)
LDFLAGS += $(OCC_LIBS)
LDFLAGS += $(CAS_LDPATH) -lTKTopAlgo
@CONCLUDE@

2
src/GEOMDS/Makefile.in
View File

@ -63,7 +63,7 @@ EXPORT_HEADERS= GEOMDS_Application.hxx \
# additionnal information to compil and link file
CPPFLAGS += $(OCC_INCLUDES)
CXXFLAGS += $(OCC_CXXFLAGS)
LDFLAGS += $(OCC_LIBS)
LDFLAGS += $(CAS_LDPATH) -lTKCAF
# additional file to be cleaned
MOSTLYCLEAN =

2
src/GEOMFiltersSelection/Makefile.in
View File

@ -54,7 +54,7 @@ EXPORT_HEADERS= GEOM_ShapeTypeFilter.hxx \
# additionnal information to compil and link file
CPPFLAGS += $(OCC_INCLUDES) $(QT_INCLUDES) $(PYTHON_INCLUDES) $(VTK_INCLUDES)
CXXFLAGS += $(OCC_CXXFLAGS)
LDFLAGS += $(OCC_LIBS)
LDFLAGS += -lSalomeGUI
# additional file to be cleaned
MOSTLYCLEAN =

12
src/GEOMGUI/GeometryGUI.cxx
View File

@ -716,7 +716,7 @@ GEOM_Actor* GeometryGUI::ConvertIORinGEOMActor( const char * IOR,
GEOM::GEOM_Shape_ptr GeometryGUI::ConvertIOinGEOMShape( const Handle(SALOME_InteractiveObject)& IO,
Standard_Boolean& testResult )
{
GEOM::GEOM_Shape_ptr aShape ;
GEOM::GEOM_Shape_var aShape ;
testResult = false ;
/* case SObject */
@ -729,8 +729,8 @@ GEOM::GEOM_Shape_ptr GeometryGUI::ConvertIOinGEOMShape( const Handle(SALOME_Inte
if (obj->FindAttribute(anAttr, "AttributeIOR")) {
anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
aShape = myComponentGeom->GetIORFromString(anIOR->Value()) ;
testResult = true ;
return aShape;
if(!CORBA::is_nil(aShape)) testResult = true ;
return aShape._retn();
}
}
}
@ -738,11 +738,11 @@ GEOM::GEOM_Shape_ptr GeometryGUI::ConvertIOinGEOMShape( const Handle(SALOME_Inte
if ( IO->IsInstance(STANDARD_TYPE(GEOM_InteractiveObject)) ) {
Handle(GEOM_InteractiveObject) GIObject = Handle(GEOM_InteractiveObject)::DownCast( IO );
Standard_CString ior = GIObject->getIOR();
testResult = true ;
aShape = myComponentGeom->GetIORFromString(ior) ;
return aShape;
if(!CORBA::is_nil(aShape)) testResult = true ;
return aShape._retn();
}
return aShape ;
return aShape._retn();
}

8
src/GEOMGUI/GeometryGUI_PipeDlg.cxx
View File

@ -50,7 +50,11 @@ using namespace std;
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <BRepOffsetAPI_MakePipe.hxx>
#if OCC_VERSION_MAJOR >= 5
#include <BRepAlgo.hxx>
#else
#include <BRepAlgoAPI.hxx>
#endif
//=================================================================================
@ -386,7 +390,11 @@ void GeometryGUI_PipeDlg::SelectionIntoArgument()
try
{
tds = BRepOffsetAPI_MakePipe(aWire,myShape1 ) ;
#if OCC_VERSION_MAJOR >= 5
if ( BRepAlgo::IsValid(tds) )
#else
if ( BRepAlgoAPI::IsValid(tds) )
#endif
{
//Draw Pipe
mySimulationTopoDs = tds;

8
src/GEOMGUI/GeometryGUI_PointDlg.cxx
View File

@ -40,7 +40,11 @@ using namespace std;
#include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRep_Tool.hxx>
#if OCC_VERSION_MAJOR >= 5
#include <BRepAlgo.hxx>
#else
#include <BRepAlgoAPI.hxx>
#endif
#include <Geom_Curve.hxx>
#include <qbuttongroup.h>
@ -763,7 +767,11 @@ void GeometryGUI_PointDlg::ActivateThisDialog( )
//=================================================================================
bool GeometryGUI_PointDlg::CalculateVertexOnCurve(const TopoDS_Edge& anEdge, const Standard_Real aParameter, TopoDS_Shape& resultVertex)
{
#if OCC_VERSION_MAJOR >= 5
if( anEdge.IsNull() || !BRepAlgo::IsValid(anEdge) )
#else
if( anEdge.IsNull() || !BRepAlgoAPI::IsValid(anEdge) )
#endif
return false ;
Standard_Real first, last ;

2
src/GEOMGUI/Makefile.in
View File

@ -169,6 +169,6 @@ LIB_SERVER_IDL =
CPPFLAGS += $(QT_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) $(OCC_INCLUDES) $(PYTHON_INCLUDES)
CXXFLAGS += $(OCC_CXXFLAGS)
LDFLAGS += -lOCCViewer -lVTKViewer -lSalomeObject -lSalomeGUI -lGeometryClient -lGeometryObject -lGeometryFiltersSelection -lGeometrySketcher $(OCC_LIBS)
LDFLAGS += -lOCCViewer -lVTKViewer -lSalomeObject -lSalomeGUI -lGeometryClient -lGeometryObject -lGeometryFiltersSelection -lGeometrySketcher $(CAS_LDPATH) -lTKFillet -lTKOffset
@CONCLUDE@

10
src/OBJECT/GEOM_AISShape.cxx
View File

@ -101,7 +101,15 @@ void GEOM_AISShape::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresent
case StdSelect_DM_Shading:
{
myDrawer->ShadingAspect()->Aspect()->SetDistinguishOn();
myDrawer->ShadingAspect()->Aspect()->SetFrontMaterial(Graphic3d_NOM_BRASS);
Graphic3d_MaterialAspect aMatAspect;
aMatAspect.SetAmbient( 1 );
aMatAspect.SetDiffuse( 0 );
aMatAspect.SetEmissive( 0 );
aMatAspect.SetShininess(1 );
aMatAspect.SetSpecular( 0 );
myDrawer->ShadingAspect()->Aspect()->SetFrontMaterial(aMatAspect);
myDrawer->ShadingAspect()->Aspect()->SetBackMaterial(Graphic3d_NOM_JADE);
Graphic3d_MaterialAspect FMat = myDrawer->ShadingAspect()->Aspect()->FrontMaterial();

3
src/OBJECT/GEOM_Actor.cxx
View File

@ -274,7 +274,8 @@ void GEOM_Actor::Render(vtkRenderer *ren, vtkMapper *Mapper)
aMatrix->Delete();
} else
this->Device->Render(ren, this->Mapper);
this->EstimatedRenderTime = WireframeMapper->GetTimeToDraw();
if(WireframeMapper!=NULL) this->EstimatedRenderTime = WireframeMapper->GetTimeToDraw();
else if(ShadingMapper!=NULL) this->EstimatedRenderTime = ShadingMapper->GetTimeToDraw();
}
// SubShape

2
src/OBJECT/Makefile.in
View File

@ -56,7 +56,7 @@ BIN =
BIN_SRC =
CPPFLAGS+=$(QT_INCLUDES) $(PYTHON_INCLUDES) $(OCC_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES)
LDFLAGS+=$(QT_MT_LIBS) $(OCC_LIBS) $(VTK_LIBS) $(OGL_LIBS) $(PYTHON_LIBS) -lSalomeObject
LDFLAGS+=$(QT_MT_LIBS) $(VTK_LIBS) $(OGL_LIBS) $(PYTHON_LIBS) -lSalomeObject
%_moc.cxx: %.h
$(MOC) $< -o $@

2
src/PARTITION/Makefile.in
View File

@ -55,7 +55,7 @@ EXPORT_IDLS=
CPPFLAGS += $(OCC_INCLUDES)
CXXFLAGS += $(OCC_CXXFLAGS)
LDFLAGS += $(OCC_LIBS)
LDFLAGS += $(CAS_LDPATH) -lTKBool
%_moc.cxx: %.h
$(MOC) $< -o $@

19
src/PARTITION/Partition_Inter2d.cdl
View File

@ -62,13 +62,30 @@ is
AddVonE(myclass; V : Vertex from TopoDS;
E1,E2 : Edge from TopoDS;
AsDes : mutable AsDes from BRepAlgo)
AsDes : mutable AsDes from BRepAlgo;
F: Face from TopoDS)
returns Vertex from TopoDS;
---Purpose: Put V in AsDes as intersection of E1 and E2.
-- Check that vertex equal to V already exists on one
-- of edges, in such a case, V is not added but
-- existing vertex is updated to be on E1 and E2 and
-- is returned insead of V.
-- Optional F is a face E1 and E2 are on. If F is
-- provided, it is used to find new vertices on E1
-- and E2 resulting from intersection of new edges on
-- the two other faces the F interferes with and
-- through which E1 and E2 pass too. This helps to
-- avoid small edges.
GetTolerance(myclass; theV : Vertex from TopoDS;
theU : Real from Standard;
theE : Edge from TopoDS;
theAsDes : AsDes from BRepAlgo)
returns Real from Standard;
---Purpose: Returns tolerance theV must have atfer its
-- addition to theE with theU parameter. theAsDes is
-- used to find pcurves of theE
end Inter2d;

283
src/PARTITION/Partition_Inter2d.cxx
View File

@ -1,7 +1,7 @@
// GEOM PARTITION : partition algorithm
//
// Copyright (C) 2003 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
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
@ -31,30 +31,26 @@ using namespace std;
#include "utilities.h"
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAlgo_AsDes.hxx>
#include <BRepLib_MakeVertex.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepLib_MakeVertex.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <gp_Pnt.hxx>
#include <Geom_Surface.hxx>
#include <Precision.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopOpeBRepDS_Transition.hxx>
#include <TopOpeBRep_EdgesIntersector.hxx>
#include <TopOpeBRep_Point2d.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopOpeBRep_EdgesIntersector.hxx>
#include <TopOpeBRep_Point2d.hxx>
#include <TopOpeBRepDS_Transition.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <stdio.h>
#include <Precision.hxx>
#include <gp_Pnt.hxx>
#ifdef DEB
static Standard_Boolean TestEdges = 0;
@ -63,20 +59,109 @@ static Standard_Integer NbE2d = 0;
#endif
//=======================================================================
//function : StorePart2d
//function : getOtherShape
//purpose :
//=======================================================================
// static void StorePart2d (const TopoDS_Edge& E1,
// const TopoDS_Edge& E2,
// TopTools_ListOfShape& LV1,
// TopTools_ListOfShape& LV2,
// Handle(BRepAlgo_AsDes) AsDes,
// Standard_Real Tol)
static TopoDS_Shape getOtherShape(const TopoDS_Shape& theS,
const TopTools_ListOfShape& theSList)
{
TopTools_ListIteratorOfListOfShape anIt( theSList );
for ( ; anIt.More(); anIt.Next() )
if (!theS.IsSame( anIt.Value() ))
return anIt.Value();
return TopoDS_Shape();
}
//=======================================================================
//function : findVOnE
//purpose : on theE, find a vertex close to theV, such that an edge
// passing through it is an itersection of theF1 and theF2.
// theE intersects theE2 at theV
//=======================================================================
static Standard_Boolean findVOnE(const TopoDS_Vertex & theV,
const TopoDS_Edge& theE,
const TopoDS_Edge& theE2,
const TopoDS_Shape& theF1,
const TopoDS_Shape& theF2,
const Handle(BRepAlgo_AsDes)& theAsDes,
TopoDS_Vertex & theFoundV)
{
Standard_Real MinDist2 = ::RealLast();
gp_Pnt P;
// check all vertices on theE
const TopTools_ListOfShape& aVList = theAsDes->Descendant( theE );
TopTools_ListIteratorOfListOfShape anIt( aVList );
if (anIt.More())
P = BRep_Tool::Pnt( theV );
for ( ; anIt.More(); anIt.Next() )
{
// check by distance
TopoDS_Vertex & V = TopoDS::Vertex( anIt.Value() );
Standard_Real dist2 = P.SquareDistance( BRep_Tool::Pnt( V ));
if (dist2 < MinDist2)
MinDist2 = dist2;
else
continue;
// V is a candidate if among edges passing through V there is one
// which is an intersection of theF1 and theF2
TopTools_ListIteratorOfListOfShape anEIt( theAsDes->Ascendant( V ));
Standard_Boolean isOk = Standard_False;
for ( ; !isOk && anEIt.More(); anEIt.Next() )
{
const TopoDS_Shape & E2 = anEIt.Value();
if ( theE2.IsSame( E2 ))
continue;
const TopTools_ListOfShape & aFList = theAsDes->Ascendant( E2 );
if (aFList.IsEmpty())
continue;
if ( theF1.IsSame( aFList.First() ))
isOk = theF2.IsSame( aFList.Last() );
else
isOk = theF2.IsSame( aFList.First() ) && theF1.IsSame( aFList.Last() );
}
if (isOk)
theFoundV = V;
}
if (theFoundV.IsNull())
return Standard_False;
// check that MinDist2 is not too large
Standard_Real f, l;
TopLoc_Location L;
Handle(Geom_Curve) aCurve = BRep_Tool::Curve( theE, L, f, l );
gp_Pnt P1 = aCurve->Value( f );
gp_Pnt P2 = aCurve->Value( 0.3 * f + 0.7 * l );
//gp_Pnt P2 = aCurve->Value( 0.5 * ( f + l ));
if (MinDist2 > P1.SquareDistance( P2 ))
return Standard_False;
#ifdef DEB
cout << "findVOnE: found MinDist = " << sqrt (MinDist2) << endl;
#endif
return Standard_True;
}
//=======================================================================
//function : AddVonE
//purpose : Put V in AsDes as intersection of E1 and E2.
// Check that vertex equal to V already exists on one
// of edges, in such a case, V is not added but
// existing vertex is updated to be on E1 and E2 and
// is returned insead of V.
//=======================================================================
TopoDS_Vertex Partition_Inter2d::AddVonE(const TopoDS_Vertex& theV,
const TopoDS_Edge& E1,
const TopoDS_Edge& E2,
const Handle(BRepAlgo_AsDes)& AsDes)
const Handle(BRepAlgo_AsDes)& AsDes,
const TopoDS_Face& theF)
{
//-------------------------------------------------------------
@ -86,28 +171,21 @@ TopoDS_Vertex Partition_Inter2d::AddVonE(const TopoDS_Vertex& theV,
//-------------------------------------------------------------
const TopTools_ListOfShape& VOnE1 = AsDes->Descendant(E1);
const TopTools_ListOfShape& VOnE2 = AsDes->Descendant(E2);
TopTools_ListOfShape NewVOnE1;
TopTools_ListOfShape NewVOnE2;
gp_Pnt P1,P2;
TopoDS_Vertex V1,V2;
TopTools_ListIteratorOfListOfShape it, itLV1, itLV2;
TopTools_ListIteratorOfListOfShape it;
BRep_Builder B;
TopAbs_Orientation O1,O2;
Standard_Real U1,U2;
Standard_Real Tol,Tol1,Tol2;
Standard_Boolean OnE1,OnE2;
// for (itLV1.Initialize(LV1),itLV2.Initialize(LV2);
// itLV1.More();
// itLV1.Next() ,itLV2.Next()) {
TopoDS_Vertex V = theV;
// TopoDS_Vertex V = TopoDS::Vertex(itLV1.Value());
U1 = BRep_Tool::Parameter(V,E1);
U2 = BRep_Tool::Parameter(V,E2);
O1 = V.Orientation();
O2 = O1;///itLV2.Value().Orientation();
O2 = O1;
P1 = BRep_Tool::Pnt(V);
Tol = BRep_Tool::Tolerance( V );
OnE1 = OnE2 = Standard_False;
@ -159,46 +237,62 @@ TopoDS_Vertex Partition_Inter2d::AddVonE(const TopoDS_Vertex& theV,
}
}
}
if (!OnE1 && !OnE2 && !theF.IsNull())
{
// analitically find vertices E1 and E2 must pass trough
TopoDS_Shape F1 = getOtherShape( theF, AsDes->Ascendant( E1 ));
TopoDS_Shape F2 = getOtherShape( theF, AsDes->Ascendant( E2 ));
if (!F1.IsNull() && !F2.IsNull())
{
OnE1 = findVOnE ( theV, E1, E2, F1, F2, AsDes, V1 );
OnE2 = findVOnE ( theV, E2, E1, F1, F2, AsDes, V2 );
if (OnE2) V = V2;
if (OnE1) V = V1;
}
}
if (OnE1 && OnE2) {
if (!V1.IsSame(V2)) {
Standard_Real UV2;
TopoDS_Edge EWE2;
// replace V1 with V2 on all edges V1 is on
Standard_Real UV1;
TopoDS_Edge EWE1;
TopoDS_Vertex VI;
const TopTools_ListOfShape& EdgeWithV2 = AsDes->Ascendant(V2);
const TopTools_ListOfShape& EdgeWithV1 = AsDes->Ascendant(V1);
for (it.Initialize(EdgeWithV2); it.More(); it.Next()) {
EWE2 = TopoDS::Edge(it.Value());
VI = V2;
VI.Orientation(TopAbs_INTERNAL);
UV2 = BRep_Tool::Parameter(VI,EWE2);
for (it.Initialize(EdgeWithV1); it.More(); it.Next()) {
EWE1 = TopoDS::Edge(it.Value());
VI = V1;
VI.Orientation(TopAbs_INTERNAL);
B.UpdateVertex(VI,UV2,EWE2, Max(Tol1,Tol2));
UV1 = BRep_Tool::Parameter(VI,EWE1);
VI = V2;
VI.Orientation(TopAbs_INTERNAL);
B.UpdateVertex( VI, UV1, EWE1, GetTolerance( VI, UV1, EWE1, AsDes));
}
AsDes->Replace(V2,V1);
AsDes->Replace(V1,V2);
V = V2;
}
}
// add existing vertices instead of new ones
if (!OnE1) {
if (OnE2) {
V.Orientation(TopAbs_INTERNAL);
B.UpdateVertex(V,U1,E1, Tol2);
B.UpdateVertex (V, U1, E1, GetTolerance( V, U1, E1, AsDes));
}
V.Orientation(O1);
NewVOnE1.Prepend(V);
AsDes->Add(E1,V);
}
if (!OnE2) {
if (OnE1) {
V.Orientation(TopAbs_INTERNAL);
B.UpdateVertex(V,U2,E2, Tol1);
B.UpdateVertex (V, U2, E2, GetTolerance( V, U2, E2, AsDes ));
}
V.Orientation(O2);
NewVOnE2.Prepend(V);
AsDes->Add(E2,V);
}
// }
if (!NewVOnE1.IsEmpty()) AsDes->Add(E1,NewVOnE1);
if (!NewVOnE2.IsEmpty()) AsDes->Add(E2,NewVOnE2);
return V;
}
@ -341,7 +435,8 @@ static void EdgesPartition(const TopoDS_Face& F,
Standard_Boolean rejectreducedsegmentpoints = Standard_False;
EInter.InitPoint(rejectreducedsegmentpoints);
for (;EInter.MorePoint();EInter.NextPoint()) {
for ( ; EInter.MorePoint(); EInter.NextPoint() )
{
const TopOpeBRep_Point2d& P2D = EInter.Point();
const gp_Pnt& P = P2D.Value();
TopoDS_Vertex V = BRepLib_MakeVertex(P);
@ -353,25 +448,14 @@ static void EdgesPartition(const TopoDS_Face& F,
gp_Pnt P2 = CE2.Value(P2D.Parameter(2));
Standard_Real sqd1 = P1.SquareDistance(P);
Standard_Real sqd2 = P2.SquareDistance(P);
if (sqd1 > MilTol2 || sqd2 > MilTol2 ) {
//MESSAGE ( "Inter2d : Solution rejected, dist: " << sqrt(Max(sqd1,sqd2)) )
#ifdef DEB
if (TestEdges) {
MESSAGE ( " edges : E2d_"<<NbE2d-2<<" E2d_"<<NbE2d-1 ); }
#endif
if (sqd1 > MilTol2 || sqd2 > MilTol2 )
continue;
}
// add a new vertex to the both edges
Standard_Real toler = 1.5 * Max (Tol, sqrt(Max(sqd1,sqd2)) );
Standard_Real toler = Max( Tol, sqrt( Max( sqd1, sqd2 )));
Standard_Integer i;
for (i = 1; i <= 2; i++) {
Standard_Real U = P2D.Parameter(i);
#ifdef DEB
if (U < f[i]-Tol || U > l[i]+Tol) {
MESSAGE ( "out" );
}
#endif
V.Orientation(TopAbs_INTERNAL);
B.UpdateVertex( V,U,EI[i], toler);
TopAbs_Orientation OO = TopAbs_REVERSED;
@ -442,7 +526,8 @@ static void EdgesPartition(const TopoDS_Face& F,
i = 1;
Purge = Standard_False;
for (it1LV1.Initialize(LV1),it1LV2.Initialize(LV2);
it1LV1.More(); it1LV1.Next(),it1LV2.Next()) {
it1LV1.More();
it1LV1.Next(),it1LV2.Next()) {
j = 1;
it2LV1.Initialize(LV1);
while (j < i) {
@ -455,9 +540,6 @@ static void EdgesPartition(const TopoDS_Face& F,
if (P1.IsEqual(P2, Tol1 + Tol2)) {
LV1.Remove(it1LV1);
LV2.Remove(it1LV2);
if (AffichPurge) {
MESSAGE ("Vertices confused purged in EdgeInter.")
}
Purge = Standard_True;
break;
}
@ -471,17 +553,17 @@ static void EdgesPartition(const TopoDS_Face& F,
// care of new closed edges, they always intersect with seam at end
if (V1[0].IsSame( V1[1] ) && NewEdges.Contains(E1) )
treatClosed (E1,f[1],l[1],LV1,LV2);
treatClosed (E1, f[1], l[1], LV1, LV2);
if (V2[0].IsSame( V2[1] ) && NewEdges.Contains(E2) )
treatClosed (E2,f[2],l[2],LV2,LV1);
treatClosed (E2, f[2], l[2], LV2, LV1);
//---------------------------------
// Stocking vertex .
//---------------------------------
//----------------
// Stocking vertex
//----------------
//StorePart2d (E1,E2,LV1,LV2,AsDes,Tol);
for ( it1LV1.Initialize( LV1 ); it1LV1.More(); it1LV1.Next())
Partition_Inter2d::AddVonE ( TopoDS::Vertex( it1LV1.Value()), E1,E2,AsDes);
Partition_Inter2d::AddVonE (TopoDS::Vertex( it1LV1.Value()),
E1, E2, AsDes, F);
}
//=======================================================================
@ -543,3 +625,46 @@ void Partition_Inter2d::CompletPart2d (const Handle(BRepAlgo_AsDes)& AsDes,
}
}
//=======================================================================
//function : GetTolerance
//purpose : Returns tolerance theV must have atfer its
// addition to theE with theU parameter. theAsDes is
// used to find pcurves of theE
//=======================================================================
Standard_Real Partition_Inter2d::GetTolerance
(const TopoDS_Vertex & theV,
const Standard_Real theU,
const TopoDS_Edge & theE,
const Handle(BRepAlgo_AsDes)& theAsDes)
{
Standard_Real aTol = BRep_Tool::Tolerance( theV );
gp_Pnt aPnt = BRep_Tool::Pnt( theV );
// check point on 3D curve
Standard_Real f,l;
Handle(Geom_Curve) C = BRep_Tool::Curve( theE, f, l );
if (!C.IsNull())
aTol = Max ( aTol, aPnt.Distance( C->Value( theU )));
// check points on pcurves
const TopTools_ListOfShape& aFList = theAsDes->Ascendant( theE );
TopTools_ListIteratorOfListOfShape aFIt( aFList );
for ( ; aFIt.More(); aFIt.Next() )
{
const TopoDS_Face& F = TopoDS::Face( aFIt.Value() );
Handle(Geom2d_Curve) pcurve = BRep_Tool::CurveOnSurface( theE, F, f, l );
if (!pcurve.IsNull())
{
gp_Pnt2d aPnt2d = pcurve->Value( theU );
TopLoc_Location L;
Handle(Geom_Surface) S = BRep_Tool::Surface( F, L );
gp_Pnt aPntOnS = S->Value( aPnt2d.X(), aPnt2d.Y() );
if (!L.IsIdentity())
aPntOnS.Transform( L.Transformation() );
aTol = Max ( aTol, aPnt.Distance( aPntOnS ));
}
}
return aTol;
}

4
src/PARTITION/Partition_Inter2d.hxx
View File

@ -71,8 +71,8 @@ public:
//
Standard_EXPORT static void CompletPart2d(const Handle(BRepAlgo_AsDes)& AsDes,const TopoDS_Face& F,const TopTools_MapOfShape& NewEdges) ;
Standard_EXPORT static TopoDS_Vertex FindEndVertex(const TopTools_ListOfShape& VertList,const Standard_Real f,const Standard_Real l,const TopoDS_Edge& E,Standard_Boolean& First,Standard_Real& DU) ;
Standard_EXPORT static TopoDS_Vertex AddVonE(const TopoDS_Vertex& V,const TopoDS_Edge& E1,const TopoDS_Edge& E2,const Handle(BRepAlgo_AsDes)& AsDes) ;
Standard_EXPORT static TopoDS_Vertex AddVonE(const TopoDS_Vertex& V,const TopoDS_Edge& E1,const TopoDS_Edge& E2,const Handle(BRepAlgo_AsDes)& AsDes,const TopoDS_Face& F) ;
Standard_EXPORT static Standard_Real GetTolerance(const TopoDS_Vertex& theV,const Standard_Real theU,const TopoDS_Edge& theE,const Handle(BRepAlgo_AsDes)& theAsDes) ;

15
src/PARTITION/Partition_Inter3d.cdl
View File

@ -68,14 +68,21 @@ is
TouchedFaces(me : in out) returns MapOfShape from TopTools
---C++: return &
is static;
---Purpose: return map of
AsDes(me) returns AsDes from BRepAlgo
is static;
---Purpose: return map of faces cut by new or section edges
NewEdges(me : in out) returns MapOfShape from TopTools
---C++: return &
is static;
---Purpose: return new and section edges
AsDes(me) returns AsDes from BRepAlgo
is static;
---Purpose: return an object containing info about
-- Ascendants | Descendants
-- ------------------+---------------------
-- 1. faces | edges cutting them
-- 2. sectoin edges | new vertices on them
-------------------------------
---Category: Same domain shapes

281
src/PARTITION/Partition_Inter3d.cxx
View File

@ -27,58 +27,63 @@
// $Header$
using namespace std;
#include "Partition_Inter3d.ixx"
#include "Partition_Inter2d.hxx"
#include "Partition_Inter3d.ixx"
#include "utilities.h"
#include <BRepOffset_Tool.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRepAlgo_AsDes.hxx>
#include <BRepAlgo_Image.hxx>
#include <BRepLib.hxx>
#include <BRepOffset_Tool.hxx>
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopOpeBRepTool_BoxSort.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Compound.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Compound.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
#include <TopOpeBRepTool_BoxSort.hxx>
#include <TopoDS_Vertex.hxx>
#ifdef DEB
#include <DBRep.hxx>
#endif
#include <stdio.h>
#include <TopOpeBRepDS_HDataStructure.hxx>
#include <TopOpeBRep_DSFiller.hxx>
#include <TopOpeBRepTool_GeomTool.hxx>
#include <TopOpeBRepTool_OutCurveType.hxx>
#include <TopOpeBRepDS_BuildTool.hxx>
#include <TopOpeBRepBuild_Builder.hxx>
#include <TopOpeBRepDS_CurveExplorer.hxx>
#include <Geom2d_Curve.hxx>
#include <TopOpeBRepDS_PointIterator.hxx>
#include <TopOpeBRepDS_Transition.hxx>
#include <Geom_Curve.hxx>
#include <TopOpeBRepTool_CurveTool.hxx>
#include <TopOpeBRepDS_Interference.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
#include <BRepLib_MakeVertex.hxx>
#include <BRepTools.hxx>
#include <Extrema_ExtPS.hxx>
#include <Extrema_POnSurf.hxx>
#include <Geom2dAPI_ProjectPointOnCurve.hxx>
#include <Geom2d_Curve.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Geom_Curve.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_Surface.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Precision.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <BRepTools.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_Surface.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom2dAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <TopOpeBRepBuild_Builder.hxx>
#include <TopOpeBRepDS_BuildTool.hxx>
#include <TopOpeBRepDS_CurveExplorer.hxx>
#include <TopOpeBRepDS_HDataStructure.hxx>
#include <TopOpeBRepDS_Interference.hxx>
#include <TopOpeBRepDS_PointIterator.hxx>
#include <TopOpeBRepDS_Transition.hxx>
#include <TopOpeBRepTool_CurveTool.hxx>
#include <TopOpeBRepTool_GeomTool.hxx>
#include <TopOpeBRepTool_OutCurveType.hxx>
#include <TopOpeBRep_DSFiller.hxx>
#include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
#include <stdio.h>
//=======================================================================
//function : Partition_Inter3d
@ -191,19 +196,62 @@ static void PutInBounds (const TopoDS_Face& F,
if (S->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
S = (*(Handle_Geom_RectangularTrimmedSurface*)&S)->BasisSurface();
}
//---------------
// Recadre en U.
//---------------
if (!S->IsUPeriodic() && !S->IsVPeriodic()) return;
if (!S->IsUPeriodic() && !S->IsVPeriodic())
return;
BRepTools::UVBounds(F,umin,umax,vmin,vmax);
gp_Pnt2d Pf = C2d->Value(f);
gp_Pnt2d Pl = C2d->Value(l);
const Standard_Real Um = 0.34*f + 0.66*l;
gp_Pnt2d Pm = C2d->Value( Um );
// sometimes on shpere, pcurve is out of domain by V though S is
// UPeriodic, sometimes it is in domain but nontheless it has
// wrong position.
// Check pcurve position by 3D point
if (S->IsKind(STANDARD_TYPE( Geom_SphericalSurface )) ||
S->IsKind(STANDARD_TYPE( Geom_ToroidalSurface )))
{
// get point on the surface
gp_Pnt Ps = S->Value( Pm.X(), Pm.Y() );
// get point on the edge
Handle(Geom_Curve) C = BRep_Tool::Curve( E, f, l );
gp_Pnt Pc = C->Value( Um );
// compare points
Standard_Real TolE = BRep_Tool::Tolerance( E );
if ( Pc.SquareDistance( Ps ) * 0.95 < TolE * TolE )
return; // OK
// find good UV for Pc: project Pc on S
GeomAdaptor_Surface SA (S);
Extrema_ExtPS anExtPS (Pc, SA,
SA.UResolution( TolE ), SA.VResolution( TolE ));
if (anExtPS.IsDone())
{
Standard_Integer i, nbExt = anExtPS.NbExt();
Extrema_POnSurf aPOnSurf;
for (i = 1; i <= nbExt; ++i )
if (anExtPS.Value( i ) <= TolE) {
aPOnSurf = anExtPS.Point( i );
break;
}
if (i <= nbExt) {
// a point found
Standard_Real u, v;
aPOnSurf.Parameter( u, v );
gp_Pnt2d aGoodPm ( u, v );
C2d->Translate( Pm , aGoodPm );
}
}
}
//---------------
// Recadre en U.
//---------------
if (S->IsUPeriodic()) {
Standard_Real period = S->UPeriod();
Standard_Real eps = period*1.e-6;
gp_Pnt2d Pf = C2d->Value(f);
gp_Pnt2d Pl = C2d->Value(l);
gp_Pnt2d Pm = C2d->Value(0.34*f + 0.66*l);
Standard_Real minC = Min(Pf.X(),Pl.X()); minC = Min(minC,Pm.X());
Standard_Real maxC = Max(Pf.X(),Pl.X()); maxC = Max(maxC,Pm.X());
Standard_Real du = 0.;
@ -235,9 +283,6 @@ static void PutInBounds (const TopoDS_Face& F,
if (S->IsVPeriodic()) {
Standard_Real period = S->VPeriod();
Standard_Real eps = period*1.e-6;
gp_Pnt2d Pf = C2d->Value(f);
gp_Pnt2d Pl = C2d->Value(l);
gp_Pnt2d Pm = C2d->Value(0.34*f + 0.66*l);
Standard_Real minC = Min(Pf.Y(),Pl.Y()); minC = Min(minC,Pm.Y());
Standard_Real maxC = Max(Pf.Y(),Pl.Y()); maxC = Max(maxC,Pm.Y());
Standard_Real dv = 0.;
@ -309,8 +354,6 @@ void Partition_Inter3d::Inter3D(const TopoDS_Face& F1,
while (itLE.More()) {
TopoDS_Edge E = TopoDS::Edge(itLE.Value());
// Standard_Real f,l;
// BRep_Tool::Range(E,f,l);
PutInBounds (F1,E,pc1);
PutInBounds (F2,E,pc2);
@ -327,48 +370,59 @@ void Partition_Inter3d::Inter3D(const TopoDS_Face& F1,
}
}
// ===================================================
// Store section edges, same domain faces and verives
// ===================================================
// ========================
// store same domain faces
// ========================
TopTools_ListOfShape empty, LSP, LSE;
if ( DatStr->HasSameDomain( F1 )) { // same domain faces
if ( DatStr->HasSameDomain( F1 ))
{
TopTools_ListOfShape emptyList;
if (!mySameDomainFM.IsBound(F1))
mySameDomainFM.Bind(F1,empty);
mySameDomainFM.Bind(F1,emptyList);
if (!mySameDomainFM.IsBound(F2))
mySameDomainFM.Bind(F2,empty);
mySameDomainFM.Bind(F2,emptyList);
mySameDomainFM(F1).Append(F2);
mySameDomainFM(F2).Append(F1);
}
// ====================
// Store section edges
// ====================
const TopOpeBRepDS_DataStructure& DS = DatStr->DS();
Standard_Integer j,i,nes = DS.NbSectionEdges();
if (!nes) return;
Standard_Integer j,i,nse = DS.NbSectionEdges();
if (nse == 0) return;
TopoDS_Vertex V, sdeV1, sdeV2;
TopTools_MapOfShape MV;
TopTools_ListOfShape LSE; // list of section edges
TopoDS_Face dummyF;
// put vertices on section edges
for (i=1;i<=nes;i++) {
TopoDS_Edge se, sde, oe; // section, same domain, other edge
se = DS.SectionEdge(i);
for (i = 1; i <= nse; i++)
{
const TopoDS_Edge & se = DS.SectionEdge(i);
if (! TopB.IsSplit(se,TopAbs_ON))
continue;
LSE.Append( se );
// add vertices where section edges interferes with other
// edges as its descendant in myAsDes
TopoDS_Edge sde, oe; // same domain, other edge
if (DatStr->HasSameDomain(se)) {
sde = TopoDS::Edge( DatStr->SameDomain(se).Value() );
TopExp::Vertices( sde, sdeV1, sdeV2);
}
TColStd_MapOfInteger MIV;
TColStd_MapOfInteger MIV; // indices of added edges
TopOpeBRepDS_PointIterator itP (DS.ShapeInterferences( se ));
itP.SupportKind( TopOpeBRepDS_EDGE );
// loop on intersections of se
for (; itP.More(); itP.Next()) {
oe = TopoDS::Edge( DS.Shape( itP.Support()));
if (itP.IsVertex()) {
// there is a vertex at intersection
if ( !MIV.Add( itP.Current() ))
continue;
V = TopoDS::Vertex( DS.Shape( itP.Current()));
@ -376,9 +430,10 @@ void Partition_Inter3d::Inter3D(const TopoDS_Face& F1,
oe = sde;
V = ReplaceSameDomainV( V , oe );
V.Orientation( TopAbs_INTERNAL);
B.UpdateVertex( V, itP.Parameter(), se, 0.);
B.UpdateVertex( V, itP.Parameter(), se, 0.); // AddVonE() sets real U
}
else {
// create a new vertex at the intersection point
const TopOpeBRepDS_Point& DSP = DS.Point( itP.Current());
V = BRepLib_MakeVertex( DSP.Point() );
V.Orientation( TopAbs_INTERNAL);
@ -393,50 +448,56 @@ void Partition_Inter3d::Inter3D(const TopoDS_Face& F1,
}
}
}
TopoDS_Vertex addedV = Partition_Inter2d::AddVonE( V,se,oe,myAsDes);
// add V on the both intersecting edges
TopoDS_Vertex addedV = Partition_Inter2d::AddVonE( V,se,oe,myAsDes,dummyF);
if (!addedV.IsSame( V ))
mySameDomainVM.Bind (V, addedV);
MV.Add( addedV );
mySameDomainVM.Bind (V, addedV); // equal vertex is already there
MV.Add( addedV ); // to ease storage of vertices of ON splits
}
}
TopB.SplitSectionEdges();
TopTools_DataMapOfShapeShape SEM; // map split - section edge
TopTools_IndexedMapOfShape ME[2];
TopExp::MapShapes( F1, TopAbs_EDGE, ME[1]);
TopExp::MapShapes( F2, TopAbs_EDGE, ME[0]);
// add section edge to the face it intersects and find
// splits ON that do not have same domain pair
for (i=1;i<=nes;i++) {
TopB.SplitSectionEdges(); // let TopB find ON splits
const TopoDS_Edge& se = DS.SectionEdge(i);
if (! TopB.IsSplit(se,TopAbs_ON))
continue;
TopTools_MapOfShape SPM; // map of ON splits
TopTools_IndexedMapOfShape ME[2];
TopExp::MapShapes( F1, TopAbs_EDGE, ME[1]);
TopExp::MapShapes( F2, TopAbs_EDGE, ME[0]);
TopTools_ListIteratorOfListOfShape itSP, itLSE (LSE);
while ( itLSE.More() ) {
TopoDS_Edge se = TopoDS::Edge( itLSE.Value() );
Standard_Integer ancRank = DS.AncestorRank(se);
if (ME[ancRank-1].Contains( se ))
continue; // se is an edge of face it intersects
LSE.Remove( itLSE ); // se is an edge of face it intersects
else
itLSE.Next();
const TopoDS_Face& F = (ancRank == 1) ? F2 : F1;
// add se to face but dont add twice
TopTools_ListIteratorOfListOfShape itE;
TopTools_ListIteratorOfListOfShape itE( myAsDes->Descendant( F ));
if (myAsDes->HasDescendant( F )) {
for (itE.Initialize( (myAsDes->Descendant( F )) ); itE.More(); itE.Next())
for ( ; itE.More(); itE.Next())
if (se.IsSame( itE.Value() ))
break;
}
if (!itE.More()) {
if (!itE.More())
{
myAsDes->Add( F, se );
// check se pcurve on F
Standard_Real tol, f,l, umin=1e100, umax=-1e100;
Handle(Geom2d_Curve) pc = BRep_Tool::CurveOnSurface( se, F, f,l);
if (pc.IsNull()) {
TopTools_ListIteratorOfListOfShape it( TopB.Splits(se,TopAbs_ON) );
for ( ;it.More();it.Next()) {
const TopoDS_Edge& E = TopoDS::Edge ( it.Value());
itSP.Initialize( TopB.Splits(se,TopAbs_ON) );
for ( ; itSP.More(); itSP.Next()) {
const TopoDS_Edge& E = TopoDS::Edge ( itSP.Value());
BRep_Tool::Range(E, f, l);
umin = Min( umin, f);
umax = Max( umax, l);
@ -453,43 +514,41 @@ void Partition_Inter3d::Inter3D(const TopoDS_Face& F1,
}
// to detect splits that do not have same domain pair
TopTools_ListIteratorOfListOfShape it( TopB.Splits(se,TopAbs_ON) );
for ( ;it.More();it.Next()) {
const TopoDS_Edge& S = TopoDS::Edge ( it.Value());
if (SEM.IsBound( S ))
SEM.UnBind( S );
else
SEM.Bind( S, se);
// ie which split a face into parts and not pass by its boundary
itSP.Initialize( TopB.Splits(se,TopAbs_ON) );
for ( ; itSP.More(); itSP.Next()) {
const TopoDS_Shape& SP = itSP.Value();
if (!SPM.Add( SP ))
SPM.Remove( SP );
}
}
// store vertices of ON splits and bind section edges to faces
for (i=1;i<=nes;i++) {
const TopoDS_Edge& se = DS.SectionEdge(i);
if (! TopB.IsSplit(se,TopAbs_ON))
continue;
for (itLSE.Initialize (LSE); itLSE.More(); itLSE.Next())
{
const TopoDS_Shape& se = itLSE.Value();
Standard_Integer ancRank = DS.AncestorRank(se);
if (ME[ancRank-1].Contains( se ))
continue; // se is an edge of face it intersects
TopoDS_Face F = (ancRank == 1) ? F2 : F1;
// add vertices of splits
// add vertices of ON splits which have no same domain pair
Standard_Boolean added = Standard_False;
TopTools_ListIteratorOfListOfShape it( TopB.Splits(se,TopAbs_ON) );
for ( ;it.More();it.Next()) {
const TopoDS_Edge& S = TopoDS::Edge ( it.Value());
if (!SEM.IsBound( S ))
itSP.Initialize( TopB.Splits(se,TopAbs_ON) );
for ( ; itSP.More(); itSP.Next())
{
if (!SPM.Contains( itSP.Value() ))
continue;
const TopoDS_Edge& S = TopoDS::Edge ( itSP.Value());
added = Standard_True;
mySectionEdgesAD->Add( F, se );
TopoDS_Vertex VS[2];
TopExp::Vertices (S, VS[0], VS[1]);
for (j=0; j<2; ++j) {
for (j=0; j<2; ++j)
{
if (mySameDomainVM.IsBound( VS[j] ))
VS[j] = TopoDS::Vertex( mySameDomainVM( VS[j] ));
if ( !MV.Contains( VS[j] )) {
@ -498,6 +557,8 @@ void Partition_Inter3d::Inter3D(const TopoDS_Face& F1,
TopTools_ListIteratorOfListOfShape itV( myAsDes->Descendant(se) );
for (; itV.More(); itV.Next()) {
V = TopoDS::Vertex( itV.Value() );
if ( V.IsSame( VS[j] ))
break;
gp_Pnt P2 = BRep_Tool::Pnt( V );
if (P1.IsEqual( P2, Precision::Confusion())) {
mySameDomainVM.Bind (VS[j], V);
@ -508,8 +569,13 @@ void Partition_Inter3d::Inter3D(const TopoDS_Face& F1,
if (!itV.More()) // no interferences with edges
myAsDes->Add( se, VS[j]);
}
// add ends of ON splits to F in order to detect later
// if a split is on face in IsSplitOn()
mySectionEdgesAD->Add( F, VS[j]);
}
// in the descendants of F, first go ends of an ON split and
// then a split itself
mySectionEdgesAD->Add( F, S );
}
if (!added)
@ -544,13 +610,13 @@ void Partition_Inter3d::SetDone(const TopoDS_Face& F1,
const TopoDS_Face& F2)
{
if (!myDone.IsBound(F1)) {
TopTools_ListOfShape empty;
myDone.Bind(F1,empty);
TopTools_ListOfShape emptyList;
myDone.Bind(F1,emptyList);
}
myDone(F1).Append(F2);
if (!myDone.IsBound(F2)) {
TopTools_ListOfShape empty;
myDone.Bind(F2,empty);
TopTools_ListOfShape emptyList;
myDone.Bind(F2,emptyList);
}
myDone(F2).Append(F1);
}
@ -583,7 +649,6 @@ void Partition_Inter3d::StorePart3d(const TopoDS_Face& F1,
const TopoDS_Face& F2,
const TopTools_ListOfShape& LInt)
{
if (!LInt.IsEmpty()) {
myAsDes->Add( F1,LInt);
myAsDes->Add( F2,LInt);
@ -673,8 +738,8 @@ const TopTools_ListOfShape& Partition_Inter3d::SameDomain(const TopoDS_Face& F)
if (mySameDomainFM.IsBound( F ))
return mySameDomainFM (F);
static TopTools_ListOfShape empty;
return empty;
static TopTools_ListOfShape emptyList;
return emptyList;
}
//=======================================================================

309
src/PARTITION/Partition_Loop2d.cxx
View File

@ -1,6 +1,6 @@
// GEOM PARTITION : partition algorithm
//
// Copyright (C) 2003 CEA/DEN, EDF R&D
// Copyright (C) 2003 CEA/DEN, EDF R& D
//
//
//
@ -18,6 +18,7 @@ using namespace std;
#include <BRepAdaptor_Curve2d.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <BRepAlgo_AsDes.hxx>
#include <BRepAlgo_FaceRestrictor.hxx>
#include <BRepOffset_DataMapOfShapeReal.hxx>
#include <BRepTopAdaptor_FClass2d.hxx>
#include <BRep_Builder.hxx>
@ -115,11 +116,65 @@ void Partition_Loop2d::AddSectionEdge (const TopoDS_Edge& E)
}
}
//=======================================================================
//function : preciseU
//purpose : find u such that the 3D point on theE is just out of tolerance
// of theV
//=======================================================================
static Standard_Real preciseU (const BRepAdaptor_Surface& theSurf,
const TopoDS_Edge& theE,
const TopoDS_Vertex& theV,
const Handle(Geom2d_Curve)& theC,
const Standard_Boolean theFirstEnd)
{
Standard_Boolean isForward = ( theE.Orientation () == TopAbs_FORWARD );
if (theFirstEnd) isForward = !isForward;
// find the first point in 2d and 3d
Standard_Real f,l;
BRep_Tool::Range( theE, f, l );
Standard_Real u0 = isForward ? l : f;
gp_Pnt2d aP2d0 = theC->Value( u0 );
gp_Pnt aPnt0 = theSurf.Value( aP2d0.X(), aP2d0.Y() );
// shift in 2d and 3d
Standard_Real du = ( l - f ) / 100, du3d = 0;
if (isForward)
du = -du;
// target parameter
Standard_Real u;
while (du3d < ::RealSmall())
{
// u for test
u = u0 + du;
du *= 10; // for the next iteration: increase du untill du3d is large enough
// find out how u is far from u0 in 3D
gp_Pnt2d aP2d = theC->Value( u );
gp_Pnt aPnt = theSurf.Value( aP2d.X(), aP2d.Y() );
du3d = aPnt0.Distance( aPnt );
}
// find u such that the 3D point is just out of tolerance of theV
Standard_Real tolV = BRep_Tool::Tolerance( theV ) + Precision::Confusion();
u = u0 + du * tolV / du3d;
// check that u is within the range
if ( isForward ? (u < f) : (u > l) )
u = u0 + du;
return u;
}
//=======================================================================
//function : SelectEdge
//purpose : Find the edge <NE> connected <CE> by the vertex <CV> in the list <LE>.
// <NE> Is erased of the list. If <CE> is too in the list <LE>
// with the same orientation, it's erased of the list
//purpose : Find in the list <LE> the edge <NE> connected with <CE> by
// the vertex <CV>.
// <NE> is removed from the list. If <CE> is in <LE>
// with the same orientation, it's removed from the list
//=======================================================================
static Standard_Boolean SelectEdge(const BRepAdaptor_Surface& Surf,
@ -136,31 +191,25 @@ static Standard_Boolean SelectEdge(const BRepAdaptor_Surface& Surf,
// - Test the edges differents of CE
//--------------------------------------------------------------
TopoDS_Face FForward = Surf.Face();
TopoDS_Edge aPrevNE;
Standard_Real cf, cl, f, l;
Handle(Geom2d_Curve) Cc, C;
Cc = BRep_Tool::CurveOnSurface(CE,FForward,cf,cl);
// Standard_Real tolV, tol2d2;
Standard_Real tolV = BRep_Tool::Tolerance(CV);
// tol2d2 = Max ( Surf.UResolution(tolV) , Surf.VResolution(tolV) );
// tol2d2 = 2 * Max ( tol2d2, Precision::PConfusion() );
// tol2d2 *= tol2d2;
Standard_Real uc,u, du = Precision::PConfusion();
if (CE.Orientation () == TopAbs_FORWARD) uc = cl + du;
else uc = cf - du;
gp_Vec2d CTg1, Tg1;
gp_Vec2d CTg1, Tg1, CTg2, Tg2;
gp_Pnt2d PC, P;
gp_Pnt P3d;
Standard_Real f, l;
Handle(Geom2d_Curve) Cc, C;
Cc = BRep_Tool::CurveOnSurface(CE,FForward,f,l);
Standard_Boolean isForward = ( CE.Orientation () == TopAbs_FORWARD );
Standard_Real uc, u, du = Precision::PConfusion();
uc = isForward ? ( l - du ) : ( f + du );
Cc->D1(uc, PC, CTg1);
if (CE.Orientation () == TopAbs_REVERSED) CTg1.Reverse();
if (!isForward) CTg1.Reverse();
Standard_Real anglemin = 3 * PI;
// Standard_Real sqdist, sqdistmin = 1.0e50;
Standard_Real anglemin = 3 * PI, tolAng = 1.e-8;
// select an edge whose first derivative is most left of CTg1
// ie an angle between Tg1 and CTg1 is least
TopTools_ListIteratorOfListOfShape itl;
for ( itl.Initialize(LE); itl.More(); itl.Next()) {
const TopoDS_Edge& E = TopoDS::Edge(itl.Value());
@ -169,35 +218,63 @@ static Standard_Boolean SelectEdge(const BRepAdaptor_Surface& Surf,
if (! CV.IsSame( TopExp::FirstVertex( E, Standard_True )))
continue;
isForward = ( E.Orientation () == TopAbs_FORWARD );
// get E curve
C = BRep_Tool::CurveOnSurface(E,FForward,f,l);
if (E.Orientation () == TopAbs_FORWARD) u = f + du;
else u = l - du;
// get the first derivative Tg1
u = isForward ? ( f + du ) : ( l - du );
C->D1(u, P, Tg1);
// if (P.SquareDistance(PC); > tol2d2)
// continue;
if (E.Orientation () == TopAbs_REVERSED) Tg1.Reverse();
if (!isForward) Tg1.Reverse();
// -PI < angle < PI
Standard_Real angle = Tg1.Angle(CTg1);
if (PI - Abs(angle) <= tolAng)
{
// an angle is too close to PI; assure that an angle sign really
// reflects an edge position: +PI - an edge is worst,
// -PI - an edge is best.
u = preciseU( Surf, CE, CV, Cc, Standard_False);
gp_Vec2d CTg;
Cc->D1(u, PC, CTg);
if (CE.Orientation() == TopAbs_REVERSED) CTg.Reverse();
u = preciseU( Surf, E, CV, C, Standard_True);
C->D1(u, P, Tg1);
if (!isForward) Tg1.Reverse();
angle = Tg1.Angle(CTg);
}
Standard_Boolean isClose = ( Abs( angle - anglemin ) <= tolAng );
if (angle <= anglemin) {
if (isClose)
aPrevNE = NE;
else
aPrevNE.Nullify();
anglemin = angle ;
NE = E;
#ifdef DEB
// sqdist = P.SquareDistance(PC);
// if (sqdist < sqdistmin)
// sqdistmin = sqdist;
P3d = Surf.Value (PC.X(), PC.Y());
#endif
}
else
if (isClose)
aPrevNE = E;
}
#ifdef DEB
if (!NE.IsNull() && P3d.Distance( BRep_Tool::Pnt(CV)) > tolV) {
MESSAGE( "DISTANCE MORE THAN VERTEX TOL (" << tolV << ")" );
cout << "point p " << P3d.X() << " " << P3d.Y() << " " << P3d.Z() << endl;
if (!aPrevNE.IsNull()) {
// select one of close edges, the most left one.
Cc = BRep_Tool::CurveOnSurface( NE, FForward, f, l );
uc = preciseU( Surf, NE, CV, Cc, Standard_True);
Cc->D1(uc, PC, CTg1);
if (NE.Orientation() != TopAbs_FORWARD) CTg1.Reverse();
u = preciseU( Surf, aPrevNE, CV, C, Standard_True);
C->D1(u, P, Tg1);
if (aPrevNE.Orientation() != TopAbs_FORWARD) Tg1.Reverse();
if ( Tg1.Angle(CTg1) < 0)
NE = aPrevNE;
}
#endif
}
else if (LE.Extent() == 1) {
NE = TopoDS::Edge(LE.First());
@ -312,31 +389,31 @@ static void addConnected(const TopoDS_Shape& E,
//purpose :
//=======================================================================
static Standard_Boolean canPassToOld (const TopoDS_Shape& V,
TopTools_MapOfShape& UsedShapesMap,
const TopTools_DataMapOfShapeListOfShape& MVE,
const TopTools_MapOfShape& SectionEdgesMap)
{
TopTools_ListIteratorOfListOfShape itE( MVE(V) );
// Loop on edges sharing V
for (; itE.More(); itE.Next()) {
if ( !UsedShapesMap.Add( itE.Value() ))
continue; // already checked
// static Standard_Boolean canPassToOld (const TopoDS_Shape& V,
// TopTools_MapOfShape& UsedShapesMap,
// const TopTools_DataMapOfShapeListOfShape& MVE,
// const TopTools_MapOfShape& SectionEdgesMap)
// {
// TopTools_ListIteratorOfListOfShape itE( MVE(V) );
// // Loop on edges sharing V
// for (; itE.More(); itE.Next()) {
// if ( !UsedShapesMap.Add( itE.Value() ))
// continue; // already checked
if ( !SectionEdgesMap.Contains( itE.Value() ))
return Standard_True; // WE PASSED
// if ( !SectionEdgesMap.Contains( itE.Value() ))
// return Standard_True; // WE PASSED
TopoDS_Iterator itV( itE.Value() );
// Loop on vertices of an edge
for (; itV.More(); itV.Next()) {
if ( !UsedShapesMap.Add( itV.Value() ))
continue; // already checked
else
return canPassToOld( itV.Value(), UsedShapesMap, MVE, SectionEdgesMap);
}
}
return Standard_False;
}
// TopoDS_Iterator itV( itE.Value() );
// // Loop on vertices of an edge
// for (; itV.More(); itV.Next()) {
// if ( !UsedShapesMap.Add( itV.Value() ))
// continue; // already checked
// else
// return canPassToOld( itV.Value(), UsedShapesMap, MVE, SectionEdgesMap);
// }
// }
// return Standard_False;
// }
//=======================================================================
//function : MakeDegenAndSelect
@ -657,7 +734,7 @@ void Partition_Loop2d::Perform()
CE = TopoDS::Edge( WEL.First() );
WEL.RemoveFirst();
B.MakeWire( NW );
VF = TopExp::FirstVertex ( EF, Standard_True);
VF = TopExp::FirstVertex ( CE, Standard_True);
End = Standard_False;
while ( !End) {
@ -724,13 +801,10 @@ void Partition_Loop2d::Perform()
// ============================================================
Standard_Integer nbIW = myInternalWL.Extent();
if ( nbIW == 1 ) {
TopTools_MapOfShape UsedShapes( 2*NbConstEdges );
TopExp_Explorer expV (myInternalWL.First(), TopAbs_VERTEX);
if (canPassToOld (expV.Current(), UsedShapes, MVE2, mySectionEdges))
myNewWires.Append ( myInternalWL );
}
else if ( nbIW > 1 ) {
if (nbIW == 0)
return;
if ( myNewWires.Extent() != 1 && nbIW > 1) {
TopTools_MapOfShape outerEM (NbConstEdges); // edges connected to non-section ones
TopTools_MapOfShape visitedVM (NbConstEdges);
for ( itl.Initialize( myConstEdges ); itl.More(); itl.Next()) {
@ -784,10 +858,12 @@ static Standard_Boolean isInside(const TopoDS_Face& F,
// get any 2d point of W1
TopExp_Explorer exp(W1,TopAbs_EDGE);
const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
if (BRep_Tool::Degenerated( TopoDS::Edge( exp.Current() )))
exp.Next();
const TopoDS_Edge& e = TopoDS::Edge(exp.Current());
Standard_Real f,l;
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edg,F,f,l);
gp_Pnt2d pt2d(C2d->Value(f));
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(e,F,f,l);
gp_Pnt2d pt2d(C2d->Value( 0.5 * ( f + l )));
BRepTopAdaptor_FClass2d classif(newFace,Precision::PConfusion());
return (classif.Perform(pt2d) == TopAbs_IN);
@ -883,8 +959,14 @@ static void classify(const TopTools_DataMapOfShapeShape& EqWM,
TopTools_DataMapIteratorOfDataMapOfShapeShape it1, it2;
for (it1.Initialize(EqWM); it1.More(); it1.Next()) {
for (it2.Initialize(EqWM); it2.More(); it2.Next()) {
if (it1.Value().IsSame( it2.Value() )) continue;
// find next after it1.Value()
for (it2.Initialize(EqWM); it2.More(); it2.Next())
if (it1.Value().IsSame( it2.Value() ))
{
it2.Next();
break;
}
for ( ; it2.More(); it2.Next()) {
const TopoDS_Wire& Wire1 = TopoDS::Wire( it1.Value() );
const TopoDS_Wire& Wire2 = TopoDS::Wire( it2.Value() );
if (isInside(F, Wire1, Wire2))
@ -902,28 +984,12 @@ static void classify(const TopTools_DataMapOfShapeShape& EqWM,
// intersections
//=======================================================================
//#define USE_BREPFEAT_SPLITSHAPE
#ifdef USE_BREPFEAT_SPLITSHAPE
# include <BRepFeat_SplitShape.hxx>
void Partition_Loop2d::WiresToFaces(const BRepAlgo_Image& EdgeImage)
#else
# include <BRepAlgo_FaceRestrictor.hxx>
void Partition_Loop2d::WiresToFaces(const BRepAlgo_Image& )
#endif
{
Standard_Integer nbW = myNewWires.Extent() + myInternalWL.Extent();
if (nbW==0)
return;
#ifndef USE_BREPFEAT_SPLITSHAPE
// ============================================================
// use BRepAlgo_FaceRestrictor to make faces
// ============================================================
BRepAlgo_FaceRestrictor FR;
FR.Init (myFace,Standard_False);
@ -980,6 +1046,7 @@ void Partition_Loop2d::WiresToFaces(const BRepAlgo_Image& )
// find most internal wires among pairs (key - hole, value - outer part)
TopTools_DataMapIteratorOfDataMapOfShapeShape it(EqWM);
Standard_Integer nbEqW = EqWM.Extent(); // protection against infinite loop
for ( ; it.More(); it.Next()) {
TopoDS_Wire outerW = TopoDS::Wire ( it.Value() );
@ -1016,7 +1083,7 @@ void Partition_Loop2d::WiresToFaces(const BRepAlgo_Image& )
FR.Clear();
// add hole-parts to FaceRestrictor,
// remove themfrom the EqWM,
// remove them from the EqWM,
// remove found wires as internal of resting classified wires
Standard_Boolean clearOuterInner = ( prevHolesL.Extent() < EqWM.Extent() );
TopTools_ListIteratorOfListOfShape itPrev (prevHolesL);
@ -1040,9 +1107,18 @@ void Partition_Loop2d::WiresToFaces(const BRepAlgo_Image& )
EqWM.UnBind ( Hole );
}
if (nbEqW == EqWM.Extent())
{
// error: pb with wires classification
#ifdef DEB
cout << "Partition_Loop2d::WiresToFaces(), pb with wires classification" << endl;
#endif
break;
}
} // while (!EqWM.IsEmpty)
} // !EqWM.IsEmpty()
} // if !EqWM.IsEmpty()
myNewWires.Append ( myInternalWL );
@ -1056,49 +1132,6 @@ void Partition_Loop2d::WiresToFaces(const BRepAlgo_Image& )
myNewFaces.Append(FR.Current());
#else // ifndef USE_BREPFEAT_SPLITSHAPE
// ============================================================
// use BRepFeat_SplitShape to make faces
// ============================================================
BRepFeat_SplitShape Split(myFace);
TopTools_MapOfShape AddedSectionEdgesMap;
myNewWires.Append(myInternalWL);
TopTools_ListIteratorOfListOfShape it(myNewWires);
for (; it.More(); it.Next()) {
TopoDS_Iterator itE(it.Value());
for (; itE.More(); itE.Next()) {
const TopoDS_Edge& newE = TopoDS::Edge( itE.Value() );
if (AddedSectionEdgesMap.Add(newE)) {
if (mySectionEdges.Contains(newE))
Split.Add(newE,F); // new edge on face
else {
const TopoDS_Edge& oldE = TopoDS::Edge( EdgeImage.ImageFrom(newE) );
Split.Add(newE, oldE); // splited edge
}
}
}
}
Split.Build();
if (Split.IsDone())
myNewFaces = Split.Modified(F);
#endif // ifndef USE_BREPFEAT_SPLITSHAPE
#ifdef DEB
Standard_Integer nbF = myNewFaces.Extent();
if (nbW != nbF)
cout << "WiresToFaces(): " << nbW << " wires --> " << myNewFaces.Extent() << " faces "
<< endl;
#endif
TopTools_ListIteratorOfListOfShape itNF (myNewFaces);
for (; itNF.More(); itNF.Next())
itNF.Value().Orientation( myFaceOri );

37
src/PARTITION/Partition_Spliter.cdl
View File

@ -94,6 +94,11 @@ is
---Category: private methods
MakeSolids (me: in out; Solid : Shape from TopoDS;
Shells: in out ListOfShape from TopTools)
is private;
---Purpose: make solids out of Shells
MakeShells (me: in out; S : Shape from TopoDS;
NS: in out ListOfShape from TopTools) is private;
---Purpose: split S into shells
@ -131,18 +136,39 @@ is
-- shared by
-- <LE> contains edge splits
IsInside (myclass; S1,S2 : Shape from TopoDS)
returns Boolean from Standard is private;
---Purpose: Return True if the first vertex of S1 inside S2.
-- If S1.IsNull(), check infinite point against S2.
GetOriginalShape(me; aShape : Shape from TopoDS)
returns Shape from TopoDS is private;
---Purpose: Return the shape aShape originates from. aShape
-- should be a face or more complex result shape
FindToolsToReconstruct(me: in out) is private;
---Purpose: find and store as objects tools which interfere
-- with solids or are inside solids without
-- an interference
fields
myDoneStep : ShapeEnum from TopAbs; -- reconstructed topology
myDoneStep : ShapeEnum from TopAbs; -- rebuilt level
myShape : Compound from TopoDS; -- result
myBuilder : Builder from BRep;
myListShapes : ListOfShape from TopTools; -- object shapes
myMapFaces : MapOfShape from TopTools; -- object faces
myMapTools : MapOfShape from TopTools; -- tool faces
myEqualEdges : MapOfShape from TopTools; -- equal splits
myNewSection : MapOfShape from TopTools; -- new secton edges
myClosedShapes : MapOfShape from TopTools;
myWrappingSolid: MapOfShape from TopTools; -- solids having other shapes inside
myFaceShapeMap : DataMapOfShapeShape from TopTools; -- to find a shape by face
myNewSection : MapOfShape from TopTools; -- new secton edges
myInternalFaces: DataMapOfShapeShape from TopTools; -- shape and its internal faces
myIntNotClFaces: DataMapOfShapeShape from TopTools; -- internal but not closed
myAsDes : AsDes from BRepAlgo;
myImagesFaces : Image from BRepAlgo;
@ -155,11 +181,4 @@ fields
-- avoid rebuilding twice commont part of solids
myAddedFacesMap: MapOfOrientedShape from TopTools;
-- equal splits
myEqualEdges : MapOfShape from TopTools;
-- shape and its internal faces
myInternalFaces: DataMapOfShapeShape from TopTools;
myIntNotClFaces: DataMapOfShapeShape from TopTools;-- internal but not closed
end Spliter;

1200
src/PARTITION/Partition_Spliter.cxx
View File

File diff suppressed because it is too large Load Diff

34
src/PARTITION/Partition_Spliter.hxx
View File

@ -1,30 +1,12 @@
// GEOM PARTITION : partition algorithm
//
// Copyright (C) 2003 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
// Copyright (C) 2003 CEA/DEN, EDF R&D
//
//
//
// File : Partition_Spliter.hxx
// Module : GEOM
#ifndef _Partition_Spliter_HeaderFile
#define _Partition_Spliter_HeaderFile
@ -119,12 +101,16 @@ private:
// Methods PRIVATE
//
Standard_EXPORT void MakeSolids(const TopoDS_Shape& Solid,TopTools_ListOfShape& Shells) ;
Standard_EXPORT void MakeShells(const TopoDS_Shape& S,TopTools_ListOfShape& NS) ;
Standard_EXPORT TopoDS_Shape MakeFaces(const TopoDS_Shape& S) ;
Standard_EXPORT void MakeEdges(const TopoDS_Edge& E,const TopTools_ListOfShape& VOnE,TopTools_ListOfShape& NE) const;
Standard_EXPORT TopoDS_Shape FindFacesInside(const TopoDS_Shape& S,const Standard_Boolean CheckClosed = Standard_False,const Standard_Boolean All = Standard_False) ;
Standard_EXPORT Standard_Boolean CheckTool(const TopoDS_Shape& S) ;
Standard_EXPORT void MergeEqualEdges(const TopTools_ListOfShape& LE) ;
Standard_EXPORT static Standard_Boolean IsInside(const TopoDS_Shape& S1,const TopoDS_Shape& S2) ;
Standard_EXPORT TopoDS_Shape GetOriginalShape(const TopoDS_Shape& aShape) const;
Standard_EXPORT void FindToolsToReconstruct() ;
// Fields PRIVATE
@ -135,17 +121,19 @@ BRep_Builder myBuilder;
TopTools_ListOfShape myListShapes;
TopTools_MapOfShape myMapFaces;
TopTools_MapOfShape myMapTools;
TopTools_DataMapOfShapeShape myFaceShapeMap;
TopTools_MapOfShape myEqualEdges;
TopTools_MapOfShape myNewSection;
TopTools_MapOfShape myClosedShapes;
TopTools_MapOfShape myWrappingSolid;
TopTools_DataMapOfShapeShape myFaceShapeMap;
TopTools_DataMapOfShapeShape myInternalFaces;
TopTools_DataMapOfShapeShape myIntNotClFaces;
Handle_BRepAlgo_AsDes myAsDes;
BRepAlgo_Image myImagesFaces;
BRepAlgo_Image myImagesEdges;
BRepAlgo_Image myImageShape;
Partition_Inter3d myInter3d;
TopTools_MapOfOrientedShape myAddedFacesMap;
TopTools_MapOfShape myEqualEdges;
TopTools_DataMapOfShapeShape myInternalFaces;
TopTools_DataMapOfShapeShape myIntNotClFaces;
};

2
src/SKETCHER/Makefile.in
View File

@ -47,7 +47,7 @@ EXPORT_HEADERS= GEOM_Sketcher.h \
# additionnal information to compil and link file
CPPFLAGS += $(OCC_INCLUDES) $(QT_INCLUDES)
CXXFLAGS += $(OCC_CXXFLAGS)
LDFLAGS += $(OCC_LIBS)
LDFLAGS += $(QT_LIBS) $(CAS_LDPATH) -lTKTopAlgo
# additional file to be cleaned
MOSTLYCLEAN =

5385
src/diffs Normal file
View File

File diff suppressed because it is too large Load Diff