OCCT Git - occt.git/blob

1 // Created on: 1997-04-14

2 // Created by: Olga KOULECHOVA

5 //

6 // This file is part of Open CASCADE Technology software library.

7 //

8 // This library is free software; you can redistribute it and/or modify it under

9 // the terms of the GNU Lesser General Public License version 2.1 as published

10 // by the Free Software Foundation, with special exception defined in the file

11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT

12 // distribution for complete text of the license and disclaimer of any warranty.

13 //

14 // Alternatively, this file may be used under the terms of Open CASCADE

15 // commercial license or contractual agreement.

17 #include <BRep_Builder.hxx>

18 #include <BRep_Tool.hxx>

19 #include <BRepAlgoAPI_Common.hxx>

20 #include <BRepAlgoAPI_Section.hxx>

21 #include <BRepBuilderAPI.hxx>

22 #include <BRepBuilderAPI_MakeFace.hxx>

23 #include <BRepBuilderAPI_Transform.hxx>

24 #include <BRepExtrema_ExtCF.hxx>

25 #include <BRepExtrema_ExtPC.hxx>

26 #include <BRepExtrema_ExtPF.hxx>

27 #include <BRepFeat.hxx>

28 #include <BRepFeat_MakeLinearForm.hxx>

29 #include <BRepLib_MakeEdge.hxx>

30 #include <BRepLib_MakeFace.hxx>

31 #include <BRepLib_MakeVertex.hxx>

32 #include <BRepLib_MakeWire.hxx>

33 #include <BRepPrimAPI_MakeBox.hxx>

34 #include <BRepTools.hxx>

35 #include <BRepTools_Modifier.hxx>

36 #include <BRepTools_TrsfModification.hxx>

37 #include <BRepTools_WireExplorer.hxx>

38 #include <Geom_Curve.hxx>

39 #include <Geom_CylindricalSurface.hxx>

40 #include <Geom_Plane.hxx>

41 #include <Geom_RectangularTrimmedSurface.hxx>

42 #include <Geom_Surface.hxx>

43 #include <Geom_TrimmedCurve.hxx>

44 #include <gp_Dir.hxx>

45 #include <gp_Pnt.hxx>

46 #include <gp_Vec.hxx>

47 #include <IntRes2d_IntersectionPoint.hxx>

48 #include <LocOpe_Gluer.hxx>

49 #include <LocOpe_LinearForm.hxx>

50 #include <Precision.hxx>

51 #include <Standard_ConstructionError.hxx>

52 #include <TopExp.hxx>

53 #include <TopExp_Explorer.hxx>

54 #include <TopoDS.hxx>

55 #include <TopoDS_Edge.hxx>

56 #include <TopoDS_Face.hxx>

57 #include <TopoDS_Shape.hxx>

58 #include <TopoDS_Wire.hxx>

59 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>

60 #include <TopTools_ListOfShape.hxx>

62 #ifdef OCCT_DEBUG

63 extern Standard_Boolean BRepFeat_GettraceFEAT();

64 extern Standard_Boolean BRepFeat_GettraceFEATRIB();

65 #endif

67 static void MajMap(const TopoDS_Shape&, // base

68 const LocOpe_LinearForm&,

69 TopTools_DataMapOfShapeListOfShape&, // myMap

70 TopoDS_Shape&, // myFShape

71 TopoDS_Shape&); // myLShape

73 static void SetGluedFaces(const TopTools_DataMapOfShapeListOfShape& theSlmap,

74 LocOpe_LinearForm&,

75 TopTools_DataMapOfShapeShape&);

77 //=================================================================================================

79 void BRepFeat_MakeLinearForm::Init(const TopoDS_Shape& Sbase,

80 const TopoDS_Wire& W,

81 const Handle(Geom_Plane)& Plane,

82 const gp_Vec& Direc,

83 const gp_Vec& Direc1,

84 const Standard_Integer Mode,

85 const Standard_Boolean Modify)

