Back to index

salome-geom  6.5.0
NMTTools_PaveFiller_8.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 // File:        NMTTools_PaveFiller_8.cxx
00024 // Created:     Fri Dec 19 11:15:53 2003
00025 // Author:      Peter KURNEV
00026 //              <pkv@irinox>
00027 //
00028 #include <NMTTools_PaveFiller.hxx>
00029 
00030 #include <TColStd_MapOfInteger.hxx>
00031 #include <TColStd_ListOfInteger.hxx>
00032 #include <TColStd_ListIteratorOfListOfInteger.hxx>
00033 
00034 #include <TopTools_ListOfShape.hxx>
00035 
00036 #include <BooleanOperations_ShapesDataStructure.hxx>
00037 #include <BooleanOperations_OnceExplorer.hxx>
00038 
00039 #include <BOPTools_PaveBlock.hxx>
00040 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
00041 #include <BOPTools_ListOfPaveBlock.hxx>
00042 
00043 #include <NMTDS_ShapesDataStructure.hxx>
00044 
00045 #include <NMTTools_ListOfCommonBlock.hxx>
00046 #include <NMTTools_ListIteratorOfListOfCommonBlock.hxx>
00047 #include <NMTTools_CommonBlock.hxx>
00048 #include <NMTTools_CommonBlockAPI.hxx>
00049 
00050 
00051 // Modified  to add new method Thu Sep 14 14:35:18 2006
00052 // Contribution of Samtech www.samcef.com BEGIN
00053 //=======================================================================
00054 // function:  SharedEdges
00055 // purpose:
00056 //=======================================================================
00057   void NMTTools_PaveFiller::SharedEdges(const Standard_Integer nF1,
00058                                         const Standard_Integer nF2,
00059                                         TColStd_ListOfInteger& aLNE,
00060                                         TopTools_ListOfShape& aLSE)
00061 {
00062   Standard_Integer nE1, nE2;
00063   TColStd_MapOfInteger aM1;
00064   //
00065   BooleanOperations_ShapesDataStructure *pDS=myDS;
00066   BooleanOperations_OnceExplorer aExp(*pDS);
00067   //
00068   aExp.Init(nF1, TopAbs_EDGE);
00069   for (; aExp.More(); aExp.Next()) {
00070     nE1=aExp.Current();
00071     aM1.Add(nE1);
00072   }
00073 
00074   aExp.Init(nF2, TopAbs_EDGE);
00075   for (; aExp.More(); aExp.Next()) {
00076     nE2=aExp.Current();
00077     if (aM1.Contains(nE2)) {
00078       aLNE.Append(nE2);
00079       const TopoDS_Shape& aE2=myDS->Shape(nE2);
00080       aLSE.Append(aE2);
00081     }
00082   }
00083 }
00084 // Contribution of Samtech www.samcef.com END
00085 //
00086 //=======================================================================
00087 // function: RealPaveBlock
00088 // purpose:
00089 //=======================================================================
00090   const BOPTools_PaveBlock& NMTTools_PaveFiller::RealPaveBlock
00091      (const BOPTools_PaveBlock& aPB,
00092       TColStd_ListOfInteger& aLB,
00093       Standard_Integer& aIsCommonBlock)
00094 {
00095   Standard_Integer nE, nSpx;
00096   BOPTools_ListIteratorOfListOfPaveBlock aItPBx;
00097   //
00098   aIsCommonBlock=0;
00099   aLB.Clear();
00100   nE=aPB.OriginalEdge();
00101   const NMTTools_ListOfCommonBlock& aLCBE=myCommonBlockPool(myDS->RefEdge(nE));
00102   NMTTools_CommonBlockAPI aCBAPI(aLCBE);
00103   if (aCBAPI.IsCommonBlock(aPB)) {
00104     NMTTools_CommonBlock& aCB=aCBAPI.CommonBlock(aPB);
00105     //
00106     aIsCommonBlock=1;
00107     //
00108     const BOPTools_ListOfPaveBlock& aLPBx=aCB.PaveBlocks();
00109     aItPBx.Initialize(aLPBx);
00110     for (; aItPBx.More(); aItPBx.Next()) {
00111       const BOPTools_PaveBlock& aPBx=aItPBx.Value();
00112       nSpx=aPBx.Edge();
00113       aLB.Append(nSpx);
00114     }
00115     //
00116     const BOPTools_PaveBlock& aPBx=aCB.PaveBlock1();
00117     return aPBx;
00118   }
00119   return aPB;
00120 }
00121 //
00122 //=======================================================================
00123 // function: RealPaveBlock
00124 // purpose:
00125 //=======================================================================
00126   const BOPTools_PaveBlock& NMTTools_PaveFiller::RealPaveBlock(const BOPTools_PaveBlock& aPB)
00127 {
00128   Standard_Integer nE;
00129   //
00130   nE=aPB.OriginalEdge();
00131   const NMTTools_ListOfCommonBlock& aLCBE=myCommonBlockPool(myDS->RefEdge(nE));
00132   NMTTools_CommonBlockAPI aCBAPI(aLCBE);
00133   if (aCBAPI.IsCommonBlock(aPB)) {
00134     NMTTools_CommonBlock& aCB=aCBAPI.CommonBlock(aPB);
00135     const BOPTools_PaveBlock& aPBx=aCB.PaveBlock1();
00136     return aPBx;
00137   }
00138   return aPB;
00139 }
00140 //=======================================================================
00141 // function: CommonBlocksFace
00142 // purpose:
00143 //=======================================================================
00144   Standard_Integer NMTTools_PaveFiller::CommonBlocksFace(const Standard_Integer nF,
00145                                                          NMTTools_ListOfCommonBlock& aLCB)
00146 {
00147   Standard_Integer nE;
00148   TopAbs_ShapeEnum aT;
00149   NMTTools_ListIteratorOfListOfCommonBlock anIt;
00150   //
00151   aT=myDS->GetShapeType(nF);
00152   //
00153   if (aT!=TopAbs_FACE) {
00154     return 1; // Type mismatch
00155   }
00156   //
00157   BooleanOperations_ShapesDataStructure *pDS=myDS;
00158   BooleanOperations_OnceExplorer aExp(*pDS);
00159   //
00160   aExp.Init(nF, TopAbs_EDGE);
00161   for (; aExp.More(); aExp.Next()) {
00162     nE=aExp.Current();
00163     const NMTTools_ListOfCommonBlock& aLCBE=myCommonBlockPool(myDS->RefEdge(nE));
00164     anIt.Initialize(aLCBE);
00165     for (; anIt.More(); anIt.Next()) {
00166       const NMTTools_CommonBlock& aCBE=anIt.Value();
00167       aLCB.Append(aCBE);
00168     }
00169   }
00170   return 0; //Ok
00171 }
00172 //
00173 // 1 RealSplits
00174 //
00175 //
00176 //=======================================================================
00177 // function: RealSplitsFace
00178 // purpose:
00179 //=======================================================================
00180   void NMTTools_PaveFiller::RealSplitsFace(const Standard_Integer nF,
00181                                            BOPTools_ListOfPaveBlock& aLPB)
00182 {
00183   Standard_Integer nE;
00184   BOPTools_ListIteratorOfListOfPaveBlock anIt;
00185   //
00186   BooleanOperations_ShapesDataStructure *pDS=myDS;
00187   BooleanOperations_OnceExplorer aExp(*pDS);
00188   //
00189   aExp.Init(nF, TopAbs_EDGE);
00190   for (; aExp.More(); aExp.Next()) {
00191     nE=aExp.Current();
00192     const BOPTools_ListOfPaveBlock& aLPBE=mySplitShapesPool(myDS->RefEdge(nE));
00193     anIt.Initialize(aLPBE);
00194     for (; anIt.More(); anIt.Next()) {
00195       const BOPTools_PaveBlock& aPB=anIt.Value();
00196       const BOPTools_PaveBlock& aPBR=RealPaveBlock(aPB);
00197       aLPB.Append(aPBR);
00198     }
00199   }
00200 }
00201 //=======================================================================
00202 // function: HasRealSplitsInOnFace
00203 // purpose:
00204 //=======================================================================
00205   Standard_Boolean NMTTools_PaveFiller::HasRealSplitsInOnFace(const Standard_Integer nF1,
00206                                                               const Standard_Integer nF2)
00207 {
00208   Standard_Boolean bFlag;
00209   BOPTools_ListOfPaveBlock aLPB;
00210   //
00211   RealSplitsInFace(0, nF1, nF2, aLPB);
00212   //
00213   bFlag=!aLPB.IsEmpty();
00214   if (bFlag) {
00215     return bFlag;
00216   }
00217   //
00218   RealSplitsInFace(0, nF1, nF2, aLPB);
00219   //
00220   bFlag=!aLPB.IsEmpty();
00221   return bFlag;
00222 }
00223 //=======================================================================
00224 // function: RealSplitsInFace
00225 // purpose:
00226 //=======================================================================
00227   void NMTTools_PaveFiller::RealSplitsInFace(const Standard_Integer ,//for overriding
00228                                              const Standard_Integer nF1,
00229                                              const Standard_Integer nF2,
00230                                              BOPTools_ListOfPaveBlock& aLPB)
00231 {
00232   Standard_Integer nE1;
00233   //
00234   BooleanOperations_ShapesDataStructure *pDS=myDS;
00235   BooleanOperations_OnceExplorer aExp(*pDS);
00236   aExp.Init(nF1, TopAbs_EDGE);
00237   for (; aExp.More(); aExp.Next()) {
00238     nE1=aExp.Current();
00239     RealSplitsInFace (nE1, nF2, aLPB);
00240   }
00241 }
00242 //=======================================================================
00243 // function: RealSplitsInFace
00244 // purpose:
00245 //=======================================================================
00246   void NMTTools_PaveFiller::RealSplitsInFace(const Standard_Integer nE1,
00247                                              const Standard_Integer nF2,
00248                                              BOPTools_ListOfPaveBlock& aLPB)
00249 {
00250   Standard_Integer nF1;
00251   //
00252   TColStd_ListIteratorOfListOfInteger anItLFCB;
00253   NMTTools_ListIteratorOfListOfCommonBlock anItCB;
00254   //
00255   const NMTTools_ListOfCommonBlock& aLCB=myCommonBlockPool(myDS->RefEdge(nE1));
00256   //
00257   anItCB.Initialize(aLCB);
00258   for (; anItCB.More(); anItCB.Next()) {
00259     NMTTools_CommonBlock& aCB=anItCB.ChangeValue();
00260     const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1(nE1);
00261     const BOPTools_PaveBlock& aPB1R=RealPaveBlock(aPB1);
00262 
00263     const TColStd_ListOfInteger& aLFCB=aCB.Faces();
00264     anItLFCB.Initialize(aLFCB);
00265     for (; anItLFCB.More(); anItLFCB.Next()) {
00266       nF1=anItLFCB.Value();
00267       if (nF1==nF2) {
00268         aLPB.Append(aPB1R);
00269       }
00270     }
00271   }
00272 }
00273 //=======================================================================
00274 // function: RealSplitsOnEdge
00275 // purpose:
00276 //=======================================================================
00277   void NMTTools_PaveFiller::RealSplitsOnEdge(const Standard_Integer nE1,
00278                                              const Standard_Integer nE2,
00279                                              BOPTools_ListOfPaveBlock& aLPB)
00280 {
00281   Standard_Integer nE;
00282   //
00283   BOPTools_ListIteratorOfListOfPaveBlock anIt;
00284   NMTTools_ListIteratorOfListOfCommonBlock anItCB;
00285   //
00286   const NMTTools_ListOfCommonBlock& aLCB=myCommonBlockPool(myDS->RefEdge(nE1));
00287 
00288   anItCB.Initialize(aLCB);
00289   for (; anItCB.More(); anItCB.Next()) {
00290     NMTTools_CommonBlock& aCB=anItCB.ChangeValue();
00291     const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1(nE1);
00292     const BOPTools_PaveBlock& aPB1R=RealPaveBlock(aPB1);
00293     //
00294     const BOPTools_ListOfPaveBlock& aLPBx=aCB.PaveBlocks();
00295     anIt.Initialize(aLPBx);
00296     for (; anIt.More(); anIt.Next()) {
00297       const BOPTools_PaveBlock& aPB2=anIt.Value();
00298       nE=aPB2.OriginalEdge();
00299       if (nE==nE2) {
00300         aLPB.Append(aPB1R);
00301       }
00302     }
00303   }
00304 }
00305 //=======================================================================
00306 // function: RealSplitsOnFace
00307 // purpose:
00308 //=======================================================================
00309   void NMTTools_PaveFiller::RealSplitsOnFace(const Standard_Integer nE1,
00310                                              const Standard_Integer nF2,
00311                                              BOPTools_ListOfPaveBlock& aLPB)
00312 {
00313   Standard_Integer nE2;
00314   //
00315   BooleanOperations_ShapesDataStructure *pDS=myDS;
00316   BooleanOperations_OnceExplorer aExp(*pDS);
00317   aExp.Init(nF2, TopAbs_EDGE);
00318   for (; aExp.More(); aExp.Next()) {
00319     nE2=aExp.Current();
00320     RealSplitsOnEdge(nE1, nE2, aLPB);
00321   }
00322 }
00323 //=======================================================================
00324 // function: RealSplitsOnFace
00325 // purpose:
00326 //=======================================================================
00327   void NMTTools_PaveFiller::RealSplitsOnFace(const Standard_Integer ,//for overriding
00328                                              const Standard_Integer nF1,
00329                                              const Standard_Integer nF2,
00330                                              BOPTools_ListOfPaveBlock& aLPB)
00331 {
00332   Standard_Integer nE1;
00333   //
00334 //   BooleanOperations_ShapesDataStructure *pDS=myDS;
00335   BooleanOperations_OnceExplorer aExp(*myDS);
00336   aExp.Init(nF1, TopAbs_EDGE);
00337   for (; aExp.More(); aExp.Next()) {
00338     nE1=aExp.Current();
00339     RealSplitsOnFace(nE1, nF2, aLPB);
00340   }
00341 }
00342 
00343 // 2 SimpleSplits
00344 //=======================================================================
00345 // function: SplitsFace
00346 // purpose:
00347 //=======================================================================
00348   Standard_Integer NMTTools_PaveFiller::SplitsFace(const Standard_Integer nF,
00349                                                    BOPTools_ListOfPaveBlock& aLPB)
00350 {
00351   Standard_Integer nE;
00352   TopAbs_ShapeEnum aT;
00353   BOPTools_ListIteratorOfListOfPaveBlock anIt;
00354   //
00355   aT=myDS->GetShapeType(nF);
00356   //
00357   if (aT!=TopAbs_FACE) {
00358     return 1; // Type mismatch
00359   }
00360   //
00361   BooleanOperations_ShapesDataStructure *pDS=myDS;
00362   BooleanOperations_OnceExplorer aExp(*pDS);
00363   //
00364   aExp.Init(nF, TopAbs_EDGE);
00365   for (; aExp.More(); aExp.Next()) {
00366     nE=aExp.Current();
00367     const BOPTools_ListOfPaveBlock& aLPBE=mySplitShapesPool(myDS->RefEdge(nE));
00368     anIt.Initialize(aLPBE);
00369     for (; anIt.More(); anIt.Next()) {
00370       const BOPTools_PaveBlock& aPBE=anIt.Value();
00371       aLPB.Append(aPBE);
00372     }
00373   }
00374   return 0; //Ok
00375 }
00376 
00377 //=======================================================================
00378 // function: SplitsInFace
00379 // purpose: splits of edges from nF1 in nF2
00380 //=======================================================================
00381   Standard_Integer NMTTools_PaveFiller::SplitsInFace(const Standard_Integer ,//for overriding
00382                                                      const Standard_Integer nF1,
00383                                                      const Standard_Integer nF2,
00384                                                      BOPTools_ListOfPaveBlock& aLPB)
00385 {
00386   Standard_Integer nE1;
00387   TopAbs_ShapeEnum aT1, aT2;
00388 
00389   aT1=myDS->GetShapeType(nF1);
00390   aT2=myDS->GetShapeType(nF2);
00391 
00392   if (aT1!=TopAbs_FACE || aT2!=TopAbs_FACE) {
00393     return 1; // Type mismatch
00394   }
00395   BooleanOperations_ShapesDataStructure *pDS=myDS;
00396   BooleanOperations_OnceExplorer aExp(*pDS);
00397   aExp.Init(nF1, TopAbs_EDGE);
00398   for (; aExp.More(); aExp.Next()) {
00399     nE1=aExp.Current();
00400     SplitsInFace (nE1, nF2, aLPB);
00401   }
00402   return 0; //Ok
00403 }
00404 //=======================================================================
00405 // function: SplitsInFace
00406 // purpose: splits of edge nE1 in aFace2
00407 //=======================================================================
00408   Standard_Integer NMTTools_PaveFiller::SplitsInFace(const Standard_Integer nE1,
00409                                                      const Standard_Integer nF2,
00410                                                      BOPTools_ListOfPaveBlock& aLPB)
00411 {
00412   Standard_Integer nF1;
00413   TopAbs_ShapeEnum aT1, aT2;
00414 
00415   aT1=myDS->GetShapeType(nE1);
00416   aT2=myDS->GetShapeType(nF2);
00417 
00418   if (aT1!=TopAbs_EDGE || aT2!=TopAbs_FACE) {
00419     return 1; // Type mismatch
00420   }
00421   //
00422   TColStd_ListIteratorOfListOfInteger anItLFCB;
00423   NMTTools_ListIteratorOfListOfCommonBlock anItCB;
00424   //
00425   const NMTTools_ListOfCommonBlock& aLCB=myCommonBlockPool(myDS->RefEdge(nE1));
00426   //
00427   anItCB.Initialize(aLCB);
00428   for (; anItCB.More(); anItCB.Next()) {
00429     NMTTools_CommonBlock& aCB=anItCB.ChangeValue();
00430     const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1(nE1);
00431 
00432     const TColStd_ListOfInteger& aLFCB=aCB.Faces();
00433     anItLFCB.Initialize(aLFCB);
00434     for (; anItLFCB.More(); anItLFCB.Next()) {
00435       nF1=anItLFCB.Value();
00436       if (nF1==nF2) {
00437         aLPB.Append(aPB1);
00438       }
00439     }
00440   }
00441   return 0; //Ok
00442 }
00443 //=======================================================================
00444 // function: SplitsOnEdge
00445 // purpose:  splits of edge nE1 on nE2
00446 //=======================================================================
00447   Standard_Integer NMTTools_PaveFiller::SplitsOnEdge(const Standard_Integer nE1,
00448                                                      const Standard_Integer nE2,
00449                                                      BOPTools_ListOfPaveBlock& aLPB)
00450 {
00451   Standard_Integer nE;
00452   TopAbs_ShapeEnum aT1, aT2;
00453 
00454   aT1=myDS->GetShapeType(nE1);
00455   aT2=myDS->GetShapeType(nE2);
00456 
00457   if (aT1!=TopAbs_EDGE || aT2!=TopAbs_EDGE) {
00458     return 1; // Type mismatch
00459   }
00460   //
00461   BOPTools_ListIteratorOfListOfPaveBlock anIt;
00462   NMTTools_ListIteratorOfListOfCommonBlock anItCB;
00463   //
00464   const NMTTools_ListOfCommonBlock& aLCB=myCommonBlockPool(myDS->RefEdge(nE1));
00465 
00466   anItCB.Initialize(aLCB);
00467   for (; anItCB.More(); anItCB.Next()) {
00468     NMTTools_CommonBlock& aCB=anItCB.ChangeValue();
00469     const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1(nE1);//XXX
00470     //
00471     const BOPTools_ListOfPaveBlock& aLPBx=aCB.PaveBlocks();
00472     anIt.Initialize(aLPBx);
00473     for (; anIt.More(); anIt.Next()) {
00474       const BOPTools_PaveBlock& aPB2=anIt.Value();
00475       nE=aPB2.OriginalEdge();
00476       if (nE==nE2) {
00477         aLPB.Append(aPB1);
00478       }
00479     }
00480   }
00481   return 0; //Ok
00482 }
00483 //=======================================================================
00484 // function: SplitsOnFace
00485 // purpose:  splits of edge nE1 on face nF2
00486 //=======================================================================
00487   Standard_Integer NMTTools_PaveFiller::SplitsOnFace(const Standard_Integer nE1,
00488                                                      const Standard_Integer nF2,
00489                                                      BOPTools_ListOfPaveBlock& aLPB)
00490 {
00491   Standard_Integer nE2, ip;
00492   TopAbs_ShapeEnum aT1, aT2;
00493 
00494   aT1=myDS->GetShapeType(nE1);
00495   aT2=myDS->GetShapeType(nF2);
00496 
00497   if (aT1!=TopAbs_EDGE || aT2!=TopAbs_FACE) {
00498     return 1; // Type mismatch
00499   }
00500   BooleanOperations_ShapesDataStructure *pDS=myDS;
00501   BooleanOperations_OnceExplorer aExp(*pDS);
00502   aExp.Init(nF2, TopAbs_EDGE);
00503   for (; aExp.More(); aExp.Next()) {
00504     nE2=aExp.Current();
00505     ip=SplitsOnEdge(nE1, nE2, aLPB);
00506     if (ip) {
00507       return ip;
00508     }
00509   }
00510   return 0; //Ok
00511 }
00512 //=======================================================================
00513 // function: SplitsOnFace
00514 // purpose:  splits of edges from face nF1 on face nF2
00515 //=======================================================================
00516   Standard_Integer NMTTools_PaveFiller::SplitsOnFace(const Standard_Integer ,//for overriding
00517                                                      const Standard_Integer nF1,
00518                                                      const Standard_Integer nF2,
00519                                                      BOPTools_ListOfPaveBlock& aLPB)
00520 {
00521   Standard_Integer nE1, ip;
00522   TopAbs_ShapeEnum aT1, aT2;
00523 
00524   aT1=myDS->GetShapeType(nF1);
00525   aT2=myDS->GetShapeType(nF2);
00526 
00527   if (aT1!=TopAbs_FACE || aT2!=TopAbs_FACE) {
00528     return 1; // Type mismatch
00529   }
00530 //   BooleanOperations_ShapesDataStructure *pDS=myDS;
00531   BooleanOperations_OnceExplorer aExp(*myDS);
00532   aExp.Init(nF1, TopAbs_EDGE);
00533   for (; aExp.More(); aExp.Next()) {
00534     nE1=aExp.Current();
00535     ip=SplitsOnFace(nE1, nF2, aLPB);
00536     if (ip) {
00537       return ip;
00538     }
00539   }
00540   return 0; //Ok
00541 }
00542 
00543 // 3 Simple Splits indices
00544 //=======================================================================
00545 // function: SplitsFace
00546 // purpose:
00547 //=======================================================================
00548   Standard_Integer NMTTools_PaveFiller::SplitsFace(const Standard_Integer nF,
00549                                                    TColStd_ListOfInteger& aSplits)
00550 {
00551   Standard_Integer nE, iErr;
00552   BOPTools_ListIteratorOfListOfPaveBlock aIt;
00553   BOPTools_ListOfPaveBlock aLPB;
00554   //
00555   iErr=SplitsFace(nF, aLPB);
00556    if (iErr) {
00557     return iErr;
00558   }
00559 
00560   aIt.Initialize(aLPB);
00561   for (; aIt.More(); aIt.Next()) {
00562     const BOPTools_PaveBlock& aPB=aIt.Value();
00563     nE=aPB.Edge();
00564     aSplits.Append(nE);
00565   }
00566   return 0; //Ok
00567 }
00568 
00569 //=======================================================================
00570 // function: SplitsInFace
00571 // purpose: splits of edges from nF1 in nF2
00572 //=======================================================================
00573   Standard_Integer NMTTools_PaveFiller::SplitsInFace(const Standard_Integer ,//for overriding
00574                                                      const Standard_Integer nF1,
00575                                                      const Standard_Integer nF2,
00576                                                      TColStd_ListOfInteger& aSplits)
00577 {
00578   Standard_Integer nE, iErr;
00579   BOPTools_ListIteratorOfListOfPaveBlock aIt;
00580   BOPTools_ListOfPaveBlock aLPB;
00581   //
00582   iErr=SplitsInFace(0, nF1, nF2, aLPB);
00583   if (iErr) {
00584     return iErr;
00585   }
00586   aIt.Initialize(aLPB);
00587   for (; aIt.More(); aIt.Next()) {
00588     const BOPTools_PaveBlock& aPB=aIt.Value();
00589     nE=aPB.Edge();
00590     aSplits.Append(nE);
00591   }
00592   return iErr;
00593 }
00594 //=======================================================================
00595 // function: SplitsInFace
00596 // purpose: splits of edge nE1 in aFace2
00597 //=======================================================================
00598   Standard_Integer NMTTools_PaveFiller::SplitsInFace(const Standard_Integer nE1,
00599                                                      const Standard_Integer nF2,
00600                                                      TColStd_ListOfInteger& aSplits)
00601 {
00602   Standard_Integer nE, iErr;
00603   BOPTools_ListIteratorOfListOfPaveBlock aIt;
00604   BOPTools_ListOfPaveBlock aLPB;
00605   //
00606   iErr=SplitsInFace(nE1, nF2, aLPB);
00607   if (iErr) {
00608     return iErr;
00609   }
00610   aIt.Initialize(aLPB);
00611   for (; aIt.More(); aIt.Next()) {
00612     const BOPTools_PaveBlock& aPB=aIt.Value();
00613     nE=aPB.Edge();
00614     aSplits.Append(nE);
00615   }
00616   return iErr;
00617 }
00618 //=======================================================================
00619 // function: SplitsOnEdge
00620 // purpose:  splits of edge nE1 on nE2
00621 //=======================================================================
00622   Standard_Integer NMTTools_PaveFiller::SplitsOnEdge(const Standard_Integer nE1,
00623                                                      const Standard_Integer nE2,
00624                                                      TColStd_ListOfInteger& aSplits)
00625 {
00626   Standard_Integer nE, iErr;
00627   BOPTools_ListIteratorOfListOfPaveBlock aIt;
00628   BOPTools_ListOfPaveBlock aLPB;
00629   //
00630   iErr=SplitsOnEdge(nE1, nE2, aLPB);
00631   if (iErr) {
00632     return iErr;
00633   }
00634   aIt.Initialize(aLPB);
00635   for (; aIt.More(); aIt.Next()) {
00636     const BOPTools_PaveBlock& aPB=aIt.Value();
00637     nE=aPB.Edge();
00638     aSplits.Append(nE);
00639   }
00640   return iErr;
00641 }
00642 //=======================================================================
00643 // function: SplitsOnFace
00644 // purpose:  splits of edge nE1 on face nF2
00645 //=======================================================================
00646   Standard_Integer NMTTools_PaveFiller::SplitsOnFace(const Standard_Integer nE1,
00647                                                      const Standard_Integer nF2,
00648                                                      TColStd_ListOfInteger& aSplits)
00649 {
00650   Standard_Integer nE, iErr;
00651   BOPTools_ListIteratorOfListOfPaveBlock aIt;
00652   BOPTools_ListOfPaveBlock aLPB;
00653   //
00654   iErr=SplitsOnEdge(nE1, nF2, aLPB);
00655   if (iErr) {
00656     return iErr;
00657   }
00658   aIt.Initialize(aLPB);
00659   for (; aIt.More(); aIt.Next()) {
00660     const BOPTools_PaveBlock& aPB=aIt.Value();
00661     nE=aPB.Edge();
00662     aSplits.Append(nE);
00663   }
00664   return iErr;
00665 }
00666 //=======================================================================
00667 // function: SplitsOnFace
00668 // purpose:  splits of edges from face nF1 on face nF2
00669 //=======================================================================
00670   Standard_Integer NMTTools_PaveFiller::SplitsOnFace(const Standard_Integer ,//for overriding
00671                                                      const Standard_Integer nF1,
00672                                                      const Standard_Integer nF2,
00673                                                      TColStd_ListOfInteger& aSplits)
00674 {
00675   Standard_Integer nE, iErr;
00676   BOPTools_ListIteratorOfListOfPaveBlock aIt;
00677   BOPTools_ListOfPaveBlock aLPB;
00678   //
00679   iErr=SplitsOnFace(0, nF1, nF2, aLPB);
00680    if (iErr) {
00681     return iErr;
00682   }
00683 
00684   aIt.Initialize(aLPB);
00685   for (; aIt.More(); aIt.Next()) {
00686     const BOPTools_PaveBlock& aPB=aIt.Value();
00687     nE=aPB.Edge();
00688     aSplits.Append(nE);
00689   }
00690   return 0; //Ok
00691 }
00692 //modified by NIZNHY-PKV Mon Oct 17 12:07:48 2011f
00693 static
00694   void SortPaveBlocks(BOPTools_ListOfPaveBlock &);
00695 static
00696   void SortShell(const Standard_Integer,
00697                BOPTools_PaveBlock *);
00698 static
00699   Standard_Boolean Less(const BOPTools_PaveBlock &,
00700                      const BOPTools_PaveBlock &);
00701 
00702 //=======================================================================
00703 // function: RealSplitsInFace
00704 // purpose:
00705 //=======================================================================
00706   void NMTTools_PaveFiller::RealSplitsInFace(const Standard_Integer nF,
00707                                              BOPTools_ListOfPaveBlock& aLPBIn)
00708 {
00709   Standard_Integer j, aNbCBP, nSpIn;
00710   TColStd_MapOfInteger aMFence;
00711   BOPTools_ListOfPaveBlock aLPB;
00712   BOPTools_ListIteratorOfListOfPaveBlock aItPB;
00713   NMTTools_ListIteratorOfListOfCommonBlock aItCB;
00714   //
00715   NMTTools_CommonBlockPool& aCBP=ChangeCommonBlockPool();
00716   //
00717   aNbCBP=aCBP.Extent();
00718   for (j=1; j<=aNbCBP; ++j) {
00719     NMTTools_ListOfCommonBlock& aLCB=aCBP(j);
00720     aItCB.Initialize(aLCB);
00721     for (; aItCB.More(); aItCB.Next()) {
00722       NMTTools_CommonBlock& aCB=aItCB.ChangeValue();
00723       if (aCB.IsPaveBlockOnFace(nF)) {
00724        const BOPTools_PaveBlock& aPB1=aCB.PaveBlock1();
00725        nSpIn=aPB1.Edge();
00726        if (aMFence.Add(nSpIn)){
00727          aLPB.Append(aPB1);
00728        }
00729       }
00730     }
00731   }
00732   //
00733   SortPaveBlocks(aLPB);
00734   //
00735   aItPB.Initialize(aLPB);
00736   for (; aItPB.More(); aItPB.Next()) {
00737     const BOPTools_PaveBlock& aPB=aItPB.Value();
00738     aLPBIn.Append(aPB);
00739   }
00740 }
00741 //=======================================================================
00742 // function: SortPaveBlocks
00743 // purpose:
00744 //=======================================================================
00745 void SortPaveBlocks(BOPTools_ListOfPaveBlock &aLPBIn)
00746 {
00747   Standard_Integer i, aNbPBIn;
00748   BOPTools_ListIteratorOfListOfPaveBlock aItPB;
00749   BOPTools_PaveBlock *pPB;
00750   //
00751   aNbPBIn=aLPBIn.Extent();
00752   if (aNbPBIn<2) {
00753     return;
00754   }
00755   //
00756   pPB=new BOPTools_PaveBlock[aNbPBIn];
00757   //
00758   aItPB.Initialize(aLPBIn);
00759   for (i=0; aItPB.More(); aItPB.Next(), ++i) {
00760     const BOPTools_PaveBlock& aPB=aItPB.Value();
00761     pPB[i]=aPB;
00762   }
00763   //
00764   SortShell(aNbPBIn, pPB);
00765   //
00766   aLPBIn.Clear();
00767   for (i=0; i<aNbPBIn; ++i) {
00768     aLPBIn.Append(pPB[i]);
00769   }
00770   //
00771   delete [] (BOPTools_PaveBlock*)pPB;
00772 }
00773 //=======================================================================
00774 //function : SortShell
00775 //purpose  :
00776 //=======================================================================
00777 void SortShell(const Standard_Integer n,
00778               BOPTools_PaveBlock *a)
00779 {
00780   Standard_Integer nd, i, j, l, d=1;
00781   BOPTools_PaveBlock x;
00782   //
00783   while(d<=n) {
00784     d*=2;
00785   }
00786   //
00787   while (d) {
00788     d=(d-1)/2;
00789     //
00790     nd=n-d;
00791     for (i=0; i<nd; ++i) {
00792       j=i;
00793     m30:;
00794       l=j+d;
00795       if (Less(a[l], a[j])) {
00796       //if (a[l] < a[j]){
00797        x=a[j];
00798        a[j]=a[l];
00799        a[l]=x;
00800        j-=d;
00801        if (j > -1) goto m30;
00802       }//if (a[l] < a[j]){
00803     }//for (i=0; i<nd; ++i)
00804   }//while (1)
00805 }
00806 
00807 //=======================================================================
00808 //function : Less
00809 //purpose  :
00810 //=======================================================================
00811 Standard_Boolean Less(const BOPTools_PaveBlock &aPB1,
00812                     const BOPTools_PaveBlock &aPB2)
00813 {
00814   Standard_Boolean bRet;
00815   Standard_Integer iE1, iE2;
00816   Standard_Real aT11, aT12, aT21, aT22;
00817   //
00818   iE1=aPB1.OriginalEdge();
00819   iE2=aPB2.OriginalEdge();
00820   if (iE1!=iE2) {
00821     bRet=(iE1<iE2);
00822     return bRet;
00823   }
00824   //
00825   aPB1.Parameters(aT11, aT12);
00826   aPB2.Parameters(aT21, aT22);
00827   bRet=(aT11<aT21);
00828   return bRet;
00829 }
00830 //modified by NIZNHY-PKV Mon Oct 17 11:44:45 2011t