[occt.git] / src / BOPAlgo / BOPAlgo_Tools.cxx

// Created by: Peter KURNEV
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.


#include <BOPAlgo_Tools.hxx>
#include <BOPCol_IndexedMapOfInteger.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_PaveBlock.hxx>

//=======================================================================
//function : MakeBlocksCnx
//purpose  : 
//=======================================================================
  void BOPAlgo_Tools::MakeBlocksCnx(const BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
                                    BOPCol_DataMapOfIntegerListOfInteger& aMBlocks,
                                    Handle(NCollection_BaseAllocator)& aAllocator)
{
  Standard_Integer aNbV, nV, aNbVS, nVP, nVx, aNbVP, aNbEC, k, i, j;
  BOPCol_ListIteratorOfListOfInteger aItLI;
  //
  BOPCol_MapOfInteger aMVS(100, aAllocator);
  BOPCol_IndexedMapOfInteger aMEC(100, aAllocator);
  BOPCol_IndexedMapOfInteger aMVP(100, aAllocator);
  BOPCol_IndexedMapOfInteger aMVAdd(100, aAllocator);
  //
  aNbV=aMILI.Extent();
  //
  for (k=0,i=1; i<=aNbV; ++i) {
    aNbVS=aMVS.Extent();
    if (aNbVS==aNbV) {
      break;
    }
    //
    nV = aMILI.FindKey(i);
    if (aMVS.Contains(nV)){
      continue;
    }
    aMVS.Add(nV);
    //
    aMEC.Clear();
    aMVP.Clear();
    aMVAdd.Clear();
    //
    aMVP.Add(nV);
    for(;;) {
      aNbVP=aMVP.Extent();
      for (j=1; j<=aNbVP; ++j) {
        nVP=aMVP(j);
        const BOPCol_ListOfInteger& aLV=aMILI.FindFromKey(nVP);
        aItLI.Initialize(aLV);
        for (; aItLI.More(); aItLI.Next()) {
          nVx=aItLI.Value();
          if (aMEC.Contains(nVx)) {
            continue;
          }
          //
          aMVS.Add(nVx);
          aMEC.Add(nVx);
          aMVAdd.Add(nVx);
        }
      }
      //
      aNbVP=aMVAdd.Extent();
      if (!aNbVP) {
        break; // from while(1)
      }
      //
      aMVP.Clear();
      for (j=1; j<=aNbVP; ++j) {
        aMVP.Add(aMVAdd(j));
      }
      aMVAdd.Clear();
    }//while(1) {
    //
    BOPCol_ListOfInteger aLIx(aAllocator);
    //
    aNbEC = aMEC.Extent();
    for (j=1; j<=aNbEC; ++j) {
      nVx=aMEC(j);
      aLIx.Append(nVx);
    }
    //
    aMBlocks.Bind(k, aLIx);
    ++k;
  }//for (k=0,i=1; i<=aNbV; ++i)
  aMVAdd.Clear();
  aMVP.Clear();
  aMEC.Clear();
  aMVS.Clear();
}
//=======================================================================
//function : FillMap
//purpose  : 
//=======================================================================
  void BOPAlgo_Tools::FillMap(const Standard_Integer n1,
                              const Standard_Integer n2,
                              BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
                              Handle(NCollection_BaseAllocator)& aAllocator)
{
  if (aMILI.Contains(n1)) {
    BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n1);
    aLI.Append(n2);
  }
  else {
    BOPCol_ListOfInteger aLI(aAllocator);
    aLI.Append(n2);
    aMILI.Add(n1, aLI);
  }
  if (aMILI.Contains(n2)) {
    BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n2);
    aLI.Append(n1);
  }
  else {
    BOPCol_ListOfInteger aLI(aAllocator);
    aLI.Append(n1);
    aMILI.Add(n2, aLI);
  }
}
//=======================================================================
//function : FillMap
//purpose  : 
//=======================================================================
  void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB1,
                              const Handle(BOPDS_PaveBlock)& aPB2,
                              BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
                              Handle(NCollection_BaseAllocator)& aAllocator)
{
  if (aMPBLPB.Contains(aPB1)) {
    BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB1);
    aLPB.Append(aPB2);
  }
  else {
    BOPDS_ListOfPaveBlock aLPB(aAllocator);
    aLPB.Append(aPB2);
    aMPBLPB.Add(aPB1, aLPB);
  }
  if (aMPBLPB.Contains(aPB2)) {
    BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB2);
    aLPB.Append(aPB1);
  }
  else {
    BOPDS_ListOfPaveBlock aLPB(aAllocator);
    aLPB.Append(aPB1);
    aMPBLPB.Add(aPB2, aLPB);
  }
}
//=======================================================================
//function : FillMap
//purpose  : 
//=======================================================================
  void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB,
                              const Standard_Integer nF,
                              BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
                              Handle(NCollection_BaseAllocator)& aAllocator)
{
  if (aMPBLI.Contains(aPB)) {
    BOPCol_ListOfInteger& aLI=aMPBLI.ChangeFromKey(aPB);
    aLI.Append(nF);
  }
  else {
    BOPCol_ListOfInteger aLI(aAllocator);
    aLI.Append(nF);
    aMPBLI.Add(aPB, aLI);
  }
}
//=======================================================================
//function : MakeBlocks
//purpose  : 
//=======================================================================
  void BOPAlgo_Tools::MakeBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMILI,
                                 BOPDS_DataMapOfIntegerListOfPaveBlock& aMBlocks,
                                 Handle(NCollection_BaseAllocator)& aAllocator)
{
  Standard_Integer aNbV,  aNbVS, aNbVP, aNbEC, k, i, j;
  BOPDS_ListIteratorOfListOfPaveBlock aItLI;
  //
  BOPDS_MapOfPaveBlock aMVS(100, aAllocator);
  BOPDS_IndexedMapOfPaveBlock aMEC(100, aAllocator);
  BOPDS_IndexedMapOfPaveBlock aMVP(100, aAllocator);
  BOPDS_IndexedMapOfPaveBlock aMVAdd(100, aAllocator);
  //
  aNbV=aMILI.Extent();
  //
  for (k=0, i=1; i<=aNbV; ++i) {
    aNbVS=aMVS.Extent();
    if (aNbVS==aNbV) {
      break;
    }
    //
    const Handle(BOPDS_PaveBlock)& nV=aMILI.FindKey(i);
    if (aMVS.Contains(nV)){
      continue;
    }
    aMVS.Add(nV);
    //
    aMEC.Clear();
    aMVP.Clear();
    aMVAdd.Clear();
    //
    aMVP.Add(nV);
    for(;;) {
      aNbVP=aMVP.Extent();
      for (j=1; j<=aNbVP; ++j) {
        const Handle(BOPDS_PaveBlock)& nVP=aMVP(j);
        const BOPDS_ListOfPaveBlock& aLV=aMILI.FindFromKey(nVP);
        aItLI.Initialize(aLV);
        for (; aItLI.More(); aItLI.Next()) {
          const Handle(BOPDS_PaveBlock)& nVx=aItLI.Value();
          if (aMEC.Contains(nVx)) {
            continue;
          }
          //
          aMVS.Add(nVx);
          aMEC.Add(nVx);
          aMVAdd.Add(nVx);
        }
      }
      //
      aNbVP=aMVAdd.Extent();
      if (!aNbVP) {
        break; // from while(1)
      }
      //
      aMVP.Clear();
      for (j=1; j<=aNbVP; ++j) {
        aMVP.Add(aMVAdd(j));
      }
      aMVAdd.Clear();
    }//while(1) {
    //
    BOPDS_ListOfPaveBlock aLIx(aAllocator);
    //
    aNbEC = aMEC.Extent();
    for (j=1; j<=aNbEC; ++j) {
      const Handle(BOPDS_PaveBlock)& nVx=aMEC(j);
      aLIx.Append(nVx);
    }
    //
    aMBlocks.Bind(k, aLIx);
    ++k;
  }//for (k=0, i=1; i<=aNbV; ++i)
  aMVAdd.Clear();
  aMVP.Clear();
  aMEC.Clear();
  aMVS.Clear();
}
//=======================================================================
//function : PerformCommonBlocks
//purpose  : 
//=======================================================================
  void BOPAlgo_Tools::PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
                                          Handle(NCollection_BaseAllocator)& aAllocator,
                                          BOPDS_PDS& pDS)
{
  Standard_Integer aNbCB;
  //
  aNbCB=aMPBLPB.Extent();
  if (!aNbCB) {
    return;
  }
  //
  Standard_Integer aNbPB, aNbBlocks, k;
  BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
  Handle(BOPDS_CommonBlock) aCB;
  BOPDS_DataMapOfIntegerListOfPaveBlock aMBlocks(100, aAllocator);
  //
  BOPAlgo_Tools::MakeBlocks(aMPBLPB, aMBlocks, aAllocator);
  //
  aNbBlocks = aMBlocks.Extent();
  for (k=0; k<aNbBlocks; ++k) {
    const BOPDS_ListOfPaveBlock& aLPB=aMBlocks.Find(k);
    aNbPB=aLPB.Extent();
    if (aNbPB>1) {
      aCB=new BOPDS_CommonBlock;
      //
      aItLPB.Initialize(aLPB);
      for (; aItLPB.More(); aItLPB.Next()) {
        const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
        aCB->AddPaveBlock(aPBx);
      }
      //
      aItLPB.Initialize(aLPB);
      for (; aItLPB.More(); aItLPB.Next()) {
        const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
        pDS->SetCommonBlock(aPBx, aCB);
      }
    }//if (aNbPB>1) {
  }
}
//=======================================================================
//function : PerformCommonBlocks
//purpose  : 
//=======================================================================
  void BOPAlgo_Tools::PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
                                          Handle(NCollection_BaseAllocator)& ,//aAllocator
                                          BOPDS_PDS& pDS)
{
  Standard_Integer nF, i, aNb;
  BOPCol_ListIteratorOfListOfInteger aItLI;
  Handle(BOPDS_PaveBlock) aPB;
  Handle(BOPDS_CommonBlock) aCB;
  //
  aNb=aMPBLI.Extent();
  for (i=1; i<=aNb; ++i) {
    aPB=aMPBLI.FindKey(i);
    if (pDS->IsCommonBlock(aPB)) {
      aCB=pDS->CommonBlock(aPB);
    }
    else {
      aCB=new BOPDS_CommonBlock;
      aCB->AddPaveBlock(aPB);
    }
    //
    const BOPCol_ListOfInteger& aLI=aMPBLI.FindFromKey(aPB);
    aItLI.Initialize(aLI);
    for (; aItLI.More(); aItLI.Next()) {
      nF=aItLI.Value();
      aCB->AddFace(nF);
    }
    pDS->SetCommonBlock(aPB, aCB);
  }
}
Commit	Line	Data
4e57c75e	1	// Created by: Peter KURNEV
973c2be1	2	// Copyright (c) 1999-2014 OPEN CASCADE SAS
4e57c75e	3	//
973c2be1	4	// This file is part of Open CASCADE Technology software library.
4e57c75e	5	//
d5f74e42	6	// This library is free software; you can redistribute it and/or modify it under
d5f74e42	7	// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1	8	// by the Free Software Foundation, with special exception defined in the file
	9	// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
	10	// distribution for complete text of the license and disclaimer of any warranty.