86 {

87 #ifdef OCCT_DEBUG

88 Standard_Boolean trc = BRepFeat_GettraceFEAT();

89 if (trc)

90 std::cout << "BRepFeat_MakeLinearForm::Init" << std::endl;

91 #endif

92 Standard_Boolean RevolRib = Standard_False;

93 Done();

94 myGenerated.Clear();

96 // modify = 0 if there is no intention to make sliding

97 // = 1 if one tries to make sliding

98 Standard_Boolean Sliding = Modify;

99 myLFMap.Clear();

100

101 myShape.Nullify();

102 myMap.Clear();

103 myFShape.Nullify();

104 myLShape.Nullify();

105 mySbase = Sbase;

106 mySkface.Nullify();

107 myPbase.Nullify();

108

109 myGShape.Nullify();

110 mySUntil.Nullify();

111 myListOfEdges.Clear();

112 mySlface.Clear();

113

114 TopoDS_Shape aLocalShapeW = W.Oriented(TopAbs_FORWARD);

115 myWire = TopoDS::Wire(aLocalShapeW);

116 // myWire = TopoDS::Wire(W.Oriented(TopAbs_FORWARD));

117 myDir = Direc;

118 myDir1 = Direc1;

119 myPln = Plane;

120

121 if (Mode == 0)

122 myFuse = Standard_False;

123 else // if(Mode == 1)

124 myFuse = Standard_True;

125 #ifdef OCCT_DEBUG

126 if (trc)

127 {

128 if (myFuse)

129 std::cout << " Fuse" << std::endl;

130 if (!myFuse)

131 std::cout << " Cut" << std::endl;

132 }

133 #endif

134

135 // ---Determine Tolerance : max tolerance on parameters

136 myTol = Precision::Confusion();

137

138 TopExp_Explorer exx;

139 exx.Init(myWire, TopAbs_VERTEX);

140 for (; exx.More(); exx.Next())

141 {

142 const Standard_Real& tol = BRep_Tool::Tolerance(TopoDS::Vertex(exx.Current()));

143 if (tol > myTol)

144 myTol = tol;

145 }

146

147 exx.Init(Sbase, TopAbs_VERTEX);

148 for (; exx.More(); exx.Next())

149 {

150 const Standard_Real& tol = BRep_Tool::Tolerance(TopoDS::Vertex(exx.Current()));

151 if (tol > myTol)

152 myTol = tol;

153 }

154

155 // ---Control of directions

156 // the wire should be in the rib

157 gp_Vec nulldir(0, 0, 0);

158 if (!myDir1.IsEqual(nulldir, myTol, myTol))

159 {

160 Standard_Real ang = myDir1.Angle(myDir);

161 if (ang != M_PI)

162 {

163 #ifdef OCCT_DEBUG

164 if (trc)

165 std::cout << " Directions must be opposite" << std::endl;

166 #endif

167 myStatusError = BRepFeat_BadDirect;

168 NotDone();

169 return;

170 }

171 }

172 else

173 {

174

175 // Rib is centre in the middle of translation

176 #ifdef OCCT_DEBUG

177 if (trc)

178 std::cout << " Rib is centre" << std::endl;

179 #endif

180 const gp_Vec& DirTranslation = (Direc + Direc1) * 0.5;

181 gp_Trsf T;

182 T.SetTranslation(DirTranslation);

183 BRepBuilderAPI_Transform trf(T);

184 trf.Perform(myWire);

185 myWire = TopoDS::Wire(trf.Shape());

186 myDir = Direc - DirTranslation;

187 myDir1 = Direc1 - DirTranslation;

188 myPln->Transform(T);

189 }

190

191 // ---Calculate bounding box

192 BRep_Builder BB;

193

194 TopTools_ListOfShape theList;

195

196 TopoDS_Shape U;

197 U.Nullify();

198 gp_Pnt FirstCorner, LastCorner;

199 Standard_Real bnd = HeightMax(mySbase, U, FirstCorner, LastCorner);

200 myBnd = bnd;

201

202 BRepPrimAPI_MakeBox Bndbox(FirstCorner, LastCorner);

203 TopoDS_Solid BndBox = Bndbox.Solid();

204

205 // ---Construction of the face workplane (section bounding box)

206 BRepLib_MakeFace PlaneF(myPln->Pln(), -6. * myBnd, 6. * myBnd, -6. * myBnd, 6. * myBnd);

207 TopoDS_Face PlaneFace = TopoDS::Face(PlaneF.Shape());

208

209 BRepAlgoAPI_Common PlaneS(BndBox, PlaneFace);

210 TopExp_Explorer EXP;

211 TopoDS_Shape PlaneSect = PlaneS.Shape();

212 EXP.Init(PlaneSect, TopAbs_WIRE);

213 TopoDS_Wire www = TopoDS::Wire(EXP.Current());

214 BRepLib_MakeFace Bndface(myPln->Pln(), www, Standard_True);

215 TopoDS_Face BndFace = TopoDS::Face(Bndface.Shape());

216

217 // ---Find support faces of the rib

218 TopoDS_Edge FirstEdge, LastEdge;

219 TopoDS_Face FirstFace, LastFace;

220 TopoDS_Vertex FirstVertex, LastVertex;

221

222 Standard_Boolean OnFirstFace = Standard_False;

223 Standard_Boolean OnLastFace = Standard_False;

224 Standard_Boolean PtOnFirstEdge = Standard_False;

225 Standard_Boolean PtOnLastEdge = Standard_False;

226 TopoDS_Edge OnFirstEdge, OnLastEdge;

227 OnFirstEdge.Nullify();

228 OnLastEdge.Nullify();

229

230 Standard_Boolean Data = ExtremeFaces(RevolRib,

231 myBnd,

232 myPln,

233 FirstEdge,

234 LastEdge,

235 FirstFace,

236 LastFace,

237 FirstVertex,

238 LastVertex,

239 OnFirstFace,

240 OnLastFace,

241 PtOnFirstEdge,

242 PtOnLastEdge,

243 OnFirstEdge,

244 OnLastEdge);

245

246 if (!Data)

247 {

248 #ifdef OCCT_DEBUG

249 if (trc)

250 std::cout << " No Extreme faces" << std::endl;

251 #endif

252 myStatusError = BRepFeat_NoExtFace;

253 NotDone();

254 return;

255 }

256

257 // ---Proofing Point for the side of the wire to be filled - side material

258 gp_Pnt CheckPnt = CheckPoint(FirstEdge, bnd / 10., myPln);

259

260 // Standard_Real f, l;

261

262 // ---Control sliding valuable

263 // Many cases when the sliding is abandoned

264 Standard_Integer Concavite = 3; // a priori the profile is not concave

265

266 myFirstPnt = BRep_Tool::Pnt(FirstVertex);

267 myLastPnt = BRep_Tool::Pnt(LastVertex);

268

269 // SliList : list of faces concerned by the rib

270 TopTools_ListOfShape SliList;

271 SliList.Append(FirstFace);

272

273 if (Sliding)

274 { // sliding

275 #ifdef OCCT_DEBUG

276 if (trc)

277 std::cout << " Sliding" << std::endl;

278 #endif

279 Sliding = Standard_False;

280 Handle(Geom_Surface) s = BRep_Tool::Surface(FirstFace);

281 if (s->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))

282 {

283 s = Handle(Geom_RectangularTrimmedSurface)::DownCast(s)->BasisSurface();

284 }

285 if (s->DynamicType() == STANDARD_TYPE(Geom_Plane)

286 || s->DynamicType() == STANDARD_TYPE(Geom_CylindricalSurface))

287 {

288 // if plane or cylinder : sliding is possible

289 Sliding = Standard_True;

290 }

291 }

292

293 // Control only start and end points

294 // -> no control at the middle - improve

295 // Controle between Surface and segment between 2 limit points

296 // is too expensive - improve

297 if (Sliding)

