// Created on: 1994-03-10 // Created by: Laurent BUCHARD // Copyright (c) 1994-1999 Matra Datavision // Copyright (c) 1999-2014 OPEN CASCADE SAS // // This file is part of Open CASCADE Technology software library. // // This library is free software; you can redistribute it and/or modify it under // the terms of the GNU Lesser General Public License version 2.1 as published // by the Free Software Foundation, with special exception defined in the file // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT // distribution for complete text of the license and disclaimer of any warranty. // // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. // Modifed: Porting NT 7-5-97 DPF (stdio.h) // Apr 16 2002 eap, classification against infinite solid (occ299) // Modified by skv - Thu Sep 4 12:29:30 2003 OCC578 //-- Process the case of a hole!! #define REJECTION 1 //-- To printf on NT #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include //OCC454(apo)-> //<-OCC454(apo) //======================================================================= //function : FindAPointInTheFace //purpose : Compute a point P in the face F. Param is a Real in // ]0,1[ and is used to initialise the algorithm. For // different values , different points are returned. //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::FindAPointInTheFace (const TopoDS_Face& _face, gp_Pnt& APoint_, Standard_Real& param_) { Standard_Real u,v; Standard_Boolean r = FindAPointInTheFace(_face,APoint_,u,v,param_); return r; } //======================================================================= //function : FindAPointInTheFace //purpose : //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::FindAPointInTheFace (const TopoDS_Face& _face, gp_Pnt& APoint_, Standard_Real& u_, Standard_Real& v_, Standard_Real& param_) { gp_Vec aVecD1U, aVecD1V; return FindAPointInTheFace (_face, APoint_, u_, v_, param_, aVecD1U, aVecD1V); } //======================================================================= //function : FindAPointInTheFace //purpose : //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::FindAPointInTheFace (const TopoDS_Face& _face, gp_Pnt& APoint_, Standard_Real& u_, Standard_Real& v_, Standard_Real& param_, gp_Vec& theVecD1U, gp_Vec& theVecD1V) { TopoDS_Face face = _face; face.Orientation (TopAbs_FORWARD); TopExp_Explorer faceexplorer; BRepAdaptor_Curve2d c; gp_Vec2d T; gp_Pnt2d P; for (faceexplorer.Init(face,TopAbs_EDGE); faceexplorer.More(); faceexplorer.Next()) { TopoDS_Edge Edge = TopoDS::Edge (faceexplorer.Current()); c.Initialize (Edge, face); c.D1((c.LastParameter() - c.FirstParameter()) * param_ + c.FirstParameter(),P,T); Standard_Real x = T.X(); Standard_Real y = T.Y(); if (Edge.Orientation() == TopAbs_FORWARD) { T.SetCoord (-y, x); } else { T.SetCoord ( y, -x); } Standard_Real ParamInit = RealLast(); Standard_Real TolInit = 0.00001; Standard_Boolean APointExist = Standard_False; BRepClass_FacePassiveClassifier FClassifier; T.Normalize(); P.SetCoord (P.X() + TolInit * T.X(), P.Y() + TolInit * T.Y()); FClassifier.Reset (gp_Lin2d (P, T), ParamInit, RealEpsilon()); //-- Length and Tolerance ####### TopExp_Explorer otherfaceexplorer; Standard_Integer aNbEdges = 0; for (otherfaceexplorer.Init (face, TopAbs_EDGE); otherfaceexplorer.More(); otherfaceexplorer.Next(), ++aNbEdges) { TopoDS_Edge OtherEdge = TopoDS::Edge (otherfaceexplorer.Current()); if (OtherEdge.Orientation() != TopAbs_EXTERNAL && OtherEdge != Edge) { BRepClass_Edge AEdge (OtherEdge, face); FClassifier.Compare (AEdge, OtherEdge.Orientation()); if (FClassifier.ClosestIntersection()) { if(ParamInit > FClassifier.Parameter()) { ParamInit = FClassifier.Parameter(); APointExist = Standard_True; } } } } if (aNbEdges == 1) { BRepClass_Edge AEdge (Edge, face); FClassifier.Compare (AEdge, Edge.Orientation()); if (FClassifier.ClosestIntersection()) { if (ParamInit > FClassifier.Parameter()) { ParamInit = FClassifier.Parameter(); APointExist = Standard_True; } } } while (APointExist) { ParamInit *= 0.41234; u_ = P.X() + ParamInit* T.X(); v_ = P.Y() + ParamInit* T.Y(); //Additional check BRepTopAdaptor_FClass2d Classifier(face, Precision::Confusion()); gp_Pnt2d aPnt2d(u_, v_); TopAbs_State StateOfResultingPoint = Classifier.Perform(aPnt2d); if (StateOfResultingPoint != TopAbs_IN) return Standard_False; BRepAdaptor_Surface s; s.Initialize (face, Standard_False); s.D1 (u_, v_, APoint_, theVecD1U, theVecD1V); if(theVecD1U.CrossMagnitude(theVecD1V) > gp::Resolution()) return Standard_True; if(ParamInit < Precision::PConfusion()) return Standard_False; } } return Standard_False; } //======================================================================= //function : PointInTheFace //purpose : //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::PointInTheFace (const TopoDS_Face& Face, gp_Pnt& APoint_, Standard_Real& u_, Standard_Real& v_, Standard_Real& param_, Standard_Integer& IndexPoint, const Handle(BRepAdaptor_HSurface)& surf, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2) const { gp_Vec aVecD1U, aVecD1V; return PointInTheFace (Face, APoint_, u_, v_, param_, IndexPoint, surf, U1, V1, U2, V2, aVecD1U, aVecD1V); } //======================================================================= //function : ClassifyUVPoint //purpose : //======================================================================= TopAbs_State BRepClass3d_SolidExplorer::ClassifyUVPoint (const IntCurvesFace_Intersector& theIntersector, const Handle(BRepAdaptor_HSurface)& theSurf, const gp_Pnt2d& theP2d) const { // first find if the point is near an edge/vertex gp_Pnt aP3d = theSurf->Value(theP2d.X(), theP2d.Y()); BRepClass3d_BndBoxTreeSelectorPoint aSelectorPoint(myMapEV); aSelectorPoint.SetCurrentPoint(aP3d); Standard_Integer aSelsVE = myTree.Select(aSelectorPoint); if (aSelsVE > 0) { // The point is inside the tolerance area of vertices/edges => return ON state. return TopAbs_ON; } return theIntersector.ClassifyUVPoint(theP2d); } //======================================================================= //function : PointInTheFace //purpose : //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::PointInTheFace (const TopoDS_Face& Face, gp_Pnt& APoint_, Standard_Real& u_, Standard_Real& v_, Standard_Real& param_, Standard_Integer& IndexPoint, const Handle(BRepAdaptor_HSurface)& surf, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, gp_Vec& theVecD1U, gp_Vec& theVecD1V) const { Standard_Real u,du = (U2-U1)/6.0; Standard_Real v,dv = (V2-V1)/6.0; if(du<1e-12) du=1e-12; if(dv<1e-12) dv=1e-12; Standard_Boolean IsNotUper = !surf->IsUPeriodic(), IsNotVper = !surf->IsVPeriodic(); Standard_Integer NbPntCalc=0; if(myMapOfInter.IsBound(Face)) { void *ptr = (void*)(myMapOfInter.Find(Face)); Standard_Boolean IsInside = Standard_True; if(IsNotUper) { IsInside = (u_ >= U1) && (u_ <= U2); } if(IsNotVper) { IsInside &= (v_ >= V1) && (v_ <= V2); } if(ptr) { const IntCurvesFace_Intersector& TheIntersector = (*((IntCurvesFace_Intersector *)ptr)); // Check if the point is already in the face if (IsInside && (ClassifyUVPoint(TheIntersector, surf, gp_Pnt2d(u_, v_)) == TopAbs_IN)) { gp_Pnt aPnt; surf->D1(u_, v_, aPnt, theVecD1U, theVecD1V); if (aPnt.SquareDistance(APoint_) < Precision::Confusion() * Precision::Confusion()) return Standard_True; } //-- Take 4 points in each Quarter of surface //-- -> Index : 1 -> 16 //-- //-- //-- Then take a matrix of points on a tight grid //-- for(u=du+(U1+U2)*0.5; u=IndexPoint) { if (ClassifyUVPoint(TheIntersector, surf, gp_Pnt2d(u, v)) == TopAbs_IN) { u_=u; v_=v; surf->D1 (u, v, APoint_, theVecD1U, theVecD1V); IndexPoint = NbPntCalc; return(Standard_True); } } } } for(u=-du+(U1+U2)*0.5; u>U1; u-=du) { //-- 0 0 u decreases for(v=-dv+(V1+V2)*0.5; v>V1; v-=dv) { //-- X 0 v decreases if(++NbPntCalc>=IndexPoint) { if (ClassifyUVPoint(TheIntersector, surf, gp_Pnt2d(u, v)) == TopAbs_IN) { u_=u; v_=v; surf->D1 (u, v, APoint_, theVecD1U, theVecD1V); IndexPoint = NbPntCalc; return(Standard_True); } } } } for(u=-du+(U1+U2)*0.5; u>U1; u-=du) { //-- X 0 u decreases for(v=dv+(V1+V2)*0.5; v=IndexPoint) { if (ClassifyUVPoint(TheIntersector, surf, gp_Pnt2d(u, v)) == TopAbs_IN) { u_=u; v_=v; surf->D1 (u, v, APoint_, theVecD1U, theVecD1V); IndexPoint = NbPntCalc; return(Standard_True); } } } } for(u=du+(U1+U2)*0.5; uV1; v-=dv) { //-- 0 X v decreases if(++NbPntCalc>=IndexPoint) { if (ClassifyUVPoint(TheIntersector, surf, gp_Pnt2d(u, v)) == TopAbs_IN) { u_=u; v_=v; surf->D1 (u, v, APoint_, theVecD1U, theVecD1V); IndexPoint = NbPntCalc; return(Standard_True); } } } } //-- the remainder du = (U2-U1)/37.0; dv = (V2-V1)/37.0; if(du<1e-12) du=1e-12; if(dv<1e-12) dv=1e-12; for(u=du+U1; u=IndexPoint) { if (ClassifyUVPoint(TheIntersector, surf, gp_Pnt2d(u, v)) == TopAbs_IN) { u_=u; v_=v; surf->D1 (u, v, APoint_, theVecD1U, theVecD1V); IndexPoint = NbPntCalc; return(Standard_True); } } } } u=(U1+U2)*0.5; v=(V1+V2)*0.5; if(++NbPntCalc>=IndexPoint) { if (ClassifyUVPoint(TheIntersector, surf, gp_Pnt2d(u, v)) == TopAbs_IN) { u_=u; v_=v; surf->D1 (u, v, APoint_, theVecD1U, theVecD1V); IndexPoint = NbPntCalc; return(Standard_True); } } } IndexPoint = NbPntCalc; } else { //printf("BRepClass3d_SolidExplorer Face not found ds the map \n"); } return BRepClass3d_SolidExplorer ::FindAPointInTheFace (Face,APoint_, u_, v_, param_, theVecD1U, theVecD1V); } //======================================================================= //function : LimitInfiniteUV //purpose : Limit infinite parameters //======================================================================= static void LimitInfiniteUV (Standard_Real& U1, Standard_Real& V1, Standard_Real& U2, Standard_Real& V2) { Standard_Boolean infU1 = Precision::IsNegativeInfinite(U1), infV1 = Precision::IsNegativeInfinite(V1), infU2 = Precision::IsPositiveInfinite(U2), infV2 = Precision::IsPositiveInfinite(V2); if (infU1) U1 = -1e10; if (infV1) V1 = -1e10; if (infU2) U2 = 1e10; if (infV2) V2 = 1e10; } //======================================================================= //function : IsInfiniteUV //purpose : //======================================================================= static Standard_Integer IsInfiniteUV (Standard_Real& U1, Standard_Real& V1, Standard_Real& U2, Standard_Real& V2) { Standard_Integer aVal = 0; if (Precision::IsInfinite(U1)) aVal |= 1; if (Precision::IsInfinite(V1)) aVal |= 2; if (Precision::IsInfinite(U2)) aVal |= 4; if (Precision::IsInfinite(V2)) aVal |= 8; return aVal; } //<-OCC454 // Modified by skv - Tue Sep 16 13:50:39 2003 OCC578 End //======================================================================= //function : OtherSegment //purpose : Returns in , a segment having at least // one intersection with the shape boundary to // compute intersections. // The First Call to this method returns a line which // point to a point of the first face of the shape. // The Second Call provide a line to the second face // and so on. //======================================================================= Standard_Integer BRepClass3d_SolidExplorer::OtherSegment(const gp_Pnt& P, gp_Lin& L, Standard_Real& _Par) { const Standard_Real TolU = Precision::PConfusion(); const Standard_Real TolV = TolU; TopoDS_Face face; TopExp_Explorer faceexplorer; gp_Pnt APoint; gp_Vec aVecD1U, aVecD1V; Standard_Real maxscal=0; Standard_Boolean ptfound=Standard_False; Standard_Real Par; Standard_Real _u,_v; Standard_Integer IndexPoint=0; Standard_Integer NbPointsOK=0; Standard_Integer NbFacesInSolid=0; Standard_Boolean aRestr = Standard_True; Standard_Boolean aTestInvert = Standard_False; for(;;) { myFirstFace++; faceexplorer.Init(myShape,TopAbs_FACE); // look for point on face starting from myFirstFace // Modified by skv - Thu Sep 4 14:31:12 2003 OCC578 Begin // while (faceexplorer.More()) { NbFacesInSolid = 0; for (; faceexplorer.More(); faceexplorer.Next()) { // Modified by skv - Thu Sep 4 14:31:12 2003 OCC578 End NbFacesInSolid++; if (myFirstFace > NbFacesInSolid) continue; face = TopoDS::Face(faceexplorer.Current()); Handle(BRepAdaptor_HSurface) surf = new BRepAdaptor_HSurface(); if(aTestInvert) { BRepTopAdaptor_FClass2d aClass(face, Precision::Confusion()); if(aClass.PerformInfinitePoint() == TopAbs_IN) { aRestr = Standard_False; if(myMapOfInter.IsBound(face)) { myMapOfInter.UnBind(face); void *ptr = (void *)(new IntCurvesFace_Intersector(face, Precision::Confusion(), aRestr, Standard_False)); myMapOfInter.Bind(face,ptr); } } else { aRestr = Standard_True; } } surf->ChangeSurface().Initialize(face, aRestr); Standard_Real U1,V1,U2,V2; U1 = surf->FirstUParameter(); V1 = surf->FirstVParameter(); U2 = surf->LastUParameter(); V2 = surf->LastVParameter(); face.Orientation(TopAbs_FORWARD); // //avoid process faces from uncorrected shells const Standard_Real eps = Precision::PConfusion(); Standard_Real epsU = Max(eps * Max(Abs(U2), Abs(U1)), eps); Standard_Real epsV = Max(eps * Max(Abs(V2), Abs(V1)), eps); if( Abs (U2 - U1) < epsU || Abs(V2 - V1) < epsV) { return 2; } // Standard_Real svmyparam=myParamOnEdge; // // Check if the point is on the face or the face is infinite. Standard_Integer anInfFlag = IsInfiniteUV(U1,V1,U2,V2); // default values _u = (U1 + U2) * 0.5; _v = (V1 + V2) * 0.5; GeomAdaptor_Surface GA(BRep_Tool::Surface(face)); Extrema_ExtPS Ext(P, GA, TolU, TolV); // if (Ext.IsDone() && Ext.NbExt() > 0) { Standard_Integer i, iNear, iEnd; Standard_Real aUx, aVx, Dist2, Dist2Min; Extrema_POnSurf aPx; // iNear = 1; Dist2Min = Ext.SquareDistance(1); iEnd = Ext.NbExt(); for (i = 2; i <= iEnd; i++) { aPx=Ext.Point(i); aPx.Parameter(aUx, aVx); if (aUx>=U1 && aUx<=U2 && aVx>=V1 && aVx<=V2) { Dist2 = Ext.SquareDistance(i); if (Dist2 < Dist2Min) { Dist2Min = Dist2; iNear = i; } } } // Standard_Real aDist2Tresh=1.e-24; // if (Dist2Min gp::Resolution() && aVecD1U.Magnitude() > gp::Resolution() && aVecD1V.Magnitude() > gp::Resolution()) { gp_Vec Norm = aVecD1U.Crossed (aVecD1V); Standard_Real tt = Norm.Magnitude(); tt = Abs (Norm.Dot (V)) / (tt * Par); if (tt > maxscal) { maxscal = tt; L = gp_Lin (P, V); _Par = Par; ptfound = Standard_True; if (maxscal>0.2) { myParamOnEdge=svmyparam; return 0; } } } } } while(IndexPoint<200 && NbPointsOK<16); myParamOnEdge=svmyparam; if(maxscal>0.2) { return 0; } // Modified by skv - Thu Sep 4 14:32:14 2003 OCC578 Begin // Next is done in the main for(..) loop. // faceexplorer.Next(); // Modified by skv - Thu Sep 4 14:32:14 2003 OCC578 End IndexPoint = 0; Standard_Boolean encoreuneface = faceexplorer.More(); if(ptfound==Standard_False && encoreuneface==Standard_False) { if(myParamOnEdge < 0.0001) { //-- This case takes place when the point is on the solid //-- and this solid is reduced to a face gp_Pnt PBidon(P.X()+1.0,P.Y(),P.Z()); gp_Vec V(P,PBidon); Par= 1.0; _Par=Par; L = gp_Lin(P,V); return 0; } } } //-- Exploration of the faces if(NbFacesInSolid==0) { _Par=0.0; myReject=Standard_True; #ifdef OCCT_DEBUG cout<<"\nWARNING : BRepClass3d_SolidExplorer.cxx (Solid without face)"<ChangeSurface().Initialize(Face); Standard_Real U1,V1,U2,V2;//,u,v; U1 = surf->FirstUParameter(); V1 = surf->FirstVParameter(); U2 = surf->LastUParameter(); V2 = surf->LastVParameter(); LimitInfiniteUV (U1,V1,U2,V2); return(PointInTheFace(Face,APoint_,u_,v_,param_,IndexPoint,surf,U1,V1,U2,V2)); } //======================================================================= //function : FindAPointInTheFace //purpose : //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::FindAPointInTheFace (const TopoDS_Face& _face, gp_Pnt& APoint_, Standard_Real& u_,Standard_Real& v_) { Standard_Real param = 0.1; Standard_Boolean r = FindAPointInTheFace(_face,APoint_,u_,v_,param); return r; } //======================================================================= //function : FindAPointInTheFace //purpose : //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::FindAPointInTheFace (const TopoDS_Face& _face, gp_Pnt& APoint_) { Standard_Real u,v; Standard_Boolean r = FindAPointInTheFace(_face,APoint_,u,v); return r; } //======================================================================= //function : FindAPointInTheFace //purpose : //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::FindAPointInTheFace (const TopoDS_Face& _face, Standard_Real& u_,Standard_Real& v_) { gp_Pnt APoint; Standard_Boolean r = FindAPointInTheFace(_face,APoint,u_,v_); return r; } //======================================================================= //function : BRepClass3d_SolidExplorer //purpose : //======================================================================= BRepClass3d_SolidExplorer::BRepClass3d_SolidExplorer() { } #include //======================================================================= //function : BRepClass3d_SolidExplorer //purpose : Raise if called. //======================================================================= //BRepClass3d_SolidExplorer::BRepClass3d_SolidExplorer(const BRepClass3d_SolidExplorer& Oth) BRepClass3d_SolidExplorer::BRepClass3d_SolidExplorer(const BRepClass3d_SolidExplorer& ) { Standard_ConstructionError::Raise("Magic constructor not allowed"); } //======================================================================= //function : BRepClass3d_SolidExplorer //purpose : //======================================================================= BRepClass3d_SolidExplorer::BRepClass3d_SolidExplorer(const TopoDS_Shape& S) { InitShape(S); } //======================================================================= //function : ~BRepClass3d_SolidExplorer //purpose : //======================================================================= BRepClass3d_SolidExplorer::~BRepClass3d_SolidExplorer() { Destroy() ; } //======================================================================= //function : Destroy //purpose : C++: alias ~ //======================================================================= void BRepClass3d_SolidExplorer::Destroy() { BRepClass3d_DataMapIteratorOfMapOfInter iter(myMapOfInter); for(;iter.More();iter.Next()) { void *ptr=iter.Value(); if(ptr) { delete (IntCurvesFace_Intersector *)ptr; myMapOfInter.ChangeFind(iter.Key()) = NULL; } } myMapOfInter.Clear(); } //======================================================================= //function : InitShape //purpose : //======================================================================= void BRepClass3d_SolidExplorer::InitShape(const TopoDS_Shape& S) { myMapEV.Clear(); myTree.Clear(); myShape = S; myFirstFace = 0; myParamOnEdge = 0.512345; //-- Exploring of the Map and removal of allocated objects BRepClass3d_DataMapIteratorOfMapOfInter iter(myMapOfInter); for(;iter.More();iter.Next()) { void *ptr=iter.Value(); if(ptr) { delete (IntCurvesFace_Intersector *)ptr; myMapOfInter.ChangeFind(iter.Key()) = NULL; } } myMapOfInter.Clear(); myReject = Standard_True; //-- case of infinite solid (without any face) TopExp_Explorer Expl; for(Expl.Init(S,TopAbs_FACE); Expl.More(); Expl.Next()) { const TopoDS_Face Face = TopoDS::Face(Expl.Current()); void *ptr = (void *)(new IntCurvesFace_Intersector(Face,Precision::Confusion(),Standard_True, Standard_False)); myMapOfInter.Bind(Face,ptr); myReject=Standard_False; //-- at least one face in the solid } #ifdef OCCT_DEBUG if(myReject) { cout<<"\nWARNING : BRepClass3d_SolidExplorer.cxx (Solid without face)"< aTreeFiller (myTree); for (Standard_Integer i = 1; i <= myMapEV.Extent(); i++) { Bnd_Box B; const TopoDS_Shape& Sh = myMapEV(i); TopAbs_Orientation ori = Sh.Orientation(); if (ori == TopAbs_EXTERNAL || ori == TopAbs_INTERNAL) continue; if (Sh.ShapeType() == TopAbs_EDGE && BRep_Tool::Degenerated(TopoDS::Edge(Sh))) continue; BRepBndLib::Add(Sh,B); aTreeFiller.Add(i, B); } aTreeFiller.Fill(); } //======================================================================= //function : Reject //purpose : Should return True if P outside of bounding vol. of the shape //======================================================================= //Standard_Boolean BRepClass3d_SolidExplorer::Reject(const gp_Pnt& P) const Standard_Boolean BRepClass3d_SolidExplorer::Reject(const gp_Pnt& ) const { return(myReject); // case of solid without face } //======================================================================= //function : InitShell //purpose : Starts an exploration of the shells. //======================================================================= void BRepClass3d_SolidExplorer::InitShell() { myShellExplorer.Init(myShape,TopAbs_SHELL); } //======================================================================= //function : MoreShell //purpose : Returns True if there is a current shell. //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::MoreShell() const { return(myShellExplorer.More()); } //======================================================================= //function : NextShell //purpose : Sets the explorer to the next shell. //======================================================================= void BRepClass3d_SolidExplorer::NextShell() { myShellExplorer.Next(); } //======================================================================= //function : CurrentShell //purpose : Returns the current shell. //======================================================================= TopoDS_Shell BRepClass3d_SolidExplorer::CurrentShell() const { return(TopoDS::Shell(myShellExplorer.Current())); } //======================================================================= //function : RejectShell //purpose : Returns True if the Shell is rejected. //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::RejectShell(const gp_Lin& ) const { return(Standard_False); } //======================================================================= //function : InitFace //purpose : Starts an exploration of the faces of the current shell. //======================================================================= void BRepClass3d_SolidExplorer::InitFace() { myFaceExplorer.Init(TopoDS::Shell(myShellExplorer.Current()),TopAbs_FACE); } //======================================================================= //function : MoreFace //purpose : Returns True if current face in current shell. //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::MoreFace() const { return(myFaceExplorer.More()); } //======================================================================= //function : NextFace //purpose : Sets the explorer to the next Face of the current shell. //======================================================================= void BRepClass3d_SolidExplorer::NextFace() { myFaceExplorer.Next(); } //======================================================================= //function : CurrentFace //purpose : Returns the current face. //======================================================================= TopoDS_Face BRepClass3d_SolidExplorer::CurrentFace() const { return(TopoDS::Face(myFaceExplorer.Current())); } //======================================================================= //function : RejectFace //purpose : returns True if the face is rejected. //======================================================================= Standard_Boolean BRepClass3d_SolidExplorer::RejectFace(const gp_Lin& ) const { return(Standard_False); } #ifdef OCCT_DEBUG #include #endif //======================================================================= //function : Segment //purpose : Returns in , a segment having at least // one intersection with the shape boundary to // compute intersections. //======================================================================= Standard_Integer BRepClass3d_SolidExplorer::Segment(const gp_Pnt& P, gp_Lin& L, Standard_Real& Par) { Standard_Integer bRetFlag; myFirstFace = 0; bRetFlag=OtherSegment(P,L,Par); return bRetFlag; } //======================================================================= //function : Intersector //purpose : //======================================================================= IntCurvesFace_Intersector& BRepClass3d_SolidExplorer::Intersector(const TopoDS_Face& F) const { void *ptr = (void*)(myMapOfInter.Find(F)); IntCurvesFace_Intersector& curr = (*((IntCurvesFace_Intersector *)ptr)); return curr; } //======================================================================= //function : Box //purpose : //======================================================================= const Bnd_Box& BRepClass3d_SolidExplorer::Box() const { return(myBox); } //======================================================================= //function : DumpSegment //purpose : //======================================================================= void BRepClass3d_SolidExplorer::DumpSegment(const gp_Pnt&, const gp_Lin&, const Standard_Real, const TopAbs_State) const { #ifdef OCCT_DEBUG #endif } const TopoDS_Shape& BRepClass3d_SolidExplorer::GetShape() const { return(myShape); }