/src/contrib/geom-5.1.2.7/src/NMTTools/NMTTools_Tools.cpp

http://pythonocc.googlecode.com/ · C++ · 613 lines · 401 code · 14 blank · 198 comment · 46 complexity · 50d5230ff7c120f849a8991ae7ad52fc MD5 · raw file 

    

  1. //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
    2. 

  2. //
    3. 

  3. //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
    4. 

  4. //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
    5. 

  5. //
    6. 

  6. //  This library is free software; you can redistribute it and/or
    7. 

  7. //  modify it under the terms of the GNU Lesser General Public
    8. 

  8. //  License as published by the Free Software Foundation; either
    9. 

  9. //  version 2.1 of the License.
    10. 

  10. //
    11. 

  11. //  This library is distributed in the hope that it will be useful,
    12. 

  12. //  but WITHOUT ANY WARRANTY; without even the implied warranty of
    13. 

  13. //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    14. 

  14. //  Lesser General Public License for more details.
    15. 

  15. //
    16. 

  16. //  You should have received a copy of the GNU Lesser General Public
    17. 

  17. //  License along with this library; if not, write to the Free Software
    18. 

  18. //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
    19. 

  19. //
    20. 

  20. //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
    21. 

  21. //
    22. 

  22. // File:	NMTTools_Tools.cxx
    23. 

  23. // Created:	Mon Dec  8 10:35:15 2003
    24. 

  24. // Author:	Peter KURNEV
    25. 

  25. //		<pkv@irinox>
    26. 

  26. //
    27. 

  27. #include <NMTTools_Tools.ixx>
    28. 

  28. 

  29. #include <TColStd_IndexedMapOfInteger.hxx>
    30. 

  30. 

  31. #include <gp_Pnt.hxx>
    32. 

  32. #include <gp_XYZ.hxx>
    33. 

  33. #include <gp_Pnt2d.hxx>
    34. 

  34. 

  35. #include <Geom_Surface.hxx>
    36. 

  36. #include <GeomAPI_ProjectPointOnSurf.hxx>
    37. 

  37. 

  38. #include <TopoDS.hxx>
    39. 

  39. #include <TopoDS_Vertex.hxx>
    40. 

  40. #include <TopoDS_Shape.hxx>
    41. 

  41. #include <TopoDS_Edge.hxx>
    42. 

  42. 

  43. #include <TopExp.hxx>
    44. 

  44. 

  45. #include <TopTools_ListIteratorOfListOfShape.hxx>
    46. 

  46. #include <TopTools_IndexedMapOfShape.hxx>
    47. 

  47. 

  48. #include <BRep_Tool.hxx>
    49. 

  49. #include <BRep_Builder.hxx>
    50. 

  50. #include <BRepTools.hxx>
    51. 

  51. 

  52. #include <BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger.hxx>
    53. 

  53. #include <BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger.hxx>
    54. 

  54. 

  55. #include <BOPTools_VVInterference.hxx>
    56. 

  56. #include <BOPTools_SSInterference.hxx>
    57. 

  57. 

  58. #include <BOPTools_Tools2D.hxx>
    59. 

  59. #include <BOPTools_Tools.hxx>
    60. 

  60. #include <NMTTools_ListIteratorOfListOfCoupleOfShape.hxx>
    61. 

  61. #include <NMTTools_IndexedDataMapOfShapeIndexedMapOfShape.hxx>
    62. 

  62. #include <NMTTools_CoupleOfShape.hxx>
    63. 

  63. #include <TopTools_IndexedMapOfShape.hxx>
    64. 

  64. #include <Geom2d_Curve.hxx>
    65. 

  65. #include <Geom_Curve.hxx>
    66. 

  66. #include <Geom_TrimmedCurve.hxx>
    67. 

  67. #include <BOPTools_Tools2D.hxx>
    68. 

  68. #include <BRepLib.hxx>
    69. 

  69. #include <BOPTools_Tools3D.hxx>
    70. 

  70. #include <TopExp_Explorer.hxx>
    71. 

  71. //
    72. 

  72. #include <TopTools_MapOfShape.hxx>
    73. 

  73. #include <TopTools_MapIteratorOfMapOfShape.hxx>
    74. 

  74. #include <TopoDS_Iterator.hxx>
    75. 

  75. 

  76. static 
    77. 

  77.   void ProcessBlock(const Standard_Integer iV,
    78. 

  78. 		    const BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMCV,
    79. 

  79. 		    TColStd_IndexedMapOfInteger& aProcessed,
    80. 

  80. 		    TColStd_IndexedMapOfInteger& aChain);
    81. 

  81. static
    82. 

  82.   void ProcessBlock(const TopoDS_Shape& aF,
    83. 

  83. 		    const NMTTools_IndexedDataMapOfShapeIndexedMapOfShape& aMCV,
    84. 

  84. 		    TopTools_IndexedMapOfShape& aProcessed,
    85. 

  85. 		    TopTools_IndexedMapOfShape& aChain);
    86. 

  86. 

  87. //modified by NIZNHY-PKV Thu Nov 16 10:46:53 2006f SKL/PartC5
    88. 

  88. //=======================================================================
    89. 

  89. // function: UpdateEdge
    90. 

  90. // purpose: 
    91. 

  91. //=======================================================================
    92. 

  92.   void  NMTTools_Tools::UpdateEdge(const TopoDS_Edge& aE,
    93. 

  93. 				   const Standard_Real aTolR)
    94. 

  94. { 
    95. 

  95.   Standard_Real aTolE, aTolES, aTolV;
    96. 

  96.   TopoDS_Iterator aIt;
    97. 

  97.   BRep_Builder aBB;
    98. 

  98.   //
    99. 

  99.   aTolE=BRep_Tool::Tolerance(aE);
    100. 

  100.   aTolES=Max(aTolR, aTolE);
    101. 

  101.   aBB.UpdateEdge(aE, aTolES);
    102. 

  102.   //
    103. 

  103.   aIt.Initialize(aE);
    104. 

  104.   for (; aIt.More(); aIt.Next()) {
    105. 

  105.     const TopoDS_Vertex& aV=TopoDS::Vertex(aIt.Value());
    106. 

  106.     aTolV=BRep_Tool::Tolerance(aV);
    107. 

  107.     if (aTolV<aTolES) {
    108. 

  108.        aBB.UpdateVertex(aV, aTolES);
    109. 

  109.     }
    110. 

  110.   }
    111. 

  111. }
    112. 

  112. //=======================================================================
    113. 

  113. // function: MakePCurve
    114. 

  114. // purpose: 
    115. 

  115. //=======================================================================
    116. 

  116.   void  NMTTools_Tools::MakePCurve(const TopoDS_Edge& aE,
    117. 

  117. 				    const TopoDS_Face& aF,
    118. 

  118. 				    const Handle(Geom2d_Curve)& aC2Dx1)
    119. 

  119. 				    
    120. 

  120. {
    121. 

  121.   Standard_Real aTolE, aT1, aT2, aOutFirst, aOutLast, aOutTol;
    122. 

  122.   Handle(Geom2d_Curve) aC2D, aC2DA;
    123. 

  123.   TopoDS_Face aFFWD;
    124. 

  124.   BRep_Builder aBB;
    125. 

  125.   //
    126. 

  126.   aFFWD=aF;
    127. 

  127.   aFFWD.Orientation(TopAbs_FORWARD);
    128. 

  128.   //
    129. 

  129.   aTolE=BRep_Tool::Tolerance(aE);
    130. 

  130.   //
    131. 

  131.   const Handle(Geom_Curve)& aC3DE=BRep_Tool::Curve(aE, aT1, aT2);
    132. 

  132.   Handle(Geom_TrimmedCurve)aC3DETrim=new Geom_TrimmedCurve(aC3DE, aT1, aT2);
    133. 

  133.   //
    134. 

  134.   aC2D=aC2Dx1;
    135. 

  135.   if (aC2D.IsNull()) { // ?
    136. 

  136.     BOPTools_Tools2D::BuildPCurveForEdgeOnFace(aE, aFFWD);
    137. 

  137.     BOPTools_Tools2D::CurveOnSurface(aE, aFFWD, aC2D, aOutFirst, aOutLast, aOutTol, Standard_True);
    138. 

  138.   }
    139. 

  139.   //
    140. 

  140.   if (aC3DE->IsPeriodic()) {
    141. 

  141.     BOPTools_Tools2D::AdjustPCurveOnFace(aFFWD, aT1, aT2,  aC2D, aC2DA); 
    142. 

  142.   }
    143. 

  143.   else {
    144. 

  144.     BOPTools_Tools2D::AdjustPCurveOnFace(aFFWD, aC3DETrim, aC2D, aC2DA); 
    145. 

  145.   }
    146. 

  146.   //
    147. 

  147.   aBB.UpdateEdge(aE, aC2DA, aFFWD, aTolE);
    148. 

  148.   BRepLib::SameParameter(aE);
    149. 

  149. }
    150. 

  150. /*
    151. 

  151. //=======================================================================
    152. 

  152. // function: MakePCurve
    153. 

  153. // purpose: 
    154. 

  154. //=======================================================================
    155. 

  155.   void  NMTTools_Tools::MakePCurve(const TopoDS_Edge& aE,
    156. 

  156. 				   const TopoDS_Face& aF,
    157. 

  157. 				   const Handle(Geom2d_Curve)& aC2Dx,
    158. 

  158. 				   const Standard_Real aTolR2D)
    159. 

  159. {
    160. 

  160.   Standard_Integer k, aNbV;   
    161. 

  161.   Standard_Real aTolEdge, aTolFact, aTolV, aTolVmax;
    162. 

  162.   Standard_Real aTFirst, aTLast, aOutFirst, aOutLast, aOutTol;
    163. 

  163.   TopoDS_Face aFFWD;
    164. 

  164.   TopTools_IndexedMapOfShape aVMap;
    165. 

  165.   BRep_Builder aBB;
    166. 

  166.   //
    167. 

  167.   aFFWD=aF;
    168. 

  168.   aFFWD.Orientation(TopAbs_FORWARD);
    169. 

  169.   //
    170. 

  170.   aTolEdge=BRep_Tool::Tolerance(aE);
    171. 

  171.   aTolFact=Max(aTolEdge, aTolR2D);
    172. 

  172.   //
    173. 

  173.   TopExp::MapShapes(aE, TopAbs_VERTEX, aVMap);
    174. 

  174.   //
    175. 

  175.   aTolVmax=-1.;
    176. 

  176.   aNbV=aVMap.Extent();
    177. 

  177.   for (k=1; k<=aNbV; ++k) {
    178. 

  178.     const TopoDS_Vertex& aV=TopoDS::Vertex(aVMap(k));
    179. 

  179.     aTolV=BRep_Tool::Tolerance(aV);
    180. 

  180.     if (aTolV>aTolVmax) {
    181. 

  181.       aTolVmax=aTolV;
    182. 

  182.     }
    183. 

  183.   }
    184. 

  184.   //
    185. 

  185.   if (aTolFact>aTolVmax) {
    186. 

  186.     aTolFact=aTolVmax;
    187. 

  187.   }
    188. 

  188.   //
    189. 

  189.   const Handle(Geom_Curve)& aC3DE=BRep_Tool::Curve(aE, aTFirst, aTLast);
    190. 

  190.   Handle(Geom_TrimmedCurve)aC3DETrim=new Geom_TrimmedCurve(aC3DE, aTFirst, aTLast);
    191. 

  191.   //
    192. 

  192.   Handle(Geom2d_Curve) aC2D, aC2DA;
    193. 

  193.   //
    194. 

  194.   aC2D=aC2Dx;
    195. 

  195.   if (aC2D.IsNull()) {
    196. 

  196.     BOPTools_Tools2D::BuildPCurveForEdgeOnFace(aE, aFFWD);
    197. 

  197.     BOPTools_Tools2D::CurveOnSurface(aE, aFFWD, aC2D, aOutFirst, aOutLast, aOutTol, Standard_True);
    198. 

  198.   }
    199. 

  199.   if (aC3DE->IsPeriodic()) {
    200. 

  200.     BOPTools_Tools2D::AdjustPCurveOnFace(aFFWD, aTFirst, aTLast,  aC2D, aC2DA); 
    201. 

  201.   }
    202. 

  202.   else {
    203. 

  203.     BOPTools_Tools2D::AdjustPCurveOnFace(aFFWD, aC3DETrim, aC2D, aC2DA); 
    204. 

  204.   }
    205. 

  205.   //
    206. 

  206.   aBB.UpdateEdge(aE, aC2DA, aFFWD, aTolFact);
    207. 

  207.   BRepLib::SameParameter(aE);
    208. 

  208. }
    209. 

  209. */
    210. 

  210. //modified by NIZNHY-PKV Thu Nov 16 10:46:55 2006t 
    211. 

  211. //=======================================================================
    212. 

  212. // function: IsSplitInOnFace
    213. 

  213. // purpose: 
    214. 

  214. //=======================================================================
    215. 

  215.   Standard_Boolean NMTTools_Tools::IsSplitInOnFace(const TopoDS_Edge& aE,
    216. 

  216. 						   const TopoDS_Face& aF,
    217. 

  217. 						   IntTools_Context& aContext)
    218. 

  218. {
    219. 

  219.   Standard_Boolean bFlag;
    220. 

  220.   Standard_Real aT, aTolE, aTolF, aTol, aDist, aU, aV;
    221. 

  221.   gp_Pnt aP;
    222. 

  222.   gp_Pnt2d aP2D;
    223. 

  223.   //
    224. 

  224.   aTolE=BRep_Tool::Tolerance(aE);
    225. 

  225.   aTolF=BRep_Tool::Tolerance(aF);
    226. 

  226.   aTol=aTolE+aTolF;
    227. 

  227.   //
    228. 

  228.   GeomAPI_ProjectPointOnSurf& aProjector=aContext.ProjPS(aF);
    229. 

  229.   //
    230. 

  230.   aT=BOPTools_Tools2D::IntermediatePoint(aE);
    231. 

  231.   BOPTools_Tools::PointOnEdge(aE, aT, aP);
    232. 

  232.   //
    233. 

  233.   aProjector.Perform(aP);
    234. 

  234.   bFlag=aProjector.IsDone();
    235. 

  235.   if (!bFlag) {
    236. 

  236.     return bFlag;
    237. 

  237.   }
    238. 

  238.   //
    239. 

  239.   aDist=aProjector.LowerDistance();
    240. 

  240.   bFlag=(aDist <= aTol);
    241. 

  241.   if (!bFlag) {
    242. 

  242.     return bFlag;
    243. 

  243.   }
    244. 

  244.   //
    245. 

  245.   aProjector.LowerDistanceParameters(aU, aV);
    246. 

  246.   aP2D.SetCoord(aU, aV);
    247. 

  247.   bFlag=aContext.IsPointInOnFace (aF, aP2D);
    248. 

  248.   return bFlag;
    249. 

  249. }
    250. 

  250. //=======================================================================
    251. 

  251. // function: NMTTools_Tools::MakeNewVertex
    252. 

  252. // purpose : 
    253. 

  253. //=======================================================================
    254. 

  254.   void NMTTools_Tools::MakeNewVertex(const TopTools_ListOfShape& aLVs,
    255. 

  255. 				     TopoDS_Vertex& aNewVertex)
    256. 

  256. {
    257. 

  257.   Standard_Integer aNb;
    258. 

  258.   Standard_Real aTi, aDi, aDmax=-1.e5;
    259. 

  259.   gp_Pnt aPi, aP;
    260. 

  260.   gp_XYZ aXYZ(0.,0.,0.), aXYZi;
    261. 

  261.   TopTools_ListIteratorOfListOfShape anIt;
    262. 

  262.   //
    263. 

  263.   aNb=aLVs.Extent();
    264. 

  264.   if (!aNb) {
    265. 

  265.     return;
    266. 

  266.   }
    267. 

  267.   //
    268. 

  268.   anIt.Initialize(aLVs);
    269. 

  269.   for (; anIt.More(); anIt.Next()) {
    270. 

  270.     TopoDS_Vertex aVi=TopoDS::Vertex(anIt.Value());
    271. 

  271.     aPi=BRep_Tool::Pnt(aVi);
    272. 

  272.     aXYZi=aPi.XYZ();
    273. 

  273.     aXYZ=aXYZ+aXYZi;
    274. 

  274.   }
    275. 

  275.   //
    276. 

  276.   aXYZ.Divide((Standard_Real)aNb);
    277. 

  277.   aP.SetXYZ(aXYZ);
    278. 

  278.   //
    279. 

  279.   anIt.Initialize(aLVs);
    280. 

  280.   for (; anIt.More(); anIt.Next()) {
    281. 

  281.     TopoDS_Vertex aVi=TopoDS::Vertex(anIt.Value());
    282. 

  282.     aPi=BRep_Tool::Pnt(aVi);
    283. 

  283.     aTi=BRep_Tool::Tolerance(aVi);
    284. 

  284.     aDi=aP.Distance(aPi);
    285. 

  285.     aDi=aDi+aTi;
    286. 

  286.     if (aDi > aDmax) {
    287. 

  287.       aDmax=aDi;
    288. 

  288.     }
    289. 

  289.   }
    290. 

  290.   BRep_Builder aBB;
    291. 

  291.   aBB.MakeVertex (aNewVertex, aP, aDmax);
    292. 

  292. }
    293. 

  293. //=======================================================================
    294. 

  294. // function: FindChains
    295. 

  295. // purpose : 
    296. 

  296. //=======================================================================
    297. 

  297.   void NMTTools_Tools::FindChains(const BOPTools_CArray1OfSSInterference& FFs,
    298. 

  298. 				  BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMapChains)
    299. 

  299. {
    300. 

  300.   Standard_Boolean bIsTangentFaces;
    301. 

  301.   Standard_Integer j, aNb, anIndex1, anIndex2;
    302. 

  302.   BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger aMCV;
    303. 

  303.   //
    304. 

  304.   aNb=FFs.Extent();
    305. 

  305.   for (j=1; j<=aNb; ++j) {
    306. 

  306.     const BOPTools_SSInterference& aFF=FFs(j);
    307. 

  307.     //
    308. 

  308.     bIsTangentFaces=aFF.IsTangentFaces();
    309. 

  309.     if (!bIsTangentFaces) {
    310. 

  310.       continue;
    311. 

  311.     }
    312. 

  312.     //
    313. 

  313.     aFF.Indices(anIndex1, anIndex2);
    314. 

  314.     //
    315. 

  315.     if (aMCV.Contains(anIndex1)) {
    316. 

  316.       TColStd_IndexedMapOfInteger& aMV=aMCV.ChangeFromKey(anIndex1);
    317. 

  317.       aMV.Add(anIndex1);
    318. 

  318.       aMV.Add(anIndex2);
    319. 

  319.     }
    320. 

  320.     else {
    321. 

  321.       TColStd_IndexedMapOfInteger aMV;
    322. 

  322.       aMV.Add(anIndex1);
    323. 

  323.       aMV.Add(anIndex2);
    324. 

  324.       aMCV.Add(anIndex1, aMV);
    325. 

  325.     }
    326. 

  326.     //
    327. 

  327.     if (aMCV.Contains(anIndex2)) {
    328. 

  328.       TColStd_IndexedMapOfInteger& aMV=aMCV.ChangeFromKey(anIndex2);
    329. 

  329.       aMV.Add(anIndex1);
    330. 

  330.       aMV.Add(anIndex2);
    331. 

  331.     }
    332. 

  332.     else {
    333. 

  333.       TColStd_IndexedMapOfInteger aMV;
    334. 

  334.       aMV.Add(anIndex1);
    335. 

  335.       aMV.Add(anIndex2);
    336. 

  336.       aMCV.Add(anIndex2, aMV);
    337. 

  337.     }
    338. 

  338.   }
    339. 

  339.   NMTTools_Tools::FindChains(aMCV, aMapChains);
    340. 

  340. }
    341. 

  341. //=======================================================================
    342. 

  342. // function: FindChains
    343. 

  343. // purpose : 
    344. 

  344. //=======================================================================
    345. 

  345.   void NMTTools_Tools::FindChains(const BOPTools_CArray1OfVVInterference& VVs,
    346. 

  346. 				  BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMapChains)
    347. 

  347. {
    348. 

  348.   Standard_Integer j, aNb, anIndex1, anIndex2;
    349. 

  349.   BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger aMCV;
    350. 

  350.   //
    351. 

  351.   aNb=VVs.Extent();
    352. 

  352.   for (j=1; j<=aNb; ++j) {
    353. 

  353.     const BOPTools_VVInterference& VV=VVs(j);
    354. 

  354.     VV.Indices(anIndex1, anIndex2);
    355. 

  355.     //
    356. 

  356.     if (aMCV.Contains(anIndex1)) {
    357. 

  357.       TColStd_IndexedMapOfInteger& aMV=aMCV.ChangeFromKey(anIndex1);
    358. 

  358.       aMV.Add(anIndex1);
    359. 

  359.       aMV.Add(anIndex2);
    360. 

  360.     }
    361. 

  361.     else {
    362. 

  362.       TColStd_IndexedMapOfInteger aMV;
    363. 

  363.       aMV.Add(anIndex1);
    364. 

  364.       aMV.Add(anIndex2);
    365. 

  365.       aMCV.Add(anIndex1, aMV);
    366. 

  366.     }
    367. 

  367.     //
    368. 

  368.     if (aMCV.Contains(anIndex2)) {
    369. 

  369.       TColStd_IndexedMapOfInteger& aMV=aMCV.ChangeFromKey(anIndex2);
    370. 

  370.       aMV.Add(anIndex1);
    371. 

  371.       aMV.Add(anIndex2);
    372. 

  372.     }
    373. 

  373.     else {
    374. 

  374.       TColStd_IndexedMapOfInteger aMV;
    375. 

  375.       aMV.Add(anIndex1);
    376. 

  376.       aMV.Add(anIndex2);
    377. 

  377.       aMCV.Add(anIndex2, aMV);
    378. 

  378.     }
    379. 

  379.   }
    380. 

  380.   NMTTools_Tools::FindChains(aMCV, aMapChains);
    381. 

  381. }
    382. 

  382. 

  383. //=======================================================================
    384. 

  384. // function: FindChains
    385. 

  385. // purpose : 
    386. 

  386. //=======================================================================
    387. 

  387.   void NMTTools_Tools::FindChains(const BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMCV,
    388. 

  388. 				  BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMapChains)
    389. 

  389. {
    390. 

  390.   Standard_Integer  i, j, aNbCV, aNbV, iV, iVx;
    391. 

  391.   TColStd_IndexedMapOfInteger aProcessed, aChain;
    392. 

  392.   //
    393. 

  393.   aNbCV=aMCV.Extent();
    394. 

  394.   for (i=1; i<=aNbCV; ++i) {
    395. 

  395.     iV=aMCV.FindKey(i);
    396. 

  396.     if (aProcessed.Contains(iV)) {
    397. 

  397.       continue;
    398. 

  398.     }
    399. 

  399.     //
    400. 

  400.     aProcessed.Add(iV);
    401. 

  401.     aChain.Add(iV);
    402. 

  402.     //
    403. 

  403.     const TColStd_IndexedMapOfInteger& aMV=aMCV(i);
    404. 

  404.     aNbV=aMV.Extent();
    405. 

  405.     for (j=1; j<=aNbV; ++j) {
    406. 

  406.       iVx=aMV(j);
    407. 

  407.       ProcessBlock(iVx, aMCV, aProcessed, aChain);
    408. 

  408.     }
    409. 

  409.     aMapChains.Add(i, aChain);
    410. 

  410.     aChain.Clear();
    411. 

  411.   }
    412. 

  412. }
    413. 

  413. //=======================================================================
    414. 

  414. // function: ProcessBlock
    415. 

  415. // purpose: 
    416. 

  416. //=======================================================================
    417. 

  417. void ProcessBlock(const Standard_Integer iV,
    418. 

  418. 		  const BOPTColStd_IndexedDataMapOfIntegerIndexedMapOfInteger& aMCV,
    419. 

  419. 		  TColStd_IndexedMapOfInteger& aProcessed,
    420. 

  420. 		  TColStd_IndexedMapOfInteger& aChain)
    421. 

  421. {
    422. 

  422.   Standard_Integer j, aNbV, iVx;
    423. 

  423.   //
    424. 

  424.   if (aProcessed.Contains(iV)) {
    425. 

  425.     return;
    426. 

  426.   }
    427. 

  427.   aProcessed.Add(iV);
    428. 

  428.   aChain.Add(iV);
    429. 

  429.   //
    430. 

  430.   const TColStd_IndexedMapOfInteger& aMV=aMCV.FindFromKey(iV);
    431. 

  431.   aNbV=aMV.Extent();
    432. 

  432.   for (j=1; j<=aNbV; ++j) {
    433. 

  433.     iVx=aMV(j);
    434. 

  434.     ProcessBlock(iVx, aMCV, aProcessed, aChain);
    435. 

  435.   }
    436. 

  436. }
    437. 

  437. //=======================================================================
    438. 

  438. // function: AreFacesSameDomain
    439. 

  439. // purpose : 
    440. 

  440. //=======================================================================
    441. 

  441.   Standard_Boolean NMTTools_Tools::AreFacesSameDomain(const TopoDS_Face& aF1x,
    442. 

  442. 						      const TopoDS_Face& aF2y,
    443. 

  443. 						      IntTools_Context& aCtx)
    444. 

  444. {
    445. 

  445.   Standard_Boolean bFlag;
    446. 

  446.   // Modified  Thu Sep 14 14:35:18 2006 
    447. 

  447.   // Contribution of Samtech www.samcef.com BEGIN
    448. 

  448.   Standard_Integer aNbE1, aNbE2;
    449. 

  449.   Standard_Real aTolF1, aTolF2, aTol;
    450. 

  450.   gp_Pnt2d aP2D;
    451. 

  451.   gp_Pnt aP;
    452. 

  452.   TopoDS_Face aF1, aF2;
    453. 

  453.   TopExp_Explorer aExp;
    454. 

  454.   TopTools_MapOfShape aME1, aME2;
    455. 

  455.   TopTools_MapIteratorOfMapOfShape aIt;
    456. 

  456.   //
    457. 

  457.   bFlag=Standard_False;
    458. 

  458.   // Contribution of Samtech www.samcef.com END
    459. 

  459.   //
    460. 

  460.   aF1=aF1x;
    461. 

  461.   aF1.Orientation(TopAbs_FORWARD);
    462. 

  462.   aF2=aF2y;
    463. 

  463.   aF2.Orientation(TopAbs_FORWARD);
    464. 

  464.   //
    465. 

  465.   // Modified  Thu Sep 14 14:35:18 2006 
    466. 

  466.   // Contribution of Samtech www.samcef.com BEGIN
    467. 

  467.   //
    468. 

  468.   // 1
    469. 

  469.   aExp.Init(aF1, TopAbs_EDGE);
    470. 

  470.   for (; aExp.More(); aExp.Next()) {
    471. 

  471.     const TopoDS_Edge& aE=TopoDS::Edge(aExp.Current());
    472. 

  472.     if (!BRep_Tool::Degenerated(aE)) {
    473. 

  473.       aME1.Add(aE);
    474. 

  474.     }
    475. 

  475.   }
    476. 

  476.   //
    477. 

  477.   aExp.Init(aF2, TopAbs_EDGE);
    478. 

  478.   for (; aExp.More(); aExp.Next()) {
    479. 

  479.     const TopoDS_Edge& aE=TopoDS::Edge(aExp.Current());
    480. 

  480.     if (!BRep_Tool::Degenerated(aE)) {
    481. 

  481.       if (!aME1.Contains(aE)) {
    482. 

  482. 	return bFlag;
    483. 

  483.       }
    484. 

  484.       aME2.Add(aE);
    485. 

  485.     }
    486. 

  486.   }
    487. 

  487.   //
    488. 

  488.   // Contribution of Samtech www.samcef.com END
    489. 

  489.   //
    490. 

  490.   aNbE1=aME1.Extent();
    491. 

  491.   aNbE2=aME2.Extent();
    492. 

  492.   //
    493. 

  493.   if(!aNbE1 || !aNbE2){
    494. 

  494.     return bFlag;
    495. 

  495.   }
    496. 

  496.   //
    497. 

  497.   if(aNbE1!=aNbE2) {
    498. 

  498.     return bFlag;
    499. 

  499.   }
    500. 

  500.   //
    501. 

  501.   // 2
    502. 

  502.   aTolF1=BRep_Tool::Tolerance(aF1);
    503. 

  503.   aTolF2=BRep_Tool::Tolerance(aF2);
    504. 

  504.   aTol=aTolF1+aTolF2;
    505. 

  505.   //
    506. 

  506.   aIt.Initialize(aME1);
    507. 

  507.   for (; aIt.More(); aIt.Next()) {
    508. 

  508.     const TopoDS_Edge& aE=TopoDS::Edge(aIt.Key());
    509. 

  509.     BOPTools_Tools3D::PointNearEdge(aE, aF1, aP2D, aP);
    510. 

  510.     bFlag=aCtx.IsValidPointForFace(aP, aF2, aTol);
    511. 

  511.     break;
    512. 

  512.   }
    513. 

  513.   //
    514. 

  514.   return bFlag;
    515. 

  515. }
    516. 

  516. //=======================================================================
    517. 

  517. // function: FindChains
    518. 

  518. // purpose : 
    519. 

  519. //=======================================================================
    520. 

  520.   void NMTTools_Tools::FindChains(const NMTTools_ListOfCoupleOfShape& aLCS,
    521. 

  521. 				  NMTTools_IndexedDataMapOfShapeIndexedMapOfShape& aMapChains)
    522. 

  522. {
    523. 

  523.   NMTTools_ListIteratorOfListOfCoupleOfShape aItCS; 
    524. 

  524.   NMTTools_IndexedDataMapOfShapeIndexedMapOfShape aMCV;
    525. 

  525.   //
    526. 

  526.   aItCS.Initialize(aLCS);
    527. 

  527.   for (; aItCS.More(); aItCS.Next()) {
    528. 

  528.     const NMTTools_CoupleOfShape& aCS=aItCS.Value();
    529. 

  529.     //
    530. 

  530.     const TopoDS_Shape& aF1=aCS.Shape1();
    531. 

  531.     const TopoDS_Shape& aF2=aCS.Shape2();
    532. 

  532.     //
    533. 

  533.     //
    534. 

  534.     if (aMCV.Contains(aF1)) {
    535. 

  535.       TopTools_IndexedMapOfShape& aMV=aMCV.ChangeFromKey(aF1);
    536. 

  536.       aMV.Add(aF1);
    537. 

  537.       aMV.Add(aF2);
    538. 

  538.     }
    539. 

  539.     else {
    540. 

  540.       TopTools_IndexedMapOfShape aMV;
    541. 

  541.       aMV.Add(aF1);
    542. 

  542.       aMV.Add(aF2);
    543. 

  543.       aMCV.Add(aF1, aMV);
    544. 

  544.     }
    545. 

  545.     //
    546. 

  546.     if (aMCV.Contains(aF2)) {
    547. 

  547.       TopTools_IndexedMapOfShape& aMV=aMCV.ChangeFromKey(aF2);
    548. 

  548.       aMV.Add(aF1);
    549. 

  549.       aMV.Add(aF2);
    550. 

  550.     }
    551. 

  551.     else {
    552. 

  552.       TopTools_IndexedMapOfShape aMV;
    553. 

  553.       aMV.Add(aF1);
    554. 

  554.       aMV.Add(aF2);
    555. 

  555.       aMCV.Add(aF2, aMV);
    556. 

  556.     }
    557. 

  557.   }
    558. 

  558.   NMTTools_Tools::FindChains(aMCV, aMapChains);
    559. 

  559. }
    560. 

  560. //=======================================================================
    561. 

  561. // function: FindChains
    562. 

  562. // purpose : 
    563. 

  563. //=======================================================================
    564. 

  564.   void NMTTools_Tools::FindChains(const NMTTools_IndexedDataMapOfShapeIndexedMapOfShape& aMCV,
    565. 

  565. 				  NMTTools_IndexedDataMapOfShapeIndexedMapOfShape& aMapChains)
    566. 

  566. {
    567. 

  567.   Standard_Integer  i, j, aNbCV, aNbV;
    568. 

  568.   TopTools_IndexedMapOfShape aProcessed, aChain;
    569. 

  569.   //
    570. 

  570.   aNbCV=aMCV.Extent();
    571. 

  571.   for (i=1; i<=aNbCV; ++i) {
    572. 

  572.     const TopoDS_Shape& aF=aMCV.FindKey(i);
    573. 

  573.     if (aProcessed.Contains(aF)) {
    574. 

  574.       continue;
    575. 

  575.     }
    576. 

  576.     //
    577. 

  577.     aProcessed.Add(aF);
    578. 

  578.     aChain.Add(aF);
    579. 

  579.     //
    580. 

  580.     const TopTools_IndexedMapOfShape& aMV=aMCV(i);
    581. 

  581.     aNbV=aMV.Extent();
    582. 

  582.     for (j=1; j<=aNbV; ++j) {
    583. 

  583.       const TopoDS_Shape& aFx=aMV(j);
    584. 

  584.       ProcessBlock(aFx, aMCV, aProcessed, aChain);
    585. 

  585.     }
    586. 

  586.     aMapChains.Add(aF, aChain);
    587. 

  587.     aChain.Clear();
    588. 

  588.   }
    589. 

  589. }
    590. 

  590. //=======================================================================
    591. 

  591. // function: ProcessBlock
    592. 

  592. // purpose: 
    593. 

  593. //=======================================================================
    594. 

  594. void ProcessBlock(const TopoDS_Shape& aF,
    595. 

  595. 		  const NMTTools_IndexedDataMapOfShapeIndexedMapOfShape& aMCV,
    596. 

  596. 		  TopTools_IndexedMapOfShape& aProcessed,
    597. 

  597. 		  TopTools_IndexedMapOfShape& aChain)
    598. 

  598. {
    599. 

  599.   Standard_Integer j, aNbV;
    600. 

  600.   //
    601. 

  601.   if (aProcessed.Contains(aF)) {
    602. 

  602.     return;
    603. 

  603.   }
    604. 

  604.   aProcessed.Add(aF);
    605. 

  605.   aChain.Add(aF);
    606. 

  606.   //
    607. 

  607.   const TopTools_IndexedMapOfShape& aMV=aMCV.FindFromKey(aF);
    608. 

  608.   aNbV=aMV.Extent();
    609. 

  609.   for (j=1; j<=aNbV; ++j) {
    610. 

  610.     const TopoDS_Shape& aFx=aMV(j);
    611. 

  611.     ProcessBlock(aFx, aMCV, aProcessed, aChain);
    612. 

  612.   }
    613. 

  613. }
    614.