298 {

299 gp_Pnt p1(myFirstPnt.X() + myDir.X(), myFirstPnt.Y() + myDir.Y(), myFirstPnt.Z() + myDir.Z());

300 BRepLib_MakeEdge ee1(myFirstPnt, p1);

301 BRepExtrema_ExtCF ext1(ee1, FirstFace);

302 if (ext1.NbExt() == 1

303 && ext1.SquareDistance(1)

304 <= BRep_Tool::Tolerance(FirstFace) * BRep_Tool::Tolerance(FirstFace))

305 {

306 gp_Pnt p2(myLastPnt.X() + myDir.X(), myLastPnt.Y() + myDir.Y(), myLastPnt.Z() + myDir.Z());

307 BRepLib_MakeEdge ee2(myLastPnt, p2);

308 BRepExtrema_ExtCF ext2(ee2, LastFace); // ExtCF : curves and surfaces

309 if (ext2.NbExt() == 1

310 && ext2.SquareDistance(1)

311 <= BRep_Tool::Tolerance(LastFace) * BRep_Tool::Tolerance(LastFace))

312 {

313 Sliding = Standard_True;

314 }

315 else

316 {

317 Sliding = Standard_False;

318 }

319 }

320 else

321 {

322 Sliding = Standard_False;

323 }

324 }

325

326 if (!myDir1.IsEqual(nulldir, Precision::Confusion(), Precision::Confusion()))

327 {

328 if (Sliding)

329 {

330 gp_Pnt p1(myFirstPnt.X() + myDir1.X(),

331 myFirstPnt.Y() + myDir1.Y(),

332 myFirstPnt.Z() + myDir1.Z());

333 BRepLib_MakeEdge ee1(myFirstPnt, p1);

334 BRepExtrema_ExtCF ext1(ee1, FirstFace);

335 if (ext1.NbExt() == 1

336 && ext1.SquareDistance(1)

337 <= BRep_Tool::Tolerance(FirstFace) * BRep_Tool::Tolerance(FirstFace))

338 {

339 gp_Pnt p2(myLastPnt.X() + myDir1.X(),

340 myLastPnt.Y() + myDir1.Y(),

341 myLastPnt.Z() + myDir1.Z());

342 BRepLib_MakeEdge ee2(myLastPnt, p2);

343 BRepExtrema_ExtCF ext2(ee2, LastFace);

344 if (ext2.NbExt() == 1

345 && ext2.SquareDistance(1)

346 <= BRep_Tool::Tolerance(LastFace) * BRep_Tool::Tolerance(LastFace))

347 {

348 Sliding = Standard_True;

349 }

350 else

351 {

352 Sliding = Standard_False;

353 }

354 }

355 else

356 {

357 Sliding = Standard_False;

358 }

359 }

360 }

361

362 // Construct a great profile that goes till the bounding box

363 // -> by tangency with the first and the last edge of the Wire

364 // -> by normals to the support faces : statistically better

365 // Intersect everything to find the final profile

366

367 // ---case of sliding : construction of the profile face

368 if (Sliding)

369 {

370 #ifdef OCCT_DEBUG

371 if (trc)

372 std::cout << " still Sliding" << std::endl;

373 #endif

374 TopoDS_Face Prof;

375 Standard_Boolean ProfileOK;

376 ProfileOK = SlidingProfile(Prof,

377 RevolRib,

378 myTol,

379 Concavite,

380 myPln,

381 BndFace,

382 CheckPnt,

383 FirstFace,

384 LastFace,

385 FirstVertex,

386 LastVertex,

387 FirstEdge,

388 LastEdge);

389

390 if (!ProfileOK)

391 {

392 #ifdef OCCT_DEBUG

393 if (trc)

394 {

395 std::cout << "Not computable" << std::endl;

396 std::cout << "Face profile not computable" << std::endl;

397 }

398 #endif

399 myStatusError = BRepFeat_NoFaceProf;

400 NotDone();

401 return;

402 }

403

404 // ---Propagation on faces of the initial shape

405 // to find the faces concerned by the rib

406 Standard_Boolean falseside = Standard_True;

407 Sliding = Propagate(SliList, Prof, myFirstPnt, myLastPnt, falseside);

408 // Control if there is everything required to have the material at the proper side

409 if (falseside == Standard_False)

410 {

411 #ifdef OCCT_DEBUG

412 std::cout << "Verify plane and wire orientation" << std::endl;

413 #endif

414 myStatusError = BRepFeat_FalseSide;

415 NotDone();

416 return;

417 }

418 }

419

420 // ---Generation of the base of the rib profile

421

422 TopoDS_Wire w;

423 BB.MakeWire(w);

424 TopoDS_Edge thePreviousEdge;

425 TopoDS_Vertex theFV;

426 thePreviousEdge.Nullify();

427

428 // calculate the number of edges to fill the map

429 Standard_Integer counter = 1;

430

431 // ---case of sliding

432 if (Sliding && !myListOfEdges.IsEmpty())

433 {

434 BRepTools_WireExplorer EX1(myWire);

435 for (; EX1.More(); EX1.Next())

436 {

437 const TopoDS_Edge& E = EX1.Current();

438 if (!myLFMap.IsBound(E))

439 {

440 TopTools_ListOfShape theTmpList;

441 myLFMap.Bind(E, theTmpList);

442 }

443 if (E.IsSame(FirstEdge))

444 {

445 Standard_Real f, l;

446 Handle(Geom_Curve) cc = BRep_Tool::Curve(E, f, l);

447 cc = new Geom_TrimmedCurve(cc, f, l);

448 gp_Pnt pt;

449 if (!FirstEdge.IsSame(LastEdge))

450 {

451 pt = BRep_Tool::Pnt(TopExp::LastVertex(E, Standard_True));

452 }

453 else

454 {

455 pt = myLastPnt;

456 Standard_Real fpar = IntPar(cc, myFirstPnt);

457 Standard_Real lpar = IntPar(cc, pt);

458 if (fpar > lpar)

459 {

460 cc = cc->Reversed();

461 }

462 }

463 TopoDS_Edge ee1;

464 if (thePreviousEdge.IsNull())

465 {

466 BRepLib_MakeVertex v1(myFirstPnt);

467 BRepLib_MakeVertex v2(pt);

468 BRepLib_MakeEdge e(cc, v1, v2);

469 ee1 = TopoDS::Edge(e.Shape());

470 }

471 else

472 {

473 const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge, Standard_True);

474 BRepLib_MakeVertex v2(pt);

475

476 BRepLib_MakeEdge e(cc, v1, v2);

477 ee1 = TopoDS::Edge(e.Shape());

478 }

479 TopoDS_Shape aLocalShape = ee1.Oriented(E.Orientation());

480 ee1 = TopoDS::Edge(aLocalShape);

481 // ee1 = TopoDS::Edge(ee1.Oriented(E.Orientation()));

482 if (counter == 1)

483 theFV = TopExp::FirstVertex(ee1, Standard_True);

484 myLFMap(E).Append(ee1);

485 BB.Add(w, ee1);

486 thePreviousEdge = ee1;

487 counter++;

488 EX1.Next();

489 break;

490 }

491 }