4e57c75e	11	//
973c2be1	12	// Alternatively, this file may be used under the terms of Open CASCADE
973c2be1	13	// commercial license or contractual agreement.
4e57c75e	14
42cf5bc1	15
	16	#include <BOPAlgo_Tools.hxx>
	17	#include <BOPCol_IndexedMapOfInteger.hxx>
4e57c75e	18	#include <BOPDS_CommonBlock.hxx>
4e57c75e	19	#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
42cf5bc1	20	#include <BOPDS_DS.hxx>
	21	#include <BOPDS_IndexedMapOfPaveBlock.hxx>
	22	#include <BOPDS_MapOfPaveBlock.hxx>
	23	#include <BOPDS_PaveBlock.hxx>
4e57c75e	24
	25	//=======================================================================
	26	//function : MakeBlocksCnx
	27	//purpose :
	28	//=======================================================================
	29	void BOPAlgo_Tools::MakeBlocksCnx(const BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
	30	BOPCol_DataMapOfIntegerListOfInteger& aMBlocks,
	31	Handle(NCollection_BaseAllocator)& aAllocator)
	32	{
	33	Standard_Integer aNbV, nV, aNbVS, nVP, nVx, aNbVP, aNbEC, k, i, j;
	34	BOPCol_ListIteratorOfListOfInteger aItLI;
	35	//
	36	BOPCol_MapOfInteger aMVS(100, aAllocator);
	37	BOPCol_IndexedMapOfInteger aMEC(100, aAllocator);
	38	BOPCol_IndexedMapOfInteger aMVP(100, aAllocator);
	39	BOPCol_IndexedMapOfInteger aMVAdd(100, aAllocator);
	40	//
	41	aNbV=aMILI.Extent();
	42	//
	43	for (k=0,i=1; i<=aNbV; ++i) {
	44	aNbVS=aMVS.Extent();
	45	if (aNbVS==aNbV) {
	46	break;
	47	}
	48	//
	49	nV = aMILI.FindKey(i);
	50	if (aMVS.Contains(nV)){
	51	continue;
	52	}
	53	aMVS.Add(nV);
	54	//
	55	aMEC.Clear();
	56	aMVP.Clear();
	57	aMVAdd.Clear();
	58	//
	59	aMVP.Add(nV);
302f96fb	60	for(;;) {
4e57c75e	61	aNbVP=aMVP.Extent();
	62	for (j=1; j<=aNbVP; ++j) {
	63	nVP=aMVP(j);
	64	const BOPCol_ListOfInteger& aLV=aMILI.FindFromKey(nVP);
	65	aItLI.Initialize(aLV);
	66	for (; aItLI.More(); aItLI.Next()) {
	67	nVx=aItLI.Value();
	68	if (aMEC.Contains(nVx)) {
	69	continue;
	70	}
	71	//
	72	aMVS.Add(nVx);
	73	aMEC.Add(nVx);
	74	aMVAdd.Add(nVx);
	75	}
	76	}
	77	//
	78	aNbVP=aMVAdd.Extent();
	79	if (!aNbVP) {
	80	break; // from while(1)
	81	}
	82	//
	83	aMVP.Clear();
	84	for (j=1; j<=aNbVP; ++j) {
	85	aMVP.Add(aMVAdd(j));
	86	}
	87	aMVAdd.Clear();
	88	}//while(1) {
	89	//
	90	BOPCol_ListOfInteger aLIx(aAllocator);
	91	//
	92	aNbEC = aMEC.Extent();
	93	for (j=1; j<=aNbEC; ++j) {
	94	nVx=aMEC(j);
	95	aLIx.Append(nVx);
	96	}
	97	//
	98	aMBlocks.Bind(k, aLIx);
	99	++k;
	100	}//for (k=0,i=1; i<=aNbV; ++i)
	101	aMVAdd.Clear();
	102	aMVP.Clear();
	103	aMEC.Clear();
	104	aMVS.Clear();
	105	}
	106	//=======================================================================
	107	//function : FillMap
	108	//purpose :
	109	//=======================================================================
	110	void BOPAlgo_Tools::FillMap(const Standard_Integer n1,
	111	const Standard_Integer n2,
	112	BOPCol_IndexedDataMapOfIntegerListOfInteger& aMILI,
	113	Handle(NCollection_BaseAllocator)& aAllocator)
	114	{
	115	if (aMILI.Contains(n1)) {
	116	BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n1);
	117	aLI.Append(n2);
	118	}
	119	else {
	120	BOPCol_ListOfInteger aLI(aAllocator);
	121	aLI.Append(n2);
	122	aMILI.Add(n1, aLI);
	123	}
	124	if (aMILI.Contains(n2)) {
125	BOPCol_ListOfInteger& aLI=aMILI.ChangeFromKey(n2);
126	aLI.Append(n1);
127	}
128	else {
129	BOPCol_ListOfInteger aLI(aAllocator);
130	aLI.Append(n1);
131	aMILI.Add(n2, aLI);
132	}
133	}
134	//=======================================================================
135	//function : FillMap
136	//purpose :
137	//=======================================================================
138	void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB1,
139	const Handle(BOPDS_PaveBlock)& aPB2,
140	BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
141	Handle(NCollection_BaseAllocator)& aAllocator)
142	{
143	if (aMPBLPB.Contains(aPB1)) {
144	BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB1);
145	aLPB.Append(aPB2);
146	}
147	else {
148	BOPDS_ListOfPaveBlock aLPB(aAllocator);
149	aLPB.Append(aPB2);
150	aMPBLPB.Add(aPB1, aLPB);
151	}
152	if (aMPBLPB.Contains(aPB2)) {
153	BOPDS_ListOfPaveBlock& aLPB=aMPBLPB.ChangeFromKey(aPB2);
154	aLPB.Append(aPB1);
155	}
156	else {
157	BOPDS_ListOfPaveBlock aLPB(aAllocator);
158	aLPB.Append(aPB1);
159	aMPBLPB.Add(aPB2, aLPB);
160	}
161	}
162	//=======================================================================
163	//function : FillMap
164	//purpose :
165	//=======================================================================
166	void BOPAlgo_Tools::FillMap(const Handle(BOPDS_PaveBlock)& aPB,
167	const Standard_Integer nF,
168	BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
169	Handle(NCollection_BaseAllocator)& aAllocator)
170	{
171	if (aMPBLI.Contains(aPB)) {
172	BOPCol_ListOfInteger& aLI=aMPBLI.ChangeFromKey(aPB);
173	aLI.Append(nF);
174	}
175	else {
176	BOPCol_ListOfInteger aLI(aAllocator);
177	aLI.Append(nF);
178	aMPBLI.Add(aPB, aLI);
179	}
180	}
181	//=======================================================================
182	//function : MakeBlocks
183	//purpose :
184	//=======================================================================
185	void BOPAlgo_Tools::MakeBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMILI,
186	BOPDS_DataMapOfIntegerListOfPaveBlock& aMBlocks,
187	Handle(NCollection_BaseAllocator)& aAllocator)
188	{
189	Standard_Integer aNbV, aNbVS, aNbVP, aNbEC, k, i, j;
190	BOPDS_ListIteratorOfListOfPaveBlock aItLI;
191	//
192	BOPDS_MapOfPaveBlock aMVS(100, aAllocator);
193	BOPDS_IndexedMapOfPaveBlock aMEC(100, aAllocator);
194	BOPDS_IndexedMapOfPaveBlock aMVP(100, aAllocator);
195	BOPDS_IndexedMapOfPaveBlock aMVAdd(100, aAllocator);
196	//
197	aNbV=aMILI.Extent();
198	//
199	for (k=0, i=1; i<=aNbV; ++i) {
200	aNbVS=aMVS.Extent();
201	if (aNbVS==aNbV) {
202	break;
203	}
204	//
205	const Handle(BOPDS_PaveBlock)& nV=aMILI.FindKey(i);
206	if (aMVS.Contains(nV)){
207	continue;
208	}
209	aMVS.Add(nV);
210	//
211	aMEC.Clear();
212	aMVP.Clear();
213	aMVAdd.Clear();
214	//
215	aMVP.Add(nV);
302f96fb	216	for(;;) {
4e57c75e	217	aNbVP=aMVP.Extent();
	218	for (j=1; j<=aNbVP; ++j) {
	219	const Handle(BOPDS_PaveBlock)& nVP=aMVP(j);
	220	const BOPDS_ListOfPaveBlock& aLV=aMILI.FindFromKey(nVP);
	221	aItLI.Initialize(aLV);
	222	for (; aItLI.More(); aItLI.Next()) {
	223	const Handle(BOPDS_PaveBlock)& nVx=aItLI.Value();
	224	if (aMEC.Contains(nVx)) {
	225	continue;
	226	}
	227	//
	228	aMVS.Add(nVx);
	229	aMEC.Add(nVx);
	230	aMVAdd.Add(nVx);
	231	}
	232	}
	233	//
	234	aNbVP=aMVAdd.Extent();
	235	if (!aNbVP) {
	236	break; // from while(1)
	237	}
	238	//
	239	aMVP.Clear();
	240	for (j=1; j<=aNbVP; ++j) {
	241	aMVP.Add(aMVAdd(j));
	242	}
	243	aMVAdd.Clear();
	244	}//while(1) {
	245	//
	246	BOPDS_ListOfPaveBlock aLIx(aAllocator);
	247	//
	248	aNbEC = aMEC.Extent();
	249	for (j=1; j<=aNbEC; ++j) {
	250	const Handle(BOPDS_PaveBlock)& nVx=aMEC(j);
	251	aLIx.Append(nVx);
	252	}
	253	//
	254	aMBlocks.Bind(k, aLIx);
	255	++k;
	256	}//for (k=0, i=1; i<=aNbV; ++i)
	257	aMVAdd.Clear();
	258	aMVP.Clear();
	259	aMEC.Clear();
	260	aMVS.Clear();
	261	}
	262	//=======================================================================
	263	//function : PerformCommonBlocks
	264	//purpose :
	265	//=======================================================================
	266	void BOPAlgo_Tools::PerformCommonBlocks(BOPDS_IndexedDataMapOfPaveBlockListOfPaveBlock& aMPBLPB,
5a77460e	267	Handle(NCollection_BaseAllocator)& aAllocator,
5a77460e	268	BOPDS_PDS& pDS)
4e57c75e	269	{
	270	Standard_Integer aNbCB;
	271	//
	272	aNbCB=aMPBLPB.Extent();
	273	if (!aNbCB) {
	274	return;
	275	}
	276	//
	277	Standard_Integer aNbPB, aNbBlocks, k;
	278	BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
	279	Handle(BOPDS_CommonBlock) aCB;
	280	BOPDS_DataMapOfIntegerListOfPaveBlock aMBlocks(100, aAllocator);
	281	//
	282	BOPAlgo_Tools::MakeBlocks(aMPBLPB, aMBlocks, aAllocator);
	283	//
	284	aNbBlocks = aMBlocks.Extent();
	285	for (k=0; k<aNbBlocks; ++k) {
	286	const BOPDS_ListOfPaveBlock& aLPB=aMBlocks.Find(k);
	287	aNbPB=aLPB.Extent();
	288	if (aNbPB>1) {
	289	aCB=new BOPDS_CommonBlock;
	290	//
	291	aItLPB.Initialize(aLPB);
	292	for (; aItLPB.More(); aItLPB.Next()) {
	293	const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
	294	aCB->AddPaveBlock(aPBx);
	295	}
	296	//
	297	aItLPB.Initialize(aLPB);
	298	for (; aItLPB.More(); aItLPB.Next()) {
	299	const Handle(BOPDS_PaveBlock)& aPBx=aItLPB.Value();
5a77460e	300	pDS->SetCommonBlock(aPBx, aCB);
4e57c75e	301	}
	302	}//if (aNbPB>1) {
	303	}
	304	}
	305	//=======================================================================
	306	//function : PerformCommonBlocks
	307	//purpose :
	308	//=======================================================================
	309	void BOPAlgo_Tools::PerformCommonBlocks(const BOPDS_IndexedDataMapOfPaveBlockListOfInteger& aMPBLI,
5a77460e	310	Handle(NCollection_BaseAllocator)& ,//aAllocator
5a77460e	311	BOPDS_PDS& pDS)
4e57c75e	312	{
	313	Standard_Integer nF, i, aNb;
	314	BOPCol_ListIteratorOfListOfInteger aItLI;
	315	Handle(BOPDS_PaveBlock) aPB;
	316	Handle(BOPDS_CommonBlock) aCB;
	317	//
	318	aNb=aMPBLI.Extent();
	319	for (i=1; i<=aNb; ++i) {
	320	aPB=aMPBLI.FindKey(i);
5a77460e	321	if (pDS->IsCommonBlock(aPB)) {
5a77460e	322	aCB=pDS->CommonBlock(aPB);
4e57c75e	323	}
	324	else {
	325	aCB=new BOPDS_CommonBlock;
	326	aCB->AddPaveBlock(aPB);
	327	}
	328	//
	329	const BOPCol_ListOfInteger& aLI=aMPBLI.FindFromKey(aPB);
	330	aItLI.Initialize(aLI);
	331	for (; aItLI.More(); aItLI.Next()) {
	332	nF=aItLI.Value();
	333	aCB->AddFace(nF);
	334	}
5a77460e	335	pDS->SetCommonBlock(aPB, aCB);
4e57c75e	336	}
4e57c75e	337	}