492

493 // Case of several edges

494 if (!FirstEdge.IsSame(LastEdge))

495 {

496 for (; EX1.More(); EX1.Next())

497 {

498 const TopoDS_Edge& E = EX1.Current();

499 if (!myLFMap.IsBound(E))

500 {

501 TopTools_ListOfShape thelist1;

502 myLFMap.Bind(E, thelist1);

503 }

504 theList.Append(E);

505 Standard_Real f, l;

506 if (!E.IsSame(LastEdge))

507 {

508 Handle(Geom_Curve) ccc = BRep_Tool::Curve(E, f, l);

509 TopoDS_Vertex v1, v2;

510 if (!thePreviousEdge.IsNull())

511 {

512 v1 = TopExp::LastVertex(thePreviousEdge, Standard_True);

513 v2 = TopExp::LastVertex(E, Standard_True);

514 }

515 else

516 {

517 // v1 = TopExp::LastVertex(E,Standard_True);

518 v1 = TopExp::FirstVertex(E, Standard_True);

519 v2 = TopExp::LastVertex(E, Standard_True);

520 }

521 BRepLib_MakeEdge E1(ccc, v1, v2);

522 TopoDS_Edge E11 = TopoDS::Edge(E1.Shape());

523 TopoDS_Shape aLocalShape = E11.Oriented(E.Orientation());

524 E11 = TopoDS::Edge(aLocalShape);

525 // E11 = TopoDS::Edge(E11.Oriented(E.Orientation()));

526 thePreviousEdge = E11;

527 myLFMap(E).Append(E11);

528 BB.Add(w, E11);

529 if (counter == 1)

530 theFV = TopExp::FirstVertex(E11, Standard_True);

531 counter++;

532 }

533 else

534 {

535 Handle(Geom_Curve) cc = BRep_Tool::Curve(E, f, l);

536 gp_Pnt pf = BRep_Tool::Pnt(TopExp::FirstVertex(E, Standard_True));

537 gp_Pnt pl = myLastPnt;

538 TopoDS_Edge ee;

539 if (thePreviousEdge.IsNull())

540 {

541 BRepLib_MakeEdge e(cc, pf, pl);

542 ee = TopoDS::Edge(e.Shape());

543 }

544 else

545 {

546 const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge, Standard_True);

547 BRepLib_MakeVertex v2(pl);

548 BRepLib_MakeEdge e(cc, v1, v2);

549 ee = TopoDS::Edge(e.Shape());

550 }

551 TopoDS_Shape aLocalShape = ee.Oriented(E.Orientation());

552 ee = TopoDS::Edge(aLocalShape);

553 // ee = TopoDS::Edge(ee.Oriented(E.Orientation()));

554 BB.Add(w, ee);

555 myLFMap(E).Append(ee);

556 if (counter == 1)

557 theFV = TopExp::FirstVertex(ee, Standard_True);

558 thePreviousEdge = ee;

559 counter++;

560 break;

561 }

562 }

563 }

564

565 TopTools_ListIteratorOfListOfShape it(myListOfEdges);

566 Standard_Boolean FirstOK = Standard_False;

567 Standard_Boolean LastOK = Standard_False;

568

569 gp_Pnt theLastPnt = myLastPnt;

570 Standard_Integer sens = 0;

571 TopoDS_Edge theEdge, theLEdge, theFEdge;

572 Standard_Integer counter1 = counter;

573 TopTools_ListOfShape NewListOfEdges;

574 NewListOfEdges.Clear();

575 while (!FirstOK)

576 {

577 const TopoDS_Edge& edg = TopoDS::Edge(it.Value());

578 gp_Pnt fp, lp;

579 Standard_Real f, l;

580 Handle(Geom_Curve) ccc = BRep_Tool::Curve(edg, f, l);

581 Handle(Geom_TrimmedCurve) cc = new Geom_TrimmedCurve(ccc, f, l);

582 if (edg.Orientation() == TopAbs_REVERSED)

583 cc->Reverse();

584

585 fp = cc->Value(cc->FirstParameter());

586 lp = cc->Value(cc->LastParameter());

587 Standard_Real dist = fp.Distance(theLastPnt);

588 if (dist <= myTol)

589 {

590 sens = 1;

591 LastOK = Standard_True;

592 }

593 else

594 {

595 dist = lp.Distance(theLastPnt);

596 if (dist <= myTol)

597 {

598 sens = 2;

599 LastOK = Standard_True;

600 cc->Reverse();

601 }

602 }

603 Standard_Integer FirstFlag = 0;

604 if (sens == 1 && lp.Distance(myFirstPnt) <= myTol)

605 {

606 FirstOK = Standard_True;

607 FirstFlag = 1;

608 }

609 else if (sens == 2 && fp.Distance(myFirstPnt) <= myTol)

610 {

611 FirstOK = Standard_True;

612 FirstFlag = 2;

613 }

614

615 if (LastOK)

616 {

617 TopoDS_Edge eeee;

618 Standard_Real fpar = cc->FirstParameter();

619 Standard_Real lpar = cc->LastParameter();

620 if (!FirstOK)

621 {

622 if (thePreviousEdge.IsNull())

623 {

624 BRepLib_MakeEdge e(cc, fpar, lpar);

625 eeee = TopoDS::Edge(e.Shape());

626 }

627 else

628 {

629 const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge, Standard_True);

630 BB.UpdateVertex(v1, dist);

631 BRepLib_MakeVertex v2(cc->Value(lpar));

632 TopoDS_Vertex nv = v2.Vertex();

633 BRepLib_MakeEdge e(cc, v1, nv);

634 eeee = TopoDS::Edge(e.Shape());

635 }

636 }

637 else

638 {

639 if (thePreviousEdge.IsNull())

640 {

641 BRepLib_MakeVertex v1(cc->Value(fpar));

642 BRepLib_MakeEdge e(cc, v1, theFV);

643 eeee = TopoDS::Edge(e.Shape());

644 }

645 else

646 {

647 const TopoDS_Vertex& v1 = TopExp::LastVertex(thePreviousEdge, Standard_True);

648 BRepLib_MakeEdge e(cc, v1, theFV);

649 eeee = TopoDS::Edge(e.Shape());

650 }

651 }

652

653 thePreviousEdge = eeee;

654 BB.Add(w, eeee);

655 if (counter == 1)

656 theFV = TopExp::FirstVertex(eeee, Standard_True);

657 counter1++;

658 NewListOfEdges.Append(edg);

659 theEdge = eeee;

660

661 if (dist <= myTol)

662 theFEdge = edg;

663 theLastPnt = BRep_Tool::Pnt(TopExp::LastVertex(theEdge, Standard_True));

664 }

665

666 if (FirstFlag == 1)

667 {

668 theLEdge = edg;

669 }

670 else if (FirstFlag == 2)

671 {

672 theLEdge = theEdge;

673 }

674

675 if (LastOK)

676 {

677 myListOfEdges.Remove(it);

678 it.Initialize(myListOfEdges);

679 LastOK = Standard_False;

680 }

681 else if (it.More())

682 it.Next();

683 else

684 {

685 Sliding = Standard_False;

686 break;

687 }

688 sens = 0;

689 }

690

691 TopTools_DataMapOfShapeListOfShape SlidMap;

692 SlidMap.Clear();

693

694 if (Sliding && counter1 > counter)

695 {

696 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm;

697 TopExp_Explorer EX2(w, TopAbs_EDGE);

698 Standard_Integer ii = 0;

699 for (; EX2.More(); EX2.Next())

700 {

701 const TopoDS_Edge& E = TopoDS::Edge(EX2.Current());

702 ii++;

703 if (ii >= counter && ii <= counter1)

704 {

705 it.Initialize(NewListOfEdges);

706 Standard_Integer jj = 0;

707 for (; it.More(); it.Next())

708 {

709 const TopoDS_Edge& e2 = TopoDS::Edge(it.Value());

710 jj++;

711 if (jj == (ii - counter + 1))

712 {

713 itm.Initialize(mySlface);

714 for (; itm.More(); itm.Next())

715 {

716 const TopoDS_Face& fac = TopoDS::Face(itm.Key());

717 const TopTools_ListOfShape& ledg = itm.Value();

718 TopTools_ListIteratorOfListOfShape itedg(ledg);

719 // Standard_Integer iiii = 0;

720 for (; itedg.More(); itedg.Next())

721 {

722 const TopoDS_Edge& e1 = TopoDS::Edge(itedg.Value());

723 if (e1.IsSame(e2))

724 {

725 if (!SlidMap.IsBound(fac))

726 {

727 TopTools_ListOfShape thelist2;

728 SlidMap.Bind(fac, thelist2);

729 }

730 SlidMap(fac).Append(E);

731 }

732 }

733 }

734 }

735 }

736 }

737 }

738 }

739

740 mySlface.Clear();

741 mySlface = SlidMap;

742 }

743

744 // ---Arguments of LocOpe_LinearForm : arguments of the prism sliding

745 if (Sliding)

746 {

747 TopoDS_Face F;

748 BB.MakeFace(F, myPln, myTol);

749 w.Closed(BRep_Tool::IsClosed(w));

750 BB.Add(F, w);

751 // BRepLib_MakeFace F(myPln->Pln(),w, Standard_True);

752 mySkface = F;

753 myPbase = mySkface;

754 mySUntil.Nullify();

755 }

756

757 // ---Case without sliding : construction of the profile face

758 if (!Sliding)

759 {

760 #ifdef OCCT_DEBUG

761 if (trc)

762 {

763 if (Modify)

764 std::cout << " Sliding failure" << std::endl;

765 std::cout << " no Sliding" << std::endl;

766 }

767 #endif

768 TopoDS_Face Prof;

769 Standard_Boolean ProfileOK;

770 ProfileOK = NoSlidingProfile(Prof,

771 RevolRib,

772 myTol,

773 Concavite,

774 myPln,

775 bnd,

776 BndFace,

777 CheckPnt,

778 FirstFace,

779 LastFace,

780 FirstVertex,

781 LastVertex,

782 FirstEdge,

783 LastEdge,

784 OnFirstFace,

785 OnLastFace);

786

787 if (!ProfileOK)

788 {

789 #ifdef OCCT_DEBUG

790 if (trc)

791 {

792 std::cout << "Not computable" << std::endl;

793 std::cout << " Face profile not computable" << std::endl;

794 }

795 #endif

796 myStatusError = BRepFeat_NoFaceProf;

797 NotDone();

798 return;

799 }

800

801 // ---Propagation on faces of the initial shape

802 // to find the faces concerned by the rib

803 Standard_Boolean falseside = Standard_True;

804 Propagate(SliList, Prof, myFirstPnt, myLastPnt, falseside);

805 // Control if there is everything required to have the material at the proper side

806 if (falseside == Standard_False)

807 {

808 #ifdef OCCT_DEBUG

809 std::cout << "Verify plane and wire orientation" << std::endl;

810 #endif

811 myStatusError = BRepFeat_FalseSide;

812 NotDone();

813 return;

814 }

815

816 mySlface.Clear();

817

818 TopTools_ListIteratorOfListOfShape it;

819 it.Initialize(SliList);

820

821 TopoDS_Shape comp;

822

823 BB.MakeShell(TopoDS::Shell(comp));

824

825 for (; it.More(); it.Next())

826 {

827 BB.Add(comp, it.Value());

828 }

829 comp.Closed(BRep_Tool::IsClosed(comp));

830

831 mySUntil = comp;

832

833 mySkface = Prof;

834 myPbase = Prof;

835 }

836

837 mySliding = Sliding;

838

839 TopExp_Explorer exp;

840 for (exp.Init(mySbase, TopAbs_FACE); exp.More(); exp.Next())

841 {

842 TopTools_ListOfShape thelist3;

843 myMap.Bind(exp.Current(), thelist3);

844 myMap(exp.Current()).Append(exp.Current());

845 }

846 }

847

848 //=======================================================================

849 // function : Add

850 // purpose : add des element de collage

851 //=======================================================================

852

853 void BRepFeat_MakeLinearForm::Add(const TopoDS_Edge& E, const TopoDS_Face& F)

854 {

855 #ifdef OCCT_DEBUG

856 Standard_Boolean trc = BRepFeat_GettraceFEAT();

857 if (trc)

858 std::cout << "BRepFeat_MakeLinearForm::Add" << std::endl;

859 #endif

860 if (mySlface.IsEmpty())

861 {

862 TopExp_Explorer exp;

863 for (exp.Init(mySbase, TopAbs_FACE); exp.More(); exp.Next())

864 {

865 if (exp.Current().IsSame(F))

866 {

867 break;

868 }

869 }

870 if (!exp.More())

871 {

872 throw Standard_ConstructionError();

873 }

874

875 if (!mySlface.IsBound(F))

876 {

877 TopTools_ListOfShape thelist;

878 mySlface.Bind(F, thelist);

879 }

880 TopTools_ListIteratorOfListOfShape itl(mySlface(F));

881 for (; itl.More(); itl.Next())

882 {

883 if (itl.Value().IsSame(E))

884 {

885 break;

886 }

887 }

888 if (!itl.More())

889 {

890 mySlface(F).Append(E);

891 }

892 }

893 }

894

895 //=======================================================================

896 // function : Perform

897 // purpose : construction of rib from a profile and the initial shape

898 //=======================================================================

899

900 void BRepFeat_MakeLinearForm::Perform()

901 {

902 #ifdef OCCT_DEBUG

903 Standard_Boolean trc = BRepFeat_GettraceFEAT();

904 if (trc)

905 std::cout << "BRepFeat_MakeLinearForm::Perform()" << std::endl;

906 #endif

907 if (mySbase.IsNull() || mySkface.IsNull() || myPbase.IsNull())

908 {

909 #ifdef OCCT_DEBUG

910 if (trc)

911 std::cout << " Fields not initialized" << std::endl;

912 #endif

913 myStatusError = BRepFeat_NotInitialized;

914 NotDone();

915 return;

916 }

917

918 gp_Vec nulldir(0, 0, 0);

919

920 Standard_Real Length = myDir.Magnitude() + myDir1.Magnitude();

921

922 myGluedF.Clear();

923

924 if (!mySUntil.IsNull())

925 myPerfSelection = BRepFeat_SelectionU;

926 else

927 myPerfSelection = BRepFeat_NoSelection;

928

929 gp_Dir dir(myDir);

930 gp_Vec V = Length * dir;

931

932 LocOpe_LinearForm theForm;

933

934 if (myDir1.IsEqual(nulldir, Precision::Confusion(), Precision::Confusion()))

935 theForm.Perform(myPbase, V, myFirstPnt, myLastPnt);

936 else

937 theForm.Perform(myPbase, V, myDir1, myFirstPnt, myLastPnt);

938

939 TopoDS_Shape VraiForm = theForm.Shape(); // primitive of the rib

940

941 myFacesForDraft.Append(theForm.FirstShape());

942 myFacesForDraft.Append(theForm.LastShape());

943 MajMap(myPbase, theForm, myMap, myFShape, myLShape); // management of descendants

944

945 TopExp_Explorer exx(myPbase, TopAbs_EDGE);

946 for (; exx.More(); exx.Next())

947 {

948 const TopoDS_Edge& e = TopoDS::Edge(exx.Current());

949 if (!myMap.IsBound(e))

950 {

951 #ifdef OCCT_DEBUG

952 if (trc)

953 std::cout << " Sliding face not in Base shape" << std::endl;

954 #endif

955 myStatusError = BRepFeat_IncSlidFace;

956 NotDone();

957 return;

958 }

959 }

960

961 myGShape = VraiForm;

962 SetGluedFaces(mySlface, theForm, myGluedF); // management of sliding faces

963

964 if (!myGluedF.IsEmpty() && !mySUntil.IsNull())

965 {

966 #ifdef OCCT_DEBUG

967 if (trc)

968 {

969 std::cout << "The case is not computable" << std::endl;

970 std::cout << " Glued faces not empty and Until shape not null" << std::endl;

971 }

972 #endif

973 myStatusError = BRepFeat_InvShape;

974 NotDone();

975 return;

976 }

977

978 LFPerform();

979

980 /*

981

982 TopExp_Explorer expr(mySbase, TopAbs_FACE);

983 char nom1[20], nom2[20];

984 Standard_Integer ii = 0;

985 for(; expr.More(); expr.Next()) {

986 ii++;

987 Sprintf(nom1, "faceinitial_%d", ii);

988 DBRep::Set(nom1, expr.Current());

989 Standard_Integer jj = 0;

990 const TopTools_ListOfShape& list = Modified(expr.Current());

991 TopTools_ListIteratorOfListOfShape ite(list);

992 for(; ite.More(); ite.Next()) {

993 jj++;

994 Sprintf(nom2, "facemodifie_%d_%d", ii, jj);

995 DBRep::Set(nom2, ite.Value());

996 }

997 }

998

999 expr.Init(myWire, TopAbs_EDGE);

1000 ii=0;

1001 for(; expr.More(); expr.Next()) {

1002 ii++;

1003 Sprintf(nom1, "edgeinitial_%d", ii);

1004 DBRep::Set(nom1, expr.Current());

1005 Standard_Integer jj = 0;

1006 const TopTools_ListOfShape& genf = Generated(expr.Current());

1007 TopTools_ListIteratorOfListOfShape ite(genf);

1008 for(; ite.More(); ite.Next()) {

1009 jj++;

1010 Sprintf(nom2, "egdegeneree_%d_%d", ii, jj);

1011 DBRep::Set(nom2, ite.Value());

1012 }

1013 }

1014 */

1015 }

1016

1017 //=======================================================================

1018 // function : Propagate

1019 // purpose : propagation on faces of the initial shape, find

1020 // faces concerned by the rib

1021 //=======================================================================

1022 Standard_Boolean BRepFeat_MakeLinearForm::Propagate(TopTools_ListOfShape& SliList,

1023 const TopoDS_Face& fac,

1024 const gp_Pnt& Firstpnt,

1025 const gp_Pnt& Lastpnt,

1026 Standard_Boolean& falseside)

1027 {

1028 #ifdef OCCT_DEBUG

1029 Standard_Boolean trc = BRepFeat_GettraceFEATRIB();

1030 if (trc)

1031 std::cout << "BRepFeat_MakeLinearForm::Propagate" << std::endl;

1032 #endif

1033 gp_Pnt Firstpoint = Firstpnt;

1034 gp_Pnt Lastpoint = Lastpnt;

1035

1036 Standard_Boolean result = Standard_True;

1037 TopoDS_Face CurrentFace, saveFace;

1038 CurrentFace = TopoDS::Face(SliList.First());

1039 saveFace = CurrentFace;

1040

1041 Standard_Boolean LastOK = Standard_False, FirstOK = Standard_False;

1042 Standard_Boolean v1OK = Standard_False, v2OK = Standard_False;

1043 TopoDS_Vertex v1, v2, v3, v4, ve1, ve2;

1044

1045 BRepAlgoAPI_Section sect(fac, CurrentFace, Standard_False);

1046

1047 sect.Approximation(Standard_True);

1048 sect.Build();

1049

1050 TopExp_Explorer Ex;

1051 TopoDS_Edge eb, ec;

1052 gp_Pnt p1, p2;

1053 Standard_Real t1 = 0., t2 = 0.;

1054 Standard_Boolean c1f, c2f, c1l, c2l;

1055

1056 for (Ex.Init(sect.Shape(), TopAbs_EDGE); Ex.More(); Ex.Next())

1057 {

1058 ec = TopoDS::Edge(Ex.Current());

1059 v1 = TopExp::FirstVertex(ec, Standard_True);

1060 v2 = TopExp::LastVertex(ec, Standard_True);

1061 p1 = BRep_Tool::Pnt(v1);

1062 p2 = BRep_Tool::Pnt(v2);

1063 t1 = BRep_Tool::Tolerance(v1);

1064 t2 = BRep_Tool::Tolerance(v2);

1065 c1f = p1.Distance(Firstpoint) <= t1;

1066 c2f = p2.Distance(Firstpoint) <= t2;

1067 c1l = p1.Distance(Lastpoint) <= t1;

1068 c2l = p2.Distance(Lastpoint) <= t2;

1069 if (c1f || c2f || c1l || c2l)

1070 {

1071 eb = ec;

1072 if (c1f || c1l)

1073 v1OK = Standard_True;

1074 if (c2f || c2l)

1075 v2OK = Standard_True;

1076 if (c1f || c2f)

1077 FirstOK = Standard_True;

1078 if (c1l || c2l)

1079 LastOK = Standard_True;

1080 break;

1081 }

1082 }

1083

1084 if (eb.IsNull())

1085 {

1086 falseside = Standard_False;

1087 return Standard_False;

1088 }

1089 TopTools_ListOfShape thelist;

1090 mySlface.Bind(CurrentFace, thelist);

1091 mySlface(CurrentFace).Append(eb);

1092

1093 myListOfEdges.Clear();

1094 myListOfEdges.Append(eb);

1095

1096 // two points are on the same face.

1097 if (LastOK && FirstOK)

1098 {

1099 return result;

1100 }

1101

1102 TopTools_IndexedDataMapOfShapeListOfShape mapedges;

1103 TopExp::MapShapesAndAncestors(mySbase, TopAbs_EDGE, TopAbs_FACE, mapedges);

1104 TopExp_Explorer ex;

1105 TopoDS_Edge FirstEdge;

1106 BRep_Builder BB;

1107

1108 TopoDS_Vertex Vprevious;

1109 gp_Pnt ptprev;

1110 Standard_Real dp;

1111

1112 while (!(LastOK && FirstOK))

1113 {

1114 if (v1OK)

1115 {

1116 Vprevious = v2;

1117 ptprev = p2;

1118 }

1119 else

1120 {

1121 Vprevious = v1;

1122 ptprev = p1;

1123 }

1124

1125 // find edge connected to v1 or v2:

1126 for (ex.Init(CurrentFace, TopAbs_EDGE); ex.More(); ex.Next())

1127 {

1128 const TopoDS_Edge& rfe = TopoDS::Edge(ex.Current());

1129

1130 BRepExtrema_ExtPC projF(Vprevious, rfe);

1131

1132 if (projF.IsDone() && projF.NbExt() >= 1)

1133 {

1134 Standard_Real dist2min = RealLast();

1135 Standard_Integer index = 0;

1136 for (Standard_Integer sol = 1; sol <= projF.NbExt(); sol++)

1137 {

1138 if (projF.SquareDistance(sol) <= dist2min)

1139 {

1140 index = sol;

1141 dist2min = projF.SquareDistance(sol);

1142 }

1143 }

1144 if (index != 0)

1145 {

1146 if (dist2min <= BRep_Tool::Tolerance(rfe) * BRep_Tool::Tolerance(rfe))

1147 {

1148 FirstEdge = rfe;

1149 // If the edge is not perpendicular to the plane of the rib

1150 // it is required to set Sliding(result) to false.

1151 if (result)

1152 {

1153 result = Standard_False;

1154 ve1 = TopExp::FirstVertex(rfe, Standard_True);

1155 ve2 = TopExp::LastVertex(rfe, Standard_True);

1156 BRepExtrema_ExtPF perp(ve1, fac);

1157 if (perp.IsDone())

1158 {

1159 gp_Pnt pe1 = perp.Point(1);

1160 perp.Perform(ve2, fac);

1161 if (perp.IsDone())

1162 {

1163 gp_Pnt pe2 = perp.Point(1);

1164 if (pe1.Distance(pe2) <= BRep_Tool::Tolerance(rfe))

1165 result = Standard_True;

1166 }

1167 }

1168 }

1169 break;

1170 }

1171 }

1172 }

1173 }

1174

1175 const TopTools_ListOfShape& L = mapedges.FindFromKey(FirstEdge);

1176 TopTools_ListIteratorOfListOfShape It(L);

1177

1178 for (; It.More(); It.Next())

1179 {

1180 const TopoDS_Face& FF = TopoDS::Face(It.Value());

1181 if (!FF.IsSame(CurrentFace))

1182 {

1183 CurrentFace = FF;

1184 break;

1185 }

1186 }

1187

1188 BRepAlgoAPI_Section sectf(fac, CurrentFace, Standard_False);

1189 sectf.Approximation(Standard_True);

1190 sectf.Build();

1191

1192 TopoDS_Edge edg1;

1193 for (Ex.Init(sectf.Shape(), TopAbs_EDGE); Ex.More(); Ex.Next())

1194 {

1195 edg1 = TopoDS::Edge(Ex.Current());

1196 v1 = TopExp::FirstVertex(edg1, Standard_True);

1197 v2 = TopExp::LastVertex(edg1, Standard_True);

1198 t1 = BRep_Tool::Tolerance(v1);

1199 t2 = BRep_Tool::Tolerance(v2);

1200 p1 = BRep_Tool::Pnt(v1);

1201 p2 = BRep_Tool::Pnt(v2);

1202 v1OK = p1.Distance(ptprev) <= t1;

1203 v2OK = p2.Distance(ptprev) <= t2;

1204 if (v1OK || v2OK)

1205 break;

1206 }

1207

1208 if (v1OK)

1209 {

1210 if (!FirstOK)

1211 {

1212 dp = p2.Distance(Firstpoint);

1213 if (dp <= 2 * t2)

1214 {

1215 FirstOK = Standard_True;

1216 BB.UpdateVertex(v2, dp);

1217 }

1218 }

1219 if (!LastOK)

1220 {

1221 dp = p2.Distance(Lastpoint);

1222 if (dp <= 2 * t2)

1223 {

1224 LastOK = Standard_True;

1225 BB.UpdateVertex(v2, dp);

1226 }

1227 }

1228 }

1229 else if (v2OK)

1230 {

1231 if (!FirstOK)

1232 {

1233 dp = p1.Distance(Firstpoint);

1234 if (dp <= 2 * t1)

1235 {

1236 FirstOK = Standard_True;

1237 BB.UpdateVertex(v1, dp);

1238 }

1239 }

1240 if (!LastOK)

1241 {

1242 dp = p1.Distance(Lastpoint);

1243 if (dp <= 2 * t1)

1244 {

1245 LastOK = Standard_True;

1246 BB.UpdateVertex(v1, dp);

1247 }

1248 }

1249 }

1250 else

1251 {

1252 // end by chaining the section

1253 return Standard_False;

1254 }

1255 TopTools_ListOfShape thelist1;

1256 mySlface.Bind(CurrentFace, thelist1);

1257 mySlface(CurrentFace).Append(edg1);

1258 myListOfEdges.Append(edg1);

1259 }

1260

1261 return result;

1262 }

1263

1264 //=======================================================================

1265 // function : MajMap

1266 // purpose : management of descendants

1267 //=======================================================================

1268

1269 static void MajMap(const TopoDS_Shape& theB,

1270 const LocOpe_LinearForm& theP,

1271 TopTools_DataMapOfShapeListOfShape& theMap, // myMap

1272 TopoDS_Shape& theFShape, // myFShape

1273 TopoDS_Shape& theLShape) // myLShape

1274 {

1275 TopExp_Explorer exp(theP.FirstShape(), TopAbs_WIRE);

1276 if (exp.More())

1277 {

1278 theFShape = exp.Current();

1279 TopTools_ListOfShape thelist;

1280 theMap.Bind(theFShape, thelist);

1281 for (exp.Init(theP.FirstShape(), TopAbs_FACE); exp.More(); exp.Next())

1282 {

1283 theMap(theFShape).Append(exp.Current());

1284 }

1285 }

1286

1287 exp.Init(theP.LastShape(), TopAbs_WIRE);

1288 if (exp.More())

1289 {

1290 theLShape = exp.Current();

1291 TopTools_ListOfShape thelist1;

1292 theMap.Bind(theLShape, thelist1);

1293 for (exp.Init(theP.LastShape(), TopAbs_FACE); exp.More(); exp.Next())

1294 {

1295 theMap(theLShape).Append(exp.Current());

1296 }

1297 }

1298

1299 for (exp.Init(theB, TopAbs_EDGE); exp.More(); exp.Next())

1300 {

1301 if (!theMap.IsBound(exp.Current()))

1302 {

1303 TopTools_ListOfShape thelist2;

1304 theMap.Bind(exp.Current(), thelist2);

1305 theMap(exp.Current()) = theP.Shapes(exp.Current());

1306 }

1307 }

1308 }

1309

1310 //=======================================================================

1311 // function : SetGluedFaces

1312 // purpose : management of faces of gluing

1313 //=======================================================================

1314

1315 static void SetGluedFaces(const TopTools_DataMapOfShapeListOfShape& theSlmap,

1316 LocOpe_LinearForm& thePrism,

1317 TopTools_DataMapOfShapeShape& theMap)

1318 {

1319 // Slidings

1320 TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm(theSlmap);

1321 if (!theSlmap.IsEmpty())

1322 {

1323 for (; itm.More(); itm.Next())

1324 {

1325 const TopoDS_Face& fac = TopoDS::Face(itm.Key());

1326 const TopTools_ListOfShape& ledg = itm.Value();

1327 TopTools_ListIteratorOfListOfShape it;

1328 for (it.Initialize(ledg); it.More(); it.Next())

1329 {

1330 const TopTools_ListOfShape& gfac = thePrism.Shapes(it.Value());

1331 if (gfac.Extent() != 1)

1332 {

1333 #ifdef OCCT_DEBUG

1334 std::cout << "Pb SetGluedFace" << std::endl;

1335 #endif

1336 }

1337 theMap.Bind(gfac.First(), fac);

1338 }

1339 }

1340 }

1341